diff --git a/lib/crm/cib/cib_client.c b/lib/crm/cib/cib_client.c
index a5e29f030c..f653c408dc 100755
--- a/lib/crm/cib/cib_client.c
+++ b/lib/crm/cib/cib_client.c
@@ -1,1488 +1,1498 @@
 /*
  * Copyright (c) 2004 International Business Machines
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  * 
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  * 
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  */
 #include <portability.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
 
 #include <glib.h>
 #include <heartbeat.h>
 #include <clplumbing/ipc.h>
 
 #include <crm/crm.h>
 #include <crm/cib.h>
 #include <crm/msg_xml.h>
 #include <crm/common/xml.h>
 #include <cib_private.h>
 
 /* short term hack to reduce callback messages */
 typedef struct cib_native_opaque_s 
 {
 		IPC_Channel	*command_channel;
 		IPC_Channel	*callback_channel;
  		GCHSource	*callback_source; 
 		
 } cib_native_opaque_t;
 
 GHashTable *cib_op_callback_table = NULL;
 
 gboolean verify_cib_cmds(cib_t *cib);
 
 int cib_client_set_op_callback(
 	cib_t *cib, void (*callback)(const struct ha_msg *msg, int call_id,
 				     int rc, crm_data_t *output));
 int cib_client_noop(cib_t *cib, int call_options);
 int cib_client_ping(cib_t *cib, crm_data_t **output_data, int call_options);
 
 int cib_client_query(cib_t *cib, const char *section,
 	     crm_data_t **output_data, int call_options);
 int cib_client_query_from(cib_t *cib, const char *host, const char *section,
 			  crm_data_t **output_data, int call_options);
 
 int cib_client_sync(cib_t *cib, const char *section, int call_options);
 int cib_client_sync_from(
 	cib_t *cib, const char *host, const char *section, int call_options);
 
 int cib_client_is_master(cib_t *cib);
 int cib_client_set_slave(cib_t *cib, int call_options);
 int cib_client_set_slave_all(cib_t *cib, int call_options);
 int cib_client_set_master(cib_t *cib, int call_options);
 
 int cib_client_bump_epoch(cib_t *cib, int call_options);
 int cib_client_create(cib_t *cib, const char *section, crm_data_t *data,
 		      crm_data_t **output_data, int call_options);
 int cib_client_modify(cib_t *cib, const char *section, crm_data_t *data,
 		      crm_data_t **output_data, int call_options);
 int cib_client_update(cib_t *cib, const char *section, crm_data_t *data,
 		      crm_data_t **output_data, int call_options);
 int cib_client_replace(cib_t *cib, const char *section, crm_data_t *data,
 		       crm_data_t **output_data, int call_options);
 int cib_client_delete(cib_t *cib, const char *section, crm_data_t *data,
 		      crm_data_t **output_data, int call_options);
 int cib_client_delete_absolute(
 	cib_t *cib, const char *section, crm_data_t *data,
 	crm_data_t **output_data, int call_options);
 int cib_client_erase(
 	cib_t *cib, crm_data_t **output_data, int call_options);
 int cib_client_quit(cib_t *cib,   int call_options);
 
 int cib_client_add_notify_callback(
 	cib_t *cib, const char *event, void (*callback)(
 		const char *event, struct ha_msg *msg));
 
 int cib_client_del_notify_callback(
 	cib_t *cib, const char *event, void (*callback)(
 		const char *event, struct ha_msg *msg));
 
 gint ciblib_GCompareFunc(gconstpointer a, gconstpointer b);
 
 extern cib_t *cib_native_new(cib_t *cib);
+extern void cib_native_delete(cib_t *cib);
 
 static enum cib_variant configured_variant = cib_native;
 
 /* define of the api functions*/
 cib_t*
 cib_new(void)
 {
 	cib_t* new_cib = NULL;
 
 	if(configured_variant != cib_native) {
 		crm_err("Only the native CIB type is currently implemented");
 		return NULL;
 	}
 
 	if(cib_op_callback_table != NULL) {
 		g_hash_table_destroy(cib_op_callback_table);
 		cib_op_callback_table = NULL;
 	}
 	if(cib_op_callback_table == NULL) {
 		cib_op_callback_table = g_hash_table_new_full(
 			g_direct_hash, g_direct_equal,
 			NULL, g_hash_destroy_str);
 	}
 
 	crm_malloc0(new_cib, sizeof(cib_t));
 
 	new_cib->call_id = 1;
 
 	new_cib->type  = cib_none;
 	new_cib->state = cib_disconnected;
 
 	new_cib->op_callback	= NULL;
 	new_cib->variant_opaque = NULL;
 	new_cib->notify_list    = NULL;
 
 	/* the rest will get filled in by the variant constructor */
 	crm_malloc0(new_cib->cmds, sizeof(cib_api_operations_t));
-	memset(new_cib->cmds, 0, sizeof(cib_api_operations_t));
 
 	new_cib->cmds->set_op_callback     = cib_client_set_op_callback;
 	new_cib->cmds->add_notify_callback = cib_client_add_notify_callback;
 	new_cib->cmds->del_notify_callback = cib_client_del_notify_callback;
 	
 	new_cib->cmds->noop    = cib_client_noop;
 	new_cib->cmds->ping    = cib_client_ping;
 	new_cib->cmds->query   = cib_client_query;
 	new_cib->cmds->sync    = cib_client_sync;
 
 	new_cib->cmds->query_from = cib_client_query_from;
 	new_cib->cmds->sync_from  = cib_client_sync_from;
 	
 	new_cib->cmds->is_master  = cib_client_is_master;
 	new_cib->cmds->set_master = cib_client_set_master;
 	new_cib->cmds->set_slave  = cib_client_set_slave;
 	new_cib->cmds->set_slave_all = cib_client_set_slave_all;
 
 	new_cib->cmds->bump_epoch = cib_client_bump_epoch;
 
 	new_cib->cmds->create  = cib_client_create;
 	new_cib->cmds->modify  = cib_client_modify;
 	new_cib->cmds->update  = cib_client_update;
 	new_cib->cmds->replace = cib_client_replace;
 	new_cib->cmds->delete  = cib_client_delete;
 	new_cib->cmds->erase   = cib_client_erase;
 	new_cib->cmds->quit    = cib_client_quit;
 
 	new_cib->cmds->delete_absolute  = cib_client_delete_absolute;
 	
 	cib_native_new(new_cib);
 	if(verify_cib_cmds(new_cib) == FALSE) {
 		return NULL;
 	}
 	
 	return new_cib;
 }
 
+void
+cib_delete(cib_t *cib)
+{
+	cib_native_delete(cib);
+	g_hash_table_destroy(cib_op_callback_table);
+	crm_free(cib->cmds);
+	crm_free(cib);
+}
+
+
 int
 cib_client_set_op_callback(
 	cib_t *cib, void (*callback)(const struct ha_msg *msg, int call_id,
 				     int rc, crm_data_t *output)) 
 {
 	if(callback == NULL) {
 		crm_info("Un-Setting operation callback");
 		
 	} else {
 		crm_debug_3("Setting operation callback");
 	}
 	cib->op_callback = callback;
 	return cib_ok;
 }
 	
 int cib_client_noop(cib_t *cib, int call_options)
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	}
 	
 	return cib->cmds->variant_op(
 		cib, CRM_OP_NOOP, NULL, NULL, NULL, NULL, call_options);
 }
 
 int cib_client_ping(cib_t *cib, crm_data_t **output_data, int call_options)
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	}
 	
 	return cib->cmds->variant_op(
 		cib, CRM_OP_PING, NULL,NULL,NULL, output_data, call_options);
 }
 
 
 int cib_client_query(cib_t *cib, const char *section,
 		     crm_data_t **output_data, int call_options)
 {
 	return cib->cmds->query_from(
 		cib, NULL, section, output_data, call_options);
 }
 
 int cib_client_query_from(cib_t *cib, const char *host, const char *section,
 			  crm_data_t **output_data, int call_options)
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	}
 	
 	return cib->cmds->variant_op(cib, CIB_OP_QUERY, host, section,
 				     NULL, output_data, call_options);
 }
 
 
 int cib_client_is_master(cib_t *cib)
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	} 
 	return cib->cmds->variant_op(
 		cib, CIB_OP_ISMASTER, NULL, NULL,NULL,NULL,
 		cib_scope_local|cib_sync_call);
 }
 
 int cib_client_set_slave(cib_t *cib, int call_options)
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	} 
 
 	return cib->cmds->variant_op(
 		cib, CIB_OP_SLAVE, NULL,NULL,NULL,NULL, call_options);
 }
 
 int cib_client_set_slave_all(cib_t *cib, int call_options)
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	} 
 
 	return cib->cmds->variant_op(
 		cib, CIB_OP_SLAVEALL, NULL,NULL,NULL,NULL, call_options);
 }
 
 int cib_client_set_master(cib_t *cib, int call_options)
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	} 
 
 	crm_debug_3("Adding cib_scope_local to options");
 	return cib->cmds->variant_op(
 		cib, CIB_OP_MASTER, NULL,NULL,NULL,NULL,
 		call_options|cib_scope_local);
 }
 
 
 
 int cib_client_bump_epoch(cib_t *cib, int call_options)
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	} 
 
 	return cib->cmds->variant_op(
 		cib, CIB_OP_BUMP, NULL, NULL, NULL, NULL, call_options);
 }
 
 int cib_client_sync(cib_t *cib, const char *section, int call_options)
 {
 	return cib->cmds->sync_from(cib, NULL, section, call_options);
 }
 
 int cib_client_sync_from(
 	cib_t *cib, const char *host, const char *section, int call_options)
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	}
 
 	return cib->cmds->variant_op(
 		cib, CIB_OP_SYNC, host, section, NULL, NULL, call_options);
 }
 
 int cib_client_create(cib_t *cib, const char *section, crm_data_t *data,
 		      crm_data_t **output_data, int call_options) 
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	} 
 
 	return cib->cmds->variant_op(cib, CIB_OP_CREATE, NULL, section,
 				     data, output_data, call_options);
 }
 
 
 int cib_client_modify(cib_t *cib, const char *section, crm_data_t *data,
 	   crm_data_t **output_data, int call_options) 
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	} 
 
 	return cib->cmds->variant_op(cib, CIB_OP_MODIFY, NULL, section,
 				     data, output_data, call_options);
 }
 
 int cib_client_update(cib_t *cib, const char *section, crm_data_t *data,
 		      crm_data_t **output_data, int call_options) 
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	} 
 
 	return cib->cmds->variant_op(cib, CIB_OP_UPDATE, NULL, section,
 				     data, output_data, call_options);
 }
 
 
 int cib_client_replace(cib_t *cib, const char *section, crm_data_t *data,
 	    crm_data_t **output_data, int call_options) 
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	} else if(data == NULL) {
 		return cib_missing_data;
 	}
 	
 	return cib->cmds->variant_op(cib, CIB_OP_REPLACE, NULL, section,
 				     data, output_data, call_options);
 }
 
 
 int cib_client_delete(cib_t *cib, const char *section, crm_data_t *data,
 	   crm_data_t **output_data, int call_options) 
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	}
 	
 	return cib->cmds->variant_op(cib, CIB_OP_DELETE, NULL, section,
 				     data, output_data, call_options);
 }
 
 int cib_client_delete_absolute(
 	cib_t *cib, const char *section, crm_data_t *data,
 	crm_data_t **output_data, int call_options) 
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	}
 	
 	return cib->cmds->variant_op(cib, CIB_OP_DELETE_ALT, NULL, section,
 				     data, output_data, call_options);
 }
 
 int cib_client_erase(
 	cib_t *cib, crm_data_t **output_data, int call_options)
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	} 
 
 	return cib->cmds->variant_op(cib, CIB_OP_ERASE, NULL, NULL, NULL,
 				     output_data, call_options);
 }
 
 
 int cib_client_quit(cib_t *cib, int call_options)
 {
 	if(cib == NULL) {
 		return cib_missing;
 	} else if(cib->state == cib_disconnected) {
 		return cib_not_connected;
 	} else if(cib->cmds->variant_op == NULL) {
 		return cib_variant;
 	} 
 
 	return cib->cmds->variant_op(
 		cib, CRM_OP_QUIT, NULL, NULL, NULL, NULL, call_options);
 }
 
 int cib_client_add_notify_callback(
 	cib_t *cib, const char *event, void (*callback)(
 		const char *event, struct ha_msg *msg))
 {
 	GList *list_item = NULL;
 	cib_notify_client_t *new_client = NULL;
 	
 	crm_debug_2("Adding callback for %s events (%d)",
 		    event, g_list_length(cib->notify_list));
 
 	crm_malloc0(new_client, sizeof(cib_notify_client_t));
 	new_client->event = event;
 	new_client->callback = callback;
 
 	list_item = g_list_find_custom(
 		cib->notify_list, new_client, ciblib_GCompareFunc);
 	
 	if(list_item != NULL) {
 		crm_warn("Callback already present");
 
 	} else {
 		cib->notify_list = g_list_append(
 			cib->notify_list, new_client);
 
 		cib->cmds->register_callback(cib, event, 1);
 		
 		crm_debug_3("Callback added (%d)", g_list_length(cib->notify_list));
 	}
 	return cib_ok;
 }
 
 
 int cib_client_del_notify_callback(
 	cib_t *cib, const char *event, void (*callback)(
 		const char *event, struct ha_msg *msg))
 {
 	GList *list_item = NULL;
 	cib_notify_client_t *new_client = NULL;
 
 	crm_debug("Removing callback for %s events", event);
 
 	crm_malloc0(new_client, sizeof(cib_notify_client_t));
 	new_client->event = event;
 	new_client->callback = callback;
 
 	list_item = g_list_find_custom(
 		cib->notify_list, new_client, ciblib_GCompareFunc);
 	
 	cib->cmds->register_callback(cib, event, 0);
 
 	if(list_item != NULL) {
 		cib_notify_client_t *list_client = list_item->data;
 		cib->notify_list =
 			g_list_remove(cib->notify_list, list_client);
 		crm_free(list_client);
 
 		crm_debug_3("Removed callback");
 
 	} else {
 		crm_debug_3("Callback not present");
 	}
 	crm_free(new_client);
 	return cib_ok;
 }
 
 gint ciblib_GCompareFunc(gconstpointer a, gconstpointer b)
 {
 	const cib_notify_client_t *a_client = a;
 	const cib_notify_client_t *b_client = b;
 	if(a_client->callback == b_client->callback
 	   && safe_str_neq(a_client->event, b_client->event)) {
 		return 0;
 	} else if(((long)a_client->callback) < ((long)b_client->callback)) {
 		return -1;
 	}
 	return 1;
 }
 
 
 
 gboolean
 add_cib_op_callback(
 	int call_id, gboolean only_success, void *user_data,
 	void (*callback)(const HA_Message*, int, int, crm_data_t*,void*)) 
 {
 	cib_callback_client_t *blob = NULL;
 
 	if(call_id < 0) {
 		crm_warn("CIB call failed: %s", cib_error2string(call_id));
 		if(only_success == FALSE) {
 			callback(NULL, call_id, call_id, NULL, user_data);
 		}
 		return FALSE;
 	}
 	
 	crm_malloc0(blob, sizeof(cib_callback_client_t));
 	blob->only_success = only_success;
 	blob->user_data = user_data;
 	blob->callback = callback;
 	
 	g_hash_table_insert(
 		cib_op_callback_table, GINT_TO_POINTER(call_id), blob);
 	return TRUE;
 }
 
 void
 remove_cib_op_callback(int call_id, gboolean all_callbacks) 
 {
 	if(all_callbacks) {
 		if(cib_op_callback_table != NULL) {
 			g_hash_table_destroy(cib_op_callback_table);
 		}
 		cib_op_callback_table = g_hash_table_new_full(
 			g_direct_hash, g_direct_equal,
 			NULL, g_hash_destroy_str);
 	} else {
 		g_hash_table_remove(
 			cib_op_callback_table,
 			GINT_TO_POINTER(call_id));
 	}
 }
 
 int
 num_cib_op_callbacks(void)
 {
 	return g_hash_table_size(cib_op_callback_table);
 }
 
 
 
 char *
 cib_pluralSection(const char *a_section)
 {
 	char *a_section_parent = NULL;
 	if (a_section == NULL) {
 		a_section_parent = crm_strdup("all");
 
 	} else if(strcmp(a_section, XML_TAG_CIB) == 0) {
 		a_section_parent = crm_strdup("all");
 
 	} else if(strcmp(a_section, XML_CIB_TAG_NODE) == 0) {
 		a_section_parent = crm_strdup(XML_CIB_TAG_NODES);
 
 	} else if(strcmp(a_section, XML_CIB_TAG_STATE) == 0) {
 		a_section_parent = crm_strdup(XML_CIB_TAG_STATUS);
 
 	} else if(strcmp(a_section, XML_CIB_TAG_CONSTRAINT) == 0) {
 		a_section_parent = crm_strdup(XML_CIB_TAG_CONSTRAINTS);
 		
 	} else if(strcmp(a_section, XML_CONS_TAG_RSC_LOCATION) == 0) {
 		a_section_parent = crm_strdup(XML_CIB_TAG_CONSTRAINTS);
 		
 	} else if(strcmp(a_section, XML_CONS_TAG_RSC_DEPEND) == 0) {
 		a_section_parent = crm_strdup(XML_CIB_TAG_CONSTRAINTS);
 		
 	} else if(strcmp(a_section, XML_CONS_TAG_RSC_ORDER) == 0) {
 		a_section_parent = crm_strdup(XML_CIB_TAG_CONSTRAINTS);
 		
 	} else if(strcmp(a_section, "resource") == 0) {
 		a_section_parent = crm_strdup(XML_CIB_TAG_RESOURCES);
 
 	} else if(strcmp(a_section, XML_CIB_TAG_RESOURCE) == 0) {
 		a_section_parent = crm_strdup(XML_CIB_TAG_RESOURCES);
 
 	} else if(strcmp(a_section, XML_CIB_TAG_GROUP) == 0) {
 		a_section_parent = crm_strdup(XML_CIB_TAG_RESOURCES);
 
 	} else if(strcmp(a_section, XML_CIB_TAG_INCARNATION) == 0) {
 		a_section_parent = crm_strdup(XML_CIB_TAG_RESOURCES);
 		
 	} else if(strcmp(a_section, XML_CIB_TAG_NVPAIR) == 0) {
 		a_section_parent = crm_strdup(XML_CIB_TAG_CRMCONFIG);
 
 	} else if(strcmp(a_section, XML_TAG_ATTR_SETS) == 0) {
 		a_section_parent = crm_strdup(XML_CIB_TAG_CRMCONFIG);
 
 	} else {
 		crm_err("Unknown section %s", a_section);
 		a_section_parent = crm_strdup("all");
 	}
 	
 	crm_debug_2("Plural of %s is %s", crm_str(a_section), a_section_parent);
 
 	return a_section_parent;
 }
 
 const char *
 cib_error2string(enum cib_errors return_code)
 {
 	const char *error_msg = NULL;
 	switch(return_code) {
 		case cib_msg_field_add:
 			error_msg = "failed adding field to cib message";
 			break;			
 		case cib_operation:
 			error_msg = "invalid operation";
 			break;
 		case cib_create_msg:
 			error_msg = "couldnt create cib message";
 			break;
 		case cib_client_gone:
 			error_msg = "client left before we could send reply";
 			break;
 		case cib_not_connected:
 			error_msg = "not connected";
 			break;
 		case cib_not_authorized:
 			error_msg = "not authorized";
 			break;
 		case cib_send_failed:
 			error_msg = "send failed";
 			break;
 		case cib_reply_failed:
 			error_msg = "reply failed";
 			break;
 		case cib_return_code:
 			error_msg = "no return code";
 			break;
 		case cib_output_ptr:
 			error_msg = "nowhere to store output";
 			break;
 		case cib_output_data:
 			error_msg = "corrupt output data";
 			break;
 		case cib_connection:
 			error_msg = "connection failed";
 			break;
 		case cib_callback_register:
 			error_msg = "couldnt register callback channel";
 			break;
 		case cib_authentication:
 			error_msg = "";
 			break;
 		case cib_registration_msg:
 			error_msg = "invalid registration msg";
 			break;
 		case cib_callback_token:
 			error_msg = "callback token not found";
 			break;
 		case cib_missing:
 			error_msg = "cib object missing";
 			break;
 		case cib_variant:
 			error_msg = "unknown/corrupt cib variant";
 			break;
 		case CIBRES_MISSING_ID:
 			error_msg = "The id field is missing";
 			break;
 		case CIBRES_MISSING_TYPE:
 			error_msg = "The type field is missing";
 			break;
 		case CIBRES_MISSING_FIELD:
 			error_msg = "A required field is missing";
 			break;
 		case CIBRES_OBJTYPE_MISMATCH:
 			error_msg = "CIBRES_OBJTYPE_MISMATCH";
 			break;
 		case cib_EXISTS:
 			error_msg = "The object already exists";
 			break;
 		case cib_NOTEXISTS:
 			error_msg = "The object does not exist";
 			break;
 		case CIBRES_CORRUPT:
 			error_msg = "The CIB is corrupt";
 			break;
 		case cib_NOOBJECT:
 			error_msg = "The update was empty";
 			break;
 		case cib_NOPARENT:
 			error_msg = "The parent object does not exist";
 			break;
 		case cib_NODECOPY:
 			error_msg = "Failed while copying update";
 			break;
 		case CIBRES_OTHER:
 			error_msg = "CIBRES_OTHER";
 			break;
 		case cib_ok:
 			error_msg = "ok";
 			break;
 		case cib_unknown:
 			error_msg = "Unknown error";
 			break;
 		case cib_STALE:
 			error_msg = "Discarded old update";
 			break;
 		case cib_ACTIVATION:
 			error_msg = "Activation Failed";
 			break;
 		case cib_NOSECTION:
 			error_msg = "Required section was missing";
 			break;
 		case cib_NOTSUPPORTED:
 			error_msg = "Supplied information is not supported";
 			break;
 		case cib_not_master:
 			error_msg = "Local service is not the master instance";
 			break;
 		case cib_client_corrupt:
 			error_msg = "Service client not valid";
 			break;
 		case cib_remote_timeout:
 			error_msg = "Remote node did not respond";
 			break;
 		case cib_master_timeout:
 			error_msg = "No master service is currently active";
 			break;
 		case cib_revision_unsupported:
 			error_msg = "The required CIB revision number is not supported";
 			break;
 		case cib_revision_unknown:
 			error_msg = "The CIB revision number could not be determined";
 			break;
 		case cib_missing_data:
 			error_msg = "Required data for this CIB API call not found";
 			break;
 		case cib_no_quorum:
 			error_msg = "Write requires quorum";
 			break;
 		case cib_diff_failed:
 			error_msg = "Application of an update diff failed";
 			break;
 		case cib_diff_resync:
 			error_msg = "Application of an update diff failed, requesting a full refresh";
 			break;
 		case cib_old_data:
 			error_msg = "Update was older than existing configuration";
 			break;
 	}
 			
 	if(error_msg == NULL) {
 		crm_err("Unknown CIB Error Code: %d", return_code);
 		error_msg = "<unknown error>";
 	}
 	
 	return error_msg;
 }
 
 const char *
 cib_op2string(enum cib_update_op operation)
 {
 	const char *operation_msg = NULL;
 	switch(operation) {
 		case 0:
 			operation_msg = "none";
 			break;
 		case 1:
 			operation_msg = "add";
 			break;
 		case 2:
 			operation_msg = "modify";
 			break;
 		case 3:
 			operation_msg = "delete";
 			break;
 		case CIB_UPDATE_OP_MAX:
 			operation_msg = "invalid operation";
 			break;
 			
 	}
 
 	if(operation_msg == NULL) {
 		crm_err("Unknown CIB operation %d", operation);
 		operation_msg = "<unknown operation>";
 	}
 	
 	return operation_msg;
 }
 
 
 
 
 int
 cib_section2enum(const char *a_section) 
 {
 	if(a_section == NULL || strcmp(a_section, "all") == 0) {
 		return cib_section_all;
 
 	} else if(strcmp(a_section, XML_CIB_TAG_NODES) == 0) {
 		return cib_section_nodes;
 
 	} else if(strcmp(a_section, XML_CIB_TAG_STATUS) == 0) {
 		return cib_section_status;
 
 	} else if(strcmp(a_section, XML_CIB_TAG_CONSTRAINTS) == 0) {
 		return cib_section_constraints;
 		
 	} else if(strcmp(a_section, XML_CIB_TAG_RESOURCES) == 0) {
 		return cib_section_resources;
 
 	} else if(strcmp(a_section, XML_CIB_TAG_CRMCONFIG) == 0) {
 		return cib_section_crmconfig;
 
 	}
 	crm_err("Unknown CIB section: %s", a_section);
 	return cib_section_none;
 }
 
 
 int
 cib_compare_generation(crm_data_t *left, crm_data_t *right)
 {
 	int lpc = 0;
 	const char *attributes[] = {
 		XML_ATTR_GENERATION_ADMIN,
 		XML_ATTR_GENERATION,
 		XML_ATTR_NUMUPDATES,
 		XML_ATTR_NUMPEERS
 	};
 
 	crm_log_xml_debug_3(left, "left");
 	crm_log_xml_debug_3(right, "right");
 	
 	for(lpc = 0; lpc < DIMOF(attributes); lpc++) {
 		int int_elem_l = -1;
 		int int_elem_r = -1;
 		const char *elem_r = NULL;
 		const char *elem_l = crm_element_value(left, attributes[lpc]);
 
 		if(right != NULL) {
 			elem_r = crm_element_value(right, attributes[lpc]);
 		}
 	
 		if(elem_l != NULL) { int_elem_l = atoi(elem_l); }
 		if(elem_r != NULL) { int_elem_r = atoi(elem_r); }
 
 		if(int_elem_l < int_elem_r) {
 			crm_debug_2("%s (%s < %s)", attributes[lpc],
 				    crm_str(elem_l), crm_str(elem_r));
 			return -1;
 			
 		} else if(int_elem_l > int_elem_r) {
 			crm_debug_2("%s (%s > %s)", attributes[lpc],
 				    crm_str(elem_l), crm_str(elem_r));
 			return 1;
 		}
 	}
 	
 	return 0;
 }
 
 
 crm_data_t*
 get_cib_copy(cib_t *cib)
 {
 	crm_data_t *xml_cib;
 	crm_data_t *xml_cib_copy;
 	int options = cib_scope_local|cib_sync_call;
 	if(cib->cmds->query(cib, NULL, &xml_cib, options) != cib_ok) {
 		crm_err("Couldnt retrieve the CIB");
 		return NULL;
 	} else if(xml_cib == NULL) {
 		crm_err("The CIB result was empty");
 		return NULL;
 	}
 
 	xml_cib_copy = copy_xml(
 		find_xml_node(xml_cib, XML_TAG_CIB, TRUE));
 	free_xml(xml_cib);
 	
 	return xml_cib_copy;
 }
 
 crm_data_t*
 cib_get_generation(cib_t *cib)
 {
 	crm_data_t *the_cib = get_cib_copy(cib);
 	crm_data_t *generation = create_xml_node(
 		NULL, XML_CIB_TAG_GENERATION_TUPPLE);
 
 	if(the_cib != NULL) {
 		copy_in_properties(generation, the_cib);
 		free_xml(the_cib);
 	}
 	
 	return generation;
 }
 
 gboolean
 apply_cib_diff(crm_data_t *old, crm_data_t *diff, crm_data_t **new)
 {
 	gboolean result = TRUE;
 	const char *value = NULL;
 
 	int this_updates = 0;
 	int this_epoch  = 0;
 	int this_admin_epoch = 0;
 
 	int diff_add_updates = 0;
 	int diff_add_epoch  = 0;
 	int diff_add_admin_epoch = 0;
 
 	int diff_del_updates = 0;
 	int diff_del_epoch  = 0;
 	int diff_del_admin_epoch = 0;
 
 	CRM_DEV_ASSERT(diff != NULL);
 	CRM_DEV_ASSERT(old != NULL);
 	
 	value = crm_element_value(old, XML_ATTR_GENERATION_ADMIN);
 	this_admin_epoch = atoi(value?value:"0");
 	crm_debug_3("%s=%d (%s)", XML_ATTR_GENERATION_ADMIN,
 		  this_admin_epoch, value);
 	
 	value = crm_element_value(old, XML_ATTR_GENERATION);
 	this_epoch = atoi(value?value:"0");
 	crm_debug_3("%s=%d (%s)", XML_ATTR_GENERATION, this_epoch, value);
 	
 	value = crm_element_value(old, XML_ATTR_NUMUPDATES);
 	this_updates = atoi(value?value:"0");
 	crm_debug_3("%s=%d (%s)", XML_ATTR_NUMUPDATES, this_updates, value);
 	
 	cib_diff_version_details(
 		diff,
 		&diff_add_admin_epoch, &diff_add_epoch, &diff_add_updates, 
 		&diff_del_admin_epoch, &diff_del_epoch, &diff_del_updates);
 
 	value = NULL;
 	if(result && diff_del_admin_epoch != this_admin_epoch) {
 		value = XML_ATTR_GENERATION_ADMIN;
 		result = FALSE;
 		crm_debug_3("%s=%d", value, diff_del_admin_epoch);
 
 	} else if(result && diff_del_epoch != this_epoch) {
 		value = XML_ATTR_GENERATION;
 		result = FALSE;
 		crm_debug_3("%s=%d", value, diff_del_epoch);
 
 	} else if(result && diff_del_updates != this_updates) {
 		value = XML_ATTR_NUMUPDATES;
 		result = FALSE;
 		crm_debug_3("%s=%d", value, diff_del_updates);
 	}
 
 	if(result) {
 		int len = 0;
 		crm_data_t *tmp = NULL;
 		crm_data_t *diff_copy = copy_xml(diff);
 		
 		tmp = find_xml_node(diff_copy, "diff-removed", TRUE);
 		if(tmp != NULL) {
 			len = tmp->nfields;
 			cl_msg_remove(tmp, XML_ATTR_GENERATION_ADMIN);
 			cl_msg_remove(tmp, XML_ATTR_GENERATION);
 			cl_msg_remove(tmp, XML_ATTR_NUMUPDATES);
 			CRM_DEV_ASSERT(tmp->nfields == len - 3);
 		}
 		
 		tmp = find_xml_node(diff_copy, "diff-added", TRUE);
 		if(tmp != NULL) {
 			len = tmp->nfields;
 			cl_msg_remove(tmp, XML_ATTR_GENERATION_ADMIN);
 			cl_msg_remove(tmp, XML_ATTR_GENERATION);
 			cl_msg_remove(tmp, XML_ATTR_NUMUPDATES);
 			CRM_DEV_ASSERT(tmp->nfields == len - 3);
 		}
 		
 		result = apply_xml_diff(old, diff_copy, new);
 		free_xml(diff_copy);
 		
 	} else {
 		crm_err("target and diff %s values didnt match", value);
 	}
 	
 	
 	return result;
 }
 
 crm_data_t *
 diff_cib_object(crm_data_t *old_cib, crm_data_t *new_cib, gboolean suppress)
 {
 	crm_data_t *diff = diff_xml_object(old_cib, new_cib, suppress);
 
 	crm_data_t *dest = NULL;
 	crm_data_t *src = NULL;
 	const char *name = NULL;
 	const char *value = NULL;
 	
 	/* add complete version information */
 	src = old_cib;
 	dest = find_xml_node(diff, "diff-removed", FALSE);
 	if(src != NULL && dest != NULL) {
 		name = XML_ATTR_GENERATION_ADMIN;
 		value = crm_element_value(src, name);
 		if(value == NULL) {
 			value = "0";
 		}
 		crm_xml_add(dest, name, value);
 
 		name = XML_ATTR_GENERATION;
 		value = crm_element_value(src, name);
 		if(value == NULL) {
 			value = "0";
 		}
 		crm_xml_add(dest, name, value);
 
 		name = XML_ATTR_NUMUPDATES;
 		value = crm_element_value(src, name);
 		if(value == NULL) {
 			value = "0";
 		}
 		crm_xml_add(dest, name, value);
 	}
 	
 	src = new_cib;
 	dest = find_xml_node(diff, "diff-added", FALSE);
 	if(src != NULL && dest != NULL) {
 		name = XML_ATTR_GENERATION_ADMIN;
 		value = crm_element_value(src, name);
 		if(value == NULL) {
 			value = "0";
 		}
 		crm_xml_add(dest, name, value);
 
 		name = XML_ATTR_GENERATION;
 		value = crm_element_value(src, name);
 		if(value == NULL) {
 			value = "0";
 		}
 		crm_xml_add(dest, name, value);
 
 		name = XML_ATTR_NUMUPDATES;
 		value = crm_element_value(src, name);
 		if(value == NULL) {
 			value = "0";
 		}
 		crm_xml_add(dest, name, value);
 	}
 	return diff;
 }
 
 void
 log_cib_diff(int log_level, crm_data_t *diff, const char *function)
 {
 	int add_updates = 0;
 	int add_epoch  = 0;
 	int add_admin_epoch = 0;
 
 	int del_updates = 0;
 	int del_epoch  = 0;
 	int del_admin_epoch = 0;
 
 	if(diff == NULL) {
 		return;
 	}
 	
 	cib_diff_version_details(
 		diff, &add_admin_epoch, &add_epoch, &add_updates, 
 		&del_admin_epoch, &del_epoch, &del_updates);
 
 	if(add_updates != del_updates) {
 		do_crm_log(log_level, NULL, function, "Diff: --- %d.%d.%d",
 			   del_admin_epoch, del_epoch, del_updates);
 		do_crm_log(log_level, NULL, function, "Diff: +++ %d.%d.%d",
 			   add_admin_epoch, add_epoch, add_updates);
 	} else if(diff != NULL) {
 		do_crm_log(log_level, NULL, function,
 			   "Local-only Change: %d.%d.%d",
 			   add_admin_epoch, add_epoch, add_updates);
 	}
 	
 	log_xml_diff(log_level, diff, function);
 }
 
 gboolean
 cib_version_details(
 	crm_data_t *cib, int *admin_epoch, int *epoch, int *updates)
 {
 	const char *value = NULL;
 	if(cib == NULL) {
 		*admin_epoch = -1;
 		*epoch  = -1;
 		*updates = -1;
 		return FALSE;
 		
 	} else {
 		value = crm_element_value(cib, XML_ATTR_GENERATION_ADMIN);
 		*admin_epoch = atoi(value?value:"-1");
 
 		value  = crm_element_value(cib, XML_ATTR_GENERATION);
 		*epoch = atoi(value?value:"-1");
 
 		value = crm_element_value(cib, XML_ATTR_NUMUPDATES);
 		*updates = atoi(value?value:"-1");
 	}
 	return TRUE;	
 }
 
 gboolean
 cib_diff_version_details(
 	crm_data_t *diff, int *admin_epoch, int *epoch, int *updates, 
 	int *_admin_epoch, int *_epoch, int *_updates)
 {
 	crm_data_t *tmp = NULL;
 
 	tmp = find_xml_node(diff, "diff-added", FALSE);
 	cib_version_details(tmp, admin_epoch, epoch, updates);
 
 	tmp = find_xml_node(diff, "diff-removed", FALSE);
 	cib_version_details(tmp, _admin_epoch, _epoch, _updates);
 	return TRUE;
 }
 
 /*
  * The caller should never free the return value
  */
 crm_data_t*
 get_object_root(const char *object_type, crm_data_t *the_root)
 {
 	const char *node_stack[2];
 	crm_data_t *tmp_node = NULL;
 	
 	if(the_root == NULL) {
 		crm_err("CIB root object was NULL");
 		return NULL;
 	}
 	
 	node_stack[0] = XML_CIB_TAG_CONFIGURATION;
 	node_stack[1] = object_type;
 
 	if(object_type == NULL
 	   || strlen(object_type) == 0
 	   || safe_str_eq("all", object_type)
 	   || safe_str_eq(XML_TAG_CIB, object_type)) {
 		/* get the whole cib */
 		return the_root;
 
 	} else if(strcmp(object_type, XML_CIB_TAG_STATUS) == 0) {
 		/* these live in a different place */
 		tmp_node = find_xml_node(the_root, XML_CIB_TAG_STATUS, FALSE);
 
 		node_stack[0] = object_type;
 		node_stack[1] = NULL;
 
 	} else {
 		tmp_node = find_xml_node_nested(the_root, node_stack, 2);
 	}
 
 	if (tmp_node == NULL) {
 		crm_debug_2("Section [%s [%s]] not present in %s",
 			    node_stack[0],
 			    node_stack[1]?node_stack[1]:"",
 			    crm_element_name(the_root));
 	}
 	return tmp_node;
 }
 
 const char *
 get_crm_option(crm_data_t *cib, const char *name, gboolean do_warn) 
 {
 	const char * value = NULL;
 	crm_data_t * a_default = NULL;
 	crm_data_t * config = get_object_root(XML_CIB_TAG_CRMCONFIG, cib);
 	
 	if(config != NULL) {
 		a_default = find_entity(config, XML_CIB_TAG_NVPAIR, name);
 	}
 	
 	if(a_default == NULL) {
 		if(do_warn) {
 			crm_warn("Option %s not set", name);
 		}
 		return NULL;
 	}
 	
 	value = crm_element_value(a_default, XML_NVPAIR_ATTR_VALUE);
 	if(safe_str_eq(value, "")) {
 		value = NULL;
 	}
 	return value;
 	
 }
 
 
 crm_data_t*
 create_cib_fragment_adv(
 	crm_data_t *update, const char *update_section, const char *source)
 {
 	crm_data_t *cib = NULL;
 	gboolean whole_cib = FALSE;
 	crm_data_t *fragment = create_xml_node(NULL, XML_TAG_FRAGMENT);
 	crm_data_t *object_root  = NULL;
 	const char *update_name = NULL;
 
 /* 	crm_debug("Creating a blank fragment: %s", update_section); */
 	
 	if(update == NULL && update_section == NULL) {
 		crm_debug_3("Creating a blank fragment");
 		update = createEmptyCib();
 		whole_cib = TRUE;
 
 	} else if(update == NULL) {
 		crm_err("No update to create a fragment for");
 		return NULL;
 		
 	} else if(update_section == NULL) {
 		update_section = cib_pluralSection(update_name);
 	}
 
 	if(safe_str_eq(crm_element_name(update), XML_TAG_CIB)) {
 		whole_cib = TRUE;
 	}
 	
 	crm_xml_add(fragment, XML_ATTR_SECTION, update_section);
 
 	if(whole_cib == FALSE) {
 		cib = createEmptyCib();
 		crm_xml_add(cib, "debug_source", source);
 		object_root = get_object_root(update_section, cib);
 		add_node_copy(object_root, update);
 		add_node_copy(fragment, cib);
 		free_xml(cib);
 		cib = find_xml_node(fragment, XML_TAG_CIB, TRUE);
 
 	} else {
 		add_node_copy(fragment, update);
 		cib = find_xml_node(fragment, XML_TAG_CIB, TRUE);
 		crm_xml_add(cib, "debug_source", source);
 	}
 	
 	crm_debug_3("Verifying created fragment");
 	if(verifyCibXml(cib) == FALSE) {
 		crm_err("Fragment creation failed");
 		crm_log_xml_err(update, "[src]");
 		crm_log_xml_err(fragment, "[created]");
 		free_xml(fragment);
 		fragment = NULL;
 	}
 	
 	return fragment;
 }
 
 /*
  * It is the callers responsibility to free both the new CIB (output)
  *     and the new CIB (input)
  */
 crm_data_t*
 createEmptyCib(void)
 {
 	crm_data_t *cib_root = NULL, *config = NULL, *status = NULL;
 	
 	cib_root = create_xml_node(NULL, XML_TAG_CIB);
 
 	config = create_xml_node(cib_root, XML_CIB_TAG_CONFIGURATION);
 	status = create_xml_node(cib_root, XML_CIB_TAG_STATUS);
 
 	set_node_tstamp(cib_root);
 	set_node_tstamp(config);
 	set_node_tstamp(status);
 	
 /* 	crm_xml_add(cib_root, "version", "1"); */
 	crm_xml_add(cib_root, "generated", XML_BOOLEAN_TRUE);
 
 	create_xml_node(config, XML_CIB_TAG_CRMCONFIG);
 	create_xml_node(config, XML_CIB_TAG_NODES);
 	create_xml_node(config, XML_CIB_TAG_RESOURCES);
 	create_xml_node(config, XML_CIB_TAG_CONSTRAINTS);
 	
 	if (verifyCibXml(cib_root)) {
 		return cib_root;
 	}
 
 	free_xml(cib_root);
 	crm_crit("The generated CIB did not pass integrity testing!!"
 		 "  All hope is lost.");
 	return NULL;
 }
 
 
 gboolean
 verifyCibXml(crm_data_t *cib)
 {
 	gboolean is_valid = TRUE;
 	crm_data_t *tmp_node = NULL;
 	
 	if (cib == NULL) {
 		crm_warn("CIB was empty.");
 		return FALSE;
 	}
 	
 	tmp_node = get_object_root(XML_CIB_TAG_NODES, cib);
 	if (tmp_node == NULL) { is_valid = FALSE; }
 
 	tmp_node = get_object_root(XML_CIB_TAG_RESOURCES, cib);
 	if (tmp_node == NULL) { is_valid = FALSE; }
 
 	tmp_node = get_object_root(XML_CIB_TAG_CONSTRAINTS, cib);
 	if (tmp_node == NULL) { is_valid = FALSE; }
 
 	tmp_node = get_object_root(XML_CIB_TAG_STATUS, cib);
 	if (tmp_node == NULL) { is_valid = FALSE; }
 
 	tmp_node = get_object_root(XML_CIB_TAG_CRMCONFIG, cib);
 	if (tmp_node == NULL) { is_valid = FALSE; }
 
 	/* more integrity tests */
 
 	return is_valid;
 }
 
 
 gboolean verify_cib_cmds(cib_t *cib) 
 {
 	gboolean valid = TRUE;
 	if(cib->cmds->variant_op == NULL) {
 		crm_err("Operation variant_op not set");
 		valid = FALSE;
 	}	
 	if(cib->cmds->signon == NULL) {
 		crm_err("Operation signon not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->signoff == NULL) {
 		crm_err("Operation signoff not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->free == NULL) {
 		crm_err("Operation free not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->set_op_callback == NULL) {
 		crm_err("Operation set_op_callback not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->add_notify_callback == NULL) {
 		crm_err("Operation add_notify_callback not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->del_notify_callback == NULL) {
 		crm_err("Operation del_notify_callback not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->set_connection_dnotify == NULL) {
 		crm_err("Operation set_connection_dnotify not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->channel == NULL) {
 		crm_err("Operation channel not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->inputfd == NULL) {
 		crm_err("Operation inputfd not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->noop == NULL) {
 		crm_err("Operation noop not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->ping == NULL) {
 		crm_err("Operation ping not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->query == NULL) {
 		crm_err("Operation query not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->query_from == NULL) {
 		crm_err("Operation query_from not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->is_master == NULL) {
 		crm_err("Operation is_master not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->set_master == NULL) {
 		crm_err("Operation set_master not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->set_slave == NULL) {
 		crm_err("Operation set_slave not set");
 		valid = FALSE;
 	}		
 	if(cib->cmds->set_slave_all == NULL) {
 		crm_err("Operation set_slave_all not set");
 		valid = FALSE;
 	}		
 	if(cib->cmds->sync == NULL) {
 		crm_err("Operation sync not set");
 		valid = FALSE;
 	}		if(cib->cmds->sync_from == NULL) {
 		crm_err("Operation sync_from not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->bump_epoch == NULL) {
 		crm_err("Operation bump_epoch not set");
 		valid = FALSE;
 	}		
 	if(cib->cmds->create == NULL) {
 		crm_err("Operation create not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->modify == NULL) {
 		crm_err("Operation modify not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->replace == NULL) {
 		crm_err("Operation replace not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->delete == NULL) {
 		crm_err("Operation delete not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->erase == NULL) {
 		crm_err("Operation erase not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->quit == NULL) {
 		crm_err("Operation quit not set");
 		valid = FALSE;
 	}
 	
 	if(cib->cmds->msgready == NULL) {
 		crm_err("Operation msgready not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->rcvmsg == NULL) {
 		crm_err("Operation rcvmsg not set");
 		valid = FALSE;
 	}
 	if(cib->cmds->dispatch == NULL) {
 		crm_err("Operation dispatch not set");
 		valid = FALSE;
 	}
 
 	return valid;
 }
diff --git a/lib/crm/cib/cib_native.c b/lib/crm/cib/cib_native.c
index 5913ac06ec..2f4655961f 100755
--- a/lib/crm/cib/cib_native.c
+++ b/lib/crm/cib/cib_native.c
@@ -1,767 +1,774 @@
 /*
  * Copyright (c) 2004 International Business Machines
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  * 
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  * 
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  */
 #include <portability.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
 
 #include <glib.h>
 #include <heartbeat.h>
 #include <clplumbing/ipc.h>
 #include <ha_msg.h>
 
 #include <crm/crm.h>
 #include <crm/cib.h>
 #include <crm/msg_xml.h>
 #include <crm/common/ipc.h>
 #include <cib_private.h>
 
 typedef struct cib_native_opaque_s 
 {
 		IPC_Channel	*command_channel;
 		IPC_Channel	*callback_channel;
  		GCHSource	*callback_source; 
 		
 } cib_native_opaque_t;
 
 int cib_native_perform_op(
 	cib_t *cib, const char *op, const char *host, const char *section,
 	crm_data_t *data, crm_data_t **output_data, int call_options);
 
 int cib_native_signon(cib_t* cib, const char *name, enum cib_conn_type type);
 int cib_native_signoff(cib_t* cib);
 int cib_native_free(cib_t* cib);
 
 IPC_Channel *cib_native_channel(cib_t* cib);
 int cib_native_inputfd(cib_t* cib);
 
 gboolean cib_native_msgready(cib_t* cib);
 int cib_native_rcvmsg(cib_t* cib, int blocking);
 gboolean cib_native_dispatch(IPC_Channel *channel, gpointer user_data);
 cib_t *cib_native_new (cib_t *cib);
+void cib_native_delete(cib_t *cib);
 int cib_native_set_connection_dnotify(
 	cib_t *cib, void (*dnotify)(gpointer user_data));
 
 void cib_native_notify(gpointer data, gpointer user_data);
 
 void cib_native_callback(cib_t *cib, struct ha_msg *msg);
 
 int cib_native_register_callback(cib_t* cib, const char *callback, int enabled);
 
 cib_t*
 cib_native_new (cib_t *cib)
 {
 	cib_native_opaque_t *native = NULL;
 	crm_malloc0(cib->variant_opaque, sizeof(cib_native_opaque_t));
 	
 	native = cib->variant_opaque;
 	native->command_channel   = NULL;
 	native->callback_channel  = NULL;
 
 	/* assign variant specific ops*/
 	cib->cmds->variant_op = cib_native_perform_op;
 	cib->cmds->signon     = cib_native_signon;
 	cib->cmds->signoff    = cib_native_signoff;
 	cib->cmds->free       = cib_native_free;
 	cib->cmds->channel    = cib_native_channel;
 	cib->cmds->inputfd    = cib_native_inputfd;
 	cib->cmds->msgready   = cib_native_msgready;
 	cib->cmds->rcvmsg     = cib_native_rcvmsg;
 	cib->cmds->dispatch   = cib_native_dispatch;
 
 	cib->cmds->register_callback = cib_native_register_callback;
 	cib->cmds->set_connection_dnotify = cib_native_set_connection_dnotify;
 	
 	return cib;
 }
 
+void
+cib_native_delete(cib_t *cib)
+{
+	crm_free(cib->variant_opaque);
+}
+
 int
 cib_native_signon(cib_t* cib, const char *name, enum cib_conn_type type)
 {
 	int rc = cib_ok;
 	char *uuid_ticket = NULL;
 	struct ha_msg *reg_msg = NULL;
 	cib_native_opaque_t *native = cib->variant_opaque;
 	
 	crm_debug_4("Connecting command channel");
 	if(type == cib_command) {
 		cib->state = cib_connected_command;
 		native->command_channel = init_client_ipc_comms_nodispatch(
 			cib_channel_rw);
 		
 	} else {
 		cib->state = cib_connected_query;
 		native->command_channel = init_client_ipc_comms_nodispatch(
 			cib_channel_ro);
 	}
 	
 	if(native->command_channel == NULL) {
 		crm_debug("Connection to command channel failed");
 		rc = cib_connection;
 		
 	} else if(native->command_channel->ch_status != IPC_CONNECT) {
 		crm_err("Connection may have succeeded,"
 			" but authentication to command channel failed");
 		rc = cib_authentication;
 	}
 	
 
 	if(rc == cib_ok) {
 		crm_debug_4("Connecting callback channel");
 		native->callback_source = init_client_ipc_comms(
 			cib_channel_callback, cib_native_dispatch, cib, &(native->callback_channel));
 		
 		if(native->callback_channel == NULL) {
 			crm_debug("Connection to callback channel failed");
 			rc = cib_connection;
 		} else if(native->callback_source == NULL) {
 			crm_err("Callback source not recorded");
 			rc = cib_connection;
 		} else {
 			native->callback_channel->send_queue->max_qlen = 500;
 		}
 		
 	} else if(rc == cib_ok
 		  && native->callback_channel->ch_status != IPC_CONNECT) {
 		crm_err("Connection may have succeeded,"
 			" but authentication to callback channel failed");
 		rc = cib_authentication;
 	}
 	
 	if(rc == cib_ok) {
 		crm_debug_4("Waiting for msg on command channel");
 		
 		reg_msg = msgfromIPC(native->command_channel, MSG_ALLOWINTR);
 		
 		if(native->command_channel->ops->get_chan_status(
 			   native->command_channel) != IPC_CONNECT) {
 			crm_err("No reply message - disconnected - %d", rc);
 			rc = cib_not_connected;
 		
 		} else if(rc != IPC_OK) {
 			crm_err("No reply message - failed - %d", rc);
 			rc = cib_reply_failed;
 			
 		} else if(reg_msg == NULL) {
 			crm_err("No reply message - empty - %d", rc);
 			rc = cib_reply_failed;
 		}
 	}
 	
 	if(rc == cib_ok) {
 		const char *msg_type = NULL;
 		msg_type = cl_get_string(reg_msg, F_CIB_OPERATION);
 		if(safe_str_neq(msg_type, CRM_OP_REGISTER) ) {
 			crm_err("Invalid registration message: %s", msg_type);
 			rc = cib_registration_msg;
 
 		} else {
 			const char *tmp_ticket = NULL;
 			crm_debug_4("Retrieving callback channel ticket");
 			tmp_ticket = cl_get_string(
 				reg_msg, F_CIB_CALLBACK_TOKEN);
 
 			if(tmp_ticket == NULL) {
 				rc = cib_callback_token;
 			} else {
 				uuid_ticket = crm_strdup(tmp_ticket);
 			}
 		}
 
 	}
 
 	if(reg_msg != NULL) {
 		crm_msg_del(reg_msg);
 		reg_msg = NULL;		
 	}
 	
 	if(rc == cib_ok) {
 		crm_debug_4("Registering callback channel with ticket %s",
 			  crm_str(uuid_ticket));
 		reg_msg = ha_msg_new(2);
 		ha_msg_add(reg_msg, F_CIB_OPERATION, CRM_OP_REGISTER);
 		ha_msg_add(reg_msg, F_CIB_CALLBACK_TOKEN, uuid_ticket);
 		ha_msg_add(reg_msg, F_CIB_CLIENTNAME, name);
 
 		if(send_ipc_message(
 			   native->callback_channel, reg_msg) == FALSE) {
 			rc = cib_callback_register;
 		}
 		crm_free(uuid_ticket);
 
 	}
 	if(rc == cib_ok) {
 		/* In theory IPC_INTR could trip us up here */
 		crm_debug_4("wait for the callback channel setup to complete");
 		reg_msg = msgfromIPC(native->callback_channel, MSG_ALLOWINTR);
 
 		if(native->callback_channel->ops->get_chan_status(
 			   native->callback_channel) != IPC_CONNECT) {
 			crm_err("No reply message - disconnected - %d", rc);
 			rc = cib_not_connected;
 			
 		} else if(rc != IPC_OK) {
 			crm_err("No reply message - failed - %d", rc);
 			rc = cib_reply_failed;
 			
 		} else if(reg_msg == NULL) {
 			crm_err("No reply message - empty - %d", rc);
 			rc = cib_reply_failed;
 		}
 		crm_msg_del(reg_msg);
 	}
 	
 	if(rc == cib_ok) {
 		crm_info("Connection to CIB successful");
 		return cib_ok;
 	}
 	crm_warn("Connection to CIB failed: %s", cib_error2string(rc));
 	cib_native_signoff(cib);
 	return rc;
 }
 	
 int
 cib_native_signoff(cib_t* cib)
 {
 	cib_native_opaque_t *native = cib->variant_opaque;
 
 	crm_info("Signing out of the CIB Service");
 	
 	/* close channels */
 	if (native->command_channel != NULL) {
  		native->command_channel->ops->destroy(
 			native->command_channel);
 		native->command_channel = NULL;
 	}
 	if (native->callback_channel != NULL) {
 		G_main_del_IPC_Channel(native->callback_source);
 #ifdef BUG
  		native->callback_channel->ops->destroy(
 			native->callback_channel);
 #endif
 		native->callback_channel = NULL;
 	}
 	cib->state = cib_disconnected;
 	cib->type  = cib_none;
 
 	return cib_ok;
 }
 
 int
 cib_native_free (cib_t* cib)
 {
 	int rc = cib_ok;
 
 	crm_warn("Freeing CIB");
 	if(cib->state != cib_disconnected) {
 		rc = cib_native_signoff(cib);
 		if(rc == cib_ok) {
 			crm_free(cib);
 		}
 	}
 	
 	return rc;
 }
 
 IPC_Channel *
 cib_native_channel(cib_t* cib)
 {
 	cib_native_opaque_t *native = NULL;
 	if(cib == NULL) {
 		crm_err("Missing cib object");
 		return NULL;
 	}
 	
 	native = cib->variant_opaque;
 
 	if(native != NULL) {
 		return native->callback_channel;
 	}
 
 	crm_err("couldnt find variant specific data in %p", cib);
 	return NULL;
 }
 
 int
 cib_native_inputfd(cib_t* cib)
 {
 	IPC_Channel *ch = cib_native_channel(cib);
 	return ch->ops->get_recv_select_fd(ch);
 }
 
 int
 cib_native_perform_op(
 	cib_t *cib, const char *op, const char *host, const char *section,
 	crm_data_t *data, crm_data_t **output_data, int call_options) 
 {
 	int  rc = HA_OK;
 	
 	struct ha_msg *op_msg   = NULL;
 	struct ha_msg *op_reply = NULL;
 
  	cib_native_opaque_t *native = cib->variant_opaque;
 
 	if(cib->state ==  cib_disconnected) {
 		return cib_not_connected;
 	}
 
 	if(output_data != NULL) {
 		*output_data = NULL;
 	}
 	
 	if(op == NULL) {
 		crm_err("No operation specified");
 		rc = cib_operation;
 	}
 
 	op_msg = ha_msg_new(8);
 	if (op_msg == NULL) {
 		crm_err("No memory to create HA_Message");
 		return cib_create_msg;
 	}
 	
 	if(rc == HA_OK) {
 		rc = ha_msg_add(op_msg, F_TYPE, "cib");
 	}
 	if(rc == HA_OK) {
 		rc = ha_msg_add(op_msg, F_CIB_OPERATION, op);
 	}
 	if(rc == HA_OK && host != NULL) {
 		CRM_DEV_ASSERT(crm_is_allocated(host) == 1);
 		rc = ha_msg_add(op_msg, F_CIB_HOST, host);
 	}
 	if(rc == HA_OK && section != NULL) {
 		rc = ha_msg_add(op_msg, F_CIB_SECTION, section);
 	}
 	if(rc == HA_OK) {
 		rc = ha_msg_add_int(op_msg, F_CIB_CALLID, cib->call_id);
 	}
 	if(rc == HA_OK) {
 		crm_debug_4("Sending call options: %.8lx, %d",
 			  (long)call_options, call_options);
 		rc = ha_msg_add_int(op_msg, F_CIB_CALLOPTS, call_options);
 	}
 	if(rc == HA_OK && cib->call_timeout > 0) {
 		rc = ha_msg_add_int(op_msg, F_CIB_TIMEOUT, cib->call_timeout);
 	}
 
 	if(rc == HA_OK && data != NULL) {
 		const char *tag = crm_element_name(data);
 		crm_data_t *cib = data;
 		if(safe_str_neq(tag, XML_TAG_CIB)) {
 			cib = find_xml_node(data, XML_TAG_CIB, FALSE);
 			if(cib != NULL) {
 				tag = XML_TAG_CIB;
 			}
 		}
 		
 		if(safe_str_eq(tag, XML_TAG_CIB)) {
 			const char *version = feature_set(cib);
 #if 1
-			/* only needed for 2.0.2 */
+			/* only needed for 2.0.3 */
 			int cmp = compare_version(version, "1.1");
 			if(cmp != 0) {
 				crm_err("Set XML_ATTR_CIB_REVISION=%s",
 					version);
 				crm_xml_add(cib, XML_ATTR_CIB_REVISION,version);
 			}
 #else
 			crm_xml_add(cib, XML_ATTR_CIB_REVISION, version);
 #endif
 		} else {
-			crm_err("Skipping feature check for %s tag", tag);
+			crm_info("Skipping feature check for %s tag", tag);
 		}
 
 		add_message_xml(op_msg, F_CIB_CALLDATA, data);
 	}
 	
 	if (rc != HA_OK) {
 		crm_err("Failed to create CIB operation message");
 		crm_log_message(LOG_ERR, op_msg);
 		crm_msg_del(op_msg);
 		return cib_create_msg;
 	}
 
 	if(call_options & cib_inhibit_bcast) {
 		CRM_DEV_ASSERT((call_options & cib_scope_local));
 	}
 
 	cib->call_id++;
 	/* prevent call_id from being negative (or zero) and conflicting
 	 *    with the cib_errors enum
 	 * use 2 because we use it as (cib->call_id - 1) below
 	 */
 	if(cib->call_id < 2) {
 		cib->call_id = 2;
 	}
 	
 	crm_debug_3("Sending %s message to CIB service", op);
 	if(send_ipc_message(native->command_channel, op_msg) == FALSE) {
 		crm_err("Sending message to CIB service FAILED");
 		return cib_send_failed;
 
 	} else {
 		crm_debug_3("Message sent");
 	}
 
 	op_msg = NULL;
 
 	if((call_options & cib_discard_reply)) {
 		crm_debug_3("Discarding reply");
 		return cib_ok;
 
 	} else if(!(call_options & cib_sync_call)) {
 		crm_debug_3("Async call, returning");
 		return cib->call_id - 1;
 	}
 
 	rc = IPC_OK;
 	crm_debug_3("Waiting for a syncronous reply");
 	while(native->command_channel->ops->get_chan_status(
 		      native->command_channel) == IPC_CONNECT) {
 
 		rc = native->command_channel->ops->waitin(
 			native->command_channel);
 
 		if(rc == IPC_OK) {
 			int msg_id = cib->call_id - 1;
 			int reply_id = -1;
 			op_reply = msgfromIPC_noauth(native->command_channel);
 			if(op_reply == NULL) {
 				break;
 			}
 			CRM_DEV_ASSERT(HA_OK == ha_msg_value_int(
 					       op_reply, F_CIB_CALLID, &reply_id));
 
 			CRM_DEV_ASSERT(reply_id <= msg_id);
 			
 			if(reply_id == msg_id) {
 				break;
 
 			} else if(reply_id < msg_id) {
 				crm_debug("Recieved old reply: %d (wanted %d)",
 					reply_id, msg_id);
 				crm_log_message_adv(
 					LOG_MSG, "Old reply", op_reply);
 			} else {
 				crm_err("Received a __future__ reply:"
 					" %d (wanted %d)", reply_id, msg_id);
 			}
 			crm_msg_del(op_reply);
 
 		} else if(rc == IPC_INTR) {
 			crm_debug_3("a signal arrived, retry the read");
 
 		} else {
 			break;
 		}
 	}
 
 	if(native->command_channel->ops->get_chan_status(
 		   native->command_channel) != IPC_CONNECT) {
 		crm_err("No reply message - disconnected - %d", rc);
 		cib->state = cib_disconnected;
 		crm_msg_del(op_reply);
 		return cib_not_connected;
 		
 	} else if(rc != IPC_OK) {
 		crm_err("No reply message - failed - %d", rc);
 		crm_msg_del(op_reply);
 		return cib_reply_failed;
 
 	} else if(op_reply == NULL) {
 		crm_err("No reply message - empty - %d", rc);
 		return cib_reply_failed;
 	}
 	
 	crm_debug_3("Syncronous reply recieved");
 	rc = cib_ok;
 	
 	/* Start processing the reply... */
 	if(ha_msg_value_int(op_reply, F_CIB_RC, &rc) != HA_OK) {
 		rc = cib_return_code;
 	}	
 
 	if(rc == cib_ok || rc == cib_not_master || rc == cib_master_timeout) {
 		crm_log_message(LOG_MSG, op_reply);
 
 	} else {
 /* 	} else if(rc == cib_remote_timeout) { */
 		crm_err("Call failed: %s", cib_error2string(rc));
 		crm_log_message(LOG_WARNING, op_reply);
 	}
 	
 	if(output_data == NULL) {
 		/* do nothing more */
 		
 	} else if(!(call_options & cib_discard_reply)) {
 		*output_data = get_message_xml(op_reply, F_CIB_CALLDATA);
 		if(*output_data == NULL) {
 			crm_debug_3("No output in reply to \"%s\" command %d",
 				  op, cib->call_id - 1);
 		}
 	}
 	
 	crm_msg_del(op_reply);
 
 	return rc;
 }
 
 gboolean
 cib_native_msgready(cib_t* cib)
 {
 	IPC_Channel *ch = NULL;
 	cib_native_opaque_t *native = NULL;
 	
 	if (cib == NULL) {
 		crm_err("No CIB!");
 		return FALSE;
 	}
 
 	native = cib->variant_opaque;
 
 	ch = cib_native_channel(cib);
 	if (ch == NULL) {
 		crm_err("No channel");
 		return FALSE;
 	}
 
 	if(native->command_channel->ops->is_message_pending(
 		   native->command_channel)) {
 		crm_debug_3("Message pending on command channel");
 	}
 	if(native->callback_channel->ops->is_message_pending(
 		   native->callback_channel)) {
 		crm_debug_4("Message pending on callback channel");
 		return TRUE;
 	} 
 	crm_debug_3("No message pending");
 	return FALSE;
 }
 
 int
 cib_native_rcvmsg(cib_t* cib, int blocking)
 {
 	const char *type = NULL;
 	struct ha_msg* msg = NULL;
 	IPC_Channel *ch = cib_native_channel(cib);
 
 	/* if it is not blocking mode and no message in the channel, return */
 	if (blocking == 0 && cib_native_msgready(cib) == FALSE) {
 		crm_debug_3("No message ready and non-blocking...");
 		return 0;
 
 	} else if (cib_native_msgready(cib) == FALSE) {
 		crm_debug_3("Waiting for message from CIB service...");
 		ch->ops->waitin(ch);
 	}
 
 	/* IPC_INTR is not a factor here */
 	msg = msgfromIPC_noauth(ch);
 	if (msg == NULL) {
 		crm_warn("Received a NULL msg from CIB service.");
 		return 0;
 	}
 
 	/* do callbacks */
 	type = cl_get_string(msg, F_TYPE);
 	crm_debug_4("Activating %s callbacks...", type);
 
 	if(safe_str_eq(type, T_CIB)) {
 		cib_native_callback(cib, msg);
 		
 	} else if(safe_str_eq(type, T_CIB_NOTIFY)) {
 		g_list_foreach(cib->notify_list, cib_native_notify, msg);
 
 	} else {
 		crm_err("Unknown message type: %s", type);
 	}
 	
 	crm_msg_del(msg);
 
 	return 1;
 }
 
 void
 cib_native_callback(cib_t *cib, struct ha_msg *msg)
 {
 	int rc = 0;
 	int call_id = 0;
 	crm_data_t *output = NULL;
 
 	cib_callback_client_t *blob = NULL;
 
 	cib_callback_client_t local_blob;
 
 	/* gcc4 had a point... make sure (at least) local_blob.callback
 	 *   is initialized before use
 	 */
 	local_blob.callback = NULL;
 	local_blob.user_data = NULL;
 	local_blob.only_success = FALSE;
 
 	ha_msg_value_int(msg, F_CIB_CALLID, &call_id);
 
 	blob = g_hash_table_lookup(
 		cib_op_callback_table, GINT_TO_POINTER(call_id));
 	
 	if(blob != NULL) {
 		crm_debug_3("Callback found for call %d", call_id);
 /* 		local_blob.callback = blob->callback; */
 /* 		local_blob.user_data = blob->user_data; */
 /* 		local_blob.only_success = blob->only_success; */
 		local_blob = *blob;
 		blob = NULL;
 		
 		g_hash_table_remove(
 			cib_op_callback_table, GINT_TO_POINTER(call_id));
 	} else {
 		crm_debug_3("No callback found for call %d", call_id);
 		local_blob.callback = NULL;
 	}
 
 	ha_msg_value_int(msg, F_CIB_RC, &rc);
 	output = get_message_xml(msg, F_CIB_CALLDATA);
 	
 	if(local_blob.callback != NULL
 	   && (rc == cib_ok || local_blob.only_success == FALSE)) {
 		local_blob.callback(
 			msg, call_id, rc, output, local_blob.user_data);
 		
 	} else if(cib->op_callback == NULL && rc != cib_ok) {
 		crm_warn("CIB command failed: %s", cib_error2string(rc));
 		crm_log_message_adv(LOG_DEBUG, "Failed CIB Update", msg);
 	}
 	
 	if(cib->op_callback == NULL) {
 		crm_debug_3("No OP callback set, ignoring reply");
 	} else {
 		cib->op_callback(msg, call_id, rc, output);
 	}
 	free_xml(output);
 	
 	crm_debug_4("OP callback activated.");
 }
 
 
 void
 cib_native_notify(gpointer data, gpointer user_data)
 {
 	struct ha_msg *msg = user_data;
 	cib_notify_client_t *entry = data;
 	const char *event = NULL;
 
 	if(msg == NULL) {
 		crm_warn("Skipping callback - NULL message");
 		return;
 	}
 
 	event = cl_get_string(msg, F_SUBTYPE);
 	
 	if(entry == NULL) {
 		crm_warn("Skipping callback - NULL callback client");
 		return;
 
 	} else if(entry->callback == NULL) {
 		crm_warn("Skipping callback - NULL callback");
 		return;
 
 	} else if(safe_str_neq(entry->event, event)) {
 		crm_debug_4("Skipping callback - event mismatch %p/%s vs. %s",
 			  entry, entry->event, event);
 		return;
 	}
 	
 	crm_debug_4("Invoking callback for %p/%s event...", entry, event);
 	entry->callback(event, msg);
 	crm_debug_4("Callback invoked...");
 }
 
 gboolean
 cib_native_dispatch(IPC_Channel *channel, gpointer user_data)
 {
 	int lpc = 0;
 	cib_t *cib = user_data;
 
 	crm_debug_3("Received callback");
 
 	if(user_data == NULL){
 		crm_err("user_data field must contain the CIB struct");
 		return FALSE;
 	}
 	
 	while(cib_native_msgready(cib)) {
  		lpc++; 
 		/* invoke the callbacks but dont block */
 		if(cib_native_rcvmsg(cib, 0) < 1) {
 			break;
 		}
 	}
 
 	crm_debug_3("%d CIB messages dispatched", lpc);
 
 	if (channel && (channel->ch_status != IPC_CONNECT)) {
 		crm_crit("Lost connection to the CIB service.");
 		return FALSE;
 	}
 
 	return TRUE;
 }
 
 int cib_native_set_connection_dnotify(
 	cib_t *cib, void (*dnotify)(gpointer user_data))
 {
 	cib_native_opaque_t *native = NULL;
 	
 	if (cib == NULL) {
 		crm_err("No CIB!");
 		return FALSE;
 	}
 
 	native = cib->variant_opaque;
 
 	if(dnotify == NULL) {
 		crm_warn("Setting dnotify back to default value");
 		set_IPC_Channel_dnotify(native->callback_source,
 					default_ipc_connection_destroy);
 
 	} else {
 		crm_debug_3("Setting dnotify");
 		set_IPC_Channel_dnotify(native->callback_source, dnotify);
 	}
 	return cib_ok;
 }
 
 
 int
 cib_native_register_callback(cib_t* cib, const char *callback, int enabled) 
 {
 	HA_Message *notify_msg = ha_msg_new(3);
 	cib_native_opaque_t *native = cib->variant_opaque;
 
 	/* short term hack - should make this generic somehow */
 	ha_msg_add(notify_msg, F_CIB_OPERATION, T_CIB_NOTIFY);
 	ha_msg_add(notify_msg, F_CIB_NOTIFY_TYPE, callback);
 	ha_msg_add_int(notify_msg, F_CIB_NOTIFY_ACTIVATE, enabled);
 	send_ipc_message(native->callback_channel, notify_msg);
 	return cib_ok;
 }