diff --git a/include/corosync/corotypes.h b/include/corosync/corotypes.h
index 12b61eb8..a661cb62 100644
--- a/include/corosync/corotypes.h
+++ b/include/corosync/corotypes.h
@@ -1,188 +1,189 @@
 /*
  * Copyright (c) 2008 Allied Telesis Labs.
  * Copyright (c) 2012 Red Hat, Inc.
  *
  * All rights reserved.
  *
  * Author: Angus Salkeld (ahsalkeld@gmail.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.
  */
 
 #ifndef COROTYPES_H_DEFINED
 #define COROTYPES_H_DEFINED
 
 #include <stdint.h>
 #include <errno.h>
 #include <time.h>
 #include <sys/time.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /**
  * @brief cs_time_t
  */
 typedef int64_t cs_time_t;
 
 #define CS_FALSE 0
 #define CS_TRUE !CS_FALSE
 #define CS_MAX_NAME_LENGTH 256
 #define CS_TIME_END    ((cs_time_t)0x7FFFFFFFFFFFFFFFULL)
 #define CS_MAX(x, y) (((x) > (y)) ? (x) : (y))
 
 #define CS_PRI_NODE_ID		"%" PRIu32
+#define CS_PRI_NODE_ID_PADDED	"%10" PRIu32
 #define CS_PRI_RING_ID_SEQ	"%" PRIx64
 #define CS_PRI_RING_ID		"%" PRIx32 ".%" PRIx64
 /**
  * @brief The cs_name_t struct
  */
 typedef struct {
    uint16_t length;
    uint8_t value[CS_MAX_NAME_LENGTH];
 } cs_name_t;
 
 
 /**
  * @brief The cs_version_t struct
  */
 typedef struct {
    char releaseCode;
    unsigned char majorVersion;
    unsigned char minorVersion;
 } cs_version_t;
 
 /**
  * @brief The cs_dispatch_flags_t enum
  */
 typedef enum {
 	CS_DISPATCH_ONE = 1,
 	CS_DISPATCH_ALL = 2,
 	CS_DISPATCH_BLOCKING = 3,
 	CS_DISPATCH_ONE_NONBLOCKING = 4
 } cs_dispatch_flags_t;
 
 #define CS_TRACK_CURRENT 0x01
 #define CS_TRACK_CHANGES 0x02
 #define CS_TRACK_CHANGES_ONLY 0x04
 
 /**
  * @brief The cs_error_t enum
  */
 typedef enum {
    CS_OK = 1,
    CS_ERR_LIBRARY = 2,
    CS_ERR_VERSION = 3,
    CS_ERR_INIT = 4,
    CS_ERR_TIMEOUT = 5,
    CS_ERR_TRY_AGAIN = 6,
    CS_ERR_INVALID_PARAM = 7,
    CS_ERR_NO_MEMORY = 8,
    CS_ERR_BAD_HANDLE = 9,
    CS_ERR_BUSY = 10,
    CS_ERR_ACCESS = 11,
    CS_ERR_NOT_EXIST = 12,
    CS_ERR_NAME_TOO_LONG = 13,
    CS_ERR_EXIST = 14,
    CS_ERR_NO_SPACE = 15,
    CS_ERR_INTERRUPT = 16,
    CS_ERR_NAME_NOT_FOUND = 17,
    CS_ERR_NO_RESOURCES = 18,
    CS_ERR_NOT_SUPPORTED = 19,
    CS_ERR_BAD_OPERATION = 20,
    CS_ERR_FAILED_OPERATION = 21,
    CS_ERR_MESSAGE_ERROR = 22,
    CS_ERR_QUEUE_FULL = 23,
    CS_ERR_QUEUE_NOT_AVAILABLE = 24,
    CS_ERR_BAD_FLAGS = 25,
    CS_ERR_TOO_BIG = 26,
    CS_ERR_NO_SECTIONS = 27,
    CS_ERR_CONTEXT_NOT_FOUND = 28,
    CS_ERR_TOO_MANY_GROUPS = 30,
    CS_ERR_SECURITY = 100
 } cs_error_t;
 
 #define CS_IPC_TIMEOUT_MS -1
 
 #define CS_TIME_MS_IN_SEC   1000ULL
 #define CS_TIME_US_IN_SEC   1000000ULL
 #define CS_TIME_NS_IN_SEC   1000000000ULL
 #define CS_TIME_US_IN_MSEC  1000ULL
 #define CS_TIME_NS_IN_MSEC  1000000ULL
 #define CS_TIME_NS_IN_USEC  1000ULL
 
 /**
  * @brief cs_timestamp_get
  * @return
  */
 static inline uint64_t cs_timestamp_get(void)
 {
 	uint64_t result;
 
 #if defined _POSIX_MONOTONIC_CLOCK && _POSIX_MONOTONIC_CLOCK >= 0
 	struct timespec ts;
 
 	clock_gettime (CLOCK_MONOTONIC, &ts);
 	result = (ts.tv_sec * CS_TIME_NS_IN_SEC) + (uint64_t)ts.tv_nsec;
 #else
 	struct timeval time_from_epoch;
 
 	gettimeofday (&time_from_epoch, 0);
 	result = ((time_from_epoch.tv_sec * CS_TIME_NS_IN_SEC) +
 		(time_from_epoch.tv_usec * CS_TIME_NS_IN_USEC));
 #endif
 
 	return result;
 }
 /**
  * @brief qb_to_cs_error
  * @param result
  * @return
  */
 cs_error_t qb_to_cs_error (int result);
 
 /**
  * @brief cs_strerror
  * @param err
  * @return
  */
 const char * cs_strerror(cs_error_t err);
 
 /**
  * @brief hdb_error_to_cs
  * @param res
  * @return
  */
 cs_error_t hdb_error_to_cs (int res);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif /* COROTYPES_H_DEFINED */
 
diff --git a/tools/corosync-cfgtool.c b/tools/corosync-cfgtool.c
index dc8f99ea..d04d5bea 100644
--- a/tools/corosync-cfgtool.c
+++ b/tools/corosync-cfgtool.c
@@ -1,614 +1,614 @@
 /*
  * Copyright (c) 2006-2020 Red Hat, Inc.
  *
  * All rights reserved.
  *
  * Author: Steven Dake <sdake@redhat.com>
  *
  * This software licensed under BSD license, the text of which follows:
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  * - Redistributions of source code must retain the above copyright notice,
  *   this list of conditions and the following disclaimer.
  * - Redistributions in binary form must reproduce the above copyright notice,
  *   this list of conditions and the following disclaimer in the documentation
  *   and/or other materials provided with the distribution.
  * - Neither the name of the MontaVista Software, Inc. nor the names of its
  *   contributors may be used to endorse or promote products derived from this
  *   software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include <config.h>
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <unistd.h>
 #include <string.h>
 #include <pthread.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/select.h>
 #include <sys/un.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <limits.h>
 #include <getopt.h>
 
 #include <corosync/corotypes.h>
 #include <corosync/totem/totem.h>
 #include <corosync/cfg.h>
 #include <corosync/cmap.h>
 #include "util.h"
 
 #define cs_repeat(result, max, code)				\
 	do {							\
 		int counter = 0;				\
 		do {						\
 			result = code;				\
 			if (result == CS_ERR_TRY_AGAIN) {	\
 				sleep(1);			\
 				counter++;			\
 			} else {				\
 				break;				\
 			}					\
 		} while (counter < max);			\
 	} while (0)
 
 enum user_action {
 	ACTION_NOOP=0,
 	ACTION_LINKSTATUS_GET,
 	ACTION_NODESTATUS_GET,
 	ACTION_RELOAD_CONFIG,
 	ACTION_REOPEN_LOG_FILES,
 	ACTION_SHUTDOW,
 	ACTION_SHOWADDR,
 	ACTION_KILL_NODE,
 };
 
 static int node_compare(const void *aptr, const void *bptr)
 {
 	uint32_t a,b;
 
 	a = *(uint32_t *)aptr;
 	b = *(uint32_t *)bptr;
 
 	return a > b;
 }
 
 static int
 nodestatusget_do (enum user_action action, int brief)
 {
 	cs_error_t result;
 	corosync_cfg_handle_t handle;
 	cmap_handle_t cmap_handle;
 	char iter_key[CMAP_KEYNAME_MAXLEN];
 	cmap_iter_handle_t iter;
 	unsigned int local_nodeid;
 	unsigned int local_nodeid_index=0;
 	unsigned int other_nodeid_index=0;
 	unsigned int nodeid;
 	int nodeid_match_guard;
 	cmap_value_types_t type;
 	size_t value_len;
 	char *str;
 	char *transport_str = NULL;
 	uint32_t nodeid_list[KNET_MAX_HOST];
 	const char *link_transport[KNET_MAX_LINK];
 	int s = 0;
 	int rc = EXIT_SUCCESS;
 	int transport_number = TOTEM_TRANSPORT_KNET;
 	int i,j;
 	struct corosync_cfg_node_status_v1 node_status;
 
 	result = corosync_cfg_initialize (&handle, NULL);
 	if (result != CS_OK) {
 		fprintf (stderr, "Could not initialize corosync configuration API error %d\n", result);
 		exit (EXIT_FAILURE);
 	}
 
 	result = cmap_initialize (&cmap_handle);
 	if (result != CS_OK) {
 		fprintf (stderr, "Could not initialize corosync cmap API error %d\n", result);
 		exit (EXIT_FAILURE);
 	}
 
 	result = cmap_get_string(cmap_handle, "totem.transport", &str);
 	if (result == CS_OK) {
 		if (strcmp (str, "udpu") == 0) {
 			transport_number = TOTEM_TRANSPORT_UDPU;
 		}
 		if (strcmp (str, "udp") == 0) {
 			transport_number = TOTEM_TRANSPORT_UDP;
 		}
 		transport_str = str;
 	}
 	if (!transport_str) {
 		transport_str = strdup("knet"); /* It's the default */
 	}
 
 	result = corosync_cfg_local_get(handle, &local_nodeid);
 	if (result != CS_OK) {
 		fprintf (stderr, "Could not get the local node id, the error is: %d\n", result);
 		free(transport_str);
 		cmap_finalize(cmap_handle);
 		corosync_cfg_finalize(handle);
 		return EXIT_FAILURE;
 	}
 
 	/* Get a list of nodes. We do it this way rather than using votequorum as cfgtool
 	 * needs to be independent of quorum type
 	 */
 	result = cmap_iter_init(cmap_handle, "nodelist.node.", &iter);
 	if (result != CS_OK) {
 		fprintf (stderr, "Could not get nodelist from cmap. error %d\n", result);
 		free(transport_str);
 		cmap_finalize(cmap_handle);
 		corosync_cfg_finalize(handle);
 		exit (EXIT_FAILURE);
 	}
 
 	while ((cmap_iter_next(cmap_handle, iter, iter_key, &value_len, &type)) == CS_OK) {
 		nodeid_match_guard = 0;
 		if (sscanf(iter_key, "nodelist.node.%*u.nodeid%n", &nodeid_match_guard) != 0) {
 			continue;
 		}
 		/* check for exact match */
 		if (nodeid_match_guard != strlen(iter_key)) {
 			continue;
 		}
 		if (cmap_get_uint32(cmap_handle, iter_key, &nodeid) == CS_OK) {
 			nodeid_list[s++] = nodeid;
 		}
 	}
 
 	if (s == 0) {
 		fprintf(stderr, "No nodes found in nodelist\n");
 		exit (EXIT_FAILURE);
 	}
 
 	/* It's nice to have these in nodeid order */
 	qsort(nodeid_list, s, sizeof(uint32_t), node_compare);
 
 	/*
 	 * Find local and other nodeid index in nodeid_list
 	 */
 	for (i = 0; i < s; i++) {
 		if (nodeid_list[i] == local_nodeid) {
 			local_nodeid_index = i;
 		} else {
 			/* Bit of an odd one this. but local node only uses one link (of course, to itself)
 			   so if we want to know which links are active across the cluster we need to look
 			   at another node (any other) node's link list */
 			other_nodeid_index = i;
 		}
 	}
 
 	/* Get the transport of each link - but set reasonable defaults */
 	if (transport_number == TOTEM_TRANSPORT_KNET) {
 		for (i = 0; i<KNET_MAX_LINK; i++) {
 			link_transport[i] = "udp";
 		}
 	} else {
 		for (i = 0; i<KNET_MAX_LINK; i++) {
 			link_transport[i] = ""; /* No point in displaying "udp" again */
 		}
 	}
 	result = cmap_iter_init(cmap_handle, "totem.interface.", &iter);
 	if (result == CS_OK) { /* it's fine for this to fail, we just use the defaults */
 		while ((cmap_iter_next(cmap_handle, iter, iter_key, &value_len, &type)) == CS_OK) {
 			unsigned int link_number;
 			char *knet_transport;
 			char knet_transport_str[CMAP_KEYNAME_MAXLEN];
 
 			/* transport is (sensibly) indexed by link number */
 			if (sscanf(iter_key, "totem.interface.%u.knet_transport", &link_number) != 1) {
 				continue;
 			}
 			snprintf(knet_transport_str, sizeof(knet_transport_str),
 				 "totem.interface.%u.knet_transport", link_number);
 			if (cmap_get_string(cmap_handle, knet_transport_str, &knet_transport) == CS_OK) {
 				link_transport[link_number] = knet_transport;
 			}
 		}
 
 		cmap_iter_finalize(cmap_handle, iter);
 	}
 
 	cmap_finalize(cmap_handle);
 
 	printf ("Local node ID " CS_PRI_NODE_ID ", transport %s\n", local_nodeid, transport_str);
 
         /* If node status requested then do print node-based info */
 	if (action == ACTION_NODESTATUS_GET) {
 		for (i=0; i<s; i++) {
 			result = corosync_cfg_node_status_get(handle, nodeid_list[i], CFG_NODE_STATUS_V1, &node_status);
 			if (result == CS_OK) {
 				/* Only display node info if it is reachable (and not us) */
 				if (node_status.reachable && node_status.nodeid != local_nodeid) {
-					printf("nodeid: %d", node_status.nodeid);
+					printf("nodeid: " CS_PRI_NODE_ID "", node_status.nodeid);
 					printf(" reachable");
 					if (node_status.remote) {
 						printf(" remote");
 					}
 					if (node_status.external) {
 						printf(" external");
 					}
 #ifdef HAVE_KNET_ONWIRE_VER
 					if (transport_number == TOTEM_TRANSPORT_KNET) {
 						printf("   onwire (min/max/cur): %d, %d, %d",
 						       node_status.onwire_min,
 						       node_status.onwire_max,
 						       node_status.onwire_ver);
 					}
 #endif
 					printf("\n");
 					for (j=0; j<CFG_MAX_LINKS; j++) {
 						if (node_status.link_status[j].enabled) {
 							printf("   LINK: %d %s", j, link_transport[j]);
 							printf(" (%s%s%s)",
 							       node_status.link_status[j].src_ipaddr,
 							       transport_number==TOTEM_TRANSPORT_KNET?"->":"",
 							       node_status.link_status[j].dst_ipaddr);
 							if (node_status.link_status[j].enabled) {
 								printf(" enabled");
 							}
 							if (node_status.link_status[j].connected) {
 								printf(" connected");
 							}
 							if (node_status.link_status[j].dynconnected) {
 								printf(" dynconnected");
 							}
 							printf(" mtu: %d\n", node_status.link_status[j].mtu);
 						}
 					}
 					printf("\n");
 				}
 			}
 		}
 	}
 	/* Print in link order */
 	else {
 		struct corosync_cfg_node_status_v1 node_info[s];
 		memset(node_info, 0, sizeof(node_info));
 
 		for (i=0; i<s; i++) {
 			result = corosync_cfg_node_status_get(handle, nodeid_list[i], CFG_NODE_STATUS_V1, &node_info[i]);
 			if (result != CS_OK) {
 				fprintf (stderr, "Could not get the node status for nodeid %d, the error is: %d\n", nodeid_list[i], result);
 			}
 		}
 
 		for (i=0; i<CFG_MAX_LINKS; i++) {
 			if (node_info[other_nodeid_index].link_status[i].enabled) {
 				printf("LINK ID %d %s\n", i, link_transport[i]);
 				printf("\taddr\t= %s\n", node_info[other_nodeid_index].link_status[i].src_ipaddr);
 				if (brief) {
 					printf("\tstatus\t= ");
 					for (j=0; j<s; j++) {
 						char status = (node_info[j].link_status[i].enabled |
 							       (node_info[j].link_status[i].connected << 1)) + '0';
 						if (j == local_nodeid_index) {
 							status = 'n';
 						}
 						printf("%c", status);
 					}
 					printf("\n");
 				} else {
 					printf("\tstatus:\n");
 					for (j=0; j<s; j++) {
-						printf("\t\tnodeid: %3d:\t", node_info[j].nodeid);
+						printf("\t\tnodeid: " CS_PRI_NODE_ID_PADDED ":\t", node_info[j].nodeid);
 						if (j == local_nodeid_index) {
 							printf("localhost");
 						} else {
 							if (node_info[j].link_status[i].connected) {
 								printf("connected");
 							} else {
 								printf("disconnected");
 							}
 						}
 						printf("\n");
 					}
 				}
 			}
 		}
 	}
 	free(transport_str);
 	corosync_cfg_finalize(handle);
 	return rc;
 }
 
 static int reload_config_do (void)
 {
 	cs_error_t result;
 	corosync_cfg_handle_t handle;
 	int rc;
 
 	rc = EXIT_SUCCESS;
 
 	printf ("Reloading corosync.conf...\n");
 	result = corosync_cfg_initialize (&handle, NULL);
 	if (result != CS_OK) {
 		fprintf (stderr, "Could not initialize corosync configuration API error %s\n", cs_strerror(result));
 		exit (EXIT_FAILURE);
 	}
 
 	result = corosync_cfg_reload_config (handle);
 	if (result != CS_OK) {
 		fprintf (stderr, "Could not reload configuration. Error %s\n", cs_strerror(result));
 		rc = (int)result;
 	}
 	else {
 		printf ("Done\n");
 	}
 
 	(void)corosync_cfg_finalize (handle);
 
 	return (rc);
 }
 
 static int reopen_log_files_do (void)
 {
 	cs_error_t result;
 	corosync_cfg_handle_t handle;
 	int rc;
 
 	rc = EXIT_SUCCESS;
 
 	result = corosync_cfg_initialize (&handle, NULL);
 	if (result != CS_OK) {
 		fprintf (stderr, "Could not initialize corosync configuration API error %s\n", cs_strerror(result));
 		exit (EXIT_FAILURE);
 	}
 
 	result = corosync_cfg_reopen_log_files (handle);
 	if (result != CS_OK) {
 		fprintf (stderr, "Could not reopen corosync logging files. Error %s\n", cs_strerror(result));
 		rc = (int)result;
 	}
 
 	(void)corosync_cfg_finalize (handle);
 
 	return (rc);
 }
 
 static void shutdown_do(int force)
 {
 	cs_error_t result;
 	corosync_cfg_handle_t handle;
 	corosync_cfg_callbacks_t callbacks;
 	int flag;
 
 	callbacks.corosync_cfg_shutdown_callback = NULL;
 	if (force) {
 		flag = COROSYNC_CFG_SHUTDOWN_FLAG_REGARDLESS;
 	} else {
 		flag = COROSYNC_CFG_SHUTDOWN_FLAG_REQUEST;
 	}
 
 	result = corosync_cfg_initialize (&handle, &callbacks);
 	if (result != CS_OK) {
 		fprintf (stderr, "Could not initialize corosync configuration API error %d\n", result);
 		exit (EXIT_FAILURE);
 	}
 
 	printf ("Shutting down corosync\n");
 	cs_repeat(result, 30, corosync_cfg_try_shutdown (handle, flag));
 	if (result != CS_OK) {
 		fprintf (stderr, "Could not shutdown (error = %d)\n", result);
 	}
 
 	(void)corosync_cfg_finalize (handle);
 }
 
 static int showaddrs_do(unsigned int nodeid)
 {
 	cs_error_t result;
 	corosync_cfg_handle_t handle;
 	int numaddrs;
 	int i;
 	int rc = EXIT_SUCCESS;
 	corosync_cfg_node_address_t addrs[INTERFACE_MAX];
 
 
 	result = corosync_cfg_initialize (&handle, NULL);
 	if (result != CS_OK) {
 		fprintf (stderr, "Could not initialize corosync configuration API error %d\n", result);
 		exit (EXIT_FAILURE);
 	}
 
 	if (corosync_cfg_get_node_addrs(handle, nodeid, INTERFACE_MAX, &numaddrs, addrs) == CS_OK) {
 		for (i=0; i<numaddrs; i++) {
 			char buf[INET6_ADDRSTRLEN];
 			struct sockaddr_storage *ss = (struct sockaddr_storage *)addrs[i].address;
 			struct sockaddr_in *sin = (struct sockaddr_in *)addrs[i].address;
 			struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)addrs[i].address;
 			void *saddr;
 
 			if (!ss->ss_family) {
 				continue;
 			}
 			if (ss->ss_family == AF_INET6) {
 				saddr = &sin6->sin6_addr;
 			} else {
 				saddr = &sin->sin_addr;
 			}
 
 			inet_ntop(ss->ss_family, saddr, buf, sizeof(buf));
 			if (i != 0) {
 				printf(" ");
 			}
 			printf("%s", buf);
 		}
 		printf("\n");
 	} else {
 		fprintf (stderr, "Could not get node address for nodeid %d\n", nodeid);
 		rc = EXIT_FAILURE;
 	}
 
 
 	(void)corosync_cfg_finalize (handle);
 	return rc;
 }
 
 
 static void killnode_do(unsigned int nodeid)
 {
 	cs_error_t result;
 	corosync_cfg_handle_t handle;
 
 	printf ("Killing node " CS_PRI_NODE_ID "\n", nodeid);
 	result = corosync_cfg_initialize (&handle, NULL);
 	if (result != CS_OK) {
 		fprintf (stderr, "Could not initialize corosync configuration API error %d\n", result);
 		exit (EXIT_FAILURE);
 	}
 	result = corosync_cfg_kill_node (handle, nodeid, "Killed by corosync-cfgtool");
 	if (result != CS_OK) {
 		fprintf (stderr, "Could not kill node (error = %s)\n", cs_strerror(result));
 		exit(EXIT_FAILURE);
 	}
 	(void)corosync_cfg_finalize (handle);
 }
 
 
 static void usage_do (void)
 {
 	printf ("corosync-cfgtool [[-i <interface ip>] [-b] -s] [-R] [-L] [-k nodeid] [-a nodeid] [-h] [-H]\n\n");
 	printf ("A tool for displaying and configuring active parameters within corosync.\n");
 	printf ("options:\n");
 	printf ("\t-i\tFinds only information about the specified interface IP address or link id when used with -s..\n");
 	printf ("\t-s\tDisplays the status of the current links on this node.\n");
 	printf ("\t-n\tDisplays the status of the connected nodes and their links.\n");
 	printf ("\t-b\tDisplays the brief status of the current links on this node when used with -s.\n");
 	printf ("\t-R\tTell all instances of corosync in this cluster to reload corosync.conf.\n");
 	printf ("\t-L\tTell corosync to reopen all logging files.\n");
 	printf ("\t-k\tKill a node identified by node id.\n");
 	printf ("\t-a\tDisplay the IP address(es) of a node\n");
 	printf ("\t-h\tPrint basic usage.\n");
 	printf ("\t-H\tShutdown corosync cleanly on this node.\n");
 	printf ("\t\t--force will shut down corosync regardless of daemon vetos\n");
 }
 
 int main (int argc, char *argv[]) {
 	int opt;
 	unsigned int nodeid = 0;
 	char interface_name[128] = "";
 	int rc = EXIT_SUCCESS;
 	enum user_action action = ACTION_NOOP;
 	int brief = 0;
 	long long int l;
 	int option_index = 0;
 	int force_shutdown  = 0;
 	const char *options = "i:snbrRLk:a:hH";
 	struct option long_options[] = {
 		{"if",       required_argument, 0, 'i'},
 		{"status",   no_argument,       0, 's'},
 		{"nodes",    no_argument,       0, 'n'},
 		{"brief",    no_argument,       0, 'b'},
 		{"reload",   no_argument,       0, 'R'},
 		{"reopen",   no_argument,       0, 'L'},
 		{"kill",     required_argument, 0, 'k'},
 		{"address",  required_argument, 0, 'a'},
 		{"shutdown", no_argument,       0, 'H'},
 		{"force",    no_argument,       0, 0},
 		{0,          0,                 0, 0}
 	};
 
 		while ( (opt = getopt_long(argc, argv, options, long_options, &option_index)) != -1 ) {
 		switch (opt) {
 			case 0: // options with no short equivalent - just --force ATM
 			if (strcmp(long_options[option_index].name, "force") == 0) {
 				force_shutdown = 1;
 			}
 			break;
 		case 'i':
 			strncpy(interface_name, optarg, sizeof(interface_name));
 			interface_name[sizeof(interface_name) - 1] = '\0';
 			break;
 		case 's':
 			action = ACTION_LINKSTATUS_GET;
 			break;
 		case 'n':
 			action = ACTION_NODESTATUS_GET;
 			break;
 		case 'b':
 			brief = 1;
 			break;
 		case 'R':
 			action = ACTION_RELOAD_CONFIG;
 			break;
 		case 'L':
 			action = ACTION_REOPEN_LOG_FILES;
 			break;
 		case 'k':
 			if (util_strtonum(optarg, 1, UINT_MAX, &l) == -1) {
 				fprintf(stderr, "The nodeid was not valid, try a positive number\n");
 				exit(EXIT_FAILURE);
 			}
 			nodeid = l;
 			action = ACTION_KILL_NODE;
 			break;
 		case 'H':
 			action = ACTION_SHUTDOW;
 			break;
 		case 'a':
 			if (util_strtonum(optarg, 1, UINT_MAX, &l) == -1) {
 				fprintf(stderr, "The nodeid was not valid, try a positive number\n");
 				exit(EXIT_FAILURE);
 			}
 			nodeid = l;
 			action = ACTION_SHOWADDR;
 			break;
 		case '?':
 			return (EXIT_FAILURE);
 			break;
 		case 'h':
 		default:
 			break;
 		}
 	}
 	switch(action) {
 	case ACTION_LINKSTATUS_GET:
 		rc = nodestatusget_do(action, brief);
 		break;
 	case ACTION_NODESTATUS_GET:
 		rc = nodestatusget_do(action, brief);
 		break;
 	case ACTION_RELOAD_CONFIG:
 		rc = reload_config_do();
 		break;
 	case ACTION_REOPEN_LOG_FILES:
 		rc = reopen_log_files_do();
 		break;
 	case ACTION_KILL_NODE:
 		killnode_do(nodeid);
 		break;
 	case ACTION_SHUTDOW:
 		shutdown_do(force_shutdown);
 		break;
 	case ACTION_SHOWADDR:
 		rc = showaddrs_do(nodeid);
 		break;
 	case ACTION_NOOP:
 	default:
 		usage_do();
 		break;
 	}
 
 	return (rc);
 }