static void
_cs_local_node_info_get(char **nodename, uint32_t *nodeid)
{
cs_error_t rc;
corosync_cfg_handle_t cfg_handle;
if (local_nodeid == 0) {
rc = corosync_cfg_initialize(&cfg_handle, NULL);
if (rc != CS_OK) {
syslog (LOG_ERR, "Failed to initialize the cfg API. Error %d\n", rc);
exit (EXIT_FAILURE);
}
rc = corosync_cfg_local_get (cfg_handle, &local_nodeid);
corosync_cfg_finalize(cfg_handle);
if (rc != CS_OK) {
local_nodeid = 0;
strncpy(local_nodename, "localhost", sizeof (local_nodename));
local_nodename[sizeof (local_nodename) - 1] = '\0';
} else {
gethostname(local_nodename, CS_MAX_NAME_LENGTH);
}
}
*nodeid = local_nodeid;
*nodename = local_nodename;
}
int setup_cluster_cfg(void)
{
cs_error_t err;
unsigned int nodeid;
int fd;
err = corosync_cfg_initialize(&ch, &cfg_callbacks);
if (err != CS_OK) {
log_error("corosync cfg init error %d", err);
return -1;
}
err = corosync_cfg_fd_get(ch, &fd);
if (err != CS_OK) {
log_error("corosync cfg fd_get error %d", err);
corosync_cfg_finalize(ch);
return -1;
}
err = corosync_cfg_local_get(ch, &nodeid);
if (err != CS_OK) {
log_error("corosync cfg local_get error %d", err);
corosync_cfg_finalize(ch);
return -1;
}
our_nodeid = nodeid;
log_debug("our_nodeid %d", our_nodeid);
return fd;
}
static int reload_config_do (void)
{
cs_error_t result;
corosync_cfg_handle_t handle;
int rc;
rc = 0;
printf ("Reloading corosync.conf...\n");
result = corosync_cfg_initialize (&handle, NULL);
if (result != CS_OK) {
printf ("Could not initialize corosync configuration API error %s\n", cs_strerror(result));
exit (1);
}
result = corosync_cfg_reload_config (handle);
if (result != CS_OK) {
printf ("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 ringstatusget_do (char *interface_name)
{
cs_error_t result;
corosync_cfg_handle_t handle;
unsigned int interface_count;
char **interface_names;
char **interface_status;
unsigned int i;
unsigned int nodeid;
int rc = 0;
printf ("Printing ring status.\n");
result = corosync_cfg_initialize (&handle, NULL);
printf ("xxx 47500: tools/corosync-cfgtool.c After corosync_cfg_initialize...\n");
if (result != CS_OK) {
printf ("Could not initialize corosync configuration API error %d\n", result);
exit (1);
}
result = corosync_cfg_local_get(handle, &nodeid);
if (result != CS_OK) {
printf ("Could not get the local node id, the error is: %d\n", result);
}
else {
printf ("Local node ID %d\n", nodeid);
}
result = corosync_cfg_ring_status_get (handle,
&interface_names,
&interface_status,
&interface_count);
if (result != CS_OK) {
printf ("Could not get the ring status, the error is: %d\n", result);
} else {
for (i = 0; i < interface_count; i++) {
if ( (interface_name &&
(interface_name[0]=='\0' ||
strcasecmp (interface_name, interface_names[i]) == 0)) ||
!interface_name ) {
printf ("RING ID %d\n", i);
printf ("\tid\t= %s\n", interface_names[i]);
printf ("\tstatus\t= %s\n", interface_status[i]);
if (strstr(interface_status[i], "FAULTY")) {
rc = 1;
}
}
}
}
(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 %d\n", nodeid);
result = corosync_cfg_initialize (&handle, NULL);
if (result != CS_OK) {
printf ("Could not initialize corosync configuration API error %d\n", result);
exit (1);
}
result = corosync_cfg_kill_node (handle, nodeid, "Killed by corosync-cfgtool");
if (result != CS_OK) {
printf ("Could not kill node (error = %d)\n", result);
}
(void)corosync_cfg_finalize (handle);
}
static void service_unload_do (const char *service, unsigned int version)
{
cs_error_t result;
corosync_cfg_handle_t handle;
printf ("Unloading service '%s' version '%d'\n", service, version);
result = corosync_cfg_initialize (&handle, NULL);
if (result != CS_OK) {
printf ("Could not initialize corosync configuration API error %d\n", result);
exit (1);
}
result = corosync_cfg_service_unload (handle, service, version);
if (result != CS_OK) {
printf ("Could not unload service (error = %d)\n", result);
}
(void)corosync_cfg_finalize (handle);
}
static void showaddrs_do(unsigned int nodeid)
{
cs_error_t result;
corosync_cfg_handle_t handle;
corosync_cfg_callbacks_t callbacks;
int numaddrs;
int i;
corosync_cfg_node_address_t addrs[INTERFACE_MAX];
result = corosync_cfg_initialize (&handle, &callbacks);
if (result != CS_OK) {
printf ("Could not initialize corosync configuration API error %d\n", result);
exit (1);
}
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");
}
(void)corosync_cfg_finalize (handle);
}
static void crypto_do(unsigned int type)
{
cs_error_t result;
corosync_cfg_handle_t handle;
printf ("Setting crypto to mode %d\n", type);
result = corosync_cfg_initialize (&handle, NULL);
if (result != CS_OK) {
printf ("Could not initialize corosync configuration API error %d\n", result);
exit (1);
}
result = corosync_cfg_crypto_set (handle, type);
if (result != CS_OK) {
printf ("Could not set crypto mode (error = %d)\n", result);
}
(void)corosync_cfg_finalize (handle);
}
static int init_all(void) {
cmap_handle = 0;
q_handle = 0;
v_handle = 0;
c_handle = 0;
if (cmap_initialize(&cmap_handle) != CS_OK) {
fprintf(stderr, "Cannot initialize CMAP service\n");
cmap_handle = 0;
goto out;
}
if (quorum_initialize(&q_handle, &q_callbacks, &q_type) != CS_OK) {
fprintf(stderr, "Cannot initialize QUORUM service\n");
q_handle = 0;
goto out;
}
if (corosync_cfg_initialize(&c_handle, &c_callbacks) != CS_OK) {
fprintf(stderr, "Cannot initialise CFG service\n");
c_handle = 0;
goto out;
}
if (using_votequorum() <= 0) {
return 0;
}
if (votequorum_initialize(&v_handle, &v_callbacks) != CS_OK) {
fprintf(stderr, "Cannot initialise VOTEQUORUM service\n");
v_handle = 0;
goto out;
}
if (cmap_get_uint32(cmap_handle, "runtime.votequorum.this_node_id", &our_nodeid) != CS_OK) {
fprintf(stderr, "Unable to retrieve this_node_id\n");
goto out;
}
return 0;
out:
return -1;
}
static void ringreenable_do (void)
{
cs_error_t result;
corosync_cfg_handle_t handle;
printf ("Re-enabling all failed rings.\n");
result = corosync_cfg_initialize (&handle, NULL);
if (result != CS_OK) {
printf ("Could not initialize corosync configuration API error %d\n", result);
exit (1);
}
result = corosync_cfg_ring_reenable (handle);
if (result != CS_OK) {
printf ("Could not reenable ring error %d\n", result);
}
(void)corosync_cfg_finalize (handle);
}
gboolean
cluster_connect_cfg(uint32_t * nodeid)
{
cs_error_t rc;
int fd = 0, retries = 0;
static struct mainloop_fd_callbacks cfg_fd_callbacks =
{
.dispatch = pcmk_cfg_dispatch,
.destroy = cfg_connection_destroy,
};
cs_repeat(retries, 30, rc = corosync_cfg_initialize(&cfg_handle, &cfg_callbacks));
if (rc != CS_OK) {
crm_err("corosync cfg init error %d", rc);
return FALSE;
}
rc = corosync_cfg_fd_get(cfg_handle, &fd);
if (rc != CS_OK) {
crm_err("corosync cfg fd_get error %d", rc);
goto bail;
}
retries = 0;
cs_repeat(retries, 30, rc = corosync_cfg_local_get(cfg_handle, nodeid));
if (rc != CS_OK) {
crm_err("corosync cfg local_get error %d", rc);
goto bail;
}
crm_debug("Our nodeid: %d", *nodeid);
mainloop_add_fd("corosync-cfg", G_PRIORITY_DEFAULT, fd, &cfg_handle, &cfg_fd_callbacks);
return TRUE;
bail:
corosync_cfg_finalize(cfg_handle);
return FALSE;
}
static void ringstatusget_do (void)
{
cs_error_t result;
corosync_cfg_handle_t handle;
unsigned int interface_count;
char **interface_names;
char **interface_status;
unsigned int i;
unsigned int nodeid;
printf ("Printing ring status.\n");
result = corosync_cfg_initialize (&handle, NULL);
if (result != CS_OK) {
printf ("Could not initialize corosync configuration API error %d\n", result);
exit (1);
}
result = corosync_cfg_local_get(handle, &nodeid);
if (result != CS_OK) {
printf ("Could not get the local node id, the error is: %d\n", result);
}
else {
printf ("Local node ID %d\n", nodeid);
}
result = corosync_cfg_ring_status_get (handle,
&interface_names,
&interface_status,
&interface_count);
if (result != CS_OK) {
printf ("Could not get the ring status, the error is: %d\n", result);
} else {
for (i = 0; i < interface_count; i++) {
printf ("RING ID %d\n", i);
printf ("\tid\t= %s\n", interface_names[i]);
printf ("\tstatus\t= %s\n", interface_status[i]);
}
}
(void)corosync_cfg_finalize (handle);
}
static void shutdown_do(void)
{
cs_error_t result;
corosync_cfg_handle_t handle;
corosync_cfg_callbacks_t callbacks;
callbacks.corosync_cfg_shutdown_callback = NULL;
result = corosync_cfg_initialize (&handle, &callbacks);
if (result != CS_OK) {
printf ("Could not initialize corosync configuration API error %d\n", result);
exit (1);
}
printf ("Shutting down corosync\n");
result = corosync_cfg_try_shutdown (handle, COROSYNC_CFG_SHUTDOWN_FLAG_REQUEST);
if (result != CS_OK) {
printf ("Could not shutdown (error = %d)\n", result);
}
(void)corosync_cfg_finalize (handle);
}
gboolean
cluster_connect_cfg(uint32_t * nodeid)
{
cs_error_t rc;
int fd = 0, retries = 0;
cs_repeat(retries, 30, rc = corosync_cfg_initialize(&cfg_handle, &cfg_callbacks));
if (rc != CS_OK) {
crm_err("corosync cfg init error %d", rc);
return FALSE;
}
rc = corosync_cfg_fd_get(cfg_handle, &fd);
if (rc != CS_OK) {
crm_err("corosync cfg fd_get error %d", rc);
goto bail;
}
retries = 0;
cs_repeat(retries, 30, rc = corosync_cfg_local_get(cfg_handle, nodeid));
if (rc != CS_OK) {
crm_err("corosync cfg local_get error %d", rc);
goto bail;
}
crm_debug("Our nodeid: %d", *nodeid);
crm_debug("Adding fd=%d to mainloop", fd);
G_main_add_fd(G_PRIORITY_HIGH, fd, FALSE, pcmk_cfg_dispatch, &cfg_handle,
cfg_connection_destroy);
return TRUE;
bail:
corosync_cfg_finalize(cfg_handle);
return FALSE;
}
static void do_command (int sock, char* func, char*args[], int num_args)
{
int result;
char response[100];
struct cpg_name group_name;
ssize_t rc;
size_t send_len;
qb_log (LOG_TRACE, "RPC:%s() called.", func);
if (strcmp ("cpg_mcast_joined",func) == 0) {
struct iovec iov[5];
int a;
for (a = 0; a < num_args; a++) {
iov[a].iov_base = args[a];
iov[a].iov_len = strlen(args[a])+1;
}
cpg_mcast_joined (cpg_handle, CPG_TYPE_AGREED, iov, num_args);
} else if (strcmp ("cpg_join",func) == 0) {
if (strlen(args[0]) >= CPG_MAX_NAME_LENGTH) {
qb_log (LOG_ERR, "Invalid group name");
exit (1);
}
strcpy (group_name.value, args[0]);
group_name.length = strlen(args[0]);
result = cpg_join (cpg_handle, &group_name);
if (result != CS_OK) {
qb_log (LOG_ERR,
"Could not join process group, error %d", result);
exit (1);
}
qb_log (LOG_INFO, "called cpg_join(%s)!", group_name.value);
} else if (strcmp ("cpg_leave",func) == 0) {
strcpy (group_name.value, args[0]);
group_name.length = strlen(args[0]);
result = cpg_leave (cpg_handle, &group_name);
if (result != CS_OK) {
qb_log (LOG_ERR,
"Could not leave process group, error %d", result);
exit (1);
}
qb_log (LOG_INFO, "called cpg_leave(%s)!", group_name.value);
} else if (strcmp ("cpg_initialize",func) == 0) {
int retry_count = 0;
result = cpg_initialize (&cpg_handle, &callbacks);
while (result != CS_OK) {
qb_log (LOG_ERR,
"cpg_initialize error %d (attempt %d)",
result, retry_count);
if (retry_count >= 3) {
exit (1);
}
sleep(1);
retry_count++;
result = cpg_initialize (&cpg_handle, &callbacks);
}
cpg_fd_get (cpg_handle, &cpg_fd);
qb_loop_poll_add (ta_poll_handle_get(),
QB_LOOP_MED,
cpg_fd,
POLLIN|POLLNVAL,
NULL,
cpg_dispatch_wrapper_fn);
} else if (strcmp ("cpg_local_get", func) == 0) {
unsigned int local_nodeid;
cpg_local_get (cpg_handle, &local_nodeid);
snprintf (response, 100, "%u",local_nodeid);
send_len = strlen (response);
rc = send (sock, response, send_len, 0);
assert(rc == send_len);
} else if (strcmp ("cpg_finalize", func) == 0) {
if (cpg_handle > 0) {
cpg_finalize (cpg_handle);
cpg_handle = 0;
}
} else if (strcmp ("record_config_events", func) == 0) {
record_config_events (sock);
} else if (strcmp ("record_messages", func) == 0) {
record_messages ();
} else if (strcmp ("read_config_event", func) == 0) {
read_config_event (sock);
} else if (strcmp ("read_messages", func) == 0) {
read_messages (sock, args[0]);
} else if (strcmp ("msg_blaster_zcb", func) == 0) {
msg_blaster_zcb (sock, args[0]);
} else if (strcmp ("pcmk_test", func) == 0) {
pcmk_test = 1;
} else if (strcmp ("msg_blaster", func) == 0) {
msg_blaster (sock, args[0]);
} else if (strcmp ("context_test", func) == 0) {
context_test (sock);
} else if (strcmp ("are_you_ok_dude", func) == 0) {
snprintf (response, 100, "%s", OK_STR);
send_len = strlen (response);
rc = send (sock, response, strlen (response), 0);
assert(rc == send_len);
} else if (strcmp ("cfg_shutdown", func) == 0) {
qb_log (LOG_INFO, "calling %s() called!", func);
result = corosync_cfg_try_shutdown (cfg_handle, COROSYNC_CFG_SHUTDOWN_FLAG_REQUEST);
qb_log (LOG_INFO,"%s() returned %d!", func, result);
} else if (strcmp ("cfg_initialize",func) == 0) {
int retry_count = 0;
qb_log (LOG_INFO,"%s() called!", func);
result = corosync_cfg_initialize (&cfg_handle, &cfg_callbacks);
while (result != CS_OK) {
qb_log (LOG_ERR,
"cfg_initialize error %d (attempt %d)",
result, retry_count);
if (retry_count >= 3) {
exit (1);
}
sleep(1);
retry_count++;
result = corosync_cfg_initialize (&cfg_handle, &cfg_callbacks);
}
qb_log (LOG_INFO,"corosync_cfg_initialize() == %d", result);
result = corosync_cfg_fd_get (cfg_handle, &cfg_fd);
qb_log (LOG_INFO,"corosync_cfg_fd_get() == %d", result);
qb_loop_poll_add (ta_poll_handle_get(),
QB_LOOP_MED,
cfg_fd,
POLLIN|POLLNVAL,
NULL,
cfg_dispatch_wrapper_fn);
} else {
qb_log(LOG_ERR, "RPC:%s not supported!", func);
}
}
static int show_nodes(nodeid_format_t nodeid_format, name_format_t name_format)
{
quorum_handle_t q_handle = 0;
votequorum_handle_t v_handle = 0;
corosync_cfg_handle_t c_handle = 0;
corosync_cfg_callbacks_t c_callbacks;
int i;
int using_vq = 0;
quorum_callbacks_t q_callbacks;
votequorum_callbacks_t v_callbacks;
int err;
int result = EXIT_FAILURE;
q_callbacks.quorum_notify_fn = quorum_notification_fn;
err=quorum_initialize(&q_handle, &q_callbacks);
if (err != CS_OK) {
fprintf(stderr, "Cannot connect to quorum service, is it loaded?\n");
return result;
}
v_callbacks.votequorum_notify_fn = NULL;
v_callbacks.votequorum_expectedvotes_notify_fn = NULL;
using_vq = using_votequorum();
if (using_vq) {
if ( (err=votequorum_initialize(&v_handle, &v_callbacks)) != CS_OK) {
fprintf(stderr, "votequorum_initialize FAILED: %d, this is probably a configuration error\n", err);
v_handle = 0;
goto err_exit;
}
}
err = quorum_trackstart(q_handle, CS_TRACK_CURRENT);
if (err != CS_OK) {
fprintf(stderr, "quorum_trackstart FAILED: %d\n", err);
goto err_exit;
}
g_called = 0;
while (g_called == 0)
quorum_dispatch(q_handle, CS_DISPATCH_ONE);
quorum_finalize(q_handle);
q_handle = 0;
err = corosync_cfg_initialize(&c_handle, &c_callbacks);
if (err != CS_OK) {
fprintf(stderr, "Cannot initialise CFG service\n");
c_handle = 0;
goto err_exit;
}
if (using_vq)
printf("Nodeid Votes Name\n");
else
printf("Nodeid Name\n");
for (i=0; i < g_view_list_entries; i++) {
if (nodeid_format == NODEID_FORMAT_DECIMAL) {
printf("%4u ", g_view_list[i]);
}
else {
printf("0x%04x ", g_view_list[i]);
}
if (using_vq) {
printf("%3d %s\n", get_votes(v_handle, g_view_list[i]), node_name(c_handle, g_view_list[i], name_format));
}
else {
printf("%s\n", node_name(c_handle, g_view_list[i], name_format));
}
}
result = EXIT_SUCCESS;
err_exit:
if (q_handle != 0) {
quorum_finalize (q_handle);
}
if (using_vq && v_handle != 0) {
votequorum_finalize (v_handle);
}
if (c_handle != 0) {
corosync_cfg_finalize (c_handle);
}
return result;
}
int main (int argc, char *argv[]) {
const char *options = "hd:ne";
int opt;
const char *prog_name = basename(argv[0]);
char delimiter = 0;
int escape = 1;
operation_t operation = OPER_FULL_OUTPUT;
int result;
while ( (opt = getopt(argc, argv, options)) != -1 ) {
switch (opt) {
case 'd':
if (strlen (optarg) > 0) {
delimiter = optarg[0];
}
break;
case 'n':
operation = OPER_NAMES_ONLY;
break;
case 'e':
escape = 0;
break;
case 'h':
usage_do (prog_name);
return (EXIT_SUCCESS);
break;
case '?':
case ':':
return (EXIT_FAILURE);
break;
}
}
result = cpg_initialize (&cpg_handle, NULL);
if (result != CS_OK) {
fprintf (stderr, "Could not initialize corosync cpg API error %d\n", result);
return (EXIT_FAILURE);
}
result = corosync_cfg_initialize (&cfg_handle, NULL);
if (result != CS_OK) {
fprintf (stderr, "Could not initialize corosync configuration API error %d\n", result);
return (EXIT_FAILURE);
}
switch (operation) {
case OPER_NAMES_ONLY:
result = display_groups (delimiter, escape);
break;
case OPER_FULL_OUTPUT:
result = display_groups_with_members (delimiter, escape);
break;
}
cpg_finalize (cpg_handle);
corosync_cfg_finalize (cfg_handle);
return (result ? EXIT_SUCCESS : EXIT_FAILURE);
}
static void do_command (int sock, char* func, char*args[], int num_args)
{
int result;
char response[100];
struct cpg_name group_name;
if (parse_debug)
syslog (LOG_DEBUG,"RPC:%s() called.", func);
if (strcmp ("cpg_mcast_joined",func) == 0) {
struct iovec iov[5];
int a;
for (a = 0; a < num_args; a++) {
iov[a].iov_base = args[a];
iov[a].iov_len = strlen(args[a])+1;
}
cpg_mcast_joined (cpg_handle, CPG_TYPE_AGREED, iov, num_args);
} else if (strcmp ("cpg_join",func) == 0) {
strcpy (group_name.value, args[0]);
group_name.length = strlen(args[0]);
result = cpg_join (cpg_handle, &group_name);
if (result != CS_OK) {
syslog (LOG_ERR,
"Could not join process group, error %d\n", result);
exit (1);
}
syslog (LOG_INFO, "called cpg_join()!");
} else if (strcmp ("cpg_leave",func) == 0) {
strcpy (group_name.value, args[0]);
group_name.length = strlen(args[0]);
result = cpg_leave (cpg_handle, &group_name);
if (result != CS_OK) {
syslog (LOG_ERR,
"Could not leave process group, error %d\n", result);
exit (1);
}
syslog (LOG_INFO, "called cpg_leave()!");
} else if (strcmp ("cpg_initialize",func) == 0) {
int retry_count = 0;
result = cpg_initialize (&cpg_handle, &callbacks);
while (result != CS_OK) {
syslog (LOG_ERR,
"cpg_initialize error %d (attempt %d)\n",
result, retry_count);
if (retry_count >= 3) {
exit (1);
}
sleep(1);
retry_count++;
result = cpg_initialize (&cpg_handle, &callbacks);
}
cpg_fd_get (cpg_handle, &cpg_fd);
poll_dispatch_add (ta_poll_handle_get(), cpg_fd, POLLIN|POLLNVAL, NULL, cpg_dispatch_wrapper_fn);
} else if (strcmp ("cpg_local_get", func) == 0) {
unsigned int local_nodeid;
cpg_local_get (cpg_handle, &local_nodeid);
snprintf (response, 100, "%u",local_nodeid);
send (sock, response, strlen (response), 0);
} else if (strcmp ("cpg_finalize", func) == 0) {
cpg_finalize (cpg_handle);
poll_dispatch_delete (ta_poll_handle_get(), cpg_fd);
cpg_fd = -1;
} else if (strcmp ("record_config_events", func) == 0) {
record_config_events (sock);
} else if (strcmp ("record_messages", func) == 0) {
record_messages ();
} else if (strcmp ("read_config_event", func) == 0) {
read_config_event (sock);
} else if (strcmp ("read_messages", func) == 0) {
read_messages (sock, args[0]);
} else if (strcmp ("msg_blaster_zcb", func) == 0) {
msg_blaster_zcb (sock, args[0]);
} else if (strcmp ("pcmk_test", func) == 0) {
pcmk_test = 1;
} else if (strcmp ("msg_blaster", func) == 0) {
msg_blaster (sock, args[0]);
} else if (strcmp ("context_test", func) == 0) {
context_test (sock);
} else if (strcmp ("are_you_ok_dude", func) == 0) {
snprintf (response, 100, "%s", OK_STR);
send (sock, response, strlen (response), 0);
} else if (strcmp ("cfg_shutdown", func) == 0) {
corosync_cfg_try_shutdown (cfg_handle, COROSYNC_CFG_SHUTDOWN_FLAG_REQUEST);
} else if (strcmp ("cfg_initialize",func) == 0) {
int retry_count = 0;
syslog (LOG_INFO,"%s %s() called!", __func__, func);
result = corosync_cfg_initialize (&cfg_handle, &cfg_callbacks);
while (result != CS_OK) {
syslog (LOG_ERR,
"cfg_initialize error %d (attempt %d)\n",
result, retry_count);
if (retry_count >= 3) {
exit (1);
}
sleep(1);
retry_count++;
result = corosync_cfg_initialize (&cfg_handle, &cfg_callbacks);
}
corosync_cfg_fd_get (cfg_handle, &cfg_fd);
corosync_cfg_state_track (cfg_handle, 0, ¬ification_buffer);
poll_dispatch_add (ta_poll_handle_get(), cfg_fd, POLLIN|POLLNVAL, NULL, cfg_dispatch_wrapper_fn);
} else {
syslog (LOG_ERR,"%s RPC:%s not supported!", __func__, func);
}
}
static int
linkstatusget_do (char *interface_name, int brief)
{
cs_error_t result;
corosync_cfg_handle_t handle;
unsigned int interface_count;
char **interface_names;
char **interface_status;
unsigned int i;
unsigned int nodeid;
int rc = 0;
int len, s = 0, t;
printf ("Printing link status.\n");
result = corosync_cfg_initialize (&handle, NULL);
if (result != CS_OK) {
printf ("Could not initialize corosync configuration API error %d\n", result);
exit (1);
}
result = corosync_cfg_local_get(handle, &nodeid);
if (result != CS_OK) {
printf ("Could not get the local node id, the error is: %d\n", result);
}
else {
printf ("Local node ID %u\n", nodeid);
}
result = corosync_cfg_ring_status_get (handle,
&interface_names,
&interface_status,
&interface_count);
if (result != CS_OK) {
printf ("Could not get the link status, the error is: %d\n", result);
} else {
for (i = 0; i < interface_count; i++) {
s = 0;
if ( (interface_name &&
interface_names[i][0] != '\0' &&
(interface_name[0]=='\0' ||
strcasecmp (interface_name, interface_names[i]) == 0)) ||
!interface_name ) {
/*
* Interface_name is "<linkid> <IP address>"
* separate them out
*/
char *space = strchr(interface_names[i], ' ');
if (!space) {
continue;
}
*space = '\0';
printf ("LINK ID %s\n", interface_names[i]);
printf ("\taddr\t= %s\n", space+1);
if((!brief) && (strcmp(interface_status[i], "OK") != 0) &&
(!strstr(interface_status[i], "FAULTY"))) {
len = strlen(interface_status[i]);
printf ("\tstatus:\n");
while(s < len) {
t = interface_status[i][s] - '0';
printf("\t\tnode %d:\t", s++);
printf("link enabled:%d\t", t&1? 1 : 0);
printf("link connected:%d\n", t&2? 1: 0);
}
} else {
printf ("\tstatus\t= %s\n", interface_status[i]);
if (strstr(interface_status[i], "FAULTY")) {
rc = 1;
}
}
}
}
for (i = 0; i < interface_count; i++) {
free(interface_status[i]);
free(interface_names[i]);
}
free(interface_status);
free(interface_names);
}
(void)corosync_cfg_finalize (handle);
return rc;
}
