41#include <sys/socket.h>
46#include <netinet/in.h>
47#include <net/ethernet.h>
87static int setup_nozzle(
void *knet_context);
91#define CFG_INTERFACE_STATUS_MAX_LEN 512
109 unsigned int msg_len,
115 unsigned int link_no);
143 const char *function,
183 char *nozzle_macaddr;
184 nozzle_t nozzle_handle;
201static int totemknet_configure_compression (
205static void totemknet_start_merge_detect_timeout(
208static void totemknet_stop_merge_detect_timeout(
211static void log_flush_messages (
219 res = pthread_mutex_init(&instance->
log_mutex, NULL);
226#define knet_log_printf_lock(level, subsys, function, file, line, format, args...) \
228 (void)pthread_mutex_lock(&instance->log_mutex); \
229 instance->totemknet_log_printf ( \
230 level, subsys, function, file, line, \
231 (const char *)format, ##args); \
232 (void)pthread_mutex_unlock(&instance->log_mutex); \
235#define knet_log_printf(level, format, args...) \
237 knet_log_printf_lock ( \
238 level, instance->totemknet_subsys_id, \
239 __FUNCTION__, __FILE__, __LINE__, \
240 (const char *)format, ##args); \
243#define libknet_log_printf(level, format, args...) \
245 knet_log_printf_lock ( \
246 level, instance->knet_subsys_id, \
247 __FUNCTION__, "libknet.h", __LINE__, \
248 (const char *)format, ##args); \
251#define KNET_LOGSYS_PERROR(err_num, level, fmt, args...) \
253 char _error_str[LOGSYS_MAX_PERROR_MSG_LEN]; \
254 const char *_error_ptr = qb_strerror_r(err_num, _error_str, sizeof(_error_str)); \
255 instance->totemknet_log_printf ( \
256 level, instance->totemknet_subsys_id, \
257 __FUNCTION__, __FILE__, __LINE__, \
258 fmt ": %s (%d)", ##args, _error_ptr, err_num); \
263static inline int is_ether_addr_multicast(
const uint8_t *
addr)
265 return (
addr[0] & 0x01);
267static inline int is_ether_addr_zero(
const uint8_t *
addr)
272static int ether_host_filter_fn(
void *private_data,
273 const unsigned char *outdata,
276 knet_node_id_t this_host_id,
277 knet_node_id_t src_host_id,
279 knet_node_id_t *dst_host_ids,
280 size_t *dst_host_ids_entries)
282 struct ether_header *eth_h = (
struct ether_header *)outdata;
283 uint8_t *dst_mac = (uint8_t *)eth_h->ether_dhost;
284 uint16_t dst_host_id;
286 if (is_ether_addr_zero(dst_mac))
289 if (is_ether_addr_multicast(dst_mac)) {
293 memmove(&dst_host_id, &dst_mac[4], 2);
295 dst_host_ids[0] = ntohs(dst_host_id);
296 *dst_host_ids_entries = 1;
302static int dst_host_filter_callback_fn(
void *private_data,
303 const unsigned char *outdata,
306 knet_node_id_t this_host_id,
307 knet_node_id_t src_host_id,
309 knet_node_id_t *dst_host_ids,
310 size_t *dst_host_ids_entries)
317 return ether_host_filter_fn(private_data,
318 outdata, outdata_len,
320 this_host_id, src_host_id,
323 dst_host_ids_entries);
328 *dst_host_ids_entries = 1;
332 *dst_host_ids_entries = 0;
338static void socket_error_callback_fn(
void *private_data,
int datafd, int8_t channel, uint8_t tx_rx,
int error,
int errorno)
343 if ((error == -1 && errorno != EAGAIN) || (error == 0)) {
344 knet_handle_remove_datafd(instance->
knet_handle, datafd);
348static void host_change_callback_fn(
void *private_data, knet_node_id_t host_id, uint8_t reachable, uint8_t remote, uint8_t external)
356static void pmtu_change_callback_fn(
void *private_data,
unsigned int data_mtu)
367 const char *cipher_type,
368 const char *hash_type)
374static inline void ucast_sendmsg (
378 unsigned int msg_len)
382 struct msghdr msg_ucast;
387 iovec.iov_base = (
void *)msg;
388 iovec.iov_len = msg_len;
393 memset(&msg_ucast, 0,
sizeof(msg_ucast));
394 msg_ucast.msg_iov = (
void *)&iovec;
395 msg_ucast.msg_iovlen = 1;
396#ifdef HAVE_MSGHDR_CONTROL
397 msg_ucast.msg_control = 0;
399#ifdef HAVE_MSGHDR_CONTROLLEN
400 msg_ucast.msg_controllen = 0;
402#ifdef HAVE_MSGHDR_FLAGS
403 msg_ucast.msg_flags = 0;
405#ifdef HAVE_MSGHDR_ACCRIGHTS
406 msg_ucast.msg_accrights = NULL;
408#ifdef HAVE_MSGHDR_ACCRIGHTSLEN
409 msg_ucast.msg_accrightslen = 0;
420 "sendmsg(ucast) failed (non-critical)");
424static inline void mcast_sendmsg (
427 unsigned int msg_len,
432 struct msghdr msg_mcast;
435 iovec.iov_base = (
void *)msg;
436 iovec.iov_len = msg_len;
443 memset(&msg_mcast, 0,
sizeof(msg_mcast));
444 msg_mcast.msg_iov = (
void *)&iovec;
445 msg_mcast.msg_iovlen = 1;
446#ifdef HAVE_MSGHDR_CONTROL
447 msg_mcast.msg_control = 0;
449#ifdef HAVE_MSGHDR_CONTROLLEN
450 msg_mcast.msg_controllen = 0;
452#ifdef HAVE_MSGHDR_FLAGS
453 msg_mcast.msg_flags = 0;
455#ifdef HAVE_MSGHDR_ACCRIGHTS
456 msg_mcast.msg_accrights = NULL;
458#ifdef HAVE_MSGHDR_ACCRIGHTSLEN
459 msg_mcast.msg_accrightslen = 0;
479static int node_compare(
const void *aptr,
const void *bptr)
483 a = *(uint16_t *)aptr;
484 b = *(uint16_t *)bptr;
489#ifndef OWN_INDEX_NONE
490#define OWN_INDEX_NONE -1
500 struct knet_link_status link_status;
502 struct knet_host_status knet_host_status;
503 uint8_t link_list[KNET_MAX_LINK];
522 node_status->
reachable = knet_host_status.reachable;
523 node_status->
remote = knet_host_status.remote;
524 node_status->
external = knet_host_status.external;
526#ifdef HAVE_KNET_ONWIRE_VER
527 res = knet_handle_get_onwire_ver(instance->
knet_handle,
538 res = knet_link_get_link_list(instance->
knet_handle,
539 nodeid, link_list, &num_links);
546 for (i=0; i < num_links; i++) {
554 sizeof(link_status));
556 node_status->
link_status[link_list[i]].enabled = link_status.enabled;
557 node_status->
link_status[link_list[i]].connected = link_status.connected;
558 node_status->
link_status[link_list[i]].dynconnected = link_status.dynconnected;
559 node_status->
link_status[link_list[i]].mtu = link_status.mtu;
560 memcpy(node_status->
link_status[link_list[i]].src_ipaddr, link_status.src_ipaddr, KNET_MAX_HOST_LEN);
561 memcpy(node_status->
link_status[link_list[i]].dst_ipaddr, link_status.dst_ipaddr, KNET_MAX_HOST_LEN);
573 unsigned int *iface_count)
576 struct knet_link_status link_status;
577 knet_node_id_t host_list[KNET_MAX_HOST];
578 uint8_t link_list[KNET_MAX_LINK];
593 res = knet_host_get_host_list(instance->
knet_handle,
594 host_list, &num_hosts);
598 qsort(host_list, num_hosts,
sizeof(uint16_t), node_compare);
600 for (j=0; j<num_hosts; j++) {
618 for (j=0; j<num_hosts; j++) {
623 res = knet_link_get_link_list(instance->
knet_handle,
624 host_list[j], link_list, &num_links);
630 for (i=0; i < num_links; i++) {
645 sizeof(link_status));
647 ptr[j] =
'0' + (link_status.enabled |
648 link_status.connected<<1 |
649 link_status.dynconnected<<2);
653 "totemknet_ifaces_get: Cannot get link status: %s", strerror(errno));
672 static knet_node_id_t nodes[KNET_MAX_HOST];
673 uint8_t links[KNET_MAX_LINK];
685 res = knet_handle_setfwd(instance->
knet_handle, 0);
690 res = knet_host_get_host_list(instance->
knet_handle, nodes, &num_nodes);
698 for (i=0; i<num_nodes; i++) {
700 res = knet_link_get_link_list(instance->
knet_handle, nodes[i], links, &num_links);
705 for (j=0; j<num_links; j++) {
706 res = knet_link_set_enable(instance->
knet_handle, nodes[i], links[j], 0);
710 res = knet_link_clear_config(instance->
knet_handle, nodes[i], links[j]);
715 res = knet_host_remove(instance->
knet_handle, nodes[i]);
727 totemknet_stop_merge_detect_timeout(instance);
729 log_flush_messages(instance);
734 (void)pthread_mutex_destroy(&instance->
log_mutex);
739static int log_deliver_fn (
745 char buffer[
sizeof(
struct knet_log_msg)*4];
746 char *bufptr = buffer;
750 len = read(fd, buffer,
sizeof(buffer));
752 struct knet_log_msg *msg = (
struct knet_log_msg *)bufptr;
753 switch (msg->msglevel) {
756 knet_log_get_subsystem_name(msg->subsystem),
761 knet_log_get_subsystem_name(msg->subsystem),
766 knet_log_get_subsystem_name(msg->subsystem),
771 knet_log_get_subsystem_name(msg->subsystem),
777 knet_log_get_subsystem_name(msg->subsystem),
782 bufptr +=
sizeof(
struct knet_log_msg);
783 done +=
sizeof(
struct knet_log_msg);
788static int data_deliver_fn (
794 struct msghdr msg_hdr;
795 struct iovec iov_recv;
798 int truncated_packet;
801 iov_recv.iov_len = KNET_MAX_PACKET_SIZE;
804 msg_hdr.msg_namelen =
sizeof (
struct sockaddr_storage);
805 msg_hdr.msg_iov = &iov_recv;
806 msg_hdr.msg_iovlen = 1;
807#ifdef HAVE_MSGHDR_CONTROL
808 msg_hdr.msg_control = 0;
810#ifdef HAVE_MSGHDR_CONTROLLEN
811 msg_hdr.msg_controllen = 0;
813#ifdef HAVE_MSGHDR_FLAGS
814 msg_hdr.msg_flags = 0;
816#ifdef HAVE_MSGHDR_ACCRIGHTS
817 msg_hdr.msg_accrights = NULL;
819#ifdef HAVE_MSGHDR_ACCRIGHTSLEN
820 msg_hdr.msg_accrightslen = 0;
823 msg_len = recvmsg (fd, &msg_hdr,
MSG_NOSIGNAL | MSG_DONTWAIT);
828 truncated_packet = 0;
830#ifdef HAVE_MSGHDR_FLAGS
831 if (msg_hdr.msg_flags & MSG_TRUNC) {
832 truncated_packet = 1;
839 if (bytes_received == KNET_MAX_PACKET_SIZE) {
840 truncated_packet = 1;
844 if (truncated_packet) {
846 "Received too big message. This may be because something bad is happening"
847 "on the network (attack?), or you tried join more nodes than corosync is"
848 "compiled with (%u) or bug in the code (bad estimation of "
865static void timer_function_netif_check_timeout (
889#ifdef HAVE_KNET_ACCESS_LIST
906 int knet_log_mode = KNET_LOG_INFO;
917 switch (logsys_log_mode) {
919 knet_log_mode = KNET_LOG_INFO;
922 knet_log_mode = KNET_LOG_DEBUG;
926 knet_log_mode = KNET_LOG_TRACE;
928 knet_log_mode = KNET_LOG_DEBUG;
934 for (s = 0; s<KNET_MAX_SUBSYSTEMS; s++) {
946static void totemknet_refresh_config(
948 const char *key_name,
957 knet_node_id_t host_ids[KNET_MAX_HOST];
968 if (
icmap_get_uint8(
"config.totemconfig_reload_in_progress", &reloading) ==
CS_OK && reloading) {
972 after_reload = (strcmp(key_name,
"config.totemconfig_reload_in_progress") == 0);
974 knet_set_access_list_config(instance);
976 if (strcmp(key_name,
"totem.knet_pmtud_interval") == 0 || after_reload) {
985 if (strcmp(key_name,
"totem.knet_mtu") == 0 || after_reload) {
994 err = knet_host_get_host_list(instance->
knet_handle, host_ids, &num_nodes);
999 for (i=0; i<num_nodes; i++) {
1006 err = knet_link_set_ping_timers(instance->
knet_handle, host_ids[i], link_no,
1014 err = knet_link_set_pong_count(instance->
knet_handle, host_ids[i], link_no,
1020 err = knet_link_set_priority(instance->
knet_handle, host_ids[i], link_no,
1029 icmap_set_string(
"config.reload_error_message",
"Failed to set knet ping timers(2)");
1046 totemknet_refresh_config,
1048 &icmap_track_totem);
1052 totemknet_refresh_config,
1054 &icmap_track_reload);
1069 struct knet_handle_crypto_cfg crypto_cfg;
1079#ifdef HAVE_KNET_CRYPTO_RECONF
1082 crypto_cfg.crypto_model,
1083 crypto_cfg.crypto_cipher_type,
1084 crypto_cfg.crypto_hash_type,
1089 if (!totemknet_is_crypto_enabled(instance)) {
1090 res = knet_handle_crypto_rx_clear_traffic(instance->
knet_handle, KNET_CRYPTO_RX_ALLOW_CLEAR_TRAFFIC);
1112 crypto_cfg.crypto_model,
1113 crypto_cfg.crypto_cipher_type,
1114 crypto_cfg.crypto_hash_type
1117 res = knet_handle_crypto(instance->
knet_handle, &crypto_cfg);
1129#ifdef HAVE_KNET_CRYPTO_RECONF
1131 icmap_set_string(
"config.reload_error_message",
"Failed to set crypto parameters");
1153 qb_loop_t *poll_handle,
1154 void **knet_context,
1162 unsigned int msg_len,
1165 int (*iface_change_fn) (
1168 unsigned int link_no),
1170 void (*mtu_changed) (
1174 void (*target_set_completed) (
1180 int allow_knet_handle_fallback=0;
1185 if (instance == NULL) {
1189 totemknet_instance_initialize (instance);
1239 if (fcntl(instance->
logpipes[0], F_SETFL, O_NONBLOCK) == -1 ||
1240 fcntl(instance->
logpipes[1], F_SETFL, O_NONBLOCK) == -1) {
1246 if (strcmp(tmp_str,
"yes") == 0) {
1247 allow_knet_handle_fallback = 1;
1252#if defined(KNET_API_VER) && (KNET_API_VER == 2)
1258 if (allow_knet_handle_fallback && !instance->
knet_handle && errno == ENAMETOOLONG) {
1260#if defined(KNET_API_VER) && (KNET_API_VER == 2)
1272 knet_set_access_list_config(instance);
1282 res = knet_handle_enable_filter(instance->
knet_handle, instance, dst_host_filter_callback_fn);
1286 res = knet_handle_enable_sock_notify(instance->
knet_handle, instance, socket_error_callback_fn);
1290 res = knet_host_enable_status_change_notify(instance->
knet_handle, instance, host_change_callback_fn);
1294 res = knet_handle_enable_pmtud_notify(instance->
knet_handle, instance, pmtu_change_callback_fn);
1307 knet_log_printf(LOG_DEBUG,
"knet_handle_add_datafd failed: %s", strerror(errno));
1312#ifdef HAVE_KNET_CRYPTO_RECONF
1313 if (totemknet_is_crypto_enabled(instance)) {
1314 res = totemknet_set_knet_crypto(instance);
1318 knet_log_printf(LOG_DEBUG,
"knet_handle_crypto_use_config failed: %s", strerror(errno));
1325 res = knet_handle_crypto_rx_clear_traffic(instance->
knet_handle, KNET_CRYPTO_RX_DISALLOW_CLEAR_TRAFFIC);
1327 knet_log_printf(LOG_DEBUG,
"knet_handle_crypto_rx_clear_traffic (DISALLOW) failed: %s", strerror(errno));
1332 res = knet_handle_crypto_rx_clear_traffic(instance->
knet_handle, KNET_CRYPTO_RX_ALLOW_CLEAR_TRAFFIC);
1334 knet_log_printf(LOG_DEBUG,
"knet_handle_crypto_rx_clear_traffic (ALLOW) failed: %s", strerror(errno));
1339 if (totemknet_is_crypto_enabled(instance)) {
1340 res = totemknet_set_knet_crypto(instance);
1351 (void)totemknet_configure_compression(instance,
totem_config);
1356 instance->
link_mode = KNET_LINK_POLICY_PASSIVE;
1358 instance->
link_mode = KNET_LINK_POLICY_ACTIVE;
1361 instance->
link_mode = KNET_LINK_POLICY_RR;
1374 POLLIN, instance, log_deliver_fn);
1379 POLLIN, instance, data_deliver_fn);
1387 100*QB_TIME_NS_IN_MSEC,
1389 timer_function_netif_check_timeout,
1392 totemknet_start_merge_detect_timeout(instance);
1395 totemknet_add_config_notifications(instance);
1406 log_flush_messages(instance);
1414 return malloc(KNET_MAX_PACKET_SIZE + 512);
1424 int processor_count)
1442 unsigned int msg_len)
1447 ucast_sendmsg (instance, &instance->
token_target, msg, msg_len);
1454 unsigned int msg_len)
1459 mcast_sendmsg (instance, msg, msg_len, 0);
1467 unsigned int msg_len)
1472 mcast_sendmsg (instance, msg, msg_len, 1);
1515 struct msghdr msg_hdr;
1516 struct iovec iov_recv;
1519 int msg_processed = 0;
1522 iov_recv.iov_len = KNET_MAX_PACKET_SIZE;
1525 msg_hdr.msg_namelen =
sizeof (
struct sockaddr_storage);
1526 msg_hdr.msg_iov = &iov_recv;
1527 msg_hdr.msg_iovlen = 1;
1528#ifdef HAVE_MSGHDR_CONTROL
1529 msg_hdr.msg_control = 0;
1531#ifdef HAVE_MSGHDR_CONTROLLEN
1532 msg_hdr.msg_controllen = 0;
1534#ifdef HAVE_MSGHDR_FLAGS
1535 msg_hdr.msg_flags = 0;
1537#ifdef HAVE_MSGHDR_ACCRIGHTS
1538 msg_msg_hdr.msg_accrights = NULL;
1540#ifdef HAVE_MSGHDR_ACCRIGHTSLEN
1541 msg_msg_hdr.msg_accrightslen = 0;
1546 ufd.events = POLLIN;
1547 nfds = poll (&ufd, 1, 0);
1548 if (nfds == 1 && ufd.revents & POLLIN) {
1556 }
while (nfds == 1);
1558 return (msg_processed);
1563 unsigned short ip_port,
1564 unsigned int iface_no)
1586 int port = instance->
ip_port[link_no];
1587 struct sockaddr_storage remote_ss;
1588 struct sockaddr_storage local_ss;
1592 knet_node_id_t host_ids[KNET_MAX_HOST];
1593 size_t num_host_ids;
1611 err = knet_host_get_host_list(instance->
knet_handle, host_ids, &num_host_ids);
1616 for (i=0; i<num_host_ids; i++) {
1617 if (host_ids[i] == member->
nodeid) {
1624 if (err != 0 && errno != EEXIST) {
1640 memset(&local_ss, 0,
sizeof(local_ss));
1641 memset(&remote_ss, 0,
sizeof(remote_ss));
1650 KNET_TRANSPORT_LOOPBACK,
1651 &local_ss, &remote_ss, KNET_LINK_FLAG_TRAFFICHIPRIO);
1656 &local_ss, &remote_ss, KNET_LINK_FLAG_TRAFFICHIPRIO);
1684 int saved_errno = errno;
1685 log_flush_messages(instance);
1686 errno = saved_errno;
1689 icmap_set_string(
"config.reload_error_message",
"Failed to set knet ping timers");
1697 int saved_errno = errno;
1698 log_flush_messages(instance);
1699 errno = saved_errno;
1701 icmap_set_string(
"config.reload_error_message",
"Failed to set knet pong count");
1724 uint8_t link_list[KNET_MAX_LINK];
1751 res = knet_link_get_link_list(instance->
knet_handle,
1757 if (num_links == 0) {
1770static int totemknet_configure_compression (
1774 struct knet_handle_compress_cfg compress_cfg;
1783 res = knet_handle_compress(instance->
knet_handle, &compress_cfg);
1797 (void)totemknet_configure_compression(instance,
totem_config);
1799#ifdef HAVE_LIBNOZZLE
1803 (void)setup_nozzle(instance);
1809 res = totemknet_set_knet_crypto(instance);
1816 icmap_set_string(
"config.reload_error_message",
"Failed to set knet crypto");
1828#ifdef HAVE_KNET_CRYPTO_RECONF
1831 int config_to_clear;
1832 struct knet_handle_crypto_cfg crypto_cfg;
1840 if (!totemknet_is_crypto_enabled(instance)) {
1845 res = knet_handle_crypto_use_config(instance->
knet_handle, config_to_use);
1859 strcpy(crypto_cfg.crypto_model,
"none");
1860 strcpy(crypto_cfg.crypto_cipher_type,
"none");
1861 strcpy(crypto_cfg.crypto_hash_type,
"none");
1862 res = knet_handle_crypto_set_config(instance->
knet_handle, &crypto_cfg, config_to_clear);
1871 if (totemknet_is_crypto_enabled(instance)) {
1872 res = knet_handle_crypto_rx_clear_traffic(instance->
knet_handle, KNET_CRYPTO_RX_DISALLOW_CLEAR_TRAFFIC);
1887 (void) knet_handle_clear_stats(instance->
knet_handle, KNET_CLEARSTATS_HANDLE_AND_LINK);
1892 knet_node_id_t node, uint8_t link_no,
1893 struct knet_link_status *status)
1929 struct knet_handle_stats *stats)
1946static void timer_function_merge_detect_timeout (
1957 totemknet_start_merge_detect_timeout(instance);
1960static void totemknet_start_merge_detect_timeout(
1969 timer_function_merge_detect_timeout,
1970 &instance->timer_merge_detect_timeout);
1974static void totemknet_stop_merge_detect_timeout(
1993 pfd.events = POLLIN;
1996 if ((poll(&pfd, 1, 0) > 0) &&
1997 (pfd.revents & POLLIN) &&
1998 (log_deliver_fn(instance->
logpipes[0], POLLIN, instance) == 0)) {
2007#ifdef HAVE_LIBNOZZLE
2008#define NOZZLE_NAME "nozzle.name"
2009#define NOZZLE_IPADDR "nozzle.ipaddr"
2010#define NOZZLE_PREFIX "nozzle.ipprefix"
2011#define NOZZLE_MACADDR "nozzle.macaddr"
2013#define NOZZLE_CHANNEL 1
2019 char filename[PATH_MAX + FILENAME_MAX + 1];
2020 static char updown_dirname[PATH_MAX + FILENAME_MAX + 1];
2022 const char *dirname_res;
2027 res = snprintf(filename,
sizeof(filename),
"%s",
2029 if (res >=
sizeof(filename)) {
2034 dirname_res = dirname(filename);
2036 res = snprintf(updown_dirname,
sizeof(updown_dirname),
"%s/%s",
2037 dirname_res,
"updown.d");
2038 if (res >=
sizeof(updown_dirname)) {
2042 return updown_dirname;
2054 res = nozzle_run_updown(instance->nozzle_handle,
type, &exec_string);
2055 if (res == -1 && errno != ENOENT) {
2057 }
else if (res == -2) {
2072 const char *input_addr,
2073 const char *prefix,
int nodeid,
2074 char *output_addr,
size_t output_len)
2078 int max_prefix = 64;
2079 uint32_t nodeid_mask;
2081 uint32_t masked_nodeid;
2082 struct in_addr *
addr;
2085 coloncolon = strstr(input_addr,
"::");
2090 bits = atoi(prefix);
2091 if (bits < 8 || bits > max_prefix) {
2098 memcpy(output_addr, input_addr, coloncolon-input_addr);
2099 sprintf(output_addr + (coloncolon-input_addr),
"::%x",
nodeid);
2106 nodeid_mask = UINT32_MAX & ((1<<(32 - bits)) - 1);
2107 addr_mask = UINT32_MAX ^ nodeid_mask;
2108 masked_nodeid =
nodeid & nodeid_mask;
2114 addr = (
struct in_addr *)&totemip.addr;
2115 addr->s_addr &= htonl(addr_mask);
2116 addr->s_addr |= htonl(masked_nodeid);
2118 inet_ntop(AF_INET,
addr, output_addr, output_len);
2122static int create_nozzle_device(
void *knet_context,
const char *name,
2123 const char *ipaddr,
const char *prefix,
2124 const char *macaddr)
2127 char device_name[IFNAMSIZ+1];
2128 size_t size = IFNAMSIZ;
2129 int8_t channel = NOZZLE_CHANNEL;
2130 nozzle_t nozzle_dev;
2134 char parsed_ipaddr[INET6_ADDRSTRLEN];
2137 memset(device_name, 0, size);
2138 memset(&mac, 0,
sizeof(mac));
2139 strncpy(device_name, name, size);
2144 nozzle_dev = nozzle_open(device_name, size, updown_dir);
2149 instance->nozzle_handle = nozzle_dev;
2151 if (nozzle_set_mac(nozzle_dev, macaddr) < 0) {
2156 if (reparse_nozzle_ip_address(instance, ipaddr, prefix, instance->
our_nodeid, parsed_ipaddr,
sizeof(parsed_ipaddr))) {
2161 if (nozzle_add_ip(nozzle_dev, parsed_ipaddr, prefix) < 0) {
2166 nozzle_fd = nozzle_get_fd(nozzle_dev);
2169 res = knet_handle_add_datafd(instance->
knet_handle, &nozzle_fd, &channel);
2175 run_nozzle_script(instance, NOZZLE_PREUP,
"pre-up");
2177 res = nozzle_set_up(nozzle_dev);
2182 run_nozzle_script(instance, NOZZLE_UP,
"up");
2187 nozzle_close(nozzle_dev);
2197 res = knet_handle_get_datafd(instance->
knet_handle, NOZZLE_CHANNEL, &datafd);
2203 res = knet_handle_remove_datafd(instance->
knet_handle, datafd);
2209 run_nozzle_script(instance, NOZZLE_DOWN,
"pre-down");
2210 res = nozzle_set_down(instance->nozzle_handle);
2215 run_nozzle_script(instance, NOZZLE_POSTDOWN,
"post-down");
2217 res = nozzle_close(instance->nozzle_handle);
2228 free(instance->nozzle_name);
2229 free(instance->nozzle_ipaddr);
2230 free(instance->nozzle_prefix);
2231 free(instance->nozzle_macaddr);
2233 instance->nozzle_name = instance->nozzle_ipaddr = instance->nozzle_prefix =
2234 instance->nozzle_macaddr = NULL;
2240 char *ipaddr_str = NULL;
2241 char *name_str = NULL;
2242 char *prefix_str = NULL;
2243 char *macaddr_str = NULL;
2260 remove_nozzle_device(instance);
2261 free_nozzle(instance);
2280 if (macaddr_str && strlen(macaddr_str) != 17) {
2285 macaddr_str = (
char*)
"54:54:01:00:00:00";
2288 if (instance->nozzle_name &&
2289 (strcmp(name_str, instance->nozzle_name) == 0) &&
2290 (strcmp(ipaddr_str, instance->nozzle_ipaddr) == 0) &&
2291 (strcmp(prefix_str, instance->nozzle_prefix) == 0) &&
2292 (instance->nozzle_macaddr == NULL ||
2293 strcmp(macaddr_str, instance->nozzle_macaddr) == 0)) {
2300 memcpy(mac, macaddr_str, 12);
2301 snprintf(mac+12,
sizeof(mac) - 13,
"%02x:%02x",
2306 if (name_res ==
CS_OK && name_str) {
2308 if (instance->nozzle_name) {
2309 remove_nozzle_device(instance);
2310 free_nozzle(instance);
2313 res = create_nozzle_device(
knet_context, name_str, ipaddr_str, prefix_str,
2316 instance->nozzle_name = strdup(name_str);
2317 instance->nozzle_ipaddr = strdup(ipaddr_str);
2318 instance->nozzle_prefix = strdup(prefix_str);
2319 instance->nozzle_macaddr = strdup(macaddr_str);
2320 if (!instance->nozzle_name || !instance->nozzle_ipaddr ||
2321 !instance->nozzle_prefix) {
2328 free_nozzle(instance);
2336 if (macaddr_res ==
CS_OK) {
unsigned char addr[TOTEMIP_ADDRLEN]
#define PROCESSOR_COUNT_MAX
cs_error_t qb_to_cs_error(int result)
qb_to_cs_error
cs_error_t
The cs_error_t enum.
#define corosync_exit_error(err)
@ COROSYNC_DONE_MAINCONFIGREAD
cs_error_t icmap_get_uint8(const char *key_name, uint8_t *u8)
#define ICMAP_TRACK_MODIFY
#define ICMAP_TRACK_DELETE
cs_error_t icmap_track_add(const char *key_name, int32_t track_type, icmap_notify_fn_t notify_fn, void *user_data, icmap_track_t *icmap_track)
Add tracking function for given key_name.
cs_error_t icmap_set_string(const char *key_name, const char *value)
#define ICMAP_TRACK_PREFIX
Whole prefix is tracked, instead of key only (so "totem." tracking means that "totem....
cs_error_t icmap_get_string(const char *key_name, char **str)
Shortcut for icmap_get for string type.
#define LOGSYS_LEVEL_ERROR
#define log_printf(level, format, args...)
#define LOGSYS_LEVEL_INFO
#define LOGSYS_LEVEL_CRIT
int logsys_config_debug_get(const char *subsys)
Return the debug flag for this subsys.
#define LOGSYS_DEBUG_TRACE
#define LOGSYS_LEVEL_WARNING
int _logsys_subsys_create(const char *subsys, const char *filename)
_logsys_subsys_create
#define LOGSYS_LEVEL_DEBUG
#define LOGSYS_LEVEL_TRACE
const char * corosync_get_config_file(void)
Structure passed as new_value and old_value in change callback.
char crypto_model[CONFIG_STRING_LEN_MAX]
unsigned int private_key_len
uint32_t knet_compression_threshold
struct totem_logging_configuration totem_logging_configuration
struct totem_interface * interfaces
unsigned int merge_timeout
int knet_compression_level
char knet_compression_model[CONFIG_STRING_LEN_MAX]
unsigned int block_unlisted_ips
unsigned char private_key[TOTEM_PRIVATE_KEY_LEN_MAX]
unsigned int knet_pmtud_interval
char crypto_cipher_type[CONFIG_STRING_LEN_MAX]
char link_mode[TOTEM_LINK_MODE_BYTES]
char crypto_hash_type[CONFIG_STRING_LEN_MAX]
struct totem_ip_address boundto
struct totem_ip_address bindnet
The totem_ip_address struct.
void(* log_printf)(int level, int subsys, const char *function_name, const char *file_name, int file_line, const char *format,...) __attribute__((format(printf
struct knet_link_status link_status[KNET_MAX_LINK]
void(* totemknet_target_set_completed)(void *context)
pthread_mutex_t log_mutex
void(* totemknet_mtu_changed)(void *context, int net_mtu)
struct crypto_instance * crypto_inst
struct totem_config * totem_config
qb_loop_timer_handle timer_netif_check_timeout
char * link_status[INTERFACE_MAX]
void(* totemknet_log_printf)(int level, int subsys, const char *function, const char *file, int line, const char *format,...) __attribute__((format(printf
knet_handle_t knet_handle
uint16_t ip_port[INTERFACE_MAX]
int(* totemknet_iface_change_fn)(void *context, const struct totem_ip_address *iface_address, unsigned int link_no)
int totemknet_log_level_debug
struct knet_handle_crypto_cfg last_good_crypto_cfg
struct totem_ip_address token_target
qb_loop_timer_handle timer_merge_detect_timeout
void(*) void knet_context)
int totemknet_log_level_warning
struct totem_ip_address my_ids[INTERFACE_MAX]
int(* totemknet_deliver_fn)(void *context, const void *msg, unsigned int msg_len, const struct sockaddr_storage *system_from)
char iov_buffer[KNET_MAX_PACKET_SIZE]
unsigned int merge_detect_messages_sent_before_timeout
int send_merge_detect_message
int totemknet_log_level_error
int totemknet_log_level_security
int totemknet_log_level_notice
struct totemknet_instance * instance
cfg_message_crypto_reconfig_phase_t
@ CRYPTO_RECONFIG_PHASE_CLEANUP
@ CRYPTO_RECONFIG_PHASE_ACTIVATE
int totemip_parse(struct totem_ip_address *totemip, const char *addr, enum totem_ip_version_enum ip_version)
void totemip_copy(struct totem_ip_address *addr1, const struct totem_ip_address *addr2)
int totemip_totemip_to_sockaddr_convert(struct totem_ip_address *ip_addr, uint16_t port, struct sockaddr_storage *saddr, int *addrlen)
const char * totemip_print(const struct totem_ip_address *addr)
int totemknet_mcast_flush_send(void *knet_context, const void *msg, unsigned int msg_len)
int totemknet_iface_set(void *knet_context, const struct totem_ip_address *local_addr, unsigned short ip_port, unsigned int iface_no)
int totemknet_finalize(void *knet_context)
int totemknet_recv_flush(void *knet_context)
int totemknet_member_list_rebind_ip(void *knet_context)
void * totemknet_buffer_alloc(void)
int totemknet_processor_count_set(void *knet_context, int processor_count)
int totemknet_mcast_noflush_send(void *knet_context, const void *msg, unsigned int msg_len)
struct totemknet_instance * global_instance
void totemknet_buffer_release(void *ptr)
int totemknet_initialize(qb_loop_t *poll_handle, void **knet_context, struct totem_config *totem_config, totemsrp_stats_t *stats, void *context, int(*deliver_fn)(void *context, const void *msg, unsigned int msg_len, const struct sockaddr_storage *system_from), int(*iface_change_fn)(void *context, const struct totem_ip_address *iface_address, unsigned int link_no), void(*mtu_changed)(void *context, int net_mtu), void(*target_set_completed)(void *context))
int totemknet_ifaces_get(void *knet_context, char ***status, unsigned int *iface_count)
int totemknet_member_add(void *knet_context, const struct totem_ip_address *local, const struct totem_ip_address *member, int link_no)
int totemknet_crypto_set(void *knet_context, const char *cipher_type, const char *hash_type)
int totemknet_member_remove(void *knet_context, const struct totem_ip_address *token_target, int link_no)
int totemknet_token_send(void *knet_context, const void *msg, unsigned int msg_len)
#define CFG_INTERFACE_STATUS_MAX_LEN
int totemknet_link_get_status(knet_node_id_t node, uint8_t link_no, struct knet_link_status *status)
void totemknet_configure_log_level()
int totemknet_nodestatus_get(void *knet_context, unsigned int nodeid, struct totem_node_status *node_status)
int totemknet_handle_get_stats(struct knet_handle_stats *stats)
void totemknet_stats_clear(void *knet_context)
int totemknet_send_flush(void *knet_context)
void totemknet_net_mtu_adjust(void *knet_context, struct totem_config *totem_config)
#define knet_log_printf(level, format, args...)
int totemknet_token_target_set(void *knet_context, unsigned int nodeid)
#define KNET_LOGSYS_PERROR(err_num, level, fmt, args...)
int totemknet_reconfigure(void *knet_context, struct totem_config *totem_config)
int totemknet_crypto_reconfigure_phase(void *knet_context, struct totem_config *totem_config, cfg_message_crypto_reconfig_phase_t phase)
#define libknet_log_printf(level, format, args...)
int totemknet_recv_mcast_empty(void *knet_context)
int totemknet_iface_check(void *knet_context)
struct totem_message_header header
struct srp_addr system_from
void stats_knet_add_handle(void)
void stats_knet_del_member(knet_node_id_t nodeid, uint8_t link)
void stats_knet_add_member(knet_node_id_t nodeid, uint8_t link)