Make all the bicapitalised names in cfg more sensible.

git-svn-id: http://svn.fedorahosted.org/svn/corosync/trunk@1732 fd59a12c-fef9-0310-b244-a6a79926bd2f

include/corosync/cfg.h

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2005 MontaVista Software, Inc.
- * Copyright (c) 2006 Red Hat, Inc.
+ * Copyright (c) 2006-2009 Red Hat, Inc.
  *
  * All rights reserved.
  *
@@ -45,24 +45,24 @@ typedef enum {
 	COROSYNC_CFG_ADMINISTRATIVETARGET_SERVICEGROUP = 1,
 	COROSYNC_CFG_ADMINISTRATIVETARGET_COMPONENTSERVICEINSTANCE = 2,
 	COROSYNC_CFG_ADMINISTRATIVETARGET_NODE = 3
-} CorosyncCfgAdministrativeTargetT;
+} corosync_cfg_administrative_target_t;
 
 typedef enum {
 	COROSYNC_CFG_ADMINISTRATIVESTATE_UNLOCKED = 0,
 	COROSYNC_CFG_ADMINISTRATIVESTATE_LOCKED = 1,
 	COROSYNC_CFG_ADMINISTRATIVESTATE_STOPPING = 2
-} CorosyncCfgAdministrativeStateT;
+} corosync_cfg_administrative_state_t;
 
 typedef enum {
 	COROSYNC_CFG_OPERATIONALSTATE_ENABLED = 1,
 	COROSYNC_CFG_OPERATIONALSTATE_DISABLED = 2
-} CorosyncCfgOperationalStateT;
+} corosync_cfg_operational_state_t;
 
 typedef enum {
 	COROSYNC_CFG_READINESSSTATE_OUTOFSERVICE = 1,
 	COROSYNC_CFG_READINESSSTATE_INSERVICE = 2,
 	COROSYNC_CFG_READINESSSTATE_STOPPING = 3
-} CorosyncCfgReadinessStateT;
+} corosync_cfg_readiness_state_t;
 
 typedef enum {
 	COROSYNC_CFG_PRESENCESTATE_UNINSTANTIATED = 1,
@@ -72,7 +72,7 @@ typedef enum {
 	COROSYNC_CFG_PRESENCESTATE_RESTARTING = 5,
 	COROSYNC_CFG_PRESENCESTATE_INSTANTIATION_FAILED = 6,
 	COROSYNC_CFG_PRESENCESTATE_TERMINATION_FAILED = 7
-} CorosyncCfgPresenceStateT;
+} corosync_cfg_presence_state_t;
 
 typedef enum {
 	COROSYNC_CFG_STATETYPE_OPERATIONAL = 0,
@@ -80,7 +80,7 @@ typedef enum {
 	COROSYNC_CFG_STATETYPE_READINESS = 2,
 	COROSYNC_CFG_STATETYPE_HA = 3,
 	COROSYNC_CFG_STATETYPE_PRESENCE = 4
-} CorosyncCfgStateTypeT;
+} corosync_cfg_state_type_t;
 
 /* Shutdown types.
    REQUEST is the normal shutdown. other daemons will be consulted
@@ -91,38 +91,36 @@ typedef enum {
 	COROSYNC_CFG_SHUTDOWN_FLAG_REQUEST = 0,
 	COROSYNC_CFG_SHUTDOWN_FLAG_REGARDLESS = 1,
 	COROSYNC_CFG_SHUTDOWN_FLAG_IMMEDIATE = 2,
-} CorosyncCfgShutdownFlagsT;
+} corosync_cfg_shutdown_flags_t;
 
 typedef enum {
 	COROSYNC_CFG_SHUTDOWN_FLAG_NO = 0,
 	COROSYNC_CFG_SHUTDOWN_FLAG_YES = 1,
-} CorosyncCfgShutdownReplyFlagsT;
+} corosync_cfg_shutdown_reply_flags_t;
 
 typedef struct {
 	cs_name_t name;
-	CorosyncCfgStateTypeT stateType;
-	CorosyncCfgAdministrativeStateT administrativeState;
-} CorosyncCfgStateNotificationT;
+	corosync_cfg_state_type_t state_type;
+	corosync_cfg_administrative_state_t administrative_state;
+} corosync_cfg_state_notification_t;
 
 typedef struct {
-        uint32_t numberOfItems;
-        CorosyncCfgStateNotificationT *notification;
-} CorosyncCfgStateNotificationBufferT;
+        uint32_t number_of_items;
+        corosync_cfg_state_notification_t *notification;
+} corosync_cfg_state_notification_buffer_t;
 
-typedef void (*CorosyncCfgStateTrackCallbackT) (
-	CorosyncCfgStateNotificationBufferT *notificationBuffer,
+typedef void (*corosync_cfg_state_track_callback_t) (
+	corosync_cfg_state_notification_buffer_t *notification_buffer,
 	cs_error_t error);
 
-typedef void (*CorosyncCfgShutdownCallbackT) (
+typedef void (*corosync_cfg_shutdown_callback_t) (
 	corosync_cfg_handle_t cfg_handle,
-	CorosyncCfgShutdownFlagsT flags);
+	corosync_cfg_shutdown_flags_t flags);
 
 typedef struct {
-	CorosyncCfgStateTrackCallbackT
-		corosyncCfgStateTrackCallback;
-	CorosyncCfgShutdownCallbackT
-		corosyncCfgShutdownCallback;
-} CorosyncCfgCallbacksT;
+	corosync_cfg_state_track_callback_t corosync_cfg_state_track_callback;
+	corosync_cfg_shutdown_callback_t corosync_cfg_shutdown_callback;
+} corosync_cfg_callbacks_t;
 
 /*
  * A node address. This is a complete sockaddr_in[6]
@@ -137,7 +135,7 @@ typedef struct
 {
 	int  addressLength;
 	char address[sizeof(struct sockaddr_in6)];
-} CorosyncCfgNodeAddressT;
+} corosync_cfg_node_address_t;
 
 
 /*
@@ -150,7 +148,7 @@ extern "C" {
 cs_error_t
 corosync_cfg_initialize (
 	corosync_cfg_handle_t *cfg_handle,
-	const CorosyncCfgCallbacksT *cfgCallbacks);
+	const corosync_cfg_callbacks_t *cfg_callbacks);
 
 cs_error_t
 corosync_cfg_fd_get (
@@ -160,7 +158,7 @@ corosync_cfg_fd_get (
 cs_error_t
 corosync_cfg_dispatch (
 	corosync_cfg_handle_t cfg_handle,
-	cs_dispatch_flags_t dispatchFlags);
+	cs_dispatch_flags_t dispatch_flags);
 
 cs_error_t
 corosync_cfg_finalize (
@@ -192,14 +190,14 @@ corosync_cfg_service_unload (
 cs_error_t
 corosync_cfg_administrative_state_get (
 	corosync_cfg_handle_t cfg_handle,
-	CorosyncCfgAdministrativeTargetT administrativeTarget,
-	CorosyncCfgAdministrativeStateT *administrativeState);
+	corosync_cfg_administrative_target_t administrative_target,
+	corosync_cfg_administrative_state_t *administrative_state);
 
 cs_error_t
 corosync_cfg_administrative_state_set (
 	corosync_cfg_handle_t cfg_handle,
-	CorosyncCfgAdministrativeTargetT administrativeTarget,
-	CorosyncCfgAdministrativeStateT administrativeState);
+	corosync_cfg_administrative_target_t administrative_target,
+	corosync_cfg_administrative_state_t administrative_state);
 
 cs_error_t
 corosync_cfg_kill_node (
@@ -210,19 +208,19 @@ corosync_cfg_kill_node (
 cs_error_t
 corosync_cfg_try_shutdown (
 	corosync_cfg_handle_t cfg_handle,
-	CorosyncCfgShutdownFlagsT flags);
+	corosync_cfg_shutdown_flags_t flags);
 
 
 cs_error_t
 corosync_cfg_replyto_shutdown (
 	corosync_cfg_handle_t cfg_handle,
-	CorosyncCfgShutdownReplyFlagsT flags);
+	corosync_cfg_shutdown_reply_flags_t flags);
 
 cs_error_t
 corosync_cfg_state_track (
         corosync_cfg_handle_t cfg_handle,
-        uint8_t trackFlags,
-        const CorosyncCfgStateNotificationT *notificationBuffer);
+        uint8_t track_flags,
+        const corosync_cfg_state_notification_t *notification_buffer);
 
 cs_error_t
 corosync_cfg_state_track_stop (
@@ -235,7 +233,7 @@ corosync_cfg_get_node_addrs (
 	int nodeid,
 	int max_addrs,
 	int *num_addrs,
-	CorosyncCfgNodeAddressT *addrs);
+	corosync_cfg_node_address_t *addrs);
 
 
 #ifdef __cplusplus

include/corosync/ipc_cfg.h

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2005 MontaVista Software, Inc.
+ * Copyright (c) 2009 Red Hat, Inc.
  *
  * All rights reserved.
  *
@@ -71,8 +72,8 @@ enum res_lib_cfg_types {
 
 struct req_lib_cfg_statetrack {
 	mar_req_header_t header;
-	uint8_t trackFlags;
-	CorosyncCfgStateNotificationT *notificationBufferAddress;
+	uint8_t track_flags;
+	corosync_cfg_state_notification_t *notification_buffer_address;
 };
 
 struct res_lib_cfg_statetrack {
@@ -89,9 +90,9 @@ struct res_lib_cfg_statetrackstop {
 
 struct req_lib_cfg_administrativestateset {
 	mar_req_header_t header;
-	cs_name_t compName;
-	CorosyncCfgAdministrativeTargetT administrativeTarget;
-	CorosyncCfgAdministrativeStateT administrativeState;
+	cs_name_t comp_name;
+	corosync_cfg_administrative_target_t administrative_target;
+	corosync_cfg_administrative_state_t administrative_state;
 };
 
 struct res_lib_cfg_administrativestateset {
@@ -100,9 +101,9 @@ struct res_lib_cfg_administrativestateset {
 
 struct req_lib_cfg_administrativestateget {
 	mar_req_header_t header;
-	cs_name_t compName;
-	CorosyncCfgAdministrativeTargetT administrativeTarget;
-	CorosyncCfgAdministrativeStateT administrativeState;
+	cs_name_t comp_name;
+	corosync_cfg_administrative_target_t administrative_target;
+	corosync_cfg_administrative_state_t administrative_state;
 };
 
 struct res_lib_cfg_administrativestateget {
@@ -194,19 +195,19 @@ typedef enum {
 	AIS_AMF_ADMINISTRATIVETARGET_SERVICEGROUP = 1,
 	AIS_AMF_ADMINISTRATIVETARGET_COMPONENTSERVICEINSTANCE = 2,
 	AIS_AMF_ADMINISTRATIVETARGET_NODE = 3
-} corosyncAdministrativeTarget;
+} corosync_administrative_target_t;
 
 typedef enum {
 	AIS_AMF_ADMINISTRATIVESTATE_UNLOCKED = 0,
 	AIS_AMF_ADMINISTRATIVESTATE_LOCKED = 1,
 	AIS_AMF_ADMINISTRATIVESTATE_STOPPING = 2
-} corosyncAdministrativeState;
+} corosync_administrative_state_t;
 
 typedef enum {
 	CFG_SHUTDOWN_FLAG_REQUEST = 0,
 	CFG_SHUTDOWN_FLAG_REGARDLESS = 1,
 	CFG_SHUTDOWN_FLAG_IMMEDIATE = 2,
-} CorosyncShutdownFlagsT;
+} corosync_shutdown_flags_t;
 
 
 #endif /* AIS_IPC_CFG_H_DEFINED */

lib/cfg.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2002-2005 MontaVista Software, Inc.
- * Copyright (c) 2006-2007 Red Hat, Inc.
+ * Copyright (c) 2006-2009 Red Hat, Inc.
  *
  * All rights reserved.
  *
@@ -65,15 +65,15 @@ struct cfg_res_overlay {
 struct cfg_instance {
 	int response_fd;
 	int dispatch_fd;
-	CorosyncCfgCallbacksT callbacks;
-	cs_name_t compName;
-	int compRegistered;
+	corosync_cfg_callbacks_t callbacks;
+	cs_name_t comp_name;
+	int comp_registered;
 	int finalize;
 	pthread_mutex_t response_mutex;
 	pthread_mutex_t dispatch_mutex;
 };
 
-static void cfg_handleInstanceDestructor (void *);
+static void cfg_handle_instance_destructor (void *);
 
 /*
  * All instances in one database
@@ -82,13 +82,13 @@ static struct saHandleDatabase cfg_hdb = {
 	.handleCount			= 0,
 	.handles			= 0,
 	.mutex				= PTHREAD_MUTEX_INITIALIZER,
-	.handleInstanceDestructor	= cfg_handleInstanceDestructor
+	.handleInstanceDestructor	= cfg_handle_instance_destructor
 };
 
 /*
  * Implementation
  */
-void cfg_handleInstanceDestructor (void *instance)
+void cfg_handle_instance_destructor (void *instance)
 {
 	struct cfg_instance *cfg_instance = instance;
 
@@ -99,7 +99,7 @@ void cfg_handleInstanceDestructor (void *instance)
 cs_error_t
 corosync_cfg_initialize (
 	corosync_cfg_handle_t *cfg_handle,
-	const CorosyncCfgCallbacksT *cfgCallbacks)
+	const corosync_cfg_callbacks_t *cfg_callbacks)
 {
 	struct cfg_instance *cfg_instance;
 	cs_error_t error = CS_OK;
@@ -124,8 +124,8 @@ corosync_cfg_initialize (
 		goto error_put_destroy;
 	}
 
-	if (cfgCallbacks) {
-	memcpy (&cfg_instance->callbacks, cfgCallbacks, sizeof (CorosyncCfgCallbacksT));
+	if (cfg_callbacks) {
+	memcpy (&cfg_instance->callbacks, cfg_callbacks, sizeof (corosync_cfg_callbacks_t));
 	}
 
 	pthread_mutex_init (&cfg_instance->response_mutex, NULL);
@@ -166,7 +166,7 @@ corosync_cfg_fd_get (
 cs_error_t
 corosync_cfg_dispatch (
 	corosync_cfg_handle_t cfg_handle,
-	cs_dispatch_flags_t dispatchFlags)
+	cs_dispatch_flags_t dispatch_flags)
 {
 	struct pollfd ufds;
 	int timeout = -1;
@@ -182,7 +182,7 @@ corosync_cfg_dispatch (
 	struct res_lib_corosync_csiremovecallback *res_lib_corosync_csiremovecallback;
 	struct res_lib_cfg_statetrackcallback *res_lib_cfg_statetrackcallback;
 #endif
-	CorosyncCfgCallbacksT callbacks;
+	corosync_cfg_callbacks_t callbacks;
 	struct cfg_res_overlay dispatch_data;
 
 	error = saHandleInstanceGet (&cfg_hdb, cfg_handle,
@@ -194,7 +194,7 @@ corosync_cfg_dispatch (
 	/*
 	 * Timeout instantly for CS_DISPATCH_ALL
 	 */
-	if (dispatchFlags == CS_DISPATCH_ALL) {
+	if (dispatch_flags == CS_DISPATCH_ALL) {
 		timeout = 0;
 	}
 
@@ -228,7 +228,7 @@ corosync_cfg_dispatch (
 		}
 
 		dispatch_avail = ufds.revents & POLLIN;
-		if (dispatch_avail == 0 && dispatchFlags == CS_DISPATCH_ALL) {
+		if (dispatch_avail == 0 && dispatch_flags == CS_DISPATCH_ALL) {
 			pthread_mutex_unlock (&cfg_instance->dispatch_mutex);
 			break; /* exit do while cont is 1 loop */
 		} else
@@ -263,7 +263,7 @@ corosync_cfg_dispatch (
 		 * A risk of this dispatch method is that the callback routines may
 		 * operate at the same time that cfgFinalize has been called in another thread.
 		 */
-		memcpy (&callbacks, &cfg_instance->callbacks, sizeof (CorosyncCfgCallbacksT));
+		memcpy (&callbacks, &cfg_instance->callbacks, sizeof (corosync_cfg_callbacks_t));
 		pthread_mutex_unlock (&cfg_instance->dispatch_mutex);
 
 		/*
@@ -271,9 +271,9 @@ corosync_cfg_dispatch (
 		 */
 		switch (dispatch_data.header.id) {
 		case MESSAGE_RES_CFG_TESTSHUTDOWN:
-			if (callbacks.corosyncCfgShutdownCallback) {
+			if (callbacks.corosync_cfg_shutdown_callback) {
 				res_lib_cfg_testshutdown = (struct res_lib_cfg_testshutdown *)&dispatch_data;
-				callbacks.corosyncCfgShutdownCallback(cfg_handle, res_lib_cfg_testshutdown->flags);
+				callbacks.corosync_cfg_shutdown_callback(cfg_handle, res_lib_cfg_testshutdown->flags);
 			}
 			break;
 		default:
@@ -285,7 +285,7 @@ corosync_cfg_dispatch (
 		/*
 		 * Determine if more messages should be processed
 		 */
-		switch (dispatchFlags) {
+		switch (dispatch_flags) {
 		case CS_DISPATCH_ONE:
 			cont = 0;
 			break;
@@ -543,8 +543,8 @@ corosync_cfg_service_unload (
 cs_error_t
 corosync_cfg_state_track (
 	corosync_cfg_handle_t cfg_handle,
-	uint8_t trackFlags,
-	const CorosyncCfgStateNotificationT *notificationBuffer)
+	uint8_t track_flags,
+	const corosync_cfg_state_notification_t *notification_buffer)
 {
 	struct cfg_instance *cfg_instance;
 	struct req_lib_cfg_statetrack req_lib_cfg_statetrack;
@@ -553,8 +553,8 @@ corosync_cfg_state_track (
 
 	req_lib_cfg_statetrack.header.size = sizeof (struct req_lib_cfg_statetrack);
 	req_lib_cfg_statetrack.header.id = MESSAGE_REQ_CFG_STATETRACKSTART;
-	req_lib_cfg_statetrack.trackFlags = trackFlags;
-	req_lib_cfg_statetrack.notificationBufferAddress = (CorosyncCfgStateNotificationT *)notificationBuffer;
+	req_lib_cfg_statetrack.track_flags = track_flags;
+	req_lib_cfg_statetrack.notification_buffer_address = (corosync_cfg_state_notification_t *)notification_buffer;
 
 	error = saHandleInstanceGet (&cfg_hdb, cfg_handle,
 		(void *)&cfg_instance);
@@ -613,8 +613,8 @@ corosync_cfg_state_track_stop (
 cs_error_t
 corosync_cfg_admin_state_get (
 	corosync_cfg_handle_t cfg_handle,
-	CorosyncCfgAdministrativeTargetT administrativeTarget,
-	CorosyncCfgAdministrativeStateT *administrativeState)
+	corosync_cfg_administrative_target_t administrative_target,
+	corosync_cfg_administrative_state_t *administrative_state)
 {
 	struct cfg_instance *cfg_instance;
 	struct req_lib_cfg_administrativestateget req_lib_cfg_administrativestateget;
@@ -629,7 +629,7 @@ corosync_cfg_admin_state_get (
 
 	req_lib_cfg_administrativestateget.header.id = MESSAGE_REQ_CFG_ADMINISTRATIVESTATEGET;
 	req_lib_cfg_administrativestateget.header.size = sizeof (struct req_lib_cfg_administrativestateget);
-	req_lib_cfg_administrativestateget.administrativeTarget = administrativeTarget;
+	req_lib_cfg_administrativestateget.administrative_target = administrative_target;
 
 	pthread_mutex_lock (&cfg_instance->response_mutex);
 
@@ -651,8 +651,8 @@ corosync_cfg_admin_state_get (
 cs_error_t
 corosync_cfg_admin_state_set (
 	corosync_cfg_handle_t cfg_handle,
-	CorosyncCfgAdministrativeTargetT administrativeTarget,
-	CorosyncCfgAdministrativeStateT administrativeState)
+	corosync_cfg_administrative_target_t administrative_target,
+	corosync_cfg_administrative_state_t administrative_state)
 {
 	struct cfg_instance *cfg_instance;
 	struct req_lib_cfg_administrativestateset req_lib_cfg_administrativestateset;
@@ -667,8 +667,8 @@ corosync_cfg_admin_state_set (
 
 	req_lib_cfg_administrativestateset.header.id = MESSAGE_REQ_CFG_ADMINISTRATIVESTATEGET;
 	req_lib_cfg_administrativestateset.header.size = sizeof (struct req_lib_cfg_administrativestateset);
-	req_lib_cfg_administrativestateset.administrativeTarget = administrativeTarget;
-	req_lib_cfg_administrativestateset.administrativeState = administrativeState;
+	req_lib_cfg_administrativestateset.administrative_target = administrative_target;
+	req_lib_cfg_administrativestateset.administrative_state = administrative_state;
 
 	pthread_mutex_lock (&cfg_instance->response_mutex);
 
@@ -733,7 +733,7 @@ corosync_cfg_kill_node (
 cs_error_t
 corosync_cfg_try_shutdown (
 	corosync_cfg_handle_t cfg_handle,
-	CorosyncCfgShutdownFlagsT flags)
+	corosync_cfg_shutdown_flags_t flags)
 {
 	struct cfg_instance *cfg_instance;
 	struct req_lib_cfg_tryshutdown req_lib_cfg_tryshutdown;
@@ -768,7 +768,7 @@ corosync_cfg_try_shutdown (
 cs_error_t
 corosync_cfg_replyto_shutdown (
 	corosync_cfg_handle_t cfg_handle,
-	CorosyncCfgShutdownReplyFlagsT response)
+	corosync_cfg_shutdown_reply_flags_t response)
 {
 	struct cfg_instance *cfg_instance;
 	struct req_lib_cfg_replytoshutdown req_lib_cfg_replytoshutdown;
@@ -802,7 +802,7 @@ cs_error_t corosync_cfg_get_node_addrs (
 	int nodeid,
 	int max_addrs,
 	int *num_addrs,
-	CorosyncCfgNodeAddressT *addrs)
+	corosync_cfg_node_address_t *addrs)
 {
 	cs_error_t error;
 	char buf[PIPE_BUF];

services/cfg.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2005-2006 MontaVista Software, Inc.
- * Copyright (c) 2006-2008 Red Hat, Inc.
+ * Copyright (c) 2006-2009 Red Hat, Inc.
  *
  * All rights reserved.
  *

tools/corosync-cfgtool.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2007 Red Hat, Inc.
+ * Copyright (c) 2006-2009 Red Hat, Inc.
  *
  * All rights reserved.
  *
@@ -138,7 +138,7 @@ void service_unload_do (char *service, unsigned int version)
 	(void)corosync_cfg_finalize (handle);
 }
 
-void shutdown_callback (corosync_cfg_handle_t cfg_handle, CorosyncCfgShutdownFlagsT flags)
+void shutdown_callback (corosync_cfg_handle_t cfg_handle, corosync_cfg_shutdown_flags_t flags)
 {
 	printf("shutdown callback called, flags = %d\n",flags);
 
@@ -162,12 +162,12 @@ void shutdown_do()
 {
 	cs_error_t result;
 	corosync_cfg_handle_t handle;
-	CorosyncCfgCallbacksT callbacks;
-	CorosyncCfgStateNotificationT notificationBuffer;
+	corosync_cfg_callbacks_t callbacks;
+	corosync_cfg_state_notification_t notification_buffer;
 	pthread_t dispatch_thread;
 
 	printf ("Shutting down corosync\n");
-	callbacks.corosyncCfgShutdownCallback = shutdown_callback;
+	callbacks.corosync_cfg_shutdown_callback = shutdown_callback;
 
 	result = corosync_cfg_initialize (&handle, &callbacks);
 	if (result != CS_OK) {
@@ -179,7 +179,7 @@ void shutdown_do()
 
 	result = corosync_cfg_state_track (handle,
 					   0,
-					   &notificationBuffer);
+					   &notification_buffer);
 	if (result != CS_OK) {
 		printf ("Could not start corosync cfg tracking error %d\n", result);
 		exit (1);
@@ -197,10 +197,10 @@ void showaddrs_do(int nodeid)
 {
 	cs_error_t result;
 	corosync_cfg_handle_t handle;
-	CorosyncCfgCallbacksT callbacks;
+	corosync_cfg_callbacks_t callbacks;
 	int numaddrs;
 	int i;
-	CorosyncCfgNodeAddressT addrs[INTERFACE_MAX];
+	corosync_cfg_node_address_t addrs[INTERFACE_MAX];
 
 
 	result = corosync_cfg_initialize (&handle, &callbacks);