diff --git a/exec/coroparse.c b/exec/coroparse.c
index f4dea8a6..b660335d 100644
--- a/exec/coroparse.c
+++ b/exec/coroparse.c
@@ -1,1392 +1,1409 @@
 /*
  * Copyright (c) 2006-2013 Red Hat, Inc.
  *
  * All rights reserved.
  *
  * Author: Patrick Caulfield (pcaulfie@redhat.com)
  *         Jan Friesse (jfriesse@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 <sys/types.h>
 #include <sys/uio.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/un.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 <string.h>
 #include <dirent.h>
 #include <limits.h>
 #include <stddef.h>
 #include <grp.h>
 #include <pwd.h>
 
 #include <qb/qblist.h>
 #include <qb/qbutil.h>
 #define LOGSYS_UTILS_ONLY 1
 #include <corosync/logsys.h>
 #include <corosync/icmap.h>
 
 #include "main.h"
 #include "util.h"
 
 enum parser_cb_type {
 	PARSER_CB_START,
 	PARSER_CB_END,
 	PARSER_CB_SECTION_START,
 	PARSER_CB_SECTION_END,
 	PARSER_CB_ITEM,
 };
 
 enum main_cp_cb_data_state {
 	MAIN_CP_CB_DATA_STATE_NORMAL,
 	MAIN_CP_CB_DATA_STATE_TOTEM,
 	MAIN_CP_CB_DATA_STATE_INTERFACE,
 	MAIN_CP_CB_DATA_STATE_LOGGER_SUBSYS,
 	MAIN_CP_CB_DATA_STATE_UIDGID,
 	MAIN_CP_CB_DATA_STATE_LOGGING_DAEMON,
 	MAIN_CP_CB_DATA_STATE_MEMBER,
 	MAIN_CP_CB_DATA_STATE_QUORUM,
 	MAIN_CP_CB_DATA_STATE_QDEVICE,
 	MAIN_CP_CB_DATA_STATE_NODELIST,
 	MAIN_CP_CB_DATA_STATE_NODELIST_NODE,
 	MAIN_CP_CB_DATA_STATE_PLOAD,
 	MAIN_CP_CB_DATA_STATE_QB,
 	MAIN_CP_CB_DATA_STATE_RESOURCES,
 	MAIN_CP_CB_DATA_STATE_RESOURCES_SYSTEM,
 	MAIN_CP_CB_DATA_STATE_RESOURCES_PROCESS,
 	MAIN_CP_CB_DATA_STATE_RESOURCES_SYSTEM_MEMUSED,
 	MAIN_CP_CB_DATA_STATE_RESOURCES_PROCESS_MEMUSED
 };
 
 typedef int (*parser_cb_f)(const char *path,
 			char *key,
 			char *value,
 			enum main_cp_cb_data_state *state,
 			enum parser_cb_type type,
 			const char **error_string,
 			icmap_map_t config_map,
 			void *user_data);
 
 struct key_value_list_item {
 	char *key;
 	char *value;
 	struct qb_list_head list;
 };
 
 struct main_cp_cb_data {
 	int linknumber;
 	char *bindnetaddr;
 	char *mcastaddr;
 	char *broadcast;
 	int mcastport;
 	int ttl;
 	int knet_link_priority;
 	int knet_ping_interval;
 	int knet_ping_timeout;
 	int knet_ping_precision;
+	int knet_pong_count;
+	int knet_pmtud_interval;
 
 	struct qb_list_head logger_subsys_items_head;
 	char *subsys;
 	char *logging_daemon_name;
 	struct qb_list_head member_items_head;
 
 	int node_number;
 	int ring0_addr_added;
 };
 
 static int read_config_file_into_icmap(
 	const char **error_string, icmap_map_t config_map);
 static char error_string_response[512];
 
 static int uid_determine (const char *req_user)
 {
 	int pw_uid = 0;
 	struct passwd passwd;
 	struct passwd* pwdptr = &passwd;
 	struct passwd* temp_pwd_pt;
 	char *pwdbuffer;
 	int  pwdlinelen, rc;
 	long int id;
 	char *ep;
 
 	id = strtol(req_user, &ep, 10);
 	if (*ep == '\0' && id >= 0 && id <= UINT_MAX) {
 		return (id);
 	}
 
 	pwdlinelen = sysconf (_SC_GETPW_R_SIZE_MAX);
 
 	if (pwdlinelen == -1) {
 	        pwdlinelen = 256;
 	}
 
 	pwdbuffer = malloc (pwdlinelen);
 
 	while ((rc = getpwnam_r (req_user, pwdptr, pwdbuffer, pwdlinelen, &temp_pwd_pt)) == ERANGE) {
 		char *n;
 
 		pwdlinelen *= 2;
 		if (pwdlinelen <= 32678) {
 			n = realloc (pwdbuffer, pwdlinelen);
 			if (n != NULL) {
 				pwdbuffer = n;
 				continue;
 			}
 		}
 	}
 	if (rc != 0) {
 		free (pwdbuffer);
 	        sprintf (error_string_response, "getpwnam_r(): %s", strerror(rc));
 	        return (-1);
 	}
 	if (temp_pwd_pt == NULL) {
 		free (pwdbuffer);
 	        sprintf (error_string_response,
 	                "The '%s' user is not found in /etc/passwd, please read the documentation.",
 	                req_user);
 	        return (-1);
 	}
 	pw_uid = passwd.pw_uid;
 	free (pwdbuffer);
 
 	return pw_uid;
 }
 
 static int gid_determine (const char *req_group)
 {
 	int corosync_gid = 0;
 	struct group group;
 	struct group * grpptr = &group;
 	struct group * temp_grp_pt;
 	char *grpbuffer;
 	int  grplinelen, rc;
 	long int id;
 	char *ep;
 
 	id = strtol(req_group, &ep, 10);
 	if (*ep == '\0' && id >= 0 && id <= UINT_MAX) {
 		return (id);
 	}
 
 	grplinelen = sysconf (_SC_GETGR_R_SIZE_MAX);
 
 	if (grplinelen == -1) {
 	        grplinelen = 256;
 	}
 
 	grpbuffer = malloc (grplinelen);
 
 	while ((rc = getgrnam_r (req_group, grpptr, grpbuffer, grplinelen, &temp_grp_pt)) == ERANGE) {
 		char *n;
 
 		grplinelen *= 2;
 		if (grplinelen <= 32678) {
 			n = realloc (grpbuffer, grplinelen);
 			if (n != NULL) {
 				grpbuffer = n;
 				continue;
 			}
 		}
 	}
 	if (rc != 0) {
 		free (grpbuffer);
 	        sprintf (error_string_response, "getgrnam_r(): %s", strerror(rc));
 	        return (-1);
 	}
 	if (temp_grp_pt == NULL) {
 		free (grpbuffer);
 	        sprintf (error_string_response,
 	                "The '%s' group is not found in /etc/group, please read the documentation.",
 	                req_group);
 		return (-1);
 	}
 	corosync_gid = group.gr_gid;
 	free (grpbuffer);
 
 	return corosync_gid;
 }
 static char *strchr_rs (const char *haystack, int byte)
 {
 	const char *end_address = strchr (haystack, byte);
 	if (end_address) {
 		end_address += 1; /* skip past { or = */
 
 		while (*end_address == ' ' || *end_address == '\t')
 			end_address++;
 	}
 
 	return ((char *) end_address);
 }
 
 int coroparse_configparse (icmap_map_t config_map, const char **error_string)
 {
 	if (read_config_file_into_icmap(error_string, config_map)) {
 		return -1;
 	}
 
 	return 0;
 }
 
 static char *remove_whitespace(char *string, int remove_colon_and_brace)
 {
 	char *start;
 	char *end;
 
 	start = string;
 	while (*start == ' ' || *start == '\t')
 		start++;
 
 	end = start+(strlen(start))-1;
 	while ((*end == ' ' || *end == '\t' || (remove_colon_and_brace && (*end == ':' || *end == '{'))) && end > start)
 		end--;
 	if (end != start)
 		*(end+1) = '\0';
 
 	return start;
 }
 
 
 
 static int parse_section(FILE *fp,
 			 char *path,
 			 const char **error_string,
 			 int depth,
 			 enum main_cp_cb_data_state state,
 			 parser_cb_f parser_cb,
 			 icmap_map_t config_map,
 			 void *user_data)
 {
 	char line[512];
 	int i;
 	char *loc;
 	int ignore_line;
 	char new_keyname[ICMAP_KEYNAME_MAXLEN];
 
 	if (strcmp(path, "") == 0) {
 		parser_cb("", NULL, NULL, &state, PARSER_CB_START, error_string, config_map, user_data);
 	}
 
 	while (fgets (line, sizeof (line), fp)) {
 		if (strlen(line) > 0) {
 			if (line[strlen(line) - 1] == '\n')
 				line[strlen(line) - 1] = '\0';
 			if (strlen (line) > 0 && line[strlen(line) - 1] == '\r')
 				line[strlen(line) - 1] = '\0';
 		}
 		/*
 		 * Clear out white space and tabs
 		 */
 		for (i = strlen (line) - 1; i > -1; i--) {
 			if (line[i] == '\t' || line[i] == ' ') {
 				line[i] = '\0';
 			} else {
 				break;
 			}
 		}
 
 		ignore_line = 1;
 		for (i = 0; i < strlen (line); i++) {
 			if (line[i] != '\t' && line[i] != ' ') {
 				if (line[i] != '#')
 					ignore_line = 0;
 
 				break;
 			}
 		}
 		/*
 		 * Clear out comments and empty lines
 		 */
 		if (ignore_line) {
 			continue;
 		}
 
 		/* New section ? */
 		if ((loc = strchr_rs (line, '{'))) {
 			char *section = remove_whitespace(line, 1);
 			enum main_cp_cb_data_state newstate;
 
 			loc--;
 			*loc = '\0';
 
 			if (strlen(path) + strlen(section) + 1 >= ICMAP_KEYNAME_MAXLEN) {
 				*error_string = "parser error: Start of section makes total cmap path too long";
 				return -1;
 			}
 			strcpy(new_keyname, path);
 			if (strcmp(path, "") != 0) {
 				strcat(new_keyname, ".");
 			}
 			strcat(new_keyname, section);
 
 			/* Only use the new state for items further down the stack */
 			newstate = state;
 			if (!parser_cb(new_keyname, NULL, NULL, &newstate, PARSER_CB_SECTION_START, error_string, config_map, user_data)) {
 				return -1;
 			}
 
 			if (parse_section(fp, new_keyname, error_string, depth + 1, newstate, parser_cb, config_map, user_data))
 				return -1;
 
 			continue ;
 		}
 
 		/* New key/value */
 		if ((loc = strchr_rs (line, ':'))) {
 			char *key;
 			char *value;
 
 			*(loc-1) = '\0';
 			key = remove_whitespace(line, 1);
 			value = remove_whitespace(loc, 0);
 
 			if (strlen(path) + strlen(key) + 1 >= ICMAP_KEYNAME_MAXLEN) {
 				*error_string = "parser error: New key makes total cmap path too long";
 				return -1;
 			}
 			strcpy(new_keyname, path);
 			if (strcmp(path, "") != 0) {
 				strcat(new_keyname, ".");
 			}
 			strcat(new_keyname, key);
 
 			if (!parser_cb(new_keyname, key, value, &state, PARSER_CB_ITEM, error_string, config_map, user_data)) {
 				return -1;
 			}
 
 			continue ;
 		}
 
 		if (strchr_rs (line, '}')) {
 			if (depth == 0) {
 				*error_string = "parser error: Unexpected closing brace";
 
 				return -1;
 			}
 
 			if (!parser_cb(path, NULL, NULL, &state, PARSER_CB_SECTION_END, error_string, config_map, user_data)) {
 				return -1;
 			}
 
 			return 0;
 		}
 	}
 
 	if (strcmp(path, "") != 0) {
 		*error_string = "parser error: Missing closing brace";
 		return -1;
 	}
 
 	if (strcmp(path, "") == 0) {
 		parser_cb("", NULL, NULL, &state, PARSER_CB_END, error_string, config_map, user_data);
 	}
 
 	return 0;
 }
 
 static int safe_atoq_range(icmap_value_types_t value_type, long long int *min_val, long long int *max_val)
 {
 	switch (value_type) {
 	case ICMAP_VALUETYPE_INT8: *min_val = INT8_MIN; *max_val = INT8_MAX; break;
 	case ICMAP_VALUETYPE_UINT8: *min_val = 0; *max_val = UINT8_MAX; break;
 	case ICMAP_VALUETYPE_INT16: *min_val = INT16_MIN; *max_val = INT16_MAX; break;
 	case ICMAP_VALUETYPE_UINT16: *min_val = 0; *max_val = UINT16_MAX; break;
 	case ICMAP_VALUETYPE_INT32: *min_val = INT32_MIN; *max_val = INT32_MAX; break;
 	case ICMAP_VALUETYPE_UINT32: *min_val = 0; *max_val = UINT32_MAX; break;
 	default:
 		return (-1);
 	}
 
 	return (0);
 }
 
 /*
  * Convert string str to long long int res. Type of result is target_type and currently only
  * ICMAP_VALUETYPE_[U]INT[8|16|32] is supported.
  * Return 0 on success, -1 on failure.
  */
 static int safe_atoq(const char *str, long long int *res, icmap_value_types_t target_type)
 {
 	long long int val;
 	long long int min_val, max_val;
 	char *endptr;
 
 	errno = 0;
 
 	val = strtoll(str, &endptr, 10);
 	if (errno == ERANGE) {
 		return (-1);
 	}
 
 	if (endptr == str) {
 		return (-1);
 	}
 
 	if (*endptr != '\0') {
 		return (-1);
 	}
 
 	if (safe_atoq_range(target_type, &min_val, &max_val) != 0) {
 		return (-1);
 	}
 
 	if (val < min_val || val > max_val) {
 		return (-1);
 	}
 
 	*res = val;
 	return (0);
 }
 
 static int str_to_ull(const char *str, unsigned long long int *res)
 {
 	unsigned long long int val;
 	char *endptr;
 
 	errno = 0;
 
 	val = strtoull(str, &endptr, 10);
 	if (errno == ERANGE) {
 		return (-1);
 	}
 
 	if (endptr == str) {
 		return (-1);
 	}
 
 	if (*endptr != '\0') {
 		return (-1);
 	}
 
 	*res = val;
 	return (0);
 }
 
 static int main_config_parser_cb(const char *path,
 			char *key,
 			char *value,
 			enum main_cp_cb_data_state *state,
 			enum parser_cb_type type,
 			const char **error_string,
 			icmap_map_t config_map,
 			void *user_data)
 {
 	int ii;
 	long long int val;
 	long long int min_val, max_val;
 	icmap_value_types_t val_type = ICMAP_VALUETYPE_BINARY;
 	unsigned long long int ull;
 	int add_as_string;
 	char key_name[ICMAP_KEYNAME_MAXLEN];
 	static char formated_err[256];
 	struct main_cp_cb_data *data = (struct main_cp_cb_data *)user_data;
 	struct key_value_list_item *kv_item;
 	struct qb_list_head *iter, *tmp_iter;
 	int uid, gid;
 
 	switch (type) {
 	case PARSER_CB_START:
 		memset(data, 0, sizeof(struct main_cp_cb_data));
 		*state = MAIN_CP_CB_DATA_STATE_NORMAL;
 		break;
 	case PARSER_CB_END:
 		break;
 	case PARSER_CB_ITEM:
 		add_as_string = 1;
 
 		switch (*state) {
 		case MAIN_CP_CB_DATA_STATE_NORMAL:
 			break;
 		case MAIN_CP_CB_DATA_STATE_PLOAD:
 			if ((strcmp(path, "pload.count") == 0) ||
 			    (strcmp(path, "pload.size") == 0)) {
 				val_type = ICMAP_VALUETYPE_UINT32;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 				icmap_set_uint32_r(config_map, path, val);
 				add_as_string = 0;
 			}
 			break;
 		case MAIN_CP_CB_DATA_STATE_QUORUM:
 			if ((strcmp(path, "quorum.expected_votes") == 0) ||
 			    (strcmp(path, "quorum.votes") == 0) ||
 			    (strcmp(path, "quorum.last_man_standing_window") == 0) ||
 			    (strcmp(path, "quorum.leaving_timeout") == 0)) {
 				val_type = ICMAP_VALUETYPE_UINT32;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 				icmap_set_uint32_r(config_map, path, val);
 				add_as_string = 0;
 			}
 
 			if ((strcmp(path, "quorum.two_node") == 0) ||
 			    (strcmp(path, "quorum.expected_votes_tracking") == 0) ||
 			    (strcmp(path, "quorum.allow_downscale") == 0) ||
 			    (strcmp(path, "quorum.wait_for_all") == 0) ||
 			    (strcmp(path, "quorum.auto_tie_breaker") == 0) ||
 			    (strcmp(path, "quorum.last_man_standing") == 0)) {
 				val_type = ICMAP_VALUETYPE_UINT8;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 				icmap_set_uint8_r(config_map, path, val);
 				add_as_string = 0;
 			}
 			break;
 		case MAIN_CP_CB_DATA_STATE_QDEVICE:
 			if ((strcmp(path, "quorum.device.timeout") == 0) ||
 			    (strcmp(path, "quorum.device.sync_timeout") == 0) ||
 			    (strcmp(path, "quorum.device.votes") == 0)) {
 				val_type = ICMAP_VALUETYPE_UINT32;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 				icmap_set_uint32_r(config_map, path, val);
 				add_as_string = 0;
 			}
 			if ((strcmp(path, "quorum.device.master_wins") == 0)) {
 				val_type = ICMAP_VALUETYPE_UINT8;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 				icmap_set_uint8_r(config_map, path, val);
 				add_as_string = 0;
 			}
 			break;
 		case MAIN_CP_CB_DATA_STATE_TOTEM:
 			if ((strcmp(path, "totem.version") == 0) ||
 			    (strcmp(path, "totem.nodeid") == 0) ||
 			    (strcmp(path, "totem.threads") == 0) ||
 			    (strcmp(path, "totem.token") == 0) ||
 			    (strcmp(path, "totem.token_coefficient") == 0) ||
 			    (strcmp(path, "totem.token_retransmit") == 0) ||
 			    (strcmp(path, "totem.hold") == 0) ||
 			    (strcmp(path, "totem.token_retransmits_before_loss_const") == 0) ||
 			    (strcmp(path, "totem.join") == 0) ||
 			    (strcmp(path, "totem.send_join") == 0) ||
 			    (strcmp(path, "totem.consensus") == 0) ||
 			    (strcmp(path, "totem.merge") == 0) ||
 			    (strcmp(path, "totem.downcheck") == 0) ||
 			    (strcmp(path, "totem.fail_recv_const") == 0) ||
 			    (strcmp(path, "totem.seqno_unchanged_const") == 0) ||
 			    (strcmp(path, "totem.rrp_token_expired_timeout") == 0) ||
 			    (strcmp(path, "totem.rrp_problem_count_timeout") == 0) ||
 			    (strcmp(path, "totem.rrp_problem_count_threshold") == 0) ||
 			    (strcmp(path, "totem.rrp_problem_count_mcast_threshold") == 0) ||
 			    (strcmp(path, "totem.rrp_autorecovery_check_timeout") == 0) ||
 			    (strcmp(path, "totem.heartbeat_failures_allowed") == 0) ||
 			    (strcmp(path, "totem.max_network_delay") == 0) ||
 			    (strcmp(path, "totem.window_size") == 0) ||
 			    (strcmp(path, "totem.max_messages") == 0) ||
 			    (strcmp(path, "totem.miss_count_const") == 0) ||
+			    (strcmp(path, "totem.knet_pmtud_interval") == 0) ||
 			    (strcmp(path, "totem.netmtu") == 0)) {
 				val_type = ICMAP_VALUETYPE_UINT32;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 				icmap_set_uint32_r(config_map,path, val);
 				add_as_string = 0;
 			}
 			if (strcmp(path, "totem.config_version") == 0) {
 				if (str_to_ull(value, &ull) != 0) {
 					goto atoi_error;
 				}
 				icmap_set_uint64_r(config_map, path, ull);
 				add_as_string = 0;
 			}
 			if (strcmp(path, "totem.ip_version") == 0) {
 				if ((strcmp(value, "ipv4") != 0) &&
 				    (strcmp(value, "ipv6") != 0)) {
 					*error_string = "Invalid ip_version type";
 
 					return (0);
 				}
 			}
 			if (strcmp(path, "totem.crypto_type") == 0) {
 				if ((strcmp(value, "nss") != 0) &&
 				    (strcmp(value, "aes256") != 0) &&
 				    (strcmp(value, "aes192") != 0) &&
 				    (strcmp(value, "aes128") != 0) &&
 				    (strcmp(value, "3des") != 0)) {
 					*error_string = "Invalid crypto type";
 
 					return (0);
 				}
 			}
 			if (strcmp(path, "totem.crypto_cipher") == 0) {
 				if ((strcmp(value, "none") != 0) &&
 				    (strcmp(value, "aes256") != 0) &&
 				    (strcmp(value, "aes192") != 0) &&
 				    (strcmp(value, "aes128") != 0) &&
 				    (strcmp(value, "3des") != 0)) {
 					*error_string = "Invalid cipher type";
 
 					return (0);
 				}
 			}
 			if (strcmp(path, "totem.crypto_hash") == 0) {
 				if ((strcmp(value, "none") != 0) &&
 				    (strcmp(value, "md5") != 0) &&
 				    (strcmp(value, "sha1") != 0) &&
 				    (strcmp(value, "sha256") != 0) &&
 				    (strcmp(value, "sha384") != 0) &&
 				    (strcmp(value, "sha512") != 0)) {
 					*error_string = "Invalid hash type";
 
 					return (0);
 				}
 			}
 			break;
 
 		case MAIN_CP_CB_DATA_STATE_QB:
 			if (strcmp(path, "qb.ipc_type") == 0) {
 				if ((strcmp(value, "native") != 0) &&
 				    (strcmp(value, "shm") != 0) &&
 				    (strcmp(value, "socket") != 0)) {
 					*error_string = "Invalid qb ipc_type";
 
 					return (0);
 				}
 			}
 			break;
 
 		case MAIN_CP_CB_DATA_STATE_INTERFACE:
 			if (strcmp(path, "totem.interface.linknumber") == 0) {
 				val_type = ICMAP_VALUETYPE_UINT8;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 
 				data->linknumber = val;
 				add_as_string = 0;
 			}
 			if (strcmp(path, "totem.interface.bindnetaddr") == 0) {
 				data->bindnetaddr = strdup(value);
 				add_as_string = 0;
 			}
 			if (strcmp(path, "totem.interface.mcastaddr") == 0) {
 				data->mcastaddr = strdup(value);
 				add_as_string = 0;
 			}
 			if (strcmp(path, "totem.interface.broadcast") == 0) {
 				data->broadcast = strdup(value);
 				add_as_string = 0;
 			}
 			if (strcmp(path, "totem.interface.mcastport") == 0) {
 				val_type = ICMAP_VALUETYPE_UINT16;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 				data->mcastport = val;
 				add_as_string = 0;
 			}
 			if (strcmp(path, "totem.interface.ttl") == 0) {
 				val_type = ICMAP_VALUETYPE_UINT8;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 				data->ttl = val;
 				add_as_string = 0;
 			}
 			if (strcmp(path, "totem.interface.knet_link_priority") == 0) {
 				val_type = ICMAP_VALUETYPE_UINT8;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 				data->knet_link_priority = val;
 				add_as_string = 0;
 			}
 			if (strcmp(path, "totem.interface.knet_ping_interval") == 0) {
 				val_type = ICMAP_VALUETYPE_UINT32;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 				data->knet_ping_interval = val;
 				add_as_string = 0;
 			}
 			if (strcmp(path, "totem.interface.knet_ping_timeout") == 0) {
 				val_type = ICMAP_VALUETYPE_UINT32;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 				data->knet_ping_timeout = val;
 				add_as_string = 0;
 			}
 			if (strcmp(path, "totem.interface.knet_ping_precision") == 0) {
 				val_type = ICMAP_VALUETYPE_UINT32;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 				data->knet_ping_precision = val;
 				add_as_string = 0;
 			}
+			if (strcmp(path, "totem.interface.knet_pong_count") == 0) {
+				val_type = ICMAP_VALUETYPE_UINT32;
+				if (safe_atoq(value, &val, val_type) != 0) {
+					goto atoi_error;
+				}
+				data->knet_pong_count = val;
+				add_as_string = 0;
+			}
 			break;
 		case MAIN_CP_CB_DATA_STATE_LOGGER_SUBSYS:
 			if (strcmp(key, "subsys") == 0) {
 				data->subsys = strdup(value);
 				if (data->subsys == NULL) {
 					*error_string = "Can't alloc memory";
 
 					return (0);
 				}
 			} else {
 				kv_item = malloc(sizeof(*kv_item));
 				if (kv_item == NULL) {
 					*error_string = "Can't alloc memory";
 
 					return (0);
 				}
 				memset(kv_item, 0, sizeof(*kv_item));
 
 				kv_item->key = strdup(key);
 				kv_item->value = strdup(value);
 				if (kv_item->key == NULL || kv_item->value == NULL) {
 					free(kv_item);
 					*error_string = "Can't alloc memory";
 
 					return (0);
 				}
 				qb_list_init(&kv_item->list);
 				qb_list_add(&kv_item->list, &data->logger_subsys_items_head);
 			}
 			add_as_string = 0;
 			break;
 		case MAIN_CP_CB_DATA_STATE_LOGGING_DAEMON:
 			if (strcmp(key, "subsys") == 0) {
 				data->subsys = strdup(value);
 				if (data->subsys == NULL) {
 					*error_string = "Can't alloc memory";
 
 					return (0);
 				}
 			} else if (strcmp(key, "name") == 0) {
 				data->logging_daemon_name = strdup(value);
 				if (data->logging_daemon_name == NULL) {
 					*error_string = "Can't alloc memory";
 
 					return (0);
 				}
 			} else {
 				kv_item = malloc(sizeof(*kv_item));
 				if (kv_item == NULL) {
 					*error_string = "Can't alloc memory";
 
 					return (0);
 				}
 				memset(kv_item, 0, sizeof(*kv_item));
 
 				kv_item->key = strdup(key);
 				kv_item->value = strdup(value);
 				if (kv_item->key == NULL || kv_item->value == NULL) {
 					free(kv_item);
 					*error_string = "Can't alloc memory";
 
 					return (0);
 				}
 				qb_list_init(&kv_item->list);
 				qb_list_add(&kv_item->list, &data->logger_subsys_items_head);
 			}
 			add_as_string = 0;
 			break;
 		case MAIN_CP_CB_DATA_STATE_UIDGID:
 			if (strcmp(key, "uid") == 0) {
 				uid = uid_determine(value);
 				if (uid == -1) {
 					*error_string = error_string_response;
 					return (0);
 				}
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "uidgid.config.uid.%u",
 						uid);
 				icmap_set_uint8_r(config_map, key_name, 1);
 				add_as_string = 0;
 			} else if (strcmp(key, "gid") == 0) {
 				gid = gid_determine(value);
 				if (gid == -1) {
 					*error_string = error_string_response;
 					return (0);
 				}
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "uidgid.config.gid.%u",
 						gid);
 				icmap_set_uint8_r(config_map, key_name, 1);
 				add_as_string = 0;
 			} else {
 				*error_string = "uidgid: Only uid and gid are allowed items";
 				return (0);
 			}
 			break;
 		case MAIN_CP_CB_DATA_STATE_MEMBER:
 			if (strcmp(key, "memberaddr") != 0) {
 				*error_string = "Only memberaddr is allowed in member section";
 
 				return (0);
 			}
 
 			kv_item = malloc(sizeof(*kv_item));
 			if (kv_item == NULL) {
 				*error_string = "Can't alloc memory";
 
 				return (0);
 			}
 			memset(kv_item, 0, sizeof(*kv_item));
 
 			kv_item->key = strdup(key);
 			kv_item->value = strdup(value);
 			if (kv_item->key == NULL || kv_item->value == NULL) {
 				free(kv_item);
 				*error_string = "Can't alloc memory";
 
 				return (0);
 			}
 			qb_list_init(&kv_item->list);
 			qb_list_add(&kv_item->list, &data->member_items_head);
 			add_as_string = 0;
 			break;
 		case MAIN_CP_CB_DATA_STATE_NODELIST:
 			break;
 		case MAIN_CP_CB_DATA_STATE_NODELIST_NODE:
 			snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.%s", data->node_number, key);
 			if ((strcmp(key, "nodeid") == 0) ||
 			    (strcmp(key, "quorum_votes") == 0)) {
 				val_type = ICMAP_VALUETYPE_UINT32;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 
 				icmap_set_uint32_r(config_map, key_name, val);
 				add_as_string = 0;
 			}
 
 			if (strcmp(key, "ring0_addr") == 0) {
 				data->ring0_addr_added = 1;
 			}
 
 			if (add_as_string) {
 				icmap_set_string_r(config_map, key_name, value);
 				add_as_string = 0;
 			}
 			break;
 		case MAIN_CP_CB_DATA_STATE_RESOURCES:
 			if (strcmp(key, "watchdog_timeout") == 0) {
 				val_type = ICMAP_VALUETYPE_UINT32;
 				if (safe_atoq(value, &val, val_type) != 0) {
 					goto atoi_error;
 				}
 				icmap_set_uint32_r(config_map,path, val);
 				add_as_string = 0;
 			}
 			break;
 		case MAIN_CP_CB_DATA_STATE_RESOURCES_SYSTEM:
 		case MAIN_CP_CB_DATA_STATE_RESOURCES_SYSTEM_MEMUSED:
 			if (strcmp(key, "poll_period") == 0) {
 				if (str_to_ull(value, &ull) != 0) {
 					goto atoi_error;
 				}
 				icmap_set_uint64_r(config_map,path, ull);
 				add_as_string = 0;
 			}
 			break;
 		case MAIN_CP_CB_DATA_STATE_RESOURCES_PROCESS:
 		case MAIN_CP_CB_DATA_STATE_RESOURCES_PROCESS_MEMUSED:
 			if (strcmp(key, "poll_period") == 0) {
 				if (str_to_ull(value, &ull) != 0) {
 					goto atoi_error;
 				}
 				icmap_set_uint64_r(config_map,path, ull);
 				add_as_string = 0;
 			}
 			break;
 		}
 
 		if (add_as_string) {
 			icmap_set_string_r(config_map, path, value);
 		}
 		break;
 	case PARSER_CB_SECTION_START:
 		if (strcmp(path, "totem.interface") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_INTERFACE;
 			data->linknumber = 0;
 			data->mcastport = -1;
 			data->ttl = -1;
 			data->knet_link_priority = -1;
 			data->knet_ping_interval = -1;
 			data->knet_ping_timeout = -1;
 			data->knet_ping_precision = -1;
+			data->knet_pong_count = -1;
 			qb_list_init(&data->member_items_head);
 		};
 		if (strcmp(path, "totem") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_TOTEM;
 		};
 		if (strcmp(path, "qb") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_QB;
 		}
 		if (strcmp(path, "logging.logger_subsys") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_LOGGER_SUBSYS;
 			qb_list_init(&data->logger_subsys_items_head);
 			data->subsys = NULL;
 		}
 		if (strcmp(path, "logging.logging_daemon") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_LOGGING_DAEMON;
 			qb_list_init(&data->logger_subsys_items_head);
 			data->subsys = NULL;
 			data->logging_daemon_name = NULL;
 		}
 		if (strcmp(path, "uidgid") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_UIDGID;
 		}
 		if (strcmp(path, "totem.interface.member") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_MEMBER;
 		}
 		if (strcmp(path, "quorum") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_QUORUM;
 		}
 		if (strcmp(path, "quorum.device") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_QDEVICE;
 		}
 		if (strcmp(path, "nodelist") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_NODELIST;
 			data->node_number = 0;
 		}
 		if (strcmp(path, "nodelist.node") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_NODELIST_NODE;
 			data->ring0_addr_added = 0;
 		}
 		if (strcmp(path, "resources") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_RESOURCES;
 		}
 		if (strcmp(path, "resources.system") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_RESOURCES_SYSTEM;
 		}
 		if (strcmp(path, "resources.system.memory_used") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_RESOURCES_SYSTEM_MEMUSED;
 		}
 		if (strcmp(path, "resources.process") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_RESOURCES_PROCESS;
 		}
 		if (strcmp(path, "resources.process.memory_used") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_RESOURCES_PROCESS_MEMUSED;
 		}
 		break;
 	case PARSER_CB_SECTION_END:
 		switch (*state) {
 		case MAIN_CP_CB_DATA_STATE_INTERFACE:
 			/*
 			 * Create new interface section
 			 */
 			if (data->bindnetaddr != NULL) {
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.bindnetaddr",
 						data->linknumber);
 				icmap_set_string_r(config_map, key_name, data->bindnetaddr);
 
 				free(data->bindnetaddr);
 				data->bindnetaddr = NULL;
 			}
 
 			if (data->mcastaddr != NULL) {
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.mcastaddr",
 						data->linknumber);
 				icmap_set_string_r(config_map, key_name, data->mcastaddr);
 
 				free(data->mcastaddr);
 				data->mcastaddr = NULL;
 			}
 
 			if (data->broadcast != NULL) {
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.broadcast",
 						data->linknumber);
 				icmap_set_string_r(config_map, key_name, data->broadcast);
 
 				free(data->broadcast);
 				data->broadcast = NULL;
 			}
 
 			if (data->mcastport > -1) {
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.mcastport",
 						data->linknumber);
 				icmap_set_uint16_r(config_map, key_name, data->mcastport);
 			}
 
 			if (data->ttl > -1) {
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.ttl",
 						data->linknumber);
 				icmap_set_uint8_r(config_map, key_name, data->ttl);
 			}
 			if (data->knet_link_priority > -1) {
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.knet_link_priority",
 						data->linknumber);
 				icmap_set_uint8_r(config_map, key_name, data->knet_link_priority);
 			}
 			if (data->knet_ping_interval > -1) {
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.knet_ping_interval",
 						data->linknumber);
 				icmap_set_uint32_r(config_map, key_name, data->knet_ping_interval);
 			}
 			if (data->knet_ping_timeout > -1) {
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.knet_ping_timeout",
 						data->linknumber);
 				icmap_set_uint32_r(config_map, key_name, data->knet_ping_timeout);
 			}
 			if (data->knet_ping_precision > -1) {
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.knet_ping_precision",
 						data->linknumber);
 				icmap_set_uint32_r(config_map, key_name, data->knet_ping_precision);
 			}
+			if (data->knet_pong_count > -1) {
+				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.knet_pong_count",
+						data->linknumber);
+				icmap_set_uint32_r(config_map, key_name, data->knet_pong_count);
+			}
 
 			ii = 0;
 
 			qb_list_for_each_safe(iter, tmp_iter, &(data->member_items_head)) {
 				kv_item = qb_list_entry(iter, struct key_value_list_item, list);
 
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.member.%u",
 						data->linknumber, ii);
 				icmap_set_string_r(config_map, key_name, kv_item->value);
 
 				free(kv_item->value);
 				free(kv_item->key);
 				free(kv_item);
 				ii++;
 			}
 
 			break;
 		case MAIN_CP_CB_DATA_STATE_LOGGER_SUBSYS:
 			if (data->subsys == NULL) {
 				*error_string = "No subsys key in logger_subsys directive";
 
 				return (0);
 			}
 
 			qb_list_for_each_safe(iter, tmp_iter, &(data->logger_subsys_items_head)) {
 				kv_item = qb_list_entry(iter, struct key_value_list_item, list);
 
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "logging.logger_subsys.%s.%s",
 					 data->subsys, kv_item->key);
                                 icmap_set_string_r(config_map, key_name, kv_item->value);
 
 				free(kv_item->value);
 				free(kv_item->key);
 				free(kv_item);
 			}
 
 			snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "logging.logger_subsys.%s.subsys",
 					data->subsys);
 			icmap_set_string_r(config_map, key_name, data->subsys);
 
 			free(data->subsys);
 
 			break;
 		case MAIN_CP_CB_DATA_STATE_LOGGING_DAEMON:
 			if (data->logging_daemon_name == NULL) {
 				*error_string = "No name key in logging_daemon directive";
 
 				return (0);
 			}
 
 			qb_list_for_each_safe(iter, tmp_iter, &(data->logger_subsys_items_head)) {
 				kv_item = qb_list_entry(iter, struct key_value_list_item, list);
 
 				if (data->subsys == NULL) {
 					if (strcmp(data->logging_daemon_name, "corosync") == 0) {
 						snprintf(key_name, ICMAP_KEYNAME_MAXLEN,
 								"logging.%s",
 								kv_item->key);
 					} else {
 						snprintf(key_name, ICMAP_KEYNAME_MAXLEN,
 								"logging.logging_daemon.%s.%s",
 								data->logging_daemon_name, kv_item->key);
 					}
 				} else {
 					if (strcmp(data->logging_daemon_name, "corosync") == 0) {
 						snprintf(key_name, ICMAP_KEYNAME_MAXLEN,
 								"logging.logger_subsys.%s.%s",
 								data->subsys,
 								kv_item->key);
 					} else {
 						snprintf(key_name, ICMAP_KEYNAME_MAXLEN,
 								"logging.logging_daemon.%s.%s.%s",
 								data->logging_daemon_name, data->subsys,
 								kv_item->key);
 					}
 				}
 				icmap_set_string_r(config_map, key_name, kv_item->value);
 
 				free(kv_item->value);
 				free(kv_item->key);
 				free(kv_item);
 			}
 
 			if (data->subsys == NULL) {
 				if (strcmp(data->logging_daemon_name, "corosync") != 0) {
 					snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "logging.logging_daemon.%s.name",
 							data->logging_daemon_name);
 					icmap_set_string_r(config_map, key_name, data->logging_daemon_name);
 				}
 			} else {
 				if (strcmp(data->logging_daemon_name, "corosync") == 0) {
 					snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "logging.logger_subsys.%s.subsys",
 							data->subsys);
 					icmap_set_string_r(config_map, key_name, data->subsys);
 
 				} else {
 					snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "logging.logging_daemon.%s.%s.subsys",
 							data->logging_daemon_name, data->subsys);
 					icmap_set_string_r(config_map, key_name, data->subsys);
 					snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "logging.logging_daemon.%s.%s.name",
 							data->logging_daemon_name, data->subsys);
 					icmap_set_string_r(config_map, key_name, data->logging_daemon_name);
 				}
 			}
 
 			free(data->subsys);
 			free(data->logging_daemon_name);
 
 			break;
 		case MAIN_CP_CB_DATA_STATE_NODELIST_NODE:
 			if (!data->ring0_addr_added) {
 				*error_string = "No ring0_addr specified for node";
 
 				return (0);
 			}
 			data->node_number++;
 			break;
 		case MAIN_CP_CB_DATA_STATE_NORMAL:
 		case MAIN_CP_CB_DATA_STATE_PLOAD:
 		case MAIN_CP_CB_DATA_STATE_UIDGID:
 		case MAIN_CP_CB_DATA_STATE_MEMBER:
 		case MAIN_CP_CB_DATA_STATE_QUORUM:
 		case MAIN_CP_CB_DATA_STATE_QDEVICE:
 		case MAIN_CP_CB_DATA_STATE_NODELIST:
 		case MAIN_CP_CB_DATA_STATE_TOTEM:
 		case MAIN_CP_CB_DATA_STATE_QB:
 			break;
 		case MAIN_CP_CB_DATA_STATE_RESOURCES:
 			*state = MAIN_CP_CB_DATA_STATE_NORMAL;
 			break;
 		case MAIN_CP_CB_DATA_STATE_RESOURCES_SYSTEM:
 			*state = MAIN_CP_CB_DATA_STATE_RESOURCES;
 			break;
 		case MAIN_CP_CB_DATA_STATE_RESOURCES_SYSTEM_MEMUSED:
 			*state = MAIN_CP_CB_DATA_STATE_RESOURCES_SYSTEM;
 			break;
 		case MAIN_CP_CB_DATA_STATE_RESOURCES_PROCESS:
 			*state = MAIN_CP_CB_DATA_STATE_RESOURCES;
 			break;
 		case MAIN_CP_CB_DATA_STATE_RESOURCES_PROCESS_MEMUSED:
 			*state = MAIN_CP_CB_DATA_STATE_RESOURCES_PROCESS;
 			break;
 		}
 		break;
 	}
 
 	return (1);
 
 atoi_error:
 	min_val = max_val = 0;
 	/*
 	 * This is really assert, because developer ether doesn't set val_type correctly or
 	 * we've got here after some nasty memory overwrite
 	 */
 	assert(safe_atoq_range(val_type, &min_val, &max_val) == 0);
 
 	snprintf(formated_err, sizeof(formated_err),
 	    "Value of key \"%s\" is expected to be integer in range (%lld..%lld), but \"%s\" was given",
 	    key, min_val, max_val, value);
 	*error_string = formated_err;
 
 	return (0);
 }
 
 static int uidgid_config_parser_cb(const char *path,
 			char *key,
 			char *value,
 			enum main_cp_cb_data_state *state,
 			enum parser_cb_type type,
 			const char **error_string,
 			icmap_map_t config_map,
 			void *user_data)
 {
 	char key_name[ICMAP_KEYNAME_MAXLEN];
 	int uid, gid;
 
 	switch (type) {
 	case PARSER_CB_START:
 		break;
 	case PARSER_CB_END:
 		break;
 	case PARSER_CB_ITEM:
 		if (strcmp(path, "uidgid.uid") == 0) {
 			uid = uid_determine(value);
 			if (uid == -1) {
 				*error_string = error_string_response;
 				return (0);
 			}
 			snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "uidgid.config.uid.%u",
 					uid);
 			icmap_set_uint8_r(config_map, key_name, 1);
 		} else if (strcmp(path, "uidgid.gid") == 0) {
 			gid = gid_determine(value);
 			if (gid == -1) {
 				*error_string = error_string_response;
 				return (0);
 			}
 			snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "uidgid.config.gid.%u",
 					gid);
 			icmap_set_uint8_r(config_map, key_name, 1);
 		} else {
 			*error_string = "uidgid: Only uid and gid are allowed items";
 			return (0);
 		}
 		break;
 	case PARSER_CB_SECTION_START:
 		if (strcmp(path, "uidgid") != 0) {
 			*error_string = "uidgid: Can't add subsection different than uidgid";
 			return (0);
 		};
 		break;
 	case PARSER_CB_SECTION_END:
 		break;
 	}
 
 	return (1);
 }
 
 static int read_uidgid_files_into_icmap(
 	const char **error_string,
 	icmap_map_t config_map)
 {
 	FILE *fp;
 	const char *dirname;
 	DIR *dp;
 	struct dirent *dirent;
 	struct dirent *entry;
 	char filename[PATH_MAX + FILENAME_MAX + 1];
 	int res = 0;
 	size_t len;
 	int return_code;
 	struct stat stat_buf;
 	enum main_cp_cb_data_state state = MAIN_CP_CB_DATA_STATE_NORMAL;
 	char key_name[ICMAP_KEYNAME_MAXLEN];
 
 	dirname = COROSYSCONFDIR "/uidgid.d";
 	dp = opendir (dirname);
 
 	if (dp == NULL)
 		return 0;
 
 	len = offsetof(struct dirent, d_name) + FILENAME_MAX + 1;
 
 	entry = malloc(len);
 	if (entry == NULL) {
 		res = 0;
 		goto error_exit;
 	}
 
 	for (return_code = readdir_r(dp, entry, &dirent);
 		dirent != NULL && return_code == 0;
 		return_code = readdir_r(dp, entry, &dirent)) {
 
 		snprintf(filename, sizeof (filename), "%s/%s", dirname, dirent->d_name);
 		res = stat (filename, &stat_buf);
 		if (res == 0 && S_ISREG(stat_buf.st_mode)) {
 
 			fp = fopen (filename, "r");
 			if (fp == NULL) continue;
 
 			key_name[0] = 0;
 
 			res = parse_section(fp, key_name, error_string, 0, state, uidgid_config_parser_cb, config_map, NULL);
 
 			fclose (fp);
 
 			if (res != 0) {
 				goto error_exit;
 			}
 		}
 	}
 
 error_exit:
 	free (entry);
 	closedir(dp);
 
 	return res;
 }
 
 /* Read config file and load into icmap */
 static int read_config_file_into_icmap(
 	const char **error_string,
 	icmap_map_t config_map)
 {
 	FILE *fp;
 	const char *filename;
 	char *error_reason = error_string_response;
 	int res;
 	char key_name[ICMAP_KEYNAME_MAXLEN];
 	struct main_cp_cb_data data;
 	enum main_cp_cb_data_state state = MAIN_CP_CB_DATA_STATE_NORMAL;
 
 	filename = getenv ("COROSYNC_MAIN_CONFIG_FILE");
 	if (!filename)
 		filename = COROSYSCONFDIR "/corosync.conf";
 
 	fp = fopen (filename, "r");
 	if (fp == NULL) {
 		char error_str[100];
 		const char *error_ptr = qb_strerror_r(errno, error_str, sizeof(error_str));
 		snprintf (error_reason, sizeof(error_string_response),
 			"Can't read file %s reason = (%s)",
 			 filename, error_ptr);
 		*error_string = error_reason;
 		return -1;
 	}
 
 	key_name[0] = 0;
 
 	res = parse_section(fp, key_name, error_string, 0, state, main_config_parser_cb, config_map, &data);
 
 	fclose(fp);
 
 	if (res == 0) {
 	        res = read_uidgid_files_into_icmap(error_string, config_map);
 	}
 
 	if (res == 0) {
 		snprintf (error_reason, sizeof(error_string_response),
 			"Successfully read main configuration file '%s'.", filename);
 		*error_string = error_reason;
 	}
 
 	return res;
 }
diff --git a/exec/totemconfig.c b/exec/totemconfig.c
index 5fce2e62..3f0c262a 100644
--- a/exec/totemconfig.c
+++ b/exec/totemconfig.c
@@ -1,1653 +1,1663 @@
 /*
  * Copyright (c) 2002-2005 MontaVista Software, Inc.
  * Copyright (c) 2006-2013 Red Hat, Inc.
  *
  * All rights reserved.
  *
  * Author: Steven Dake (sdake@redhat.com)
  *         Jan Friesse (jfriesse@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 <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <unistd.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <sys/param.h>
 
 #include <corosync/swab.h>
 #include <qb/qblist.h>
 #include <qb/qbdefs.h>
 #include <corosync/totem/totem.h>
 #include <corosync/config.h>
 #include <corosync/logsys.h>
 #include <corosync/icmap.h>
 
 #include "util.h"
 #include "totemconfig.h"
 
 #define TOKEN_RETRANSMITS_BEFORE_LOSS_CONST	4
 #define TOKEN_TIMEOUT				1000
 #define TOKEN_COEFFICIENT			650
 #define JOIN_TIMEOUT				50
 #define MERGE_TIMEOUT				200
 #define DOWNCHECK_TIMEOUT			1000
 #define FAIL_TO_RECV_CONST			2500
 #define	SEQNO_UNCHANGED_CONST			30
 #define MINIMUM_TIMEOUT				(int)(1000/HZ)*3
 #define MAX_NETWORK_DELAY			50
 #define WINDOW_SIZE				50
 #define MAX_MESSAGES				17
 #define MISS_COUNT_CONST			5
 
 /* These currently match the defaults in libknet.h */
 #define KNET_PING_INTERVAL                      1000
 #define KNET_PING_TIMEOUT                       2000
 #define KNET_PING_PRECISION                     2048
+#define KNET_PONG_COUNT                         5
+#define KNET_PMTUD_INTERVAL                     30
 
 #define DEFAULT_PORT				5405
 
 static char error_string_response[512];
 
 static void add_totem_config_notification(struct totem_config *totem_config);
 
 
 /* All the volatile parameters are uint32s, luckily */
 static uint32_t *totem_get_param_by_name(struct totem_config *totem_config, const char *param_name)
 {
 	if (strcmp(param_name, "totem.token") == 0)
 		return &totem_config->token_timeout;
 	if (strcmp(param_name, "totem.token_retransmit") == 0)
 		return &totem_config->token_retransmit_timeout;
 	if (strcmp(param_name, "totem.hold") == 0)
 		return &totem_config->token_hold_timeout;
 	if (strcmp(param_name, "totem.token_retransmits_before_loss_const") == 0)
 		return &totem_config->token_retransmits_before_loss_const;
 	if (strcmp(param_name, "totem.join") == 0)
 		return &totem_config->join_timeout;
 	if (strcmp(param_name, "totem.send_join") == 0)
 		return &totem_config->send_join_timeout;
 	if (strcmp(param_name, "totem.consensus") == 0)
 		return &totem_config->consensus_timeout;
 	if (strcmp(param_name, "totem.merge") == 0)
 		return &totem_config->merge_timeout;
 	if (strcmp(param_name, "totem.downcheck") == 0)
 		return &totem_config->downcheck_timeout;
 	if (strcmp(param_name, "totem.fail_recv_const") == 0)
 		return &totem_config->fail_to_recv_const;
 	if (strcmp(param_name, "totem.seqno_unchanged_const") == 0)
 		return &totem_config->seqno_unchanged_const;
 	if (strcmp(param_name, "totem.heartbeat_failures_allowed") == 0)
 		return &totem_config->heartbeat_failures_allowed;
 	if (strcmp(param_name, "totem.max_network_delay") == 0)
 		return &totem_config->max_network_delay;
 	if (strcmp(param_name, "totem.window_size") == 0)
 		return &totem_config->window_size;
 	if (strcmp(param_name, "totem.max_messages") == 0)
 		return &totem_config->max_messages;
 	if (strcmp(param_name, "totem.miss_count_const") == 0)
 		return &totem_config->miss_count_const;
+	if (strcmp(param_name, "totem.knet_pmtud_interval") == 0)
+		return &totem_config->knet_pmtud_interval;
 
 	return NULL;
 }
 
 /*
  * Read key_name from icmap. If key is not found or key_name == delete_key or if allow_zero is false
  * and readed value is zero, default value is used and stored into totem_config.
  */
 static void totem_volatile_config_set_value (struct totem_config *totem_config,
 	const char *key_name, const char *deleted_key, unsigned int default_value,
 	int allow_zero_value)
 {
 	char runtime_key_name[ICMAP_KEYNAME_MAXLEN];
 
 	if (icmap_get_uint32(key_name, totem_get_param_by_name(totem_config, key_name)) != CS_OK ||
 	    (deleted_key != NULL && strcmp(deleted_key, key_name) == 0) ||
 	    (!allow_zero_value && *totem_get_param_by_name(totem_config, key_name) == 0)) {
 		*totem_get_param_by_name(totem_config, key_name) = default_value;
 	}
 
 	/*
 	 * Store totem_config value to cmap runtime section
 	 */
 	if (strlen("runtime.config.") + strlen(key_name) >= ICMAP_KEYNAME_MAXLEN) {
 		/*
 		 * This shouldn't happen
 		 */
 		return ;
 	}
 
 	strcpy(runtime_key_name, "runtime.config.");
 	strcat(runtime_key_name, key_name);
 
 	icmap_set_uint32(runtime_key_name, *totem_get_param_by_name(totem_config, key_name));
 }
 
 
 /*
  * Read and validate config values from cmap and store them into totem_config. If key doesn't exists,
  * default value is stored. deleted_key is name of key beeing processed by delete operation
  * from cmap. It is considered as non existing even if it can be read. Can be NULL.
  */
 static void totem_volatile_config_read (struct totem_config *totem_config, const char *deleted_key)
 {
 	uint32_t u32;
 
 	totem_volatile_config_set_value(totem_config, "totem.token_retransmits_before_loss_const", deleted_key,
 	    TOKEN_RETRANSMITS_BEFORE_LOSS_CONST, 0);
 
 	totem_volatile_config_set_value(totem_config, "totem.token", deleted_key, TOKEN_TIMEOUT, 0);
 
 	if (totem_config->interface_count > 0 && totem_config->interfaces[0].member_count > 2) {
 		u32 = TOKEN_COEFFICIENT;
 		icmap_get_uint32("totem.token_coefficient", &u32);
 		totem_config->token_timeout += (totem_config->interfaces[0].member_count - 2) * u32;
 
 		/*
 		 * Store totem_config value to cmap runtime section
 		 */
 		icmap_set_uint32("runtime.config.totem.token", totem_config->token_timeout);
 	}
 
 	totem_volatile_config_set_value(totem_config, "totem.max_network_delay", deleted_key, MAX_NETWORK_DELAY, 0);
 
 	totem_volatile_config_set_value(totem_config, "totem.window_size", deleted_key, WINDOW_SIZE, 0);
 
 	totem_volatile_config_set_value(totem_config, "totem.max_messages", deleted_key, MAX_MESSAGES, 0);
 
 	totem_volatile_config_set_value(totem_config, "totem.miss_count_const", deleted_key, MISS_COUNT_CONST, 0);
+	totem_volatile_config_set_value(totem_config, "totem.knet_pmtud_interval", deleted_key, KNET_PMTUD_INTERVAL, 0);
 
 	totem_volatile_config_set_value(totem_config, "totem.token_retransmit", deleted_key,
 	   (int)(totem_config->token_timeout / (totem_config->token_retransmits_before_loss_const + 0.2)), 0);
 
 	totem_volatile_config_set_value(totem_config, "totem.hold", deleted_key,
 	    (int)(totem_config->token_retransmit_timeout * 0.8 - (1000/HZ)), 0);
 
 	totem_volatile_config_set_value(totem_config, "totem.join", deleted_key, JOIN_TIMEOUT, 0);
 
 	totem_volatile_config_set_value(totem_config, "totem.consensus", deleted_key,
 	    (int)(float)(1.2 * totem_config->token_timeout), 0);
 
 	totem_volatile_config_set_value(totem_config, "totem.merge", deleted_key, MERGE_TIMEOUT, 0);
 
 	totem_volatile_config_set_value(totem_config, "totem.downcheck", deleted_key, DOWNCHECK_TIMEOUT, 0);
 
 	totem_volatile_config_set_value(totem_config, "totem.fail_recv_const", deleted_key, FAIL_TO_RECV_CONST, 0);
 
 	totem_volatile_config_set_value(totem_config, "totem.seqno_unchanged_const", deleted_key,
 	    SEQNO_UNCHANGED_CONST, 0);
 
 	totem_volatile_config_set_value(totem_config, "totem.send_join", deleted_key, 0, 1);
 
 	totem_volatile_config_set_value(totem_config, "totem.heartbeat_failures_allowed", deleted_key, 0, 1);
 }
 
 static int totem_volatile_config_validate (
 	struct totem_config *totem_config,
 	const char **error_string)
 {
 	static char local_error_reason[512];
 	const char *error_reason = local_error_reason;
 
 	if (totem_config->max_network_delay < MINIMUM_TIMEOUT) {
 		snprintf (local_error_reason, sizeof(local_error_reason),
 			"The max_network_delay parameter (%d ms) may not be less than (%d ms).",
 			totem_config->max_network_delay, MINIMUM_TIMEOUT);
 		goto parse_error;
 	}
 
 	if (totem_config->token_timeout < MINIMUM_TIMEOUT) {
 		snprintf (local_error_reason, sizeof(local_error_reason),
 			"The token timeout parameter (%d ms) may not be less than (%d ms).",
 			totem_config->token_timeout, MINIMUM_TIMEOUT);
 		goto parse_error;
 	}
 
 	if (totem_config->token_retransmit_timeout < MINIMUM_TIMEOUT) {
 		snprintf (local_error_reason, sizeof(local_error_reason),
 			"The token retransmit timeout parameter (%d ms) may not be less than (%d ms).",
 			totem_config->token_retransmit_timeout, MINIMUM_TIMEOUT);
 		goto parse_error;
 	}
 
 	if (totem_config->token_hold_timeout < MINIMUM_TIMEOUT) {
 		snprintf (local_error_reason, sizeof(local_error_reason),
 			"The token hold timeout parameter (%d ms) may not be less than (%d ms).",
 			totem_config->token_hold_timeout, MINIMUM_TIMEOUT);
 		goto parse_error;
 	}
 
 	if (totem_config->join_timeout < MINIMUM_TIMEOUT) {
 		snprintf (local_error_reason, sizeof(local_error_reason),
 			"The join timeout parameter (%d ms) may not be less than (%d ms).",
 			totem_config->join_timeout, MINIMUM_TIMEOUT);
 		goto parse_error;
 	}
 
 	if (totem_config->consensus_timeout < MINIMUM_TIMEOUT) {
 		snprintf (local_error_reason, sizeof(local_error_reason),
 			"The consensus timeout parameter (%d ms) may not be less than (%d ms).",
 			totem_config->consensus_timeout, MINIMUM_TIMEOUT);
 		goto parse_error;
 	}
 
 	if (totem_config->consensus_timeout < totem_config->join_timeout) {
 		snprintf (local_error_reason, sizeof(local_error_reason),
 			"The consensus timeout parameter (%d ms) may not be less than join timeout (%d ms).",
 			totem_config->consensus_timeout, totem_config->join_timeout);
 		goto parse_error;
 	}
 
 	if (totem_config->merge_timeout < MINIMUM_TIMEOUT) {
 		snprintf (local_error_reason, sizeof(local_error_reason),
 			"The merge timeout parameter (%d ms) may not be less than (%d ms).",
 			totem_config->merge_timeout, MINIMUM_TIMEOUT);
 		goto parse_error;
 	}
 
 	if (totem_config->downcheck_timeout < MINIMUM_TIMEOUT) {
 		snprintf (local_error_reason, sizeof(local_error_reason),
 			"The downcheck timeout parameter (%d ms) may not be less than (%d ms).",
 			totem_config->downcheck_timeout, MINIMUM_TIMEOUT);
 		goto parse_error;
 	}
 
 	return 0;
 
 parse_error:
 	snprintf (error_string_response, sizeof(error_string_response),
 		 "parse error in config: %s\n", error_reason);
 	*error_string = error_string_response;
 	return (-1);
 
 }
 
 static int totem_get_crypto(struct totem_config *totem_config)
 {
 	char *str;
 	const char *tmp_cipher;
 	const char *tmp_hash;
 
 	tmp_hash = "none";
 	tmp_cipher = "none";
 
 	if (icmap_get_string("totem.crypto_cipher", &str) == CS_OK) {
 		if (strcmp(str, "none") == 0) {
 			tmp_cipher = "none";
 		}
 		if (strcmp(str, "aes256") == 0) {
 			tmp_cipher = "aes256";
 		}
 		if (strcmp(str, "aes192") == 0) {
 			tmp_cipher = "aes192";
 		}
 		if (strcmp(str, "aes128") == 0) {
 			tmp_cipher = "aes128";
 		}
 		if (strcmp(str, "aes256") == 0) {
 			tmp_cipher = "aes256";
 		}
 		if (strcmp(str, "3des") == 0) {
 			tmp_cipher = "3des";
 		}
 		free(str);
 	}
 
 	if (icmap_get_string("totem.crypto_hash", &str) == CS_OK) {
 		if (strcmp(str, "none") == 0) {
 			tmp_hash = "none";
 		}
 		if (strcmp(str, "md5") == 0) {
 			tmp_hash = "md5";
 		}
 		if (strcmp(str, "sha1") == 0) {
 			tmp_hash = "sha1";
 		}
 		if (strcmp(str, "sha256") == 0) {
 			tmp_hash = "sha256";
 		}
 		if (strcmp(str, "sha384") == 0) {
 			tmp_hash = "sha384";
 		}
 		if (strcmp(str, "sha512") == 0) {
 			tmp_hash = "sha512";
 		}
 		free(str);
 	}
 
 	if ((strcmp(tmp_cipher, "none") != 0) &&
 	    (strcmp(tmp_hash, "none") == 0)) {
 		return -1;
 	}
 
 	free(totem_config->crypto_cipher_type);
 	free(totem_config->crypto_hash_type);
 
 	totem_config->crypto_cipher_type = strdup(tmp_cipher);
 	totem_config->crypto_hash_type = strdup(tmp_hash);
 
 	return 0;
 }
 
 static int totem_config_get_ip_version(void)
 {
 	int res;
 	char *str;
 
 	res = AF_INET;
 	if (icmap_get_string("totem.ip_version", &str) == CS_OK) {
 		if (strcmp(str, "ipv4") == 0) {
 			res = AF_INET;
 		}
 		if (strcmp(str, "ipv6") == 0) {
 			res = AF_INET6;
 		}
 		free(str);
 	}
 
 	return (res);
 }
 
 static uint16_t generate_cluster_id (const char *cluster_name)
 {
 	int i;
 	int value = 0;
 
 	for (i = 0; i < strlen(cluster_name); i++) {
 		value <<= 1;
 		value += cluster_name[i];
 	}
 
 	return (value & 0xFFFF);
 }
 
 static int get_cluster_mcast_addr (
 		const char *cluster_name,
 		unsigned int linknumber,
 		int ip_version,
 		struct totem_ip_address *res)
 {
 	uint16_t clusterid;
 	char addr[INET6_ADDRSTRLEN + 1];
 	int err;
 
 	if (cluster_name == NULL) {
 		return (-1);
 	}
 
 	clusterid = generate_cluster_id(cluster_name) + linknumber;
 	memset (res, 0, sizeof(*res));
 
 	switch (ip_version) {
 	case AF_INET:
 		snprintf(addr, sizeof(addr), "239.192.%d.%d", clusterid >> 8, clusterid % 0xFF);
 		break;
 	case AF_INET6:
 		snprintf(addr, sizeof(addr), "ff15::%x", clusterid);
 		break;
 	default:
 		/*
 		 * Unknown family
 		 */
 		return (-1);
 	}
 
 	err = totemip_parse (res, addr, ip_version);
 
 	return (err);
 }
 
 static unsigned int generate_nodeid_for_duplicate_test(
 	struct totem_config *totem_config,
 	char *addr)
 {
 	unsigned int nodeid;
 	struct totem_ip_address totemip;
 
 	/* AF_INET hard-coded here because auto-generated nodeids
 	   are only for IPv4 */
 	if (totemip_parse(&totemip, addr, AF_INET) != 0)
 		return -1;
 
 	memcpy (&nodeid, &totemip.addr, sizeof (unsigned int));
 
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 	nodeid = swab32 (nodeid);
 #endif
 
 	if (totem_config->clear_node_high_bit) {
 		nodeid &= 0x7FFFFFFF;
 	}
 	return nodeid;
 }
 
 static int check_for_duplicate_nodeids(
 	struct totem_config *totem_config,
 	const char **error_string)
 {
 	icmap_iter_t iter;
 	icmap_iter_t subiter;
 	const char *iter_key;
 	int res = 0;
 	int retval = 0;
 	char tmp_key[ICMAP_KEYNAME_MAXLEN];
 	char *ring0_addr=NULL;
 	char *ring0_addr1=NULL;
 	unsigned int node_pos;
 	unsigned int node_pos1;
 	unsigned int nodeid;
 	unsigned int nodeid1;
 	int autogenerated;
 
 	iter = icmap_iter_init("nodelist.node.");
 	while ((iter_key = icmap_iter_next(iter, NULL, NULL)) != NULL) {
 		res = sscanf(iter_key, "nodelist.node.%u.%s", &node_pos, tmp_key);
 		if (res != 2) {
 			continue;
 		}
 
 		if (strcmp(tmp_key, "ring0_addr") != 0) {
 			continue;
 		}
 
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.nodeid", node_pos);
 		autogenerated = 0;
 		if (icmap_get_uint32(tmp_key, &nodeid) != CS_OK) {
 
 			snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.ring0_addr", node_pos);
 			if (icmap_get_string(tmp_key, &ring0_addr) != CS_OK) {
 				continue;
 			}
 
 			/* Generate nodeid so we can check that auto-generated nodeids don't clash either */
 			nodeid = generate_nodeid_for_duplicate_test(totem_config, ring0_addr);
 			if (nodeid == -1) {
 				continue;
 			}
 			autogenerated = 1;
 		}
 
 		node_pos1 = 0;
 		subiter = icmap_iter_init("nodelist.node.");
 		while (((iter_key = icmap_iter_next(subiter, NULL, NULL)) != NULL) && (node_pos1 < node_pos)) {
 			res = sscanf(iter_key, "nodelist.node.%u.%s", &node_pos1, tmp_key);
 			if ((res != 2) || (node_pos1 >= node_pos)) {
 				continue;
 			}
 
 			if (strcmp(tmp_key, "ring0_addr") != 0) {
 				continue;
 			}
 
 			snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.nodeid", node_pos1);
 			if (icmap_get_uint32(tmp_key, &nodeid1) != CS_OK) {
 
 				snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.ring0_addr", node_pos1);
 				if (icmap_get_string(tmp_key, &ring0_addr1) != CS_OK) {
 					continue;
 				}
 				nodeid1 = generate_nodeid_for_duplicate_test(totem_config, ring0_addr1);
 				if (nodeid1 == -1) {
 					continue;
 				}
 			}
 
 			if (nodeid == nodeid1) {
 				retval = -1;
 				snprintf (error_string_response, sizeof(error_string_response),
 					  "Nodeid %u%s%s%s appears twice in corosync.conf", nodeid,
 					  autogenerated?"(autogenerated from ":"",
 					  autogenerated?ring0_addr:"",
 					  autogenerated?")":"");
 				log_printf (LOGSYS_LEVEL_ERROR, error_string_response);
 				*error_string = error_string_response;
 				break;
 			}
 		}
 		icmap_iter_finalize(subiter);
 	}
 	icmap_iter_finalize(iter);
 	return retval;
 }
 
 
 static int find_local_node_in_nodelist(struct totem_config *totem_config)
 {
 	icmap_iter_t iter;
 	const char *iter_key;
 	int res = 0;
 	unsigned int node_pos;
 	int local_node_pos = -1;
 	struct totem_ip_address bind_addr;
 	int interface_up, interface_num;
 	char tmp_key[ICMAP_KEYNAME_MAXLEN];
 	char *node_addr_str;
 	struct totem_ip_address node_addr;
 
 	res = totemip_iface_check(&totem_config->interfaces[0].bindnet,
 		&bind_addr, &interface_up, &interface_num,
 		totem_config->clear_node_high_bit);
 	if (res == -1) {
 		return (-1);
 	}
 
 	iter = icmap_iter_init("nodelist.node.");
 	while ((iter_key = icmap_iter_next(iter, NULL, NULL)) != NULL) {
 		res = sscanf(iter_key, "nodelist.node.%u.%s", &node_pos, tmp_key);
 		if (res != 2) {
 			continue;
 		}
 
 		if (strcmp(tmp_key, "ring0_addr") != 0) {
 			continue;
 		}
 
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.ring0_addr", node_pos);
 		if (icmap_get_string(tmp_key, &node_addr_str) != CS_OK) {
 			continue;
 		}
 
 		res = totemip_parse (&node_addr, node_addr_str, totem_config->ip_version);
 		free(node_addr_str);
 		if (res == -1) {
 			continue ;
 		}
 
 		if (totemip_equal(&bind_addr, &node_addr)) {
 			local_node_pos = node_pos;
 		}
 	}
 	icmap_iter_finalize(iter);
 
 	return (local_node_pos);
 }
 
 /*
  * Compute difference between two set of totem interface arrays. set1 and set2
  * are changed so for same ring, ip existing in both set1 and set2 are cleared
  * (set to 0), and ips which are only in set1 or set2 remains untouched.
  * totempg_node_add/remove is called.
  */
 static void compute_interfaces_diff(int interface_count,
 	struct totem_interface *set1,
 	struct totem_interface *set2)
 {
 	int ring_no, set1_pos, set2_pos;
 	struct totem_ip_address empty_ip_address;
 
 	memset(&empty_ip_address, 0, sizeof(empty_ip_address));
 
 	for (ring_no = 0; ring_no < interface_count; ring_no++) {
 		for (set1_pos = 0; set1_pos < set1[ring_no].member_count; set1_pos++) {
 			for (set2_pos = 0; set2_pos < set2[ring_no].member_count; set2_pos++) {
 				/*
 				 * For current ring_no remove all set1 items existing
 				 * in set2
 				 */
 				if (memcmp(&set1[ring_no].member_list[set1_pos],
 				    &set2[ring_no].member_list[set2_pos],
 				    sizeof(struct totem_ip_address)) == 0) {
 					memset(&set1[ring_no].member_list[set1_pos], 0,
 					    sizeof(struct totem_ip_address));
 					memset(&set2[ring_no].member_list[set2_pos], 0,
 					    sizeof(struct totem_ip_address));
 				}
 			}
 		}
 	}
 
 	for (ring_no = 0; ring_no < interface_count; ring_no++) {
 		for (set1_pos = 0; set1_pos < set1[ring_no].member_count; set1_pos++) {
 			/*
 			 * All items which remained in set1 doesn't exists in set2 any longer so
 			 * node has to be removed.
 			 */
 			if (memcmp(&set1[ring_no].member_list[set1_pos], &empty_ip_address, sizeof(empty_ip_address)) != 0) {
 				log_printf(LOGSYS_LEVEL_DEBUG,
 					"removing dynamic member %s for ring %u",
 					totemip_print(&set1[ring_no].member_list[set1_pos]),
 					ring_no);
 
 				totempg_member_remove(&set1[ring_no].member_list[set1_pos], ring_no);
 			}
 		}
 		for (set2_pos = 0; set2_pos < set2[ring_no].member_count; set2_pos++) {
 			/*
 			 * All items which remained in set2 doesn't existed in set1 so this is no node
 			 * and has to be added.
 			 */
 			if (memcmp(&set2[ring_no].member_list[set2_pos], &empty_ip_address, sizeof(empty_ip_address)) != 0) {
 				log_printf(LOGSYS_LEVEL_DEBUG,
 					"adding dynamic member %s for ring %u",
 					totemip_print(&set2[ring_no].member_list[set2_pos]),
 					ring_no);
 
 				totempg_member_add(&set2[ring_no].member_list[set2_pos], ring_no);
 			}
 		}
 	}
 }
 
 static void put_nodelist_members_to_config(struct totem_config *totem_config, int reload)
 {
 	icmap_iter_t iter, iter2;
 	const char *iter_key, *iter_key2;
 	int res = 0;
 	unsigned int node_pos;
 	char tmp_key[ICMAP_KEYNAME_MAXLEN];
 	char tmp_key2[ICMAP_KEYNAME_MAXLEN];
 	char *node_addr_str;
 	int member_count;
 	unsigned int linknumber = 0;
 	int i, j;
 	struct totem_interface *orig_interfaces = NULL;
 	struct totem_interface *new_interfaces = NULL;
 
 	if (reload) {
 		/*
 		 * We need to compute diff only for reload. Also for initial configuration
 		 * not all totem structures are initialized so corosync will crash during
 		 * member_add/remove
 		 */
 		orig_interfaces = malloc (sizeof (struct totem_interface) * INTERFACE_MAX);
 		assert(orig_interfaces != NULL);
 		new_interfaces = malloc (sizeof (struct totem_interface) * INTERFACE_MAX);
 		assert(new_interfaces != NULL);
 
 		memcpy(orig_interfaces, totem_config->interfaces, sizeof (struct totem_interface) * INTERFACE_MAX);
 	}
 
 	/* Clear out nodelist so we can put the new one in if needed */
 	for (i = 0; i < totem_config->interface_count; i++) {
 		for (j = 0; j < PROCESSOR_COUNT_MAX; j++) {
 			memset(&totem_config->interfaces[i].member_list[j], 0, sizeof(struct totem_ip_address));
 		}
 		totem_config->interfaces[i].member_count = 0;
 	}
 
 	iter = icmap_iter_init("nodelist.node.");
 	while ((iter_key = icmap_iter_next(iter, NULL, NULL)) != NULL) {
 		res = sscanf(iter_key, "nodelist.node.%u.%s", &node_pos, tmp_key);
 		if (res != 2) {
 			continue;
 		}
 
 		if (strcmp(tmp_key, "ring0_addr") != 0) {
 			continue;
 		}
 
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.", node_pos);
 		iter2 = icmap_iter_init(tmp_key);
 		while ((iter_key2 = icmap_iter_next(iter2, NULL, NULL)) != NULL) {
 			unsigned int nodeid;
 
 			snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.nodeid", node_pos);
 			if (icmap_get_uint32(tmp_key, &nodeid) != CS_OK) {
 			}
 
 			res = sscanf(iter_key2, "nodelist.node.%u.ring%u%s", &node_pos, &linknumber, tmp_key2);
 			if (res != 3 || strcmp(tmp_key2, "_addr") != 0) {
 				continue;
 			}
 
 			if (icmap_get_string(iter_key2, &node_addr_str) != CS_OK) {
 				continue;
 			}
 
 			member_count = totem_config->interfaces[linknumber].member_count;
 
 			res = totemip_parse(&totem_config->interfaces[linknumber].member_list[member_count],
 						node_addr_str, totem_config->ip_version);
 			if (res != -1) {
 				totem_config->interfaces[linknumber].member_list[member_count].nodeid = nodeid;
 				totem_config->interfaces[linknumber].member_count++;
 			}
 			free(node_addr_str);
 		}
 
 		icmap_iter_finalize(iter2);
 	}
 
 	icmap_iter_finalize(iter);
 
 	if (reload) {
 		memcpy(new_interfaces, totem_config->interfaces, sizeof (struct totem_interface) * INTERFACE_MAX);
 
 		compute_interfaces_diff(totem_config->interface_count, orig_interfaces, new_interfaces);
 
 		free(new_interfaces);
 		free(orig_interfaces);
 	}
 }
 
 static void nodelist_dynamic_notify(
 	int32_t event,
 	const char *key_name,
 	struct icmap_notify_value new_val,
 	struct icmap_notify_value old_val,
 	void *user_data)
 {
 	int res;
 	unsigned int ring_no;
 	unsigned int member_no;
 	char tmp_str[ICMAP_KEYNAME_MAXLEN];
 	uint8_t reloading;
 	struct totem_config *totem_config = (struct totem_config *)user_data;
 
 	/*
 	* If a full reload is in progress then don't do anything until it's done and
 	* can reconfigure it all atomically
 	*/
 	if (icmap_get_uint8("config.totemconfig_reload_in_progress", &reloading) == CS_OK && reloading) {
 		return ;
 	}
 
 	res = sscanf(key_name, "nodelist.node.%u.ring%u%s", &member_no, &ring_no, tmp_str);
 	if (res != 3)
 		return ;
 
 	if (strcmp(tmp_str, "_addr") != 0) {
 		return;
 	}
 
 	put_nodelist_members_to_config(totem_config, 1);
 }
 
 
 /*
  * Tries to find node (node_pos) in config nodelist which address matches any
  * local interface. Address can be stored in ring0_addr or if ipaddr_key_prefix is not NULL
  * key with prefix ipaddr_key is used (there can be multiuple of them)
  * This function differs  * from find_local_node_in_nodelist because it doesn't need bindnetaddr,
  * but doesn't work when bind addr is network address (so IP must be exact
  * match).
  *
  * Returns 1 on success (address was found, node_pos is then correctly set) or 0 on failure.
  */
 int totem_config_find_local_addr_in_nodelist(const char *ipaddr_key_prefix, unsigned int *node_pos)
 {
 	struct qb_list_head addrs;
 	struct totem_ip_if_address *if_addr;
 	icmap_iter_t iter, iter2;
 	const char *iter_key, *iter_key2;
 	struct qb_list_head *list;
 	const char *ipaddr_key;
 	int ip_version;
 	struct totem_ip_address node_addr;
 	char *node_addr_str;
 	int node_found = 0;
 	int res = 0;
 	char tmp_key[ICMAP_KEYNAME_MAXLEN];
 
 	if (totemip_getifaddrs(&addrs) == -1) {
 		return 0;
 	}
 
 	ip_version = totem_config_get_ip_version();
 
 	iter = icmap_iter_init("nodelist.node.");
 
 	while ((iter_key = icmap_iter_next(iter, NULL, NULL)) != NULL) {
 		res = sscanf(iter_key, "nodelist.node.%u.%s", node_pos, tmp_key);
 		if (res != 2) {
 			continue;
 		}
 
 		if (strcmp(tmp_key, "ring0_addr") != 0) {
 			continue;
 		}
 
 		if (icmap_get_string(iter_key, &node_addr_str) != CS_OK) {
 			continue ;
 		}
 
 		free(node_addr_str);
 
 		/*
 		 * ring0_addr found -> let's iterate thru ipaddr_key_prefix
 		 */
 		snprintf(tmp_key, sizeof(tmp_key), "nodelist.node.%u.%s", *node_pos,
 		    (ipaddr_key_prefix != NULL ? ipaddr_key_prefix : "ring0_addr"));
 
 		iter2 = icmap_iter_init(tmp_key);
 		while ((iter_key2 = icmap_iter_next(iter2, NULL, NULL)) != NULL) {
 			/*
 			 * ring0_addr must be exact match, not prefix
 			 */
 			ipaddr_key = (ipaddr_key_prefix != NULL ? iter_key2 : tmp_key);
 			if (icmap_get_string(ipaddr_key, &node_addr_str) != CS_OK) {
 				continue ;
 			}
 
 			if (totemip_parse(&node_addr, node_addr_str, ip_version) == -1) {
 				free(node_addr_str);
 				continue ;
 			}
 			free(node_addr_str);
 
 			/*
 			 * Try to match ip with if_addrs
 			 */
 			node_found = 0;
 			qb_list_for_each(list, &(addrs)) {
 				if_addr = qb_list_entry(list, struct totem_ip_if_address, list);
 
 				if (totemip_equal(&node_addr, &if_addr->ip_addr)) {
 					node_found = 1;
 					break;
 				}
 			}
 
 			if (node_found) {
 				break ;
 			}
 		}
 
 		icmap_iter_finalize(iter2);
 
 		if (node_found) {
 			break ;
 		}
 	}
 
 	icmap_iter_finalize(iter);
 	totemip_freeifaddrs(&addrs);
 
 	return (node_found);
 }
 
 static void config_convert_nodelist_to_interface(struct totem_config *totem_config)
 {
 	int res = 0;
 	unsigned int node_pos;
 	char tmp_key[ICMAP_KEYNAME_MAXLEN];
 	char tmp_key2[ICMAP_KEYNAME_MAXLEN];
 	char *node_addr_str;
 	unsigned int linknumber = 0;
 	icmap_iter_t iter;
 	const char *iter_key;
 
 	if (totem_config_find_local_addr_in_nodelist(NULL, &node_pos)) {
 		/*
 		 * We found node, so create interface section
 		 */
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.", node_pos);
 		iter = icmap_iter_init(tmp_key);
 		while ((iter_key = icmap_iter_next(iter, NULL, NULL)) != NULL) {
 			res = sscanf(iter_key, "nodelist.node.%u.ring%u%s", &node_pos, &linknumber, tmp_key2);
 			if (res != 3 || strcmp(tmp_key2, "_addr") != 0) {
 				continue ;
 			}
 
 			if (icmap_get_string(iter_key, &node_addr_str) != CS_OK) {
 				continue;
 			}
 
 			snprintf(tmp_key2, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.bindnetaddr", linknumber);
 			icmap_set_string(tmp_key2, node_addr_str);
 			free(node_addr_str);
 		}
 		icmap_iter_finalize(iter);
 	}
 }
 
 
 extern int totem_config_read (
 	struct totem_config *totem_config,
 	const char **error_string,
 	uint64_t *warnings)
 {
 	int res = 0;
 	char *str;
 	unsigned int linknumber = 0;
 	int member_count = 0;
 	icmap_iter_t iter, member_iter;
 	const char *iter_key;
 	const char *member_iter_key;
 	char linknumber_key[ICMAP_KEYNAME_MAXLEN];
 	char tmp_key[ICMAP_KEYNAME_MAXLEN];
 	uint8_t u8;
 	uint16_t u16;
 	uint32_t u32;
 	char *cluster_name = NULL;
 	int i;
 	int local_node_pos;
 	int nodeid_set;
 
 	*warnings = 0;
 
 	memset (totem_config, 0, sizeof (struct totem_config));
 	totem_config->interfaces = malloc (sizeof (struct totem_interface) * INTERFACE_MAX);
 	if (totem_config->interfaces == 0) {
 		*error_string = "Out of memory trying to allocate ethernet interface storage area";
 		return -1;
 	}
 
 	memset (totem_config->interfaces, 0,
 		sizeof (struct totem_interface) * INTERFACE_MAX);
 
 	strcpy (totem_config->link_mode, "passive");
 
 	icmap_get_uint32("totem.version", (uint32_t *)&totem_config->version);
 
 	if (totem_get_crypto(totem_config) != 0) {
 		*error_string = "crypto_cipher requires crypto_hash with value other than none";
 		return -1;
 	}
 
 	if (icmap_get_string("totem.link_mode", &str) == CS_OK) {
 		if (strlen(str) >= TOTEM_LINK_MODE_BYTES) {
 			*error_string = "totem.link_mode is too long";
 			free(str);
 
 			return -1;
 		}
 		strcpy (totem_config->link_mode, str);
 		free(str);
 	}
 
 	icmap_get_uint32("totem.nodeid", &totem_config->node_id);
 
 	totem_config->clear_node_high_bit = 0;
 	if (icmap_get_string("totem.clear_node_high_bit", &str) == CS_OK) {
 		if (strcmp (str, "yes") == 0) {
 			totem_config->clear_node_high_bit = 1;
 		}
 		free(str);
 	}
 
 	icmap_get_uint32("totem.threads", &totem_config->threads);
 
 	icmap_get_uint32("totem.netmtu", &totem_config->net_mtu);
 
 	if (icmap_get_string("totem.cluster_name", &cluster_name) != CS_OK) {
 		cluster_name = NULL;
 	}
 
 	totem_config->ip_version = totem_config_get_ip_version();
 
 	if (icmap_get_string("totem.interface.0.bindnetaddr", &str) != CS_OK) {
 		/*
 		 * We were not able to find ring 0 bindnet addr. Try to use nodelist informations
 		 */
 		config_convert_nodelist_to_interface(totem_config);
 	} else {
 		free(str);
 	}
 
 	/*
 	 * Broadcast option is global but set in interface section,
 	 * so reset before processing interfaces.
 	 */
 	totem_config->broadcast_use = 0;
 
 	iter = icmap_iter_init("totem.interface.");
 	while ((iter_key = icmap_iter_next(iter, NULL, NULL)) != NULL) {
 		res = sscanf(iter_key, "totem.interface.%[^.].%s", linknumber_key, tmp_key);
 		if (res != 2) {
 			continue;
 		}
 
 		if (strcmp(tmp_key, "bindnetaddr") != 0) {
 			continue;
 		}
 
 		member_count = 0;
 
 		linknumber = atoi(linknumber_key);
 
 		if (linknumber >= INTERFACE_MAX) {
 			free(cluster_name);
 
 			snprintf (error_string_response, sizeof(error_string_response),
 			    "parse error in config: interface ring number %u is bigger than allowed maximum %u\n",
 			    linknumber, INTERFACE_MAX - 1);
 
 			*error_string = error_string_response;
 			return -1;
 		}
 
 		/*
 		 * Get the bind net address
 		 */
 		if (icmap_get_string(iter_key, &str) == CS_OK) {
 			res = totemip_parse (&totem_config->interfaces[linknumber].bindnet, str,
 			    totem_config->ip_version);
 			free(str);
 		}
 
 		/*
 		 * Get interface multicast address
 		 */
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.mcastaddr", linknumber);
 		if (icmap_get_string(tmp_key, &str) == CS_OK) {
 			res = totemip_parse (&totem_config->interfaces[linknumber].mcast_addr, str, totem_config->ip_version);
 			free(str);
 		} else {
 			/*
 			 * User not specified address -> autogenerate one from cluster_name key
 			 * (if available). Return code is intentionally ignored, because
 			 * udpu doesn't need mcastaddr and validity of mcastaddr for udp is
 			 * checked later anyway.
 			 */
 			(void)get_cluster_mcast_addr (cluster_name,
 					linknumber,
 					totem_config->ip_version,
 					&totem_config->interfaces[linknumber].mcast_addr);
 		}
 
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.broadcast", linknumber);
 		if (icmap_get_string(tmp_key, &str) == CS_OK) {
 			if (strcmp (str, "yes") == 0) {
 				totem_config->broadcast_use = 1;
 			}
 			free(str);
 		}
 
 		/*
 		 * Get mcast port
 		 */
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.mcastport", linknumber);
 		if (icmap_get_uint16(tmp_key, &totem_config->interfaces[linknumber].ip_port) != CS_OK) {
 			if (totem_config->broadcast_use) {
 				totem_config->interfaces[linknumber].ip_port = DEFAULT_PORT + (2 * linknumber);
 			} else {
 				totem_config->interfaces[linknumber].ip_port = DEFAULT_PORT;
 			}
 		}
 
 		/*
 		 * Get the TTL
 		 */
 		totem_config->interfaces[linknumber].ttl = 1;
 
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.ttl", linknumber);
 
 		if (icmap_get_uint8(tmp_key, &u8) == CS_OK) {
 			totem_config->interfaces[linknumber].ttl = u8;
 		}
 
 		/*
 		 * Get the knet link params
 		 */
 		totem_config->interfaces[linknumber].knet_link_priority = 1;
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.knet_link_priority", linknumber);
 
 		if (icmap_get_uint8(tmp_key, &u8) == CS_OK) {
 			totem_config->interfaces[linknumber].knet_link_priority = u8;
 		}
 
 		totem_config->interfaces[linknumber].knet_ping_interval = KNET_PING_INTERVAL;
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.knet_ping_interval", linknumber);
 		if (icmap_get_uint32(tmp_key, &u32) == CS_OK) {
 			totem_config->interfaces[linknumber].knet_ping_interval = u32;
 		}
 		totem_config->interfaces[linknumber].knet_ping_timeout = KNET_PING_TIMEOUT;
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.knet_ping_timeout", linknumber);
 		if (icmap_get_uint32(tmp_key, &u32) == CS_OK) {
 			totem_config->interfaces[linknumber].knet_ping_timeout = u32;
 		}
 		totem_config->interfaces[linknumber].knet_ping_precision = KNET_PING_PRECISION;
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.knet_ping_precision", linknumber);
 		if (icmap_get_uint32(tmp_key, &u32) == CS_OK) {
 			totem_config->interfaces[linknumber].knet_ping_precision = u32;
 		}
+		totem_config->interfaces[linknumber].knet_pong_count = KNET_PONG_COUNT;
+		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.knet_pong_count", linknumber);
+		if (icmap_get_uint32(tmp_key, &u32) == CS_OK) {
+			totem_config->interfaces[linknumber].knet_pong_count = u32;
+		}
 
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.member.", linknumber);
 		member_iter = icmap_iter_init(tmp_key);
 		while ((member_iter_key = icmap_iter_next(member_iter, NULL, NULL)) != NULL) {
 			if (member_count == 0) {
 				if (icmap_get_string("nodelist.node.0.ring0_addr", &str) == CS_OK) {
 					free(str);
 					*warnings |= TOTEM_CONFIG_WARNING_MEMBERS_IGNORED;
 					break;
 				} else {
 					*warnings |= TOTEM_CONFIG_WARNING_MEMBERS_DEPRECATED;
 				}
 			}
 
 			if (icmap_get_string(member_iter_key, &str) == CS_OK) {
 				res = totemip_parse (&totem_config->interfaces[linknumber].member_list[member_count++],
 						str, totem_config->ip_version);
 			}
 		}
 		icmap_iter_finalize(member_iter);
 
 		totem_config->interfaces[linknumber].member_count = member_count;
 		totem_config->interface_count++;
 	}
 	icmap_iter_finalize(iter);
 
 	/*
 	 * Use broadcast is global, so if set, make sure to fill mcast addr correctly
 	 */
 	if (totem_config->broadcast_use) {
 		for (linknumber = 0; linknumber < totem_config->interface_count; linknumber++) {
 			totemip_parse (&totem_config->interfaces[linknumber].mcast_addr,
 				"255.255.255.255", 0);
 		}
 	}
 
 	/*
 	 * Store automatically generated items back to icmap
 	 */
 	for (i = 0; i < totem_config->interface_count; i++) {
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.mcastaddr", i);
 		if (icmap_get_string(tmp_key, &str) == CS_OK) {
 			free(str);
 		} else {
 			str = (char *)totemip_print(&totem_config->interfaces[i].mcast_addr);
 			icmap_set_string(tmp_key, str);
 		}
 
 		snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.mcastport", i);
 		if (icmap_get_uint16(tmp_key, &u16) != CS_OK) {
 			icmap_set_uint16(tmp_key, totem_config->interfaces[i].ip_port);
 		}
 	}
 
 	totem_config->transport_number = TOTEM_TRANSPORT_KNET;
 	if (icmap_get_string("totem.transport", &str) == CS_OK) {
 		if (strcmp (str, "udpu") == 0) {
 			totem_config->transport_number = TOTEM_TRANSPORT_UDPU;
 		}
 
 		if (strcmp (str, "udp") == 0) {
 			totem_config->transport_number = TOTEM_TRANSPORT_UDP;
 		}
 
 		if (strcmp (str, "knet") == 0) {
 			totem_config->transport_number = TOTEM_TRANSPORT_KNET;
 		}
 
 		free(str);
 	}
 
 	free(cluster_name);
 
 	/*
 	 * Check existence of nodelist
 	 */
 	if (icmap_get_string("nodelist.node.0.ring0_addr", &str) == CS_OK) {
 		free(str);
 		/*
 		 * find local node
 		 */
 		local_node_pos = find_local_node_in_nodelist(totem_config);
 		if (local_node_pos != -1) {
 			icmap_set_uint32("nodelist.local_node_pos", local_node_pos);
 
 			snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.nodeid", local_node_pos);
 
 			nodeid_set = (totem_config->node_id != 0);
 			if (icmap_get_uint32(tmp_key, &totem_config->node_id) == CS_OK && nodeid_set) {
 				*warnings |= TOTEM_CONFIG_WARNING_TOTEM_NODEID_IGNORED;
 			}
 
 			/*
 			 * Make localnode ring0_addr read only, so we can be sure that local
 			 * node never changes. If rebinding to other IP would be in future
 			 * supported, this must be changed and handled properly!
 			 */
 			snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.ring0_addr", local_node_pos);
 			icmap_set_ro_access(tmp_key, 0, 1);
 			icmap_set_ro_access("nodelist.local_node_pos", 0, 1);
 		}
 
 		put_nodelist_members_to_config(totem_config, 0);
 	}
 
 	/*
 	 * Get things that might change in the future (and can depend on totem_config->interfaces);
 	 */
 	totem_volatile_config_read(totem_config, NULL);
 
 	icmap_set_uint8("config.totemconfig_reload_in_progress", 0);
 
 	add_totem_config_notification(totem_config);
 
 	return 0;
 }
 
 
 int totem_config_validate (
 	struct totem_config *totem_config,
 	const char **error_string)
 {
 	static char local_error_reason[512];
 	char parse_error[512];
 	const char *error_reason = local_error_reason;
 	int i, j;
 	unsigned int interface_max = INTERFACE_MAX;
 	unsigned int port1, port2;
 
 	if (totem_config->interface_count == 0) {
 		error_reason = "No interfaces defined";
 		goto parse_error;
 	}
 
 	for (i = 0; i < totem_config->interface_count; i++) {
 		/*
 		 * Some error checking of parsed data to make sure its valid
 		 */
 
 		struct totem_ip_address null_addr;
 		memset (&null_addr, 0, sizeof (struct totem_ip_address));
 
 		if ((totem_config->transport_number == 0) &&
 			memcmp (&totem_config->interfaces[i].mcast_addr, &null_addr,
 				sizeof (struct totem_ip_address)) == 0) {
 			error_reason = "No multicast address specified";
 			goto parse_error;
 		}
 
 		if (totem_config->interfaces[i].ip_port == 0) {
 			error_reason = "No multicast port specified";
 			goto parse_error;
 		}
 
 		if (totem_config->interfaces[i].ttl > 255) {
 			error_reason = "Invalid TTL (should be 0..255)";
 			goto parse_error;
 		}
 		if (totem_config->transport_number != TOTEM_TRANSPORT_UDP &&
 		    totem_config->interfaces[i].ttl != 1) {
 			error_reason = "Can only set ttl on multicast transport types";
 			goto parse_error;
 		}
 		if (totem_config->interfaces[i].knet_link_priority > 255) {
 			error_reason = "Invalid link priority (should be 0..255)";
 			goto parse_error;
 		}
 		if (totem_config->transport_number != TOTEM_TRANSPORT_KNET &&
 		    totem_config->interfaces[i].knet_link_priority != 1) {
 			error_reason = "Can only set link priority on knet transport type";
 			goto parse_error;
 		}
 
 		if (totem_config->interfaces[i].mcast_addr.family == AF_INET6 &&
 			totem_config->node_id == 0) {
 
 			error_reason = "An IPV6 network requires that a node ID be specified.";
 			goto parse_error;
 		}
 
 		if (totem_config->broadcast_use == 0 && totem_config->transport_number == TOTEM_TRANSPORT_UDP) {
 			if (totem_config->interfaces[i].mcast_addr.family != totem_config->interfaces[i].bindnet.family) {
 				error_reason = "Multicast address family does not match bind address family";
 				goto parse_error;
 			}
 
 			if (totemip_is_mcast (&totem_config->interfaces[i].mcast_addr) != 0) {
 				error_reason = "mcastaddr is not a correct multicast address.";
 				goto parse_error;
 			}
 		}
 
 		if (totem_config->interfaces[0].bindnet.family != totem_config->interfaces[i].bindnet.family) {
 			error_reason =  "Not all bind address belong to the same IP family";
 			goto parse_error;
 		}
 
 		/*
 		 * Ensure mcast address/port differs
 		 */
 		if (totem_config->transport_number == TOTEM_TRANSPORT_UDP) {
 			for (j = i + 1; j < totem_config->interface_count; j++) {
 				port1 = totem_config->interfaces[i].ip_port;
 				port2 = totem_config->interfaces[j].ip_port;
 				if (totemip_equal(&totem_config->interfaces[i].mcast_addr,
 				    &totem_config->interfaces[j].mcast_addr) &&
 				    (((port1 > port2 ? port1 : port2)  - (port1 < port2 ? port1 : port2)) <= 1)) {
 					error_reason = "Interfaces multicast address/port pair must differ";
 					goto parse_error;
 				}
 			}
 		}
 	}
 
 	if (totem_config->version != 2) {
 		error_reason = "This totem parser can only parse version 2 configurations.";
 		goto parse_error;
 	}
 
 	if (totem_volatile_config_validate(totem_config, error_string) == -1) {
 		return (-1);
 	}
 
 	if (check_for_duplicate_nodeids(totem_config, error_string) == -1) {
 		return (-1);
 	}
 
 	/*
 	 * KNET Link values validation
 	 */
 	if (strcmp (totem_config->link_mode, "active") &&
 	        strcmp (totem_config->link_mode, "rr") &&
 		strcmp (totem_config->link_mode, "passive")) {
 		snprintf (local_error_reason, sizeof(local_error_reason),
 			"The Knet link mode \"%s\" specified is invalid.  It must be active, passive or rr.\n", totem_config->link_mode);
 		goto parse_error;
 	}
 
 	/* Only Knet does multiple interfaces */
 	if (totem_config->transport_number != TOTEM_TRANSPORT_KNET) {
 		interface_max = 1;
 	}
 
 	if (interface_max < totem_config->interface_count) {
 		snprintf (parse_error, sizeof(parse_error),
 			  "%d is too many configured interfaces for non-Knet transport.",
 			  totem_config->interface_count);
 		error_reason = parse_error;
 		goto parse_error;
 	}
 
 	/* Only knet allows crypto */
 	if (totem_config->transport_number != TOTEM_TRANSPORT_KNET) {
 		if ((strcmp(totem_config->crypto_cipher_type, "none") != 0) ||
 		    (strcmp(totem_config->crypto_hash_type, "none") != 0)) {
 
 			snprintf (parse_error, sizeof(parse_error),
 				  "crypto_cipher & crypto_hash are only valid for the Knet transport.");
 			error_reason = parse_error;
 			goto parse_error;
 		}
 	}
 
 	if (totem_config->net_mtu == 0) {
 		totem_config->net_mtu = 1500;
 	}
 
 	return 0;
 
 parse_error:
 	snprintf (error_string_response, sizeof(error_string_response),
 		 "parse error in config: %s\n", error_reason);
 	*error_string = error_string_response;
 	return (-1);
 
 }
 
 static int read_keyfile (
 	const char *key_location,
 	struct totem_config *totem_config,
 	const char **error_string)
 {
 	int fd;
 	int res;
 	ssize_t expected_key_len = sizeof (totem_config->private_key);
 	int saved_errno;
 	char error_str[100];
 	const char *error_ptr;
 
 	fd = open (key_location, O_RDONLY);
 	if (fd == -1) {
 		error_ptr = qb_strerror_r(errno, error_str, sizeof(error_str));
 		snprintf (error_string_response, sizeof(error_string_response),
 			"Could not open %s: %s\n",
 			 key_location, error_ptr);
 		goto parse_error;
 	}
 
 	res = read (fd, totem_config->private_key, expected_key_len);
 	saved_errno = errno;
 	close (fd);
 
 	if (res == -1) {
 		error_ptr = qb_strerror_r (saved_errno, error_str, sizeof(error_str));
 		snprintf (error_string_response, sizeof(error_string_response),
 			"Could not read %s: %s\n",
 			 key_location, error_ptr);
 		goto parse_error;
 	}
 
 	totem_config->private_key_len = expected_key_len;
 
 	if (res != expected_key_len) {
 		snprintf (error_string_response, sizeof(error_string_response),
 			"Could only read %d bits of 1024 bits from %s.\n",
 			 res * 8, key_location);
 		goto parse_error;
 	}
 
 	return 0;
 
 parse_error:
 	*error_string = error_string_response;
 	return (-1);
 }
 
 int totem_config_keyread (
 	struct totem_config *totem_config,
 	const char **error_string)
 {
 	int got_key = 0;
 	char *key_location = NULL;
 	int res;
 	size_t key_len;
 
 	memset (totem_config->private_key, 0, 128);
 	totem_config->private_key_len = 128;
 
 	if (strcmp(totem_config->crypto_cipher_type, "none") == 0 &&
 	    strcmp(totem_config->crypto_hash_type, "none") == 0) {
 		return (0);
 	}
 
 	/* cmap may store the location of the key file */
 	if (icmap_get_string("totem.keyfile", &key_location) == CS_OK) {
 		res = read_keyfile(key_location, totem_config, error_string);
 		free(key_location);
 		if (res)  {
 			goto key_error;
 		}
 		got_key = 1;
 	} else { /* Or the key itself may be in the cmap */
 		if (icmap_get("totem.key", NULL, &key_len, NULL) == CS_OK) {
 			if (key_len > sizeof (totem_config->private_key)) {
 				sprintf(error_string_response, "key is too long");
 				goto key_error;
 			}
 			if (icmap_get("totem.key", totem_config->private_key, &key_len, NULL) == CS_OK) {
 				totem_config->private_key_len = key_len;
 				got_key = 1;
 			} else {
 				sprintf(error_string_response, "can't store private key");
 				goto key_error;
 			}
 		}
 	}
 
 	/* In desperation we read the default filename */
 	if (!got_key) {
 		const char *filename = getenv("COROSYNC_TOTEM_AUTHKEY_FILE");
 		if (!filename)
 			filename = COROSYSCONFDIR "/authkey";
 		res = read_keyfile(filename, totem_config, error_string);
 		if (res)
 			goto key_error;
 
 	}
 
 	return (0);
 
 key_error:
 	*error_string = error_string_response;
 	return (-1);
 
 }
 
 static void debug_dump_totem_config(const struct totem_config *totem_config)
 {
 
 	log_printf(LOGSYS_LEVEL_DEBUG, "Token Timeout (%d ms) retransmit timeout (%d ms)",
 	    totem_config->token_timeout, totem_config->token_retransmit_timeout);
 	log_printf(LOGSYS_LEVEL_DEBUG, "token hold (%d ms) retransmits before loss (%d retrans)",
 	    totem_config->token_hold_timeout, totem_config->token_retransmits_before_loss_const);
 	log_printf(LOGSYS_LEVEL_DEBUG, "join (%d ms) send_join (%d ms) consensus (%d ms) merge (%d ms)",
 	    totem_config->join_timeout, totem_config->send_join_timeout, totem_config->consensus_timeout,
 	    totem_config->merge_timeout);
 	log_printf(LOGSYS_LEVEL_DEBUG, "downcheck (%d ms) fail to recv const (%d msgs)",
 	    totem_config->downcheck_timeout, totem_config->fail_to_recv_const);
 	log_printf(LOGSYS_LEVEL_DEBUG,
 	    "seqno unchanged const (%d rotations) Maximum network MTU %d",
 	    totem_config->seqno_unchanged_const, totem_config->net_mtu);
 	log_printf(LOGSYS_LEVEL_DEBUG,
 	    "window size per rotation (%d messages) maximum messages per rotation (%d messages)",
 	    totem_config->window_size, totem_config->max_messages);
 	log_printf(LOGSYS_LEVEL_DEBUG, "missed count const (%d messages)", totem_config->miss_count_const);
 	log_printf(LOGSYS_LEVEL_DEBUG, "heartbeat_failures_allowed (%d)",
 	    totem_config->heartbeat_failures_allowed);
 	log_printf(LOGSYS_LEVEL_DEBUG, "max_network_delay (%d ms)", totem_config->max_network_delay);
 }
 
 static void totem_change_notify(
 	int32_t event,
 	const char *key_name,
 	struct icmap_notify_value new_val,
 	struct icmap_notify_value old_val,
 	void *user_data)
 {
 	struct totem_config *totem_config = (struct totem_config *)user_data;
 	uint32_t *param;
 	uint8_t reloading;
 	const char *deleted_key = NULL;
 	const char *error_string;
 
 	/*
 	 * If a full reload is in progress then don't do anything until it's done and
 	 * can reconfigure it all atomically
 	 */
 	if (icmap_get_uint8("config.reload_in_progress", &reloading) == CS_OK && reloading)
 		return;
 
 	param = totem_get_param_by_name((struct totem_config *)user_data, key_name);
 	/*
 	 * Process change only if changed key is found in totem_config (-> param is not NULL)
 	 * or for special key token_coefficient. token_coefficient key is not stored in
 	 * totem_config, but it is used for computation of token timeout.
 	 */
 	if (!param && strcmp(key_name, "totem.token_coefficient") != 0)
 		return;
 
 	/*
 	 * Values other than UINT32 are not supported, or needed (yet)
 	 */
 	switch (event) {
 	case ICMAP_TRACK_DELETE:
 		deleted_key = key_name;
 		break;
 	case ICMAP_TRACK_ADD:
 	case ICMAP_TRACK_MODIFY:
 		deleted_key = NULL;
 		break;
 	default:
 		break;
 	}
 
 	totem_volatile_config_read (totem_config, deleted_key);
 	log_printf(LOGSYS_LEVEL_DEBUG, "Totem related config key changed. Dumping actual totem config.");
 	debug_dump_totem_config(totem_config);
 	if (totem_volatile_config_validate(totem_config, &error_string) == -1) {
 		log_printf (LOGSYS_LEVEL_ERROR, "%s", error_string);
 		/*
 		 * TODO: Consider corosync exit and/or load defaults for volatile
 		 * values. For now, log error seems to be enough
 		 */
 	}
 }
 
 static void totem_reload_notify(
 	int32_t event,
 	const char *key_name,
 	struct icmap_notify_value new_val,
 	struct icmap_notify_value old_val,
 	void *user_data)
 {
 	struct totem_config *totem_config = (struct totem_config *)user_data;
 	uint32_t local_node_pos;
 	const char *error_string;
 
 	/* Reload has completed */
 	if (*(uint8_t *)new_val.data == 0) {
 		put_nodelist_members_to_config (totem_config, 1);
 		totem_volatile_config_read (totem_config, NULL);
 		log_printf(LOGSYS_LEVEL_DEBUG, "Configuration reloaded. Dumping actual totem config.");
 		debug_dump_totem_config(totem_config);
 		if (totem_volatile_config_validate(totem_config, &error_string) == -1) {
 			log_printf (LOGSYS_LEVEL_ERROR, "%s", error_string);
 			/*
 			 * TODO: Consider corosync exit and/or load defaults for volatile
 			 * values. For now, log error seems to be enough
 			 */
 		}
 
 		/* Reinstate the local_node_pos */
 		local_node_pos = find_local_node_in_nodelist(totem_config);
 		if (local_node_pos != -1) {
 			icmap_set_uint32("nodelist.local_node_pos", local_node_pos);
 		}
 
 		icmap_set_uint8("config.totemconfig_reload_in_progress", 0);
 	} else {
 		icmap_set_uint8("config.totemconfig_reload_in_progress", 1);
 	}
 }
 
 static void add_totem_config_notification(struct totem_config *totem_config)
 {
 	icmap_track_t icmap_track;
 
 	icmap_track_add("totem.",
 		ICMAP_TRACK_ADD | ICMAP_TRACK_DELETE | ICMAP_TRACK_MODIFY | ICMAP_TRACK_PREFIX,
 		totem_change_notify,
 		totem_config,
 		&icmap_track);
 
 	icmap_track_add("config.reload_in_progress",
 		ICMAP_TRACK_ADD | ICMAP_TRACK_MODIFY,
 		totem_reload_notify,
 		totem_config,
 		&icmap_track);
 
 	icmap_track_add("nodelist.node.",
 		ICMAP_TRACK_ADD | ICMAP_TRACK_DELETE | ICMAP_TRACK_MODIFY | ICMAP_TRACK_PREFIX,
 		nodelist_dynamic_notify,
 		(void *)totem_config,
 		&icmap_track);
 }
diff --git a/exec/totemknet.c b/exec/totemknet.c
index d339b8cf..b28c0a82 100644
--- a/exec/totemknet.c
+++ b/exec/totemknet.c
@@ -1,1018 +1,1023 @@
 
 /*
  * Copyright (c) 2016 Red Hat, Inc.
  *
  * All rights reserved.
  *
  * Author: Christine Caulfield (ccaulfie@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 <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 <qb/qbdefs.h>
 #include <qb/qbloop.h>
 
 #include <corosync/sq.h>
 #include <corosync/swab.h>
 #include <corosync/logsys.h>
 #include <corosync/totem/totemip.h>
 #include "totemknet.h"
 
 #include "util.h"
 
 #include <nss.h>
 #include <pk11pub.h>
 #include <pkcs11.h>
 #include <prerror.h>
 
 #include <libknet.h>
 
 #ifndef MSG_NOSIGNAL
 #define MSG_NOSIGNAL 0
 #endif
 
 #define MCAST_SOCKET_BUFFER_SIZE (TRANSMITS_ALLOWED * FRAME_SIZE_MAX)
 
 /* Buffers for sendmmsg/recvmmsg */
 #define MAX_BUFFERS 10
 
 /* Should match that used by cfg */
 #define CFG_INTERFACE_STATUS_MAX_LEN 512
 
 struct totemknet_instance {
 	struct crypto_instance *crypto_inst;
 
 	qb_loop_t *poll_handle;
 
         knet_handle_t knet_handle;
 
 	int link_mode;
 
 	void *context;
 
 	void (*totemknet_deliver_fn) (
 		void *context,
 		const void *msg,
 		unsigned int msg_len);
 
 	void (*totemknet_iface_change_fn) (
 		void *context,
 		const struct totem_ip_address *iface_address,
 		unsigned int link_no);
 
 	void (*totemknet_mtu_changed) (
 		void *context,
 		int net_mtu);
 
 	void (*totemknet_target_set_completed) (void *context);
 
 	/*
 	 * Function and data used to log messages
 	 */
 	int totemknet_log_level_security;
 
 	int totemknet_log_level_error;
 
 	int totemknet_log_level_warning;
 
 	int totemknet_log_level_notice;
 
 	int totemknet_log_level_debug;
 
 	int totemknet_subsys_id;
 
 	int knet_subsys_id;
 
 	void (*totemknet_log_printf) (
 		int level,
 		int subsys,
 		const char *function,
 		const char *file,
 		int line,
 		const char *format,
 		...)__attribute__((format(printf, 6, 7)));
 
 	void *knet_context;
 
 	char iov_buffer[MAX_BUFFERS][FRAME_SIZE_MAX];
 
 	int stats_sent;
 
 	int stats_recv;
 
 	int stats_delv;
 
 	int stats_remcasts;
 
 	int stats_orf_token;
 
 	struct timeval stats_tv_start;
 
 	char *link_status[INTERFACE_MAX];
 
 	int num_links;
 
 	struct totem_ip_address my_ids[INTERFACE_MAX];
 
 	uint16_t ip_port[INTERFACE_MAX];
 
 	int our_nodeid;
 
 	struct totem_config *totem_config;
 
 	totemsrp_stats_t *stats;
 
 	struct totem_ip_address token_target;
 
 	qb_loop_timer_handle timer_netif_check_timeout;
 
 	qb_loop_timer_handle timer_merge_detect_timeout;
 
 	int send_merge_detect_message;
 
 	unsigned int merge_detect_messages_sent_before_timeout;
 
 	int logpipes[2];
 	int knet_fd;
 };
 
 struct work_item {
 	const void *msg;
 	unsigned int msg_len;
 	struct totemknet_instance *instance;
 };
 
 int totemknet_member_list_rebind_ip (
 	void *knet_context);
 
 static void totemknet_start_merge_detect_timeout(
 	void *knet_context);
 
 static void totemknet_stop_merge_detect_timeout(
 	void *knet_context);
 
 static void totemknet_instance_initialize (struct totemknet_instance *instance)
 {
 	memset (instance, 0, sizeof (struct totemknet_instance));
 }
 
 #define knet_log_printf(level, format, args...)		\
 do {							\
         instance->totemknet_log_printf (		\
 		level, instance->totemknet_subsys_id,	\
                 __FUNCTION__, __FILE__, __LINE__,	\
 		(const char *)format, ##args);		\
 } while (0);
 
 #define libknet_log_printf(level, format, args...)		\
 do {							\
         instance->totemknet_log_printf (		\
 		level, instance->knet_subsys_id,	\
                 __FUNCTION__, "libknet.h", __LINE__,	\
 		(const char *)format, ##args);		\
 } while (0);
 
 #define KNET_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->totemknet_log_printf (							\
 		level, instance->totemknet_subsys_id,						\
                 __FUNCTION__, __FILE__, __LINE__,						\
 		fmt ": %s (%d)", ##args, _error_ptr, err_num);				\
 	} while(0)
 
 
 static int dst_host_filter_callback_fn(void *private_data,
 				       const unsigned char *outdata,
 				       ssize_t outdata_len,
 				       uint8_t tx_rx,
 				       uint16_t this_host_id,
 				       uint16_t src_host_id,
 				       int8_t *channel,
 				       uint16_t *dst_host_ids,
 				       size_t *dst_host_ids_entries)
 {
 	struct totem_message_header *header = (struct totem_message_header *)outdata;
 //	struct totemknet_instance *instance = (struct totemknet_instance *)private_data;
 	int res;
 
 //	knet_log_printf (LOGSYS_LEVEL_DEBUG, "Filter notification called: %s target nodeid=%d, len=%ld", tx_rx==KNET_NOTIFY_RX?"RX":"TX", header->target_nodeid, outdata_len);
 
 	*channel = 0;
 	if (header->target_nodeid) {
 		dst_host_ids[0] = header->target_nodeid;
 		*dst_host_ids_entries = 1;
 		res = 0; /* unicast message */
 	}
 	else {
 		*dst_host_ids_entries = 0;
 		res = 1; /* multicast message */
 	}
 	return res;
 }
 
 static void socket_error_callback_fn(void *private_data, int datafd, int8_t channel, uint8_t tx_rx, int error, int errorno)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)private_data;
 
 	knet_log_printf (LOGSYS_LEVEL_DEBUG, "Knet socket ERROR notification called: txrx=%d, error=%d, errorno=%d", tx_rx, error, errorno);
 	if ((error == -1 && errorno != EAGAIN) || (error == 0)) {
 		knet_handle_remove_datafd(instance->knet_handle, datafd);
 	}
 }
 
 static void host_change_callback_fn(void *private_data, uint16_t host_id, uint8_t reachable, uint8_t remote, uint8_t external)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)private_data;
 
 	// TODO: what? if anything.
 	knet_log_printf (LOGSYS_LEVEL_DEBUG, "Knet host change callback. nodeid: %d reachable: %d", host_id, reachable);
 }
 
 static void pmtu_change_callback_fn(void *private_data, unsigned int data_mtu)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)private_data;
 	knet_log_printf (LOGSYS_LEVEL_DEBUG, "Knet pMTU change: %d", data_mtu);
 
 	// TODO: Check this
 	instance->totemknet_mtu_changed(instance->context, data_mtu - totemip_udpip_header_size(AF_INET));
 }
 
 int totemknet_crypto_set (
 	void *knet_context,
 	const char *cipher_type,
 	const char *hash_type)
 {
 	return (0);
 }
 
 
 static inline void ucast_sendmsg (
 	struct totemknet_instance *instance,
 	struct totem_ip_address *system_to,
 	const void *msg,
 	unsigned int msg_len)
 {
 	int res = 0;
 	struct totem_message_header *header = (struct totem_message_header *)msg;
 
 	header->target_nodeid = system_to->nodeid;
 
 	/*
 	 * Transmit unicast message
 	 * An error here is recovered by totemsrp
 	 */
 
 	/*
 	 * If sending to ourself then just pass it through knet back to
 	 * the receive fn. knet does not do local->local delivery
 	 */
 	if (system_to->nodeid == instance->our_nodeid) {
 		res = write (instance->knet_fd+1, msg, msg_len);
 		if (res < 0) {
 			KNET_LOGSYS_PERROR (errno, instance->totemknet_log_level_debug,
 				       "sendmsg(ucast-local) failed (non-critical)");
 		}
 	}
 	else {
 		res = write (instance->knet_fd, msg, msg_len);
 		if (res < 0) {
 			KNET_LOGSYS_PERROR (errno, instance->totemknet_log_level_debug,
 				       "sendmsg(ucast) failed (non-critical)");
 		}
 	}
 }
 
 static inline void mcast_sendmsg (
 	struct totemknet_instance *instance,
 	const void *msg,
 	unsigned int msg_len,
 	int only_active)
 {
 	int res;
 	struct totem_message_header *header = (struct totem_message_header *)msg;
 
 	header->target_nodeid = 0;
 
 //	log_printf (LOGSYS_LEVEL_DEBUG, "totemknet: mcast_sendmsg. only_active=%d, len=%d", only_active, msg_len);
 
 	res = write (instance->knet_fd, msg, msg_len);
 	if (res < msg_len) {
 		knet_log_printf (LOGSYS_LEVEL_DEBUG, "totemknet: mcast_send writev returned %d", res);
 	}
 
 	/*
 	 * Also send it to ourself, directly into
 	 * the receive fn. knet does not to local->local delivery
 	 */
 	res = write (instance->knet_fd+1, msg, msg_len);
 	if (res < msg_len) {
 		knet_log_printf (LOGSYS_LEVEL_DEBUG, "totemknet: mcast_send writev (local) returned %d", res);
 	}
 
 	if (!only_active || instance->send_merge_detect_message) {
 		/*
 		 * Current message was sent to all nodes
 		 */
 		instance->merge_detect_messages_sent_before_timeout++;
 		instance->send_merge_detect_message = 0;
 	}
 }
 
 static int node_compare(const void *aptr, const void *bptr)
 {
 	uint16_t a,b;
 
 	a = *(uint16_t *)aptr;
 	b = *(uint16_t *)bptr;
 
 	return a > b;
 }
 
 int totemknet_ifaces_get (void *knet_context,
 	char ***status,
 	unsigned int *iface_count)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)knet_context;
 	struct knet_link_status link_status;
 	uint16_t host_list[KNET_MAX_HOST];
 	size_t num_hosts;
 	int i,j;
 	char *ptr;
 	int res = 0;
 
 	/*
 	 * Don't do the whole 'link_info' bit if the caller just wants
 	 * a count of interfaces.
 	 */
 	if (status) {
 		res = knet_host_get_host_list(instance->knet_handle,
 					      host_list, &num_hosts);
 		if (res) {
 			return (-1);
 		}
 		qsort(host_list, num_hosts, sizeof(uint16_t), node_compare);
 
 		/* num_links is actually the highest link ID */
 		for (i=0; i <= instance->num_links; i++) {
 			ptr = instance->link_status[i];
 
 			for (j=0; j<num_hosts; j++) {
 				res = knet_link_get_status(instance->knet_handle,
 							   host_list[j],
 							   i,
 							   &link_status);
 				if (res == 0) {
 					ptr[j] = '0' + (link_status.enabled |
 							link_status.connected<<1 |
 							link_status.dynconnected<<2);
 				}
 				else {
 					ptr[j] += '?';
 				}
 			}
 			ptr[num_hosts] = '\0';
 		}
 		*status = instance->link_status;
 	}
 
 	*iface_count = instance->num_links+1;
 
 	return (res);
 }
 
 int totemknet_finalize (
 	void *knet_context)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)knet_context;
 	int res = 0;
 
 	knet_log_printf(LOG_DEBUG, "totemknet: finalize");
 
 	qb_loop_poll_del (instance->poll_handle, instance->logpipes[0]);
 	qb_loop_poll_del (instance->poll_handle, instance->knet_fd);
 	knet_handle_free(instance->knet_handle);
 
 	totemknet_stop_merge_detect_timeout(instance);
 
 	return (res);
 }
 
 static int log_deliver_fn (
 	int fd,
 	int revents,
 	void *data)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)data;
 	char buffer[KNET_MAX_LOG_MSG_SIZE*4];
 	char *bufptr = buffer;
 	int done = 0;
 	int len;
 
 	len = read(fd, buffer, sizeof(buffer));
 	while (done < len) {
 		struct knet_log_msg *msg = (struct knet_log_msg *)bufptr;
 		switch (msg->msglevel) {
 		case KNET_LOG_ERR:
 			libknet_log_printf (LOGSYS_LEVEL_ERROR, "%s", msg->msg);
 			break;
 		case KNET_LOG_WARN:
 			libknet_log_printf (LOGSYS_LEVEL_WARNING, "%s", msg->msg);
 			break;
 		case KNET_LOG_INFO:
 			libknet_log_printf (LOGSYS_LEVEL_INFO, "%s", msg->msg);
 			break;
 		case KNET_LOG_DEBUG:
 			libknet_log_printf (LOGSYS_LEVEL_DEBUG, "%s", msg->msg);
 			break;
 		}
 		bufptr += KNET_MAX_LOG_MSG_SIZE;
 		done += KNET_MAX_LOG_MSG_SIZE;
 	}
 	return 0;
 }
 
 static int data_deliver_fn (
 	int fd,
 	int revents,
 	void *data)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)data;
 	struct mmsghdr msg_recv[MAX_BUFFERS];
 	struct iovec iov_recv[MAX_BUFFERS];
 	struct sockaddr_storage system_from;
 	int msgs_received;
 	int i;
 
 	for (i=0; i<MAX_BUFFERS; i++) {
 		iov_recv[i].iov_base = instance->iov_buffer[i];
 		iov_recv[i].iov_len = FRAME_SIZE_MAX;
 
 		msg_recv[i].msg_hdr.msg_name = &system_from;
 		msg_recv[i].msg_hdr.msg_namelen = sizeof (struct sockaddr_storage);
 		msg_recv[i].msg_hdr.msg_iov = &iov_recv[i];
 		msg_recv[i].msg_hdr.msg_iovlen = 1;
 #ifdef HAVE_MSGHDR_CONTROL
 		msg_recv[i].msg_hdr.msg_control = 0;
 #endif
 #ifdef HAVE_MSGHDR_CONTROLLEN
 		msg_recv[i].msg_hdr.msg_controllen = 0;
 #endif
 #ifdef HAVE_MSGHDR_FLAGS
 		msg_recv[i].msg_hdr.msg_flags = 0;
 #endif
 #ifdef HAVE_MSGHDR_ACCRIGHTS
 		msg_recv[i].msg_hdr.msg_accrights = NULL;
 #endif
 #ifdef HAVE_MSGHDR_ACCRIGHTSLEN
 		msg_recv[i].msg_hdr.msg_accrightslen = 0;
 #endif
 	}
 
 	msgs_received = recvmmsg (fd, msg_recv, MAX_BUFFERS, MSG_NOSIGNAL | MSG_DONTWAIT, NULL);
 	if (msgs_received == -1) {
 		return (0);
 	}
 
 	for (i=0; i<msgs_received; i++) {
 
 		instance->stats_recv += msg_recv[i].msg_len;
 
 		/*
 		 * Handle incoming message
 		 */
 		instance->totemknet_deliver_fn (
 			instance->context,
 			instance->iov_buffer[i],
 			msg_recv[i].msg_len);
 	}
 	return (0);
 }
 
 static void timer_function_netif_check_timeout (
 	void *data)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)data;
 	int i;
 
 	for (i=0; i<instance->totem_config->interface_count; i++)
 		instance->totemknet_iface_change_fn (instance->context,
 						     &instance->my_ids[i],
 						     i);
 }
 
 
 /*
  * Create an instance
  */
 int totemknet_initialize (
 	qb_loop_t *poll_handle,
 	void **knet_context,
 	struct totem_config *totem_config,
 	totemsrp_stats_t *stats,
 	void *context,
 
 	void (*deliver_fn) (
 		void *context,
 		const void *msg,
 		unsigned int msg_len),
 
 	void (*iface_change_fn) (
 		void *context,
 		const struct totem_ip_address *iface_address,
 		unsigned int link_no),
 
 	void (*mtu_changed) (
 		void *context,
 		int net_mtu),
 
 	void (*target_set_completed) (
 		void *context))
 {
 	struct totemknet_instance *instance;
 	int8_t channel=0;
 	int res;
 	int i;
 
 	instance = malloc (sizeof (struct totemknet_instance));
 	if (instance == NULL) {
 		return (-1);
 	}
 
 	totemknet_instance_initialize (instance);
 
 	instance->totem_config = totem_config;
 	instance->stats = stats;
 
 	/*
 	* Configure logging
 	*/
 	instance->totemknet_log_level_security = 1; //totem_config->totem_logging_configuration.log_level_security;
 	instance->totemknet_log_level_error = totem_config->totem_logging_configuration.log_level_error;
 	instance->totemknet_log_level_warning = totem_config->totem_logging_configuration.log_level_warning;
 	instance->totemknet_log_level_notice = totem_config->totem_logging_configuration.log_level_notice;
 	instance->totemknet_log_level_debug = totem_config->totem_logging_configuration.log_level_debug;
 	instance->totemknet_subsys_id = totem_config->totem_logging_configuration.log_subsys_id;
 	instance->totemknet_log_printf = totem_config->totem_logging_configuration.log_printf;
 
 	instance->knet_subsys_id = _logsys_subsys_create("KNET", "libknet.h");
 
 	/*
 	 * Initialize local variables for totemknet
 	 */
 
 	instance->our_nodeid = instance->totem_config->node_id;
 
 	for (i=0; i< instance->totem_config->interface_count; i++) {
 		totemip_copy(&instance->my_ids[i], &totem_config->interfaces[i].bindnet);
 		instance->my_ids[i].nodeid = instance->our_nodeid;
 		instance->ip_port[i] = totem_config->interfaces[i].ip_port;
 
 		/* Needed for totemsrp */
 		totem_config->interfaces[i].boundto.nodeid = instance->our_nodeid;
 	}
 
 	instance->poll_handle = poll_handle;
 
 	instance->context = context;
 	instance->totemknet_deliver_fn = deliver_fn;
 
 	instance->totemknet_iface_change_fn = iface_change_fn;
 
 	instance->totemknet_mtu_changed = mtu_changed;
 
 	instance->totemknet_target_set_completed = target_set_completed;
 
 	pipe(instance->logpipes);
 	fcntl(instance->logpipes[0], F_SETFL, O_NONBLOCK);
 	fcntl(instance->logpipes[1], F_SETFL, O_NONBLOCK);
 
 	instance->knet_handle = knet_handle_new(instance->totem_config->node_id, instance->logpipes[1], KNET_LOG_DEBUG);
 
 	if (!instance->knet_handle) {
 		KNET_LOGSYS_PERROR(errno, LOGSYS_LEVEL_CRIT, "knet_handle_new failed");
 		return (-1);
 	}
-	res = knet_handle_pmtud_setfreq(instance->knet_handle, 5);
+	res = knet_handle_pmtud_setfreq(instance->knet_handle, instance->totem_config->knet_pmtud_interval);
 	if (res) {
 		KNET_LOGSYS_PERROR(errno, LOGSYS_LEVEL_WARNING, "knet_handle_pmtud_setfreq failed");
 	}
 	res = knet_handle_enable_filter(instance->knet_handle, instance, dst_host_filter_callback_fn);
 	if (res) {
 		KNET_LOGSYS_PERROR(errno, LOGSYS_LEVEL_WARNING, "knet_handle_enable_filter failed");
 	}
 	res = knet_handle_enable_sock_notify(instance->knet_handle, instance, socket_error_callback_fn);
 	if (res) {
 		KNET_LOGSYS_PERROR(errno, LOGSYS_LEVEL_WARNING, "knet_handle_enable_sock_notify failed");
 	}
 	res = knet_host_enable_status_change_notify(instance->knet_handle, instance, host_change_callback_fn);
 	if (res) {
 		KNET_LOGSYS_PERROR(errno, LOGSYS_LEVEL_WARNING, "knet_host_enable_status_change_notify failed");
 	}
 	res = knet_handle_enable_pmtud_notify(instance->knet_handle, instance, pmtu_change_callback_fn);
 	if (res) {
 		KNET_LOGSYS_PERROR(errno, LOGSYS_LEVEL_WARNING, "knet_handle_enable_pmtud_notify failed");
 	}
 
 	/* Get an fd into knet */
 	instance->knet_fd = 0;
 	res = knet_handle_add_datafd(instance->knet_handle, &instance->knet_fd, &channel);
 	if (res) {
 		knet_log_printf(LOG_DEBUG, "knet_handle_add_datafd failed: %s", strerror(errno));
 		return -1;
 	}
 
 	/* Enable crypto if requested */
 	if (strcmp(instance->totem_config->crypto_cipher_type, "none") != 0) {
 		struct knet_handle_crypto_cfg crypto_cfg;
 
 		strcpy(crypto_cfg.crypto_model, "nss");
 		strcpy(crypto_cfg.crypto_cipher_type, instance->totem_config->crypto_cipher_type);
 		strcpy(crypto_cfg.crypto_hash_type, instance->totem_config->crypto_hash_type);
 		memcpy(crypto_cfg.private_key, instance->totem_config->private_key, instance->totem_config->private_key_len);
 		crypto_cfg.private_key_len = instance->totem_config->private_key_len;
 
 		res = knet_handle_crypto(instance->knet_handle, &crypto_cfg);
 		if (res == -1) {
 			knet_log_printf(LOG_ERR, "knet_handle_crypto failed: %s", strerror(errno));
 			return -1;
 		}
 		if (res == -2) {
 			knet_log_printf(LOG_ERR, "knet_handle_crypto failed: -2");
 			return -1;
 		}
 		knet_log_printf(LOG_INFO, "kronosnet crypto initialized: %s/%s", crypto_cfg.crypto_cipher_type, crypto_cfg.crypto_hash_type);
 	}
 	knet_handle_setfwd(instance->knet_handle, 1);
 
 	instance->link_mode = KNET_LINK_POLICY_PASSIVE;
 	if (strcmp(instance->totem_config->link_mode, "active")==0) {
 		instance->link_mode = KNET_LINK_POLICY_ACTIVE;
 	}
 	if (strcmp(instance->totem_config->link_mode, "rr")==0) {
 		instance->link_mode = KNET_LINK_POLICY_RR;
 	}
 
 	for (i=0; i<INTERFACE_MAX; i++) {
 		instance->link_status[i] = malloc(CFG_INTERFACE_STATUS_MAX_LEN);
 		if (!instance->link_status[i]) {
 			return -1;
 		}
 	}
 
 	qb_loop_poll_add (instance->poll_handle,
 		QB_LOOP_MED,
 		instance->logpipes[0],
 		POLLIN, instance, log_deliver_fn);
 
 	qb_loop_poll_add (instance->poll_handle,
 		QB_LOOP_HIGH,
 		instance->knet_fd,
 		POLLIN, instance, data_deliver_fn);
 
 	/*
 	 * Upper 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->poll_handle,
 		QB_LOOP_MED,
 		100*QB_TIME_NS_IN_MSEC,
 		(void *)instance,
 		timer_function_netif_check_timeout,
 		&instance->timer_netif_check_timeout);
 
 	totemknet_start_merge_detect_timeout(instance);
 
 	knet_log_printf (LOGSYS_LEVEL_INFO, "totemknet initialized");
 	*knet_context = instance;
 	return (0);
 }
 
 void *totemknet_buffer_alloc (void)
 {
 	return malloc (FRAME_SIZE_MAX);
 }
 
 void totemknet_buffer_release (void *ptr)
 {
 	return free (ptr);
 }
 
 int totemknet_processor_count_set (
 	void *knet_context,
 	int processor_count)
 {
 	return (0);
 }
 
 int totemknet_recv_flush (void *knet_context)
 {
 	return (0);
 }
 
 int totemknet_send_flush (void *knet_context)
 {
 	return (0);
 }
 
 int totemknet_token_send (
 	void *knet_context,
 	const void *msg,
 	unsigned int msg_len)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)knet_context;
 	int res = 0;
 
 	ucast_sendmsg (instance, &instance->token_target, msg, msg_len);
 
 	return (res);
 }
 int totemknet_mcast_flush_send (
 	void *knet_context,
 	const void *msg,
 	unsigned int msg_len)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)knet_context;
 	int res = 0;
 
 	mcast_sendmsg (instance, msg, msg_len, 0);
 
 	return (res);
 }
 
 int totemknet_mcast_noflush_send (
 	void *knet_context,
 	const void *msg,
 	unsigned int msg_len)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)knet_context;
 	int res = 0;
 
 	mcast_sendmsg (instance, msg, msg_len, 1);
 
 	return (res);
 }
 
 
 extern int totemknet_iface_check (void *knet_context)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)knet_context;
 	int res = 0;
 
 	knet_log_printf(LOG_DEBUG, "totmeknet: iface_check");
 
 	return (res);
 }
 
 extern void totemknet_net_mtu_adjust (void *knet_context, struct totem_config *totem_config)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)knet_context;
 
 	totem_config->net_mtu -= totemip_udpip_header_size(AF_INET) + 23;
 	knet_log_printf(LOG_DEBUG, "totemknet: Returning MTU of %d", totem_config->net_mtu);
 }
 
 int totemknet_token_target_set (
 	void *knet_context,
 	const struct totem_ip_address *token_target)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)knet_context;
 	int res = 0;
 
 	memcpy (&instance->token_target, token_target,
 		sizeof (struct totem_ip_address));
 
 	instance->totemknet_target_set_completed (instance->context);
 
 	return (res);
 }
 
 extern int totemknet_recv_mcast_empty (
 	void *knet_context)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)knet_context;
 	unsigned int res;
 	struct sockaddr_storage system_from;
 	struct mmsghdr msg_recv[MAX_BUFFERS];
 	struct iovec iov_recv[MAX_BUFFERS];
 	struct pollfd ufd;
 	int nfds;
 	int msg_processed = 0;
 	int i;
 
 	for (i=0; i<MAX_BUFFERS; i++) {
 		iov_recv[i].iov_base = instance->iov_buffer[i];
 		iov_recv[i].iov_len = FRAME_SIZE_MAX;
 
 		msg_recv[i].msg_hdr.msg_name = &system_from;
 		msg_recv[i].msg_hdr.msg_namelen = sizeof (struct sockaddr_storage);
 		msg_recv[i].msg_hdr.msg_iov = &iov_recv[i];
 		msg_recv[i].msg_hdr.msg_iovlen = 1;
 #ifdef HAVE_MSGHDR_CONTROL
 		msg_recv[i].msg_hdr.msg_control = 0;
 #endif
 #ifdef HAVE_MSGHDR_CONTROLLEN
 		msg_recv[i].msg_hdr.msg_controllen = 0;
 #endif
 #ifdef HAVE_MSGHDR_FLAGS
 		msg_recv[i].msg_hdr.msg_flags = 0;
 #endif
 #ifdef HAVE_MSGHDR_ACCRIGHTS
 		msg_recv[i].msg_hdr.msg_accrights = NULL;
 #endif
 #ifdef HAVE_MSGHDR_ACCRIGHTSLEN
 		msg_recv[i].msg_hdr.msg_accrightslen = 0;
 #endif
 	}
 
 	do {
 		ufd.fd = instance->knet_fd;
 		ufd.events = POLLIN;
 		nfds = poll (&ufd, 1, 0);
 		if (nfds == 1 && ufd.revents & POLLIN) {
 			res = recvmmsg (instance->knet_fd, msg_recv, MAX_BUFFERS, MSG_NOSIGNAL | MSG_DONTWAIT, NULL);
 			if (res != -1) {
 				msg_processed = 1;
 			} else {
 				msg_processed = -1;
 			}
 		}
 	} while (nfds == 1);
 
 	return (msg_processed);
 }
 
 int totemknet_member_add (
 	void *knet_context,
 	const struct totem_ip_address *local,
 	const struct totem_ip_address *member,
 	int link_no)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)knet_context;
 	int err;
 	int port = instance->ip_port[link_no];
 	struct sockaddr_storage remote_ss;
 	struct sockaddr_storage local_ss;
 	int addrlen;
 
 	if (member->nodeid == instance->our_nodeid) {
 		return 0; /* Don't add ourself, we send loopback messages directly */
 	}
 
 	/* Keep track of the number of links */
 	if (link_no > instance->num_links) {
 		instance->num_links = link_no;
 	}
 
 	knet_log_printf (LOGSYS_LEVEL_DEBUG, "knet: member_add: %d (%s), link=%d", member->nodeid, totemip_print(member), link_no);
 	knet_log_printf (LOGSYS_LEVEL_DEBUG, "knet:      local: %d (%s)", local->nodeid, totemip_print(local));
 	if (link_no == 0) {
 		if (knet_host_add(instance->knet_handle, member->nodeid)) {
 			KNET_LOGSYS_PERROR(errno, LOGSYS_LEVEL_ERROR, "knet_host_add");
 			return -1;
 		}
 
 		if (knet_host_set_policy(instance->knet_handle, member->nodeid, instance->link_mode)) {
 			KNET_LOGSYS_PERROR(errno, LOGSYS_LEVEL_ERROR, "knet_set_policy failed");
 			return -1;
 		}
 	}
 
 	/* Casts to remove const */
 	totemip_totemip_to_sockaddr_convert((struct totem_ip_address *)member, port+link_no, &remote_ss, &addrlen);
 	totemip_totemip_to_sockaddr_convert((struct totem_ip_address *)local, port+link_no, &local_ss, &addrlen);
 	err = knet_link_set_config(instance->knet_handle, member->nodeid, link_no, &local_ss, &remote_ss);
 	if (err) {
 		KNET_LOGSYS_PERROR(errno, LOGSYS_LEVEL_ERROR, "knet_link_set_config failed");
 		return -1;
 	}
 
 	knet_log_printf (LOGSYS_LEVEL_DEBUG, "knet: member_add: Setting link prio to %d",
 		    instance->totem_config->interfaces[link_no].knet_link_priority);
 
 	err = knet_link_set_priority(instance->knet_handle, member->nodeid, link_no,
 			       instance->totem_config->interfaces[link_no].knet_link_priority);
 	if (err) {
 		KNET_LOGSYS_PERROR(errno, LOGSYS_LEVEL_ERROR, "knet_link_set_priority for nodeid %d, link %d failed", member->nodeid, link_no);
 	}
 
 	err = knet_link_set_ping_timers(instance->knet_handle, member->nodeid, link_no,
 				  instance->totem_config->interfaces[link_no].knet_ping_interval,
 				  instance->totem_config->interfaces[link_no].knet_ping_timeout,
 				  instance->totem_config->interfaces[link_no].knet_ping_precision);
 	if (err) {
 		KNET_LOGSYS_PERROR(errno, LOGSYS_LEVEL_ERROR, "knet_link_set_ping_timers for nodeid %d, link %d failed", member->nodeid, link_no);
 	}
+	err = knet_link_set_pong_count(instance->knet_handle, member->nodeid, link_no,
+				       instance->totem_config->interfaces[link_no].knet_pong_count);
+	if (err) {
+		KNET_LOGSYS_PERROR(errno, LOGSYS_LEVEL_ERROR, "knet_link_set_pong_count for nodeid %d, link %d failed", member->nodeid, link_no);
+	}
 
 	err = knet_link_set_enable(instance->knet_handle, member->nodeid, link_no, 1);
 	if (err) {
 		KNET_LOGSYS_PERROR(errno, LOGSYS_LEVEL_ERROR, "knet_link_set_enable for nodeid %d, link %d failed", member->nodeid, link_no);
 		return -1;
 	}
 
 	return (0);
 }
 
 int totemknet_member_remove (
 	void *knet_context,
 	const struct totem_ip_address *token_target,
 	int link_no)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)knet_context;
 
 	return knet_host_remove(instance->knet_handle, token_target->nodeid);
 
 }
 
 int totemknet_member_list_rebind_ip (
 	void *knet_context)
 {
 	return (0);
 }
 
 static void timer_function_merge_detect_timeout (
 	void *data)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)data;
 
 	if (instance->merge_detect_messages_sent_before_timeout == 0) {
 		instance->send_merge_detect_message = 1;
 	}
 
 	instance->merge_detect_messages_sent_before_timeout = 0;
 
 	totemknet_start_merge_detect_timeout(instance);
 }
 
 static void totemknet_start_merge_detect_timeout(
 	void *knet_context)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)knet_context;
 
 	qb_loop_timer_add(instance->poll_handle,
 	    QB_LOOP_MED,
 	    instance->totem_config->merge_timeout * 2 * QB_TIME_NS_IN_MSEC,
 	    (void *)instance,
 	    timer_function_merge_detect_timeout,
 	    &instance->timer_merge_detect_timeout);
 
 }
 
 static void totemknet_stop_merge_detect_timeout(
 	void *knet_context)
 {
 	struct totemknet_instance *instance = (struct totemknet_instance *)knet_context;
 
 	qb_loop_timer_del(instance->poll_handle,
 	    instance->timer_merge_detect_timeout);
 }
diff --git a/include/corosync/totem/totem.h b/include/corosync/totem/totem.h
index f1b88d40..37468010 100644
--- a/include/corosync/totem/totem.h
+++ b/include/corosync/totem/totem.h
@@ -1,281 +1,283 @@
 /*
  * Copyright (c) 2005 MontaVista Software, Inc.
  * Copyright (c) 2006-2012 Red Hat, Inc.
  *
  * Author: Steven Dake (sdake@redhat.com)
  *
  * All rights reserved.
  *
  * 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.
  */
 #ifndef TOTEM_H_DEFINED
 #define TOTEM_H_DEFINED
 #include "totemip.h"
 #include <corosync/hdb.h>
 
 #ifdef HAVE_SMALL_MEMORY_FOOTPRINT
 #define PROCESSOR_COUNT_MAX	16
 #define MESSAGE_SIZE_MAX	1024*64
 #define MESSAGE_QUEUE_MAX	512
 #else
 #define PROCESSOR_COUNT_MAX	384
 #define MESSAGE_SIZE_MAX	1024*1024 /* (1MB) */
 #define MESSAGE_QUEUE_MAX	((4 * MESSAGE_SIZE_MAX) / totem_config->net_mtu)
 #endif /* HAVE_SMALL_MEMORY_FOOTPRINT */
 
 #define FRAME_SIZE_MAX		10000
 #define TRANSMITS_ALLOWED	16
 #define SEND_THREADS_MAX	16
 
 /* This must be <= KNET_MAX_LINK */
 #define INTERFACE_MAX		8
 /**
  * Maximum number of continuous gather states
  */
 #define MAX_NO_CONT_GATHER	3
 /*
  * Maximum number of continuous failures get from sendmsg call
  */
 #define MAX_NO_CONT_SENDMSG_FAILURES	30
 
 struct totem_interface {
 	struct totem_ip_address bindnet;
 	struct totem_ip_address boundto;
 	struct totem_ip_address mcast_addr;
 	uint16_t ip_port;
 	uint16_t ttl;
 	int member_count;
 	int knet_link_priority;
 	int knet_ping_interval;
 	int knet_ping_timeout;
 	int knet_ping_precision;
+	int knet_pong_count;
 	struct totem_ip_address member_list[PROCESSOR_COUNT_MAX];
 };
 
 struct totem_logging_configuration {
 	void (*log_printf) (
 		int level,
 		int subsys,
 		const char *function_name,
 		const char *file_name,
 		int file_line,
 		const char *format,
 		...) __attribute__((format(printf, 6, 7)));
 
 	int log_level_security;
 	int log_level_error;
 	int log_level_warning;
 	int log_level_notice;
 	int log_level_debug;
 	int log_level_trace;
 	int log_subsys_id;
 };
 
 struct totem_message_header {
 	char type;
 	char encapsulated;
 	unsigned short endian_detector;
 	unsigned int nodeid;
 	unsigned int target_nodeid;
 } __attribute__((packed));
 
 enum { TOTEM_PRIVATE_KEY_LEN = 4096 };
 enum { TOTEM_LINK_MODE_BYTES = 64 };
 
 typedef enum {
 	TOTEM_TRANSPORT_UDP = 0,
 	TOTEM_TRANSPORT_UDPU = 1,
 	TOTEM_TRANSPORT_KNET = 2
 } totem_transport_t;
 
 #define MEMB_RING_ID
 struct memb_ring_id {
 	struct totem_ip_address rep;
 	unsigned long long seq;
 } __attribute__((packed));
 
 struct totem_config {
 	int version;
 
 	/*
 	 * network
 	 */
 	struct totem_interface *interfaces;
 	unsigned int interface_count;
 	unsigned int node_id;
 	unsigned int clear_node_high_bit;
+	unsigned int knet_pmtud_interval;
 
 	/*
 	 * key information
 	 */
 	unsigned char private_key[TOTEM_PRIVATE_KEY_LEN];
 
 	unsigned int private_key_len;
 
 	/*
 	 * Totem configuration parameters
 	 */
 	unsigned int token_timeout;
 
 	unsigned int token_retransmit_timeout;
 
 	unsigned int token_hold_timeout;
 
 	unsigned int token_retransmits_before_loss_const;
 
 	unsigned int join_timeout;
 
 	unsigned int send_join_timeout;
 
 	unsigned int consensus_timeout;
 
 	unsigned int merge_timeout;
 
 	unsigned int downcheck_timeout;
 
 	unsigned int fail_to_recv_const;
 
 	unsigned int seqno_unchanged_const;
 
 	char link_mode[TOTEM_LINK_MODE_BYTES];
 
 	struct totem_logging_configuration totem_logging_configuration;
 
 	unsigned int net_mtu;
 
 	unsigned int threads;
 
 	unsigned int heartbeat_failures_allowed;
 
 	unsigned int max_network_delay;
 
 	unsigned int window_size;
 
 	unsigned int max_messages;
 
 	const char *vsf_type;
 
 	unsigned int broadcast_use;
 
 	char *crypto_cipher_type;
 
 	char *crypto_hash_type;
 
 	totem_transport_t transport_number;
 
 	unsigned int miss_count_const;
 
 	int ip_version;
 
 	void (*totem_memb_ring_id_create_or_load) (
 	    struct memb_ring_id *memb_ring_id,
 	    const struct totem_ip_address *addr);
 
 	void (*totem_memb_ring_id_store) (
 	    const struct memb_ring_id *memb_ring_id,
 	    const struct totem_ip_address *addr);
 };
 
 #define TOTEM_CONFIGURATION_TYPE
 enum totem_configuration_type {
 	TOTEM_CONFIGURATION_REGULAR,
 	TOTEM_CONFIGURATION_TRANSITIONAL
 };
 
 #define TOTEM_CALLBACK_TOKEN_TYPE
 enum totem_callback_token_type {
 	TOTEM_CALLBACK_TOKEN_RECEIVED = 1,
 	TOTEM_CALLBACK_TOKEN_SENT = 2
 };
 
 enum totem_event_type {
 	TOTEM_EVENT_DELIVERY_CONGESTED,
 	TOTEM_EVENT_NEW_MSG,
 };
 
 typedef struct {
 	int is_dirty;
 	time_t last_updated;
 } totem_stats_header_t;
 
 typedef struct {
 	totem_stats_header_t hdr;
 	uint32_t iface_changes;
 } totemnet_stats_t;
 
 typedef struct {
 	uint32_t rx;
 	uint32_t tx;
 	int backlog_calc;
 } totemsrp_token_stats_t;
 
 typedef struct {
 	totem_stats_header_t hdr;
 	uint64_t orf_token_tx;
 	uint64_t orf_token_rx;
 	uint64_t memb_merge_detect_tx;
 	uint64_t memb_merge_detect_rx;
 	uint64_t memb_join_tx;
 	uint64_t memb_join_rx;
 	uint64_t mcast_tx;
 	uint64_t mcast_retx;
 	uint64_t mcast_rx;
 	uint64_t memb_commit_token_tx;
 	uint64_t memb_commit_token_rx;
 	uint64_t token_hold_cancel_tx;
 	uint64_t token_hold_cancel_rx;
 	uint64_t operational_entered;
 	uint64_t operational_token_lost;
 	uint64_t gather_entered;
 	uint64_t gather_token_lost;
 	uint64_t commit_entered;
 	uint64_t commit_token_lost;
 	uint64_t recovery_entered;
 	uint64_t recovery_token_lost;
 	uint64_t consensus_timeouts;
 	uint64_t rx_msg_dropped;
 	uint32_t continuous_gather;
 	uint32_t continuous_sendmsg_failures;
 
 	int earliest_token;
 	int latest_token;
 #define TOTEM_TOKEN_STATS_MAX 100
 	totemsrp_token_stats_t token[TOTEM_TOKEN_STATS_MAX];
 
 } totemsrp_stats_t;
 
  
  #define TOTEM_CONFIGURATION_TYPE
 
 typedef struct {
 	totem_stats_header_t hdr;
 	totemsrp_stats_t *srp;
 	uint32_t msg_reserved;
 	uint32_t msg_queue_avail;
 } totempg_stats_t;
 
 #endif /* TOTEM_H_DEFINED */
diff --git a/man/corosync.conf.5 b/man/corosync.conf.5
index 6df81fe7..2181057f 100644
--- a/man/corosync.conf.5
+++ b/man/corosync.conf.5
@@ -1,644 +1,653 @@
 .\"/*
 .\" * Copyright (c) 2005 MontaVista Software, Inc.
 .\" * Copyright (c) 2006-2012 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.
 .\" */
 .TH COROSYNC_CONF 5 2012-10-10 "corosync Man Page" "Corosync Cluster Engine Programmer's Manual"
 .SH NAME
 corosync.conf - corosync executive configuration file
 
 .SH SYNOPSIS
 /etc/corosync/corosync.conf
 
 .SH DESCRIPTION
 The corosync.conf instructs the corosync executive about various parameters
 needed to control the corosync executive.  Empty lines and lines starting with
 # character are ignored.  The configuration file consists of bracketed top level
 directives.  The possible directive choices are:
 
 .TP
 totem { }
 This top level directive contains configuration options for the totem protocol.
 .TP
 logging { }
 This top level directive contains configuration options for logging.
 .TP
 quorum { }
 This top level directive contains configuration options for quorum.
 .TP
 nodelist { }
 This top level directive contains configuration options for nodes in cluster.
 .TP
 qb { }
 This top level directive contains configuration options related to libqb.
 
 .PP
 The 
 .B interface sub-directive of totem is optional for UDP and knet transports.
 
 For knet, multiple interface subsections define parameters for each knet link on the
 system.
 
 For UDP, there should be just one interface section that defines the multicast or
 broadcast options for the link.
 
 For UDPU an interface section is not needed and it is recommended that the nodelist
 is used to define cluster nodes.
 
 .TP
 linknumber
 This specifies the link number for the interface.  When using the knet
 protocol, each interface should specify separate link numbers to uniquely
 identify to the membership protocol which interface to use for which link. 
 The linknumber must start at 0. For UDP the only supported linknumber is 0.
 
 .TP
 knet_link_priority
 This specifies the priority for the link when knet is used in 'passive'
 mode. (see link_mode below)
 
 .TP
 knet_ping_interval
 This specifies the interval between knet link pings. 
 (default 1000 ms)
 
 .TP
 knet_ping_timeout
 If no ping is received within this time, the knet link is declared dead. 
 (default 2000 ms)
 
 .TP
 knet_ping_precision
 How many values of latency are used to calculate
 the average link latency. (default 2048 samples)
 
+.TP
+knet_pong_count
+How many valid ping/pongs before a link is marked UP. (default 5)
+
 .TP
 bindnetaddr (udp only)
 This specifies the network address the corosync executive should bind
 to when using udp.
 
 bindnetaddr (udp only) 
 should be an IP address configured on the system, or a network
 address.
 
 For example, if the local interface is 192.168.5.92 with netmask
 255.255.255.0, you should set bindnetaddr to 192.168.5.92 or 192.168.5.0.
 If the local interface is 192.168.5.92 with netmask 255.255.255.192,
 set bindnetaddr to 192.168.5.92 or 192.168.5.64, and so forth.
 
 This may also be an IPV6 address, in which case IPV6 networking will be used.
 In this case, the exact address must be specified and there is no automatic
 selection of the network interface within a specific subnet as with IPv4.
 
 If IPv6 networking is used, the nodeid field in nodelist must be specified.
 
 .TP
 broadcast (udp only)
 This is optional and can be set to yes.  If it is set to yes, the broadcast
 address will be used for communication.  If this option is set, mcastaddr
 should not be set.
 
 .TP
 mcastaddr (udp only)
 This is the multicast address used by corosync executive.  The default
 should work for most networks, but the network administrator should be queried
 about a multicast address to use.  Avoid 224.x.x.x because this is a "config"
 multicast address.
 
 This may also be an IPV6 multicast address, in which case IPV6 networking
 will be used.  If IPv6 networking is used, the nodeid field in nodelist must
 be specified.
 
 It's not necessary to use this option if cluster_name option is used. If both options
 are used, mcastaddr has higher priority.
 
 .TP
 mcastport (udp only)
 This specifies the UDP port number.  It is possible to use the same multicast
 address on a network with the corosync services configured for different
 UDP ports.
 Please note corosync uses two UDP ports mcastport (for mcast receives) and 
 mcastport - 1 (for mcast sends).
 If you have multiple clusters on the same network using the same mcastaddr 
 please configure the mcastports with a gap.
 
 .TP
 ttl (udp only)
 This specifies the Time To Live (TTL). If you run your cluster on a routed
 network then the default of "1" will be too small. This option provides
 a way to increase this up to 255. The valid range is 0..255.
 
 .PP
 .PP
 Within the
 .B totem
 directive, there are seven configuration options of which one is required,
 five are optional, and one is required when IPV6 is configured in the interface
 subdirective.  The required directive controls the version of the totem
 configuration.  The optional option unless using IPV6 directive controls
 identification of the processor.  The optional options control secrecy and
 authentication, the network mode of operation and maximum network MTU
 field.
 
 .TP
 version
 This specifies the version of the configuration file.  Currently the only
 valid version for this directive is 2.
 
 .PP
 clear_node_high_bit
 This configuration option is optional and is only relevant when no nodeid is
 specified.  Some corosync clients require a signed 32 bit nodeid that is greater
 than zero however by default corosync uses all 32 bits of the IPv4 address space
 when generating a nodeid.  Set this option to yes to force the high bit to be
 zero and therefor ensure the nodeid is a positive signed 32 bit integer.
 
 WARNING: The clusters behavior is undefined if this option is enabled on only
 a subset of the cluster (for example during a rolling upgrade).
 
 .TP
 crypto_hash
 This specifies which HMAC authentication should be used to authenticate all
 messages. Valid values are none (no authentication), md5, sha1, sha256,
 sha384 and sha512. Encrypted transmission is only supported for
 the knet transport.
 
 The default is sha1.
 
 .TP
 crypto_cipher
 This specifies which cipher should be used to encrypt all messages.
 Valid values are none (no encryption), aes256, aes192, aes128 and 3des.
 Enabling crypto_cipher, requires also enabling of crypto_hash. Encrypted
 transmission is only supported for the knet transport.
 
 The default is aes256.
 
 .TP
 link_mode
 This specifies the Kronosnet mode, which may be passive, active, or
 rr (round-robin). 
 .B passive:
 the active link with the lowest priority will be used. If one or more 
 links share the same priority the one with the lowest link ID will
 be used.
 .B active: 
 All active links will be used simultaneously to send traffic.
 link priority is ignored.
 .B rr:
 Round-Robin policy. Each packet will be sent to the next active link in 
 order.
 
 If only one interface directive is specified, passive is automatically chosen.
 
 The maximum number of interface directives that is allowed with Kronosnet
 is 8. For other transports it is 1.
 
 When using multiple interfaces, make sure to use different multicast
 address/port (port for same address must differ by at least two) pair
 for each interface (this is checked by parser).
 
 .TP
 netmtu
 This specifies the network maximum transmit unit.  To set this value beyond
 1500, the regular frame MTU, requires ethernet devices that support large, or
 also called jumbo, frames.  If any device in the network doesn't support large
 frames, the protocol will not operate properly.  The hosts must also have their
 mtu size set from 1500 to whatever frame size is specified here.
 
 Please note while some NICs or switches claim large frame support, they support
 9000 MTU as the maximum frame size including the IP header.  Setting the netmtu
 and host MTUs to 9000 will cause totem to use the full 9000 bytes of the frame.
 Then Linux will add a 18 byte header moving the full frame size to 9018.  As a
 result some hardware will not operate properly with this size of data.  A netmtu
 of 8982 seems to work for the few large frame devices that have been tested.
 Some manufacturers claim large frame support when in fact they support frame
 sizes of 4500 bytes.
 
 When sending multicast traffic, if the network frequently reconfigures, chances are
 that some device in the network doesn't support large frames.
 
 Choose hardware carefully if intending to use large frame support.
 
 The default is 1500.
 
 .TP
 transport
 This directive controls the transport mechanism used.  
 The default is knet.  The transport type can also be set to udpu or udp.
 Only knet allows crypto or multiple interfaces per node.
 
 .TP
 cluster_name
 This specifies the name of cluster and it's used for automatic generating
 of multicast address.
 
 .TP
 config_version
 This specifies version of config file. This is converted to unsigned 64-bit int.
 By default it's 0. Option is used to prevent joining old nodes with not
 up-to-date configuration. If value is not 0, and node is going for first time
 (only for first time, join after split doesn't follow this rules)
 from single-node membership to multiple nodes membership, other nodes
 config_versions are collected. If current node config_version is not
 equal to highest of collected versions, corosync is terminated.
 
 .TP
 ip_version
 Specifies version of IP to use for communication. Value can be one of
 ipv4 or ipv6. Default (if unspecified) is ipv4.
 
 
 Within the
 .B totem
 directive, there are several configuration options which are used to control
 the operation of the protocol.  It is generally not recommended to change any
 of these values without proper guidance and sufficient testing.  Some networks
 may require larger values if suffering from frequent reconfigurations.  Some
 applications may require faster failure detection times which can be achieved
 by reducing the token timeout.
 
 .TP
 token
 This timeout is used directly or as a base for real token timeout calculation (explained in
 .B token_coefficient
 section). Token timeout specifies in milliseconds until a token loss is declared after not
 receiving a token.  This is the time spent detecting a failure of a processor
 in the current configuration.  Reforming a new configuration takes about 50
 milliseconds in addition to this timeout.
 
 For real token timeout used by totem it's possible to read cmap value of
 .B runtime.config.token
 key.
 
 The default is 1000 milliseconds.
 
 .TP
 token_coefficient
 This value is used only when
 .B nodelist
 section is specified and contains at least 3 nodes. If so, real token timeout
 is then computed as token + (number_of_nodes - 2) * token_coefficient.
 This allows cluster to scale without manually changing token timeout
 every time new node is added. This value can be set to 0 resulting
 in effective removal of this feature.
 
 The default is 650 milliseconds.
 
 .TP
 token_retransmit
 This timeout specifies in milliseconds after how long before receiving a token
 the token is retransmitted.  This will be automatically calculated if token
 is modified.  It is not recommended to alter this value without guidance from
 the corosync community.
 
 The default is 238 milliseconds.
 
 .TP
 hold
 This timeout specifies in milliseconds how long the token should be held by
 the representative when the protocol is under low utilization.   It is not
 recommended to alter this value without guidance from the corosync community.
 
 The default is 180 milliseconds.
 
 .TP
 token_retransmits_before_loss_const
 This value identifies how many token retransmits should be attempted before
 forming a new configuration.  If this value is set, retransmit and hold will
 be automatically calculated from retransmits_before_loss and token.
 
 The default is 4 retransmissions.
 
 .TP
 join
 This timeout specifies in milliseconds how long to wait for join messages in
 the membership protocol.
 
 The default is 50 milliseconds.
 
 .TP
 send_join
 This timeout specifies in milliseconds an upper range between 0 and send_join
 to wait before sending a join message.  For configurations with less then
 32 nodes, this parameter is not necessary.  For larger rings, this parameter
 is necessary to ensure the NIC is not overflowed with join messages on
 formation of a new ring.  A reasonable value for large rings (128 nodes) would
 be 80msec.  Other timer values must also change if this value is changed.  Seek
 advice from the corosync mailing list if trying to run larger configurations.
 
 The default is 0 milliseconds.
 
 .TP
 consensus
 This timeout specifies in milliseconds how long to wait for consensus to be
 achieved before starting a new round of membership configuration.  The minimum
 value for consensus must be 1.2 * token.  This value will be automatically
 calculated at 1.2 * token if the user doesn't specify a consensus value.
 
 For two node clusters, a consensus larger then the join timeout but less then
 token is safe.  For three node or larger clusters, consensus should be larger
 then token.  There is an increasing risk of odd membership changes, which stil
 guarantee virtual synchrony,  as node count grows if consensus is less than
 token.
 
 The default is 1200 milliseconds.
 
 .TP
 merge
 This timeout specifies in milliseconds how long to wait before checking for
 a partition when no multicast traffic is being sent.  If multicast traffic
 is being sent, the merge detection happens automatically as a function of
 the protocol.
 
 The default is 200 milliseconds.
 
 .TP
 downcheck
 This timeout specifies in milliseconds how long to wait before checking
 that a network interface is back up after it has been downed.
 
 The default is 1000 millseconds.
 
 .TP
 fail_recv_const
 This constant specifies how many rotations of the token without receiving any
 of the messages when messages should be received may occur before a new
 configuration is formed.
 
 The default is 2500 failures to receive a message.
 
 .TP
 seqno_unchanged_const
 This constant specifies how many rotations of the token without any multicast
 traffic should occur before the hold timer is started.
 
 The default is 30 rotations.
 
 .TP
 heartbeat_failures_allowed
 [HeartBeating mechanism]
 Configures the optional HeartBeating mechanism for faster failure detection. Keep in
 mind that engaging this mechanism in lossy networks could cause faulty loss declaration
 as the mechanism relies on the network for heartbeating.
 
 So as a rule of thumb use this mechanism if you require improved failure in low to
 medium utilized networks.
 
 This constant specifies the number of heartbeat failures the system should tolerate
 before declaring heartbeat failure e.g 3. Also if this value is not set or is 0 then the
 heartbeat mechanism is not engaged in the system and token rotation is the method
 of failure detection
 
 The default is 0 (disabled).
 
 .TP
 max_network_delay
 [HeartBeating mechanism]
 This constant specifies in milliseconds the approximate delay that your network takes
 to transport one packet from one machine to another. This value is to be set by system
 engineers and please don't change if not sure as this effects the failure detection
 mechanism using heartbeat.
 
 The default is 50 milliseconds.
 
 .TP
 window_size
 This constant specifies the maximum number of messages that may be sent on one
 token rotation.  If all processors perform equally well, this value could be
 large (300), which would introduce higher latency from origination to delivery
 for very large rings.  To reduce latency in large rings(16+), the defaults are
 a safe compromise.  If 1 or more slow processor(s) are present among fast
 processors, window_size should be no larger then 256000 / netmtu to avoid
 overflow of the kernel receive buffers.  The user is notified of this by
 the display of a retransmit list in the notification logs.  There is no loss
 of data, but performance is reduced when these errors occur.
 
 The default is 50 messages.
 
 .TP
 max_messages
 This constant specifies the maximum number of messages that may be sent by one
 processor on receipt of the token.  The max_messages parameter is limited to
 256000 / netmtu to prevent overflow of the kernel transmit buffers.
 
 The default is 17 messages.
 
 .TP
 miss_count_const
 This constant defines the maximum number of times on receipt of a token
 a message is checked for retransmission before a retransmission occurs.  This
 parameter is useful to modify for switches that delay multicast packets
 compared to unicast packets.  The default setting works well for nearly all
 modern switches.
 
 The default is 5 messages.
 
+.TP
+knet_pmtud_interval
+How often the knet PMTUd runs to look for network MTU changes.
+Value in seconds, default: 60
+
 .PP
 Within the
 .B logging
 directive, there are several configuration options which are all optional.
 
 .PP
 The following 3 options are valid only for the top level logging directive:
 
 .TP
 timestamp
 This specifies that a timestamp is placed on all log messages.
 
 The default is off.
 
 .TP
 fileline
 This specifies that file and line should be printed.
 
 The default is off.
 
 .TP
 function_name
 This specifies that the code function name should be printed.
 
 The default is off.
 
 .PP
 The following options are valid both for top level logging directive
 and they can be overridden in logger_subsys entries.
 
 .TP
 to_stderr
 .TP
 to_logfile
 .TP
 to_syslog
 These specify the destination of logging output. Any combination of
 these options may be specified. Valid options are
 .B yes
 and
 .B no.
 
 The default is syslog and stderr.
 
 Please note, if you are using to_logfile and want to rotate the file, use logrotate(8)
 with the option 
 .B
 copytruncate.
 eg.
 .ne 18
 .RS
 .nf
 .ft CW
 /var/log/corosync.log {
 	missingok
 	compress
 	notifempty
 	daily
 	rotate 7
 	copytruncate
 }
 .ft
 .fi
 .RE
 
 .TP
 logfile
 If the
 .B to_logfile
 directive is set to
 .B yes
 , this option specifies the pathname of the log file.
 
 No default.
 
 .TP
 logfile_priority
 This specifies the logfile priority for this particular subsystem. Ignored if debug is on.
 Possible values are: alert, crit, debug (same as debug = on), emerg, err, info, notice, warning.
 
 The default is: info.
 
 .TP
 syslog_facility
 This specifies the syslog facility type that will be used for any messages
 sent to syslog. options are daemon, local0, local1, local2, local3, local4,
 local5, local6 & local7.
 
 The default is daemon.
 
 .TP
 syslog_priority
 This specifies the syslog level for this particular subsystem. Ignored if debug is on.
 Possible values are: alert, crit, debug (same as debug = on), emerg, err, info, notice, warning.
 
 The default is: info.
 
 .TP
 debug
 This specifies whether debug output is logged for this particular logger. Also can contain
 value trace, what is highest level of debug information.
 
 The default is off.
 
 .PP
 Within the
 .B logging
 directive, logger_subsys directives are optional.
 
 .PP
 Within the
 .B logger_subsys
 sub-directive, all of the above logging configuration options are valid and
 can be used to override the default settings.
 The subsys entry, described below, is mandatory to identify the subsystem.
 
 .TP
 subsys
 This specifies the subsystem identity (name) for which logging is specified. This is the
 name used by a service in the log_init () call. E.g. 'CPG'. This directive is
 required.
 
 .PP
 Within the
 .B quorum
 directive it is possible to specify the quorum algorithm to use with the
 
 .TP
 provider
 directive. At the time of writing only corosync_votequorum is supported.
 See votequorum(5) for configuration options.
 
 .PP
 Within the
 .B nodelist
 directive it is possible to specify specific information about nodes in cluster. Directive
 can contain only
 .B node
 sub-directive, which specifies every node that should be a member of the membership, and where
 non-default options are needed. Every node must have at least ring0_addr field filled.
 
 Every node that should be a member of the membership must be specified.
 
 Possible options are:
 .TP
 ringX_addr
 This specifies ip address of one of the nodes. X is link number. 
 
 .TP
 nodeid
 This configuration option is required for each node. It is a 32 bit value 
 specifying the node identifier delivered to the
 cluster membership service. The node identifier value of zero is
 reserved and should not be used.
 
 .PP
 Within the
 .B qb
 directive it is possible to specify options for libqb.
 
 Possible option is:
 .TP
 ipc_type
 This specifies type of IPC to use. Can be one of native (default), shm and socket.
 Native means one of shm or socket, depending on what is supported by OS. On systems
 with support for both, SHM is selected. SHM is generally faster, but need to allocate
 ring buffer file in /dev/shm.
 
 .SH "FILES"
 .TP
 /etc/corosync/corosync.conf
 The corosync executive configuration file.
 
 .SH "SEE ALSO"
 .BR corosync_overview (8),
 .BR votequorum (5),
 .BR corosync-qdevice (8),
 .BR logrotate (8)
 .PP