No OneTemporary
Actions

Size

59 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/cib/cibio.h b/cib/cibio.h
	index dedd59f3fa..3e0c8737cd 100644
	--- a/cib/cibio.h
	+++ b/cib/cibio.h
	@@ -1,48 +1,46 @@
	/*
	* Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net>
	*
	* This program 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 of the License, or (at your option) any later version.
	*
	* This software 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
	* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#ifndef CIB_IO__H
	# define CIB_IO__H

	# include <stdio.h>
	# include <sys/types.h>
	# include <unistd.h>

	# include <stdlib.h>
	# include <errno.h>
	# include <fcntl.h>

	# include <crm/common/xml.h>
	# include <crm/common/mainloop.h>

	-extern gboolean initialized;
	extern xmlNode *the_cib;

	extern xmlNode *get_the_CIB(void);

	-extern int initializeCib(xmlNode * cib);
	extern gboolean uninitializeCib(void);
	extern gboolean verifyCibXml(xmlNode * cib);
	extern xmlNode readCibXml(char buffer);
	extern xmlNode readCibXmlFile(const char dir, const char *file, gboolean discard_status);
	extern int activateCibBuffer(char buffer, const char filename);
	extern int activateCibXml(xmlNode * doc, gboolean to_disk, const char *op);
	extern crm_trigger_t *cib_writer;
	extern volatile gboolean cib_writes_enabled;

	#endif
	diff --git a/cib/cibmessages.h b/cib/cibmessages.h
	index 720c56ce90..08c118dbfa 100644
	--- a/cib/cibmessages.h
	+++ b/cib/cibmessages.h
	@@ -1,76 +1,72 @@
	/*
	* Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net>
	*
	* This program 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 of the License, or (at your option) any later version.
	*
	* This software 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
	* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/
	#ifndef CIB_MESSAGES__H
	# define CIB_MESSAGES__H

	extern xmlNode createCibRequest(gboolean isLocal, const char operation, const char *section,
	const char verbose, xmlNode data);

	extern int cib_process_shutdown_req(const char op, int options, const char section,
	xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	extern int cib_process_default(const char op, int options, const char section,
	xmlNode * req, xmlNode * input, xmlNode * existing_cib,
	xmlNode result_cib, xmlNode answer);

	-extern int cib_process_quit(const char op, int options, const char section,
	- xmlNode * req, xmlNode * input, xmlNode * existing_cib,
	- xmlNode result_cib, xmlNode answer);
	-
	extern int cib_process_ping(const char op, int options, const char section,
	xmlNode * req, xmlNode * input, xmlNode * existing_cib,
	xmlNode result_cib, xmlNode answer);

	extern int cib_process_readwrite(const char op, int options, const char section,
	xmlNode * req, xmlNode * input, xmlNode * existing_cib,
	xmlNode result_cib, xmlNode answer);

	extern int cib_process_replace_svr(const char op, int options, const char section,
	xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	extern int cib_server_process_diff(const char op, int options, const char section,
	xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	extern int cib_process_sync(const char op, int options, const char section,
	xmlNode * req, xmlNode * input, xmlNode * existing_cib,
	xmlNode result_cib, xmlNode answer);

	extern int cib_process_sync_one(const char op, int options, const char section,
	xmlNode * req, xmlNode * input, xmlNode * existing_cib,
	xmlNode result_cib, xmlNode answer);

	extern int cib_process_delete_absolute(const char op, int options, const char section,
	xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	int cib_process_upgrade_server(const char op, int options, const char section,
	xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	void send_sync_request(const char *host);


	#endif
	diff --git a/cib/io.c b/cib/io.c
	index 643ffaaed6..0f7397f041 100644
	--- a/cib/io.c
	+++ b/cib/io.c
	@@ -1,492 +1,465 @@
	/*
	* Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net>
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public
	* License as published by the Free Software Foundation; either
	* version 2 of the License, or (at your option) any later version.
	*
	* This software 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
	* General Public License for more details.
	*
	* You should have received a copy of the GNU General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#include <crm_internal.h>

	#include <stdio.h>
	#include <unistd.h>
	#include <string.h>
	#include <stdlib.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <dirent.h>

	#include <sys/param.h>
	#include <sys/types.h>
	#include <sys/wait.h>
	#include <sys/stat.h>

	#include <crm/crm.h>

	#include <cibio.h>
	#include <crm/cib.h>
	#include <crm/common/util.h>
	#include <crm/msg_xml.h>
	#include <crm/common/xml.h>
	#include <crm/cib/internal.h>
	#include <crm/cluster.h>

	extern const char *cib_root;

	crm_trigger_t *cib_writer = NULL;
	-gboolean initialized = FALSE;

	extern int cib_status;

	int write_cib_contents(gpointer p);

	static void
	cib_rename(const char *old)
	{
	int new_fd;
	char *new = crm_strdup_printf("%s/cib.auto.XXXXXX", cib_root);

	crm_err("Archiving unusable file %s as %s", old, new);
	umask(S_IWGRP \| S_IWOTH \| S_IROTH);
	if ((new_fd = mkstemp(new) < 0) \|\| (rename(old, new) < 0)) {
	crm_perror(LOG_ERR, "Couldn't rename %s as %s", old, new);
	crm_err("Disabling disk writes and continuing");
	cib_writes_enabled = FALSE;
	}
	if (new_fd > 0) {
	close(new_fd);
	}
	free(new);
	}

	/*
	* It is the callers responsibility to free the output of this function
	*/

	static xmlNode *
	retrieveCib(const char filename, const char sigfile)
	{
	xmlNode *root = NULL;

	crm_info("Reading cluster configuration file %s (digest: %s)",
	filename, sigfile);
	switch (cib_file_read_and_verify(filename, sigfile, &root)) {
	case -pcmk_err_cib_corrupt:
	crm_warn("Continuing but %s will NOT be used.", filename);
	break;

	case -pcmk_err_cib_modified:
	/* Archive the original files so the contents are not lost */
	crm_warn("Continuing but %s will NOT be used.", filename);
	cib_rename(filename);
	cib_rename(sigfile);
	break;
	}
	return root;
	}

	/*
	* for OSs without support for direntry->d_type, like Solaris
	*/
	#ifndef DT_UNKNOWN
	# define DT_UNKNOWN 0
	# define DT_FIFO 1
	# define DT_CHR 2
	# define DT_DIR 4
	# define DT_BLK 6
	# define DT_REG 8
	# define DT_LNK 10
	# define DT_SOCK 12
	# define DT_WHT 14
	#endif /DT_UNKNOWN/

	static int cib_archive_filter(const struct dirent * a)
	{
	int rc = 0;
	/* Looking for regular files (d_type = 8) starting with 'cib-' and not ending in .sig */
	struct stat s;
	char *a_path = crm_strdup_printf("%s/%s", cib_root, a->d_name);

	if(stat(a_path, &s) != 0) {
	rc = errno;
	crm_trace("%s - stat failed: %s (%d)", a->d_name, pcmk_strerror(rc), rc);
	rc = 0;

	} else if ((s.st_mode & S_IFREG) != S_IFREG) {
	unsigned char dtype;
	#ifdef HAVE_STRUCT_DIRENT_D_TYPE
	dtype = a->d_type;
	#else
	switch (s.st_mode & S_IFMT) {
	case S_IFREG: dtype = DT_REG; break;
	case S_IFDIR: dtype = DT_DIR; break;
	case S_IFCHR: dtype = DT_CHR; break;
	case S_IFBLK: dtype = DT_BLK; break;
	case S_IFLNK: dtype = DT_LNK; break;
	case S_IFIFO: dtype = DT_FIFO; break;
	case S_IFSOCK: dtype = DT_SOCK; break;
	default: dtype = DT_UNKNOWN; break;
	}
	#endif
	crm_trace("%s - wrong type (%d)", a->d_name, dtype);

	} else if(strstr(a->d_name, "cib-") != a->d_name) {
	crm_trace("%s - wrong prefix", a->d_name);

	} else if (crm_ends_with_ext(a->d_name, ".sig")) {
	crm_trace("%s - wrong suffix", a->d_name);

	} else {
	crm_debug("%s - candidate", a->d_name);
	rc = 1;
	}

	free(a_path);
	return rc;
	}

	static int cib_archive_sort(const struct dirent a, const struct dirent b)
	{
	/* Order by creation date - most recently created file first */
	int rc = 0;
	struct stat buf;

	time_t a_age = 0;
	time_t b_age = 0;

	char *a_path = crm_strdup_printf("%s/%s", cib_root, a[0]->d_name);
	char *b_path = crm_strdup_printf("%s/%s", cib_root, b[0]->d_name);

	if(stat(a_path, &buf) == 0) {
	a_age = buf.st_ctime;
	}
	if(stat(b_path, &buf) == 0) {
	b_age = buf.st_ctime;
	}

	free(a_path);
	free(b_path);

	if(a_age > b_age) {
	rc = 1;
	} else if(a_age < b_age) {
	rc = -1;
	}

	crm_trace("%s (%lu) vs. %s (%lu) : %d",
	a[0]->d_name, (unsigned long)a_age,
	b[0]->d_name, (unsigned long)b_age, rc);
	return rc;
	}

	xmlNode *
	readCibXmlFile(const char dir, const char file, gboolean discard_status)
	{
	struct dirent **namelist = NULL;

	int lpc = 0;
	char *sigfile = NULL;
	char *filename = NULL;
	const char *name = NULL;
	const char *value = NULL;
	const char *validation = NULL;
	const char *use_valgrind = getenv("PCMK_valgrind_enabled");

	xmlNode *root = NULL;
	xmlNode *status = NULL;

	if (!crm_is_writable(dir, file, CRM_DAEMON_USER, NULL, FALSE)) {
	cib_status = -EACCES;
	return NULL;
	}

	filename = crm_concat(dir, file, '/');
	sigfile = crm_concat(filename, "sig", '.');

	cib_status = pcmk_ok;
	root = retrieveCib(filename, sigfile);
	free(filename);
	free(sigfile);

	if (root == NULL) {
	crm_warn("Primary configuration corrupt or unusable, trying backups in %s", cib_root);
	lpc = scandir(cib_root, &namelist, cib_archive_filter, cib_archive_sort);
	if (lpc < 0) {
	crm_perror(LOG_NOTICE, "scandir(%s) failed", cib_root);
	}
	}

	while (root == NULL && lpc > 1) {
	crm_debug("Testing %d candidates", lpc);

	lpc--;

	filename = crm_strdup_printf("%s/%s", cib_root, namelist[lpc]->d_name);
	sigfile = crm_concat(filename, "sig", '.');

	crm_info("Reading cluster configuration file %s (digest: %s)",
	filename, sigfile);
	if (cib_file_read_and_verify(filename, sigfile, &root) < 0) {
	crm_warn("Continuing but %s will NOT be used.", filename);
	} else {
	crm_notice("Continuing with last valid configuration archive: %s", filename);
	}

	free(namelist[lpc]);
	free(filename);
	free(sigfile);
	}
	free(namelist);

	if (root == NULL) {
	root = createEmptyCib(0);
	crm_warn("Continuing with an empty configuration.");
	}

	if (cib_writes_enabled && use_valgrind) {
	if (crm_is_true(use_valgrind) \|\| strstr(use_valgrind, "cib")) {
	cib_writes_enabled = FALSE;
	crm_err("* Disabling disk writes to avoid confusing Valgrind *");
	}
	}

	status = find_xml_node(root, XML_CIB_TAG_STATUS, FALSE);
	if (discard_status && status != NULL) {
	/* strip out the status section if there is one */
	free_xml(status);
	status = NULL;
	}
	if (status == NULL) {
	create_xml_node(root, XML_CIB_TAG_STATUS);
	}

	/* Do this before schema validation happens */

	/* fill in some defaults */
	name = XML_ATTR_GENERATION_ADMIN;
	value = crm_element_value(root, name);
	if (value == NULL) {
	crm_warn("No value for %s was specified in the configuration.", name);
	crm_warn("The recommended course of action is to shutdown,"
	" run crm_verify and fix any errors it reports.");
	crm_warn("We will default to zero and continue but may get"
	" confused about which configuration to use if"
	" multiple nodes are powered up at the same time.");
	crm_xml_add_int(root, name, 0);
	}

	name = XML_ATTR_GENERATION;
	value = crm_element_value(root, name);
	if (value == NULL) {
	crm_xml_add_int(root, name, 0);
	}

	name = XML_ATTR_NUMUPDATES;
	value = crm_element_value(root, name);
	if (value == NULL) {
	crm_xml_add_int(root, name, 0);
	}

	// Unset (DC should set appropriate value)
	xml_remove_prop(root, XML_ATTR_DC_UUID);

	if (discard_status) {
	crm_log_xml_trace(root, "[on-disk]");
	}

	validation = crm_element_value(root, XML_ATTR_VALIDATION);
	if (validate_xml(root, NULL, TRUE) == FALSE) {
	crm_err("CIB does not validate with %s", crm_str(validation));
	cib_status = -pcmk_err_schema_validation;

	} else if (validation == NULL) {
	int version = 0;

	update_validation(&root, &version, 0, FALSE, FALSE);
	if (version > 0) {
	crm_notice("Enabling %s validation on"
	" the existing (sane) configuration", get_schema_name(version));
	} else {
	crm_err("CIB does not validate with any known schema");
	cib_status = -pcmk_err_schema_validation;
	}
	}

	return root;
	}

	/*
	* The caller should never free the return value
	*/
	xmlNode *
	get_the_CIB(void)
	{
	return the_cib;
	}

	gboolean
	uninitializeCib(void)
	{
	xmlNode *tmp_cib = the_cib;

	if (tmp_cib == NULL) {
	crm_debug("The CIB has already been deallocated.");
	return FALSE;
	}

	- initialized = FALSE;
	the_cib = NULL;

	crm_debug("Deallocating the CIB.");

	free_xml(tmp_cib);

	crm_debug("The CIB has been deallocated.");

	return TRUE;
	}

	-/*
	- * This method will not free the old CIB pointer or the new one.
	- * We rely on the caller to have saved a pointer to the old CIB
	- * and to free the old/bad one depending on what is appropriate.
	- */
	-gboolean
	-initializeCib(xmlNode * new_cib)
	-{
	- if (new_cib == NULL) {
	- return FALSE;
	- }
	-
	- the_cib = new_cib;
	- initialized = TRUE;
	- return TRUE;
	-}
	-
	/*
	* This method will free the old CIB pointer on success and the new one
	* on failure.
	*/
	int
	activateCibXml(xmlNode * new_cib, gboolean to_disk, const char *op)
	{
	- xmlNode *saved_cib = the_cib;
	-
	- CRM_ASSERT(new_cib != saved_cib);
	- if (initializeCib(new_cib) == FALSE) {
	- free_xml(new_cib);
	- crm_err("Ignoring invalid or NULL CIB");
	-
	- if (saved_cib != NULL) {
	- crm_warn("Reverting to last known CIB");
	- if (initializeCib(saved_cib) == FALSE) {
	- /* oh we are so dead */
	- crm_crit("Couldn't re-initialize the old CIB!");
	- exit(1);
	- }
	-
	- } else {
	- crm_crit("Could not write out new CIB and no saved" " version to revert to");
	+ if (new_cib) {
	+ xmlNode *saved_cib = the_cib;
	+
	+ CRM_ASSERT(new_cib != saved_cib);
	+ the_cib = new_cib;
	+ free_xml(saved_cib);
	+ if (cib_writes_enabled && cib_status == pcmk_ok && to_disk) {
	+ crm_debug("Triggering CIB write for %s op", op);
	+ mainloop_set_trigger(cib_writer);
	}
	- return -ENODATA;
	+ return pcmk_ok;
	}

	- free_xml(saved_cib);
	- if (cib_writes_enabled && cib_status == pcmk_ok && to_disk) {
	- crm_debug("Triggering CIB write for %s op", op);
	- mainloop_set_trigger(cib_writer);
	+ crm_err("Ignoring invalid CIB");
	+ if (the_cib) {
	+ crm_warn("Reverting to last known CIB");
	+ } else {
	+ crm_crit("Could not write out new CIB and no saved version to revert to");
	}
	-
	- return pcmk_ok;
	+ return -ENODATA;
	}

	static void
	cib_diskwrite_complete(mainloop_child_t * p, pid_t pid, int core, int signo, int exitcode)
	{
	if (signo) {
	crm_notice("Disk write process terminated with signal %d (pid=%d, core=%d)", signo, pid,
	core);

	} else {
	do_crm_log(exitcode == 0 ? LOG_TRACE : LOG_ERR, "Disk write process exited (pid=%d, rc=%d)",
	pid, exitcode);
	}

	if (exitcode != 0 && cib_writes_enabled) {
	crm_err("Disabling disk writes after write failure");
	cib_writes_enabled = FALSE;
	}

	mainloop_trigger_complete(cib_writer);
	}

	int
	write_cib_contents(gpointer p)
	{
	int exit_rc = pcmk_ok;
	xmlNode *cib_local = NULL;

	/* Make a copy of the CIB to write (possibly in a forked child) */
	if (p) {
	/* Synchronous write out */
	cib_local = copy_xml(p);

	} else {
	int pid = 0;
	int bb_state = qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_STATE_GET, 0);

	/* Turn it off before the fork() to avoid:
	* - 2 processes writing to the same shared mem
	* - the child needing to disable it
	* (which would close it from underneath the parent)
	* This way, the shared mem files are already closed
	*/
	qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);

	pid = fork();
	if (pid < 0) {
	crm_perror(LOG_ERR, "Disabling disk writes after fork failure");
	cib_writes_enabled = FALSE;
	return FALSE;
	}

	if (pid) {
	/* Parent */
	mainloop_child_add(pid, 0, "disk-writer", NULL, cib_diskwrite_complete);
	if (bb_state == QB_LOG_STATE_ENABLED) {
	/* Re-enable now that it it safe */
	qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_TRUE);
	}

	return -1; /* -1 means 'still work to do' */
	}

	/* A-synchronous write out after a fork() */

	/* In theory we can scribble on "the_cib" here and not affect the parent
	* But lets be safe anyway
	*/
	cib_local = copy_xml(the_cib);
	}

	/* Write the CIB */
	exit_rc = cib_file_write_with_digest(cib_local, cib_root, "cib.xml");

	/* A nonzero exit code will cause further writes to be disabled */
	free_xml(cib_local);
	if (p == NULL) {
	/* Use _exit() because exit() could affect the parent adversely */
	_exit(exit_rc);
	}
	return exit_rc;
	}
	diff --git a/cib/main.c b/cib/main.c
	index 01ad152c9f..d3cda32ef4 100644
	--- a/cib/main.c
	+++ b/cib/main.c
	@@ -1,419 +1,417 @@
	/*
	* Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net>
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public
	* License as published by the Free Software Foundation; either
	* version 2 of the License, or (at your option) any later version.
	*
	* This software 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
	* General Public License for more details.
	*
	* You should have received a copy of the GNU General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#include <crm_internal.h>

	#include <sys/param.h>
	#include <stdio.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <unistd.h>
	#include <sys/utsname.h>

	#include <stdlib.h>
	#include <errno.h>
	#include <fcntl.h>

	#include <crm/crm.h>
	#include <crm/cib/internal.h>
	#include <crm/msg_xml.h>
	#include <crm/cluster/internal.h>

	#include <crm/common/xml.h>

	#include <crm/common/mainloop.h>

	#include <cibio.h>
	#include <callbacks.h>
	#include <pwd.h>
	#include <grp.h>
	#include "common.h"

	#if HAVE_LIBXML2
	# include <libxml/parser.h>
	#endif

	#ifdef HAVE_GETOPT_H
	# include <getopt.h>
	#endif

	#if HAVE_BZLIB_H
	# include <bzlib.h>
	#endif

	extern int init_remote_listener(int port, gboolean encrypted);
	gboolean cib_shutdown_flag = FALSE;
	int cib_status = pcmk_ok;

	crm_cluster_t crm_cluster;

	GMainLoop *mainloop = NULL;
	const char *cib_root = NULL;
	char *cib_our_uname = NULL;
	gboolean preserve_status = FALSE;

	/* volatile because it may be changed in a signal handler */
	volatile gboolean cib_writes_enabled = TRUE;

	int remote_fd = 0;
	int remote_tls_fd = 0;

	int cib_init(void);
	void cib_shutdown(int nsig);
	-gboolean startCib(const char *filename);
	+static bool startCib(const char *filename);
	extern int write_cib_contents(gpointer p);

	GHashTable *config_hash = NULL;
	GHashTable *local_notify_queue = NULL;

	char *channel1 = NULL;
	char *channel2 = NULL;
	char *channel3 = NULL;
	char *channel4 = NULL;
	char *channel5 = NULL;

	#define OPTARGS "maswr:V?"
	void cib_cleanup(void);

	static void
	cib_enable_writes(int nsig)
	{
	crm_info("(Re)enabling disk writes");
	cib_writes_enabled = TRUE;
	}

	static void
	log_cib_client(gpointer key, gpointer value, gpointer user_data)
	{
	crm_info("Client %s", crm_client_name(value));
	}

	/* INDENT-OFF */
	static struct crm_option long_options[] = {
	/* Top-level Options */
	{"help", 0, 0, '?', "\tThis text"},
	{"verbose", 0, 0, 'V', "\tIncrease debug output"},

	{"per-action-cib", 0, 0, 'a', "\tAdvanced use only"},
	{"stand-alone", 0, 0, 's', "\tAdvanced use only"},
	{"disk-writes", 0, 0, 'w', "\tAdvanced use only"},
	{"cib-root", 1, 0, 'r', "\tAdvanced use only"},

	{0, 0, 0, 0}
	};
	/* INDENT-ON */

	int
	main(int argc, char **argv)
	{
	int flag;
	int rc = 0;
	int index = 0;
	int argerr = 0;
	struct passwd *pwentry = NULL;

	crm_log_preinit(NULL, argc, argv);
	crm_set_options(NULL, "[options]",
	long_options, "Daemon for storing and replicating the cluster configuration");

	crm_peer_init();

	mainloop_add_signal(SIGTERM, cib_shutdown);
	mainloop_add_signal(SIGPIPE, cib_enable_writes);

	cib_writer = mainloop_add_trigger(G_PRIORITY_LOW, write_cib_contents, NULL);

	while (1) {
	flag = crm_get_option(argc, argv, &index);
	if (flag == -1)
	break;

	switch (flag) {
	case 'V':
	crm_bump_log_level(argc, argv);
	break;
	case 's':
	stand_alone = TRUE;
	preserve_status = TRUE;
	cib_writes_enabled = FALSE;

	pwentry = getpwnam(CRM_DAEMON_USER);
	CRM_CHECK(pwentry != NULL,
	crm_perror(LOG_ERR, "Invalid uid (%s) specified", CRM_DAEMON_USER);
	return 100);

	rc = setgid(pwentry->pw_gid);
	if (rc < 0) {
	crm_perror(LOG_ERR, "Could not set group to %d", pwentry->pw_gid);
	return 100;
	}

	rc = initgroups(CRM_DAEMON_GROUP, pwentry->pw_gid);
	if (rc < 0) {
	crm_perror(LOG_ERR, "Could not setup groups for user %d", pwentry->pw_uid);
	return 100;
	}

	rc = setuid(pwentry->pw_uid);
	if (rc < 0) {
	crm_perror(LOG_ERR, "Could not set user to %d", pwentry->pw_uid);
	return 100;
	}
	break;
	case '?': /* Help message */
	crm_help(flag, EX_OK);
	break;
	case 'w':
	cib_writes_enabled = TRUE;
	break;
	case 'r':
	cib_root = optarg;
	break;
	case 'm':
	cib_metadata();
	return 0;
	default:
	++argerr;
	break;
	}
	}
	if (argc - optind == 1 && safe_str_eq("metadata", argv[optind])) {
	cib_metadata();
	return 0;
	}

	if (optind > argc) {
	++argerr;
	}

	if (argerr) {
	crm_help('?', EX_USAGE);
	}

	crm_log_init(NULL, LOG_INFO, TRUE, FALSE, argc, argv, FALSE);

	if (cib_root == NULL) {
	cib_root = CRM_CONFIG_DIR;
	} else {
	crm_notice("Using custom config location: %s", cib_root);
	}

	if (crm_is_writable(cib_root, NULL, CRM_DAEMON_USER, CRM_DAEMON_GROUP, FALSE) == FALSE) {
	crm_err("Bad permissions on %s. Terminating", cib_root);
	fprintf(stderr, "ERROR: Bad permissions on %s. See logs for details\n", cib_root);
	fflush(stderr);
	return 100;
	}

	/* read local config file */
	rc = cib_init();

	CRM_CHECK(crm_hash_table_size(client_connections) == 0,
	crm_warn("Not all clients gone at exit"));
	g_hash_table_foreach(client_connections, log_cib_client, NULL);
	cib_cleanup();

	crm_info("Done");
	return rc;
	}

	void
	cib_cleanup(void)
	{
	crm_peer_destroy();
	if (local_notify_queue) {
	g_hash_table_destroy(local_notify_queue);
	}
	crm_client_cleanup();
	g_hash_table_destroy(config_hash);
	free(cib_our_uname);
	free(channel1);
	free(channel2);
	free(channel3);
	free(channel4);
	free(channel5);
	}

	unsigned long cib_num_ops = 0;
	const char *cib_stat_interval = "10min";
	unsigned long cib_num_local = 0, cib_num_updates = 0, cib_num_fail = 0;
	unsigned long cib_bad_connects = 0, cib_num_timeouts = 0;

	#if SUPPORT_COROSYNC
	static void
	cib_cs_dispatch(cpg_handle_t handle,
	const struct cpg_name *groupName,
	uint32_t nodeid, uint32_t pid, void *msg, size_t msg_len)
	{
	uint32_t kind = 0;
	xmlNode *xml = NULL;
	const char *from = NULL;
	char *data = pcmk_message_common_cs(handle, nodeid, pid, msg, &kind, &from);

	if(data == NULL) {
	return;
	}
	if (kind == crm_class_cluster) {
	xml = string2xml(data);
	if (xml == NULL) {
	crm_err("Invalid XML: '%.120s'", data);
	free(data);
	return;
	}
	crm_xml_add(xml, F_ORIG, from);
	/* crm_xml_add_int(xml, F_SEQ, wrapper->id); */
	cib_peer_callback(xml, NULL);
	}

	free_xml(xml);
	free(data);
	}

	static void
	cib_cs_destroy(gpointer user_data)
	{
	if (cib_shutdown_flag) {
	crm_info("Corosync disconnection complete");
	} else {
	crm_err("Corosync connection lost! Exiting.");
	terminate_cib(__FUNCTION__, -1);
	}
	}
	#endif

	static void
	cib_peer_update_callback(enum crm_status_type type, crm_node_t * node, const void *data)
	{
	switch (type) {
	case crm_status_processes:
	if (cib_legacy_mode()
	&& is_not_set(node->processes, crm_get_cluster_proc())) {

	uint32_t old = data? (const uint32_t )data : 0;

	if ((node->processes ^ old) & crm_proc_cpg) {
	crm_info("Attempting to disable legacy mode after %s left the cluster",
	node->uname);
	legacy_mode = FALSE;
	}
	}
	break;

	case crm_status_uname:
	case crm_status_rstate:
	case crm_status_nstate:
	if (cib_shutdown_flag && (crm_active_peers() < 2)
	&& crm_hash_table_size(client_connections) == 0) {

	crm_info("No more peers");
	terminate_cib(__FUNCTION__, 1);
	}
	break;
	}
	}

	int
	cib_init(void)
	{
	if (is_corosync_cluster()) {
	#if SUPPORT_COROSYNC
	crm_cluster.destroy = cib_cs_destroy;
	crm_cluster.cpg.cpg_deliver_fn = cib_cs_dispatch;
	crm_cluster.cpg.cpg_confchg_fn = pcmk_cpg_membership;
	#endif
	}

	config_hash = crm_str_table_new();

	if (startCib("cib.xml") == FALSE) {
	crm_crit("Cannot start CIB... terminating");
	crm_exit(ENODATA);
	}

	if (stand_alone == FALSE) {
	if (is_corosync_cluster()) {
	crm_set_status_callback(&cib_peer_update_callback);
	}

	if (crm_cluster_connect(&crm_cluster) == FALSE) {
	crm_crit("Cannot sign in to the cluster... terminating");
	crm_exit(DAEMON_RESPAWN_STOP);
	}
	cib_our_uname = crm_cluster.uname;

	} else {
	cib_our_uname = strdup("localhost");
	}

	cib_ipc_servers_init(&ipcs_ro,
	&ipcs_rw,
	&ipcs_shm,
	&ipc_ro_callbacks,
	&ipc_rw_callbacks);

	if (stand_alone) {
	cib_is_master = TRUE;
	}

	/* Create the mainloop and run it... */
	mainloop = g_main_new(FALSE);
	crm_info("Starting %s mainloop", crm_system_name);
	g_main_run(mainloop);

	/* If main loop returned, clean up and exit. We disconnect in case
	* terminate_cib() was called with fast=1.
	*/
	crm_cluster_disconnect(&crm_cluster);
	cib_ipc_servers_destroy(ipcs_ro, ipcs_rw, ipcs_shm);

	return crm_exit(pcmk_ok);
	}

	-gboolean
	+static bool
	startCib(const char *filename)
	{
	gboolean active = FALSE;
	xmlNode *cib = readCibXmlFile(cib_root, filename, !preserve_status);

	- CRM_ASSERT(cib != NULL);
	-
	if (activateCibXml(cib, TRUE, "start") == 0) {
	int port = 0;
	const char *port_s = NULL;

	active = TRUE;

	cib_read_config(config_hash, cib);

	port_s = crm_element_value(cib, "remote-tls-port");
	if (port_s) {
	port = crm_parse_int(port_s, "0");
	remote_tls_fd = init_remote_listener(port, TRUE);
	}

	port_s = crm_element_value(cib, "remote-clear-port");
	if (port_s) {
	port = crm_parse_int(port_s, "0");
	remote_fd = init_remote_listener(port, FALSE);
	}

	crm_info("CIB Initialization completed successfully");
	}

	return active;
	}
	diff --git a/cib/messages.c b/cib/messages.c
	index ff9755294a..49dc607a94 100644
	--- a/cib/messages.c
	+++ b/cib/messages.c
	@@ -1,546 +1,533 @@
	/*
	* Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net>
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public
	* License as published by the Free Software Foundation; either
	* version 2 of the License, or (at your option) any later version.
	*
	* This software 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
	* General Public License for more details.
	*
	* You should have received a copy of the GNU General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#include <crm_internal.h>

	#include <stdio.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <time.h>

	#include <sys/param.h>
	#include <sys/types.h>

	#include <crm/crm.h>
	#include <crm/cib/internal.h>
	#include <crm/msg_xml.h>

	#include <crm/common/xml.h>
	#include <crm/common/ipcs.h>
	#include <crm/cluster/internal.h>

	#include <cibio.h>
	#include <cibmessages.h>
	#include <callbacks.h>

	/* Maximum number of diffs to ignore while waiting for a resync */
	#define MAX_DIFF_RETRY 5

	gboolean cib_is_master = FALSE;

	xmlNode *the_cib = NULL;
	extern const char *cib_our_uname;
	int revision_check(xmlNode * cib_update, xmlNode * cib_copy, int flags);
	int get_revision(xmlNode * xml_obj, int cur_revision);

	int updateList(xmlNode * local_cib, xmlNode * update_command, xmlNode * failed,
	int operation, const char *section);

	gboolean check_generation(xmlNode * newCib, xmlNode * oldCib);

	gboolean update_results(xmlNode * failed, xmlNode * target, const char *operation, int return_code);

	int cib_update_counter(xmlNode * xml_obj, const char *field, gboolean reset);

	int sync_our_cib(xmlNode * request, gboolean all);

	extern xmlNode cib_msg_copy(const xmlNode msg, gboolean with_data);
	extern gboolean cib_shutdown_flag;

	int
	cib_process_shutdown_req(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	int result = pcmk_ok;
	const char *host = crm_element_value(req, F_ORIG);

	*answer = NULL;

	if (crm_element_value(req, F_CIB_ISREPLY) == NULL) {
	crm_info("Shutdown REQ from %s", host);
	return pcmk_ok;

	} else if (cib_shutdown_flag) {
	crm_info("Shutdown ACK from %s", host);
	terminate_cib(__FUNCTION__, 0);
	return pcmk_ok;

	} else {
	crm_err("Shutdown ACK from %s - not shutting down", host);
	result = -EINVAL;
	}

	return result;
	}

	int
	cib_process_default(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	int result = pcmk_ok;

	crm_trace("Processing \"%s\" event", op);
	*answer = NULL;

	if (op == NULL) {
	result = -EINVAL;
	crm_err("No operation specified");

	} else if (strcasecmp(CRM_OP_NOOP, op) == 0) {
	;

	} else {
	result = -EPROTONOSUPPORT;
	crm_err("Action [%s] is not supported by the CIB", op);
	}
	return result;
	}

	-int
	-cib_process_quit(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	- xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	-{
	- int result = pcmk_ok;
	-
	- crm_trace("Processing \"%s\" event", op);
	-
	- crm_warn("The CRMd has asked us to exit... complying");
	- crm_exit(pcmk_ok);
	- return result;
	-}
	-
	int
	cib_process_readwrite(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	int result = pcmk_ok;

	crm_trace("Processing \"%s\" event", op);

	if (safe_str_eq(op, CIB_OP_ISMASTER)) {
	if (cib_is_master == TRUE) {
	result = pcmk_ok;
	} else {
	result = -EPERM;
	}
	return result;
	}

	if (safe_str_eq(op, CIB_OP_MASTER)) {
	if (cib_is_master == FALSE) {
	crm_info("We are now in R/W mode");
	cib_is_master = TRUE;
	} else {
	crm_debug("We are still in R/W mode");
	}

	} else if (cib_is_master) {
	crm_info("We are now in R/O mode");
	cib_is_master = FALSE;
	}

	return result;
	}

	/* Set to 1 when a sync is requested, incremented when a diff is ignored,
	* reset to 0 when a sync is received
	*/
	static int sync_in_progress = 0;

	void
	send_sync_request(const char *host)
	{
	xmlNode *sync_me = create_xml_node(NULL, "sync-me");

	crm_info("Requesting re-sync from %s", (host? host : "all peers"));
	sync_in_progress = 1;

	crm_xml_add(sync_me, F_TYPE, "cib");
	crm_xml_add(sync_me, F_CIB_OPERATION, CIB_OP_SYNC_ONE);
	crm_xml_add(sync_me, F_CIB_DELEGATED, cib_our_uname);

	send_cluster_message(host ? crm_get_peer(0, host) : NULL, crm_msg_cib, sync_me, FALSE);
	free_xml(sync_me);
	}

	int
	cib_process_ping(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	const char *host = crm_element_value(req, F_ORIG);
	const char *seq = crm_element_value(req, F_CIB_PING_ID);
	char *digest = calculate_xml_versioned_digest(the_cib, FALSE, TRUE, CRM_FEATURE_SET);

	static struct qb_log_callsite *cs = NULL;

	crm_trace("Processing \"%s\" event %s from %s", op, seq, host);
	*answer = create_xml_node(NULL, XML_CRM_TAG_PING);

	crm_xml_add(*answer, XML_ATTR_CRM_VERSION, CRM_FEATURE_SET);
	crm_xml_add(*answer, XML_ATTR_DIGEST, digest);
	crm_xml_add(*answer, F_CIB_PING_ID, seq);

	if (cs == NULL) {
	cs = qb_log_callsite_get(__func__, __FILE__, __FUNCTION__, LOG_TRACE, __LINE__, crm_trace_nonlog);
	}
	if (cs && cs->targets) {
	/* Append additional detail so the reciever can log the differences */
	add_message_xml(*answer, F_CIB_CALLDATA, the_cib);

	} else {
	/* Always include at least the version details */
	const char *tag = TYPE(the_cib);
	xmlNode *shallow = create_xml_node(NULL, tag);

	copy_in_properties(shallow, the_cib);
	add_message_xml(*answer, F_CIB_CALLDATA, shallow);
	free_xml(shallow);
	}

	crm_info("Reporting our current digest to %s: %s for %s.%s.%s (%p %d)",
	host, digest,
	crm_element_value(existing_cib, XML_ATTR_GENERATION_ADMIN),
	crm_element_value(existing_cib, XML_ATTR_GENERATION),
	crm_element_value(existing_cib, XML_ATTR_NUMUPDATES),
	existing_cib,
	cs && cs->targets);

	free(digest);

	return pcmk_ok;
	}

	int
	cib_process_sync(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	return sync_our_cib(req, TRUE);
	}

	int
	cib_process_upgrade_server(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	int rc = pcmk_ok;

	*answer = NULL;

	if(crm_element_value(req, F_CIB_SCHEMA_MAX)) {
	return cib_process_upgrade(
	op, options, section, req, input, existing_cib, result_cib, answer);

	} else {
	int new_version = 0;
	int current_version = 0;
	xmlNode *scratch = copy_xml(existing_cib);
	const char *host = crm_element_value(req, F_ORIG);
	const char *value = crm_element_value(existing_cib, XML_ATTR_VALIDATION);

	crm_trace("Processing \"%s\" event", op);
	if (value != NULL) {
	current_version = get_schema_version(value);
	}

	rc = update_validation(&scratch, &new_version, 0, TRUE, TRUE);
	if (new_version > current_version) {
	xmlNode *up = create_xml_node(NULL, __FUNCTION__);

	rc = pcmk_ok;
	crm_notice("Upgrade request from %s verified", host);

	crm_xml_add(up, F_TYPE, "cib");
	crm_xml_add(up, F_CIB_OPERATION, CIB_OP_UPGRADE);
	crm_xml_add(up, F_CIB_SCHEMA_MAX, get_schema_name(new_version));
	crm_xml_add(up, F_CIB_DELEGATED, host);
	crm_xml_add(up, F_CIB_CLIENTID, crm_element_value(req, F_CIB_CLIENTID));
	crm_xml_add(up, F_CIB_CALLOPTS, crm_element_value(req, F_CIB_CALLOPTS));
	crm_xml_add(up, F_CIB_CALLID, crm_element_value(req, F_CIB_CALLID));

	if (cib_legacy_mode() && cib_is_master) {
	rc = cib_process_upgrade(
	op, options, section, up, input, existing_cib, result_cib, answer);

	} else {
	send_cluster_message(NULL, crm_msg_cib, up, FALSE);
	}

	free_xml(up);

	} else if(rc == pcmk_ok) {
	rc = -pcmk_err_schema_unchanged;
	}

	free_xml(scratch);
	}
	return rc;
	}

	int
	cib_process_sync_one(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	return sync_our_cib(req, FALSE);
	}

	int
	cib_server_process_diff(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	int rc = pcmk_ok;

	if (sync_in_progress > MAX_DIFF_RETRY) {
	/* Don't ignore diffs forever; the last request may have been lost.
	* If the diff fails, we'll ask for another full resync.
	*/
	sync_in_progress = 0;
	}

	/* The master should never ignore a diff */
	if (sync_in_progress && !cib_is_master) {
	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;

	cib_diff_version_details(input,
	&diff_add_admin_epoch, &diff_add_epoch, &diff_add_updates,
	&diff_del_admin_epoch, &diff_del_epoch, &diff_del_updates);

	sync_in_progress++;
	crm_notice("Not applying diff %d.%d.%d -> %d.%d.%d (sync in progress)",
	diff_del_admin_epoch, diff_del_epoch, diff_del_updates,
	diff_add_admin_epoch, diff_add_epoch, diff_add_updates);
	return -pcmk_err_diff_resync;
	}

	rc = cib_process_diff(op, options, section, req, input, existing_cib, result_cib, answer);
	crm_trace("result: %s (%d), %s", pcmk_strerror(rc), rc, cib_is_master?"master":"slave");

	if (rc == -pcmk_err_diff_resync && cib_is_master == FALSE) {
	free_xml(*result_cib);
	*result_cib = NULL;
	send_sync_request(NULL);

	} else if (rc == -pcmk_err_diff_resync) {
	rc = -pcmk_err_diff_failed;
	if (options & cib_force_diff) {
	crm_warn("Not requesting full refresh in R/W mode");
	}

	} else if ((rc != pcmk_ok) && !cib_is_master && cib_legacy_mode()) {
	crm_warn("Requesting full CIB refresh because update failed: %s"
	CRM_XS " rc=%d", pcmk_strerror(rc), rc);
	xml_log_patchset(LOG_INFO, __FUNCTION__, input);
	free_xml(*result_cib);
	*result_cib = NULL;
	send_sync_request(NULL);
	}

	return rc;
	}

	int
	cib_process_replace_svr(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	const char *tag = crm_element_name(input);
	int rc =
	cib_process_replace(op, options, section, req, input, existing_cib, result_cib, answer);
	if (rc == pcmk_ok && safe_str_eq(tag, XML_TAG_CIB)) {
	sync_in_progress = 0;
	}
	return rc;
	}

	static int
	delete_cib_object(xmlNode * parent, xmlNode * delete_spec)
	{
	const char *object_name = NULL;
	const char *object_id = NULL;
	xmlNode *equiv_node = NULL;
	int result = pcmk_ok;

	if (delete_spec != NULL) {
	object_name = crm_element_name(delete_spec);
	}
	object_id = crm_element_value(delete_spec, XML_ATTR_ID);

	crm_trace("Processing: <%s id=%s>", crm_str(object_name), crm_str(object_id));

	if (delete_spec == NULL) {
	result = -EINVAL;

	} else if (parent == NULL) {
	result = -EINVAL;

	} else if (object_id == NULL) {
	/* placeholder object */
	equiv_node = find_xml_node(parent, object_name, FALSE);

	} else {
	equiv_node = find_entity(parent, object_name, object_id);
	}

	if (result != pcmk_ok) {
	; /* nothing */

	} else if (equiv_node == NULL) {
	result = pcmk_ok;

	} else if (xml_has_children(delete_spec) == FALSE) {
	/* only leaves are deleted */
	crm_debug("Removing leaf: <%s id=%s>", crm_str(object_name), crm_str(object_id));
	free_xml(equiv_node);
	equiv_node = NULL;

	} else {
	xmlNode *child = NULL;

	for (child = __xml_first_child(delete_spec); child != NULL; child = __xml_next(child)) {
	int tmp_result = delete_cib_object(equiv_node, child);

	/* only the first error is likely to be interesting */
	if (tmp_result != pcmk_ok && result == pcmk_ok) {
	result = tmp_result;
	}
	}
	}

	return result;
	}

	int
	cib_process_delete_absolute(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	xmlNode *failed = NULL;
	int result = pcmk_ok;
	xmlNode *update_section = NULL;

	crm_trace("Processing \"%s\" event for section=%s", op, crm_str(section));
	if (safe_str_eq(XML_CIB_TAG_SECTION_ALL, section)) {
	section = NULL;

	} else if (safe_str_eq(XML_TAG_CIB, section)) {
	section = NULL;

	} else if (safe_str_eq(crm_element_name(input), XML_TAG_CIB)) {
	section = NULL;
	}

	CRM_CHECK(strcasecmp(CIB_OP_DELETE, op) == 0, return -EINVAL);

	if (input == NULL) {
	crm_err("Cannot perform modification with no data");
	return -EINVAL;
	}

	failed = create_xml_node(NULL, XML_TAG_FAILED);

	update_section = get_object_root(section, *result_cib);
	result = delete_cib_object(update_section, input);
	update_results(failed, input, op, result);

	if (xml_has_children(failed)) {
	CRM_CHECK(result != pcmk_ok, result = -EINVAL);
	}

	if (result != pcmk_ok) {
	crm_log_xml_err(failed, "CIB Update failures");
	*answer = failed;

	} else {
	free_xml(failed);
	}

	return result;
	}

	gboolean
	check_generation(xmlNode * newCib, xmlNode * oldCib)
	{
	if (cib_compare_generation(newCib, oldCib) >= 0) {
	return TRUE;
	}

	crm_warn("Generation from update is older than the existing one");
	return FALSE;
	}

	int
	sync_our_cib(xmlNode * request, gboolean all)
	{
	int result = pcmk_ok;
	char *digest = NULL;
	const char *host = crm_element_value(request, F_ORIG);
	const char *op = crm_element_value(request, F_CIB_OPERATION);

	xmlNode *replace_request = cib_msg_copy(request, FALSE);

	CRM_CHECK(the_cib != NULL,;);
	CRM_CHECK(replace_request != NULL,;);

	crm_debug("Syncing CIB to %s", all ? "all peers" : host);
	if (all == FALSE && host == NULL) {
	crm_log_xml_err(request, "bad sync");
	}

	/* remove the "all == FALSE" condition
	*
	* sync_from was failing, the local client wasn't being notified
	* because it didn't know it was a reply
	* setting this does not prevent the other nodes from applying it
	* if all == TRUE
	*/
	if (host != NULL) {
	crm_xml_add(replace_request, F_CIB_ISREPLY, host);
	}
	if (all) {
	xml_remove_prop(replace_request, F_CIB_HOST);
	}

	crm_xml_add(replace_request, F_CIB_OPERATION, CIB_OP_REPLACE);
	crm_xml_add(replace_request, "original_" F_CIB_OPERATION, op);
	crm_xml_add(replace_request, F_CIB_GLOBAL_UPDATE, XML_BOOLEAN_TRUE);

	crm_xml_add(replace_request, XML_ATTR_CRM_VERSION, CRM_FEATURE_SET);
	digest = calculate_xml_versioned_digest(the_cib, FALSE, TRUE, CRM_FEATURE_SET);
	crm_xml_add(replace_request, XML_ATTR_DIGEST, digest);

	add_message_xml(replace_request, F_CIB_CALLDATA, the_cib);

	if (send_cluster_message
	(all ? NULL : crm_get_peer(0, host), crm_msg_cib, replace_request, FALSE) == FALSE) {
	result = -ENOTCONN;
	}
	free_xml(replace_request);
	free(digest);
	return result;
	}
	diff --git a/include/crm/cib/internal.h b/include/crm/cib/internal.h
	index 319440eb0e..e36bb23b81 100644
	--- a/include/crm/cib/internal.h
	+++ b/include/crm/cib/internal.h
	@@ -1,221 +1,220 @@
	/*
	* Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net>
	*
	* This program 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 of the License, or (at your option) any later version.
	*
	* This software 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
	* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/
	#ifndef CIB_INTERNAL__H
	# define CIB_INTERNAL__H
	# include <crm/cib.h>
	# include <crm/common/ipcs.h>

	# define CIB_OP_SLAVE "cib_slave"
	# define CIB_OP_SLAVEALL "cib_slave_all"
	# define CIB_OP_MASTER "cib_master"
	# define CIB_OP_SYNC "cib_sync"
	# define CIB_OP_SYNC_ONE "cib_sync_one"
	# define CIB_OP_ISMASTER "cib_ismaster"
	# define CIB_OP_BUMP "cib_bump"
	# define CIB_OP_QUERY "cib_query"
	# define CIB_OP_CREATE "cib_create"
	# define CIB_OP_UPDATE "cib_update"
	# define CIB_OP_MODIFY "cib_modify"
	# define CIB_OP_DELETE "cib_delete"
	# define CIB_OP_ERASE "cib_erase"
	# define CIB_OP_REPLACE "cib_replace"
	# define CIB_OP_APPLY_DIFF "cib_apply_diff"
	# define CIB_OP_UPGRADE "cib_upgrade"
	# define CIB_OP_UPGRADE_OK "cib_upgrade_ok"
	# define CIB_OP_DELETE_ALT "cib_delete_alt"
	# define CIB_OP_NOTIFY "cib_notify"

	# define F_CIB_CLIENTID "cib_clientid"
	# define F_CIB_CALLOPTS "cib_callopt"
	# define F_CIB_CALLID "cib_callid"
	# define F_CIB_CALLDATA "cib_calldata"
	# define F_CIB_OPERATION "cib_op"
	# define F_CIB_ISREPLY "cib_isreplyto"
	# define F_CIB_SECTION "cib_section"
	# define F_CIB_HOST "cib_host"
	# define F_CIB_RC "cib_rc"
	# define F_CIB_DELEGATED "cib_delegated_from"
	# define F_CIB_OBJID "cib_object"
	# define F_CIB_OBJTYPE "cib_object_type"
	# define F_CIB_EXISTING "cib_existing_object"
	# define F_CIB_SEENCOUNT "cib_seen"
	# define F_CIB_TIMEOUT "cib_timeout"
	# define F_CIB_UPDATE "cib_update"
	# define F_CIB_CALLBACK_TOKEN "cib_async_id"
	# define F_CIB_GLOBAL_UPDATE "cib_update"
	# define F_CIB_UPDATE_RESULT "cib_update_result"
	# define F_CIB_CLIENTNAME "cib_clientname"
	# define F_CIB_NOTIFY_TYPE "cib_notify_type"
	# define F_CIB_NOTIFY_ACTIVATE "cib_notify_activate"
	# define F_CIB_UPDATE_DIFF "cib_update_diff"
	# define F_CIB_USER "cib_user"
	# define F_CIB_LOCAL_NOTIFY_ID "cib_local_notify_id"
	# define F_CIB_PING_ID "cib_ping_id"
	# define F_CIB_SCHEMA_MAX "cib_schema_max"

	# define T_CIB "cib"
	# define T_CIB_NOTIFY "cib_notify"
	/* notify sub-types */
	# define T_CIB_PRE_NOTIFY "cib_pre_notify"
	# define T_CIB_POST_NOTIFY "cib_post_notify"
	# define T_CIB_UPDATE_CONFIRM "cib_update_confirmation"
	# define T_CIB_REPLACE_NOTIFY "cib_refresh_notify"

	# define cib_channel_ro "cib_ro"
	# define cib_channel_rw "cib_rw"
	# define cib_channel_shm "cib_shm"

	void cib_add_digest(xmlNode * source, xmlNode * target);
	void fix_cib_diff(xmlNode * last, xmlNode * next, xmlNode * local_diff, gboolean changed);
	gboolean cib_diff_version_details(xmlNode * diff, int admin_epoch, int epoch, int *updates,
	int _admin_epoch, int _epoch, int *_updates);

	-gboolean startCib(const char *filename);
	int cib_compare_generation(xmlNode * left, xmlNode * right);
	gboolean cib_read_config(GHashTable * options, xmlNode * current_cib);
	void verify_cib_options(GHashTable * options);
	gboolean cib_internal_config_changed(xmlNode * diff);

	extern GHashTable *cib_op_callback_table;
	typedef struct cib_notify_client_s {
	const char *event;
	const char obj_id; / implement one day */
	const char obj_type; / implement one day */
	void (callback) (const char event, xmlNode * msg);

	} cib_notify_client_t;

	typedef struct cib_callback_client_s {
	void (callback) (xmlNode , int, int, xmlNode , void );
	const char *id;
	void *user_data;
	gboolean only_success;
	struct timer_rec_s *timer;
	void (free_func)(void );
	} cib_callback_client_t;

	struct timer_rec_s {
	int call_id;
	int timeout;
	guint ref;
	cib_t *cib;
	};

	typedef int (cib_op_t) (const char , int, const char , xmlNode ,
	xmlNode , xmlNode , xmlNode , xmlNode );

	cib_t *cib_new_variant(void);

	int cib_perform_op(const char op, int call_options, cib_op_t fn, gboolean is_query,
	const char section, xmlNode req, xmlNode * input,
	gboolean manage_counters, gboolean * config_changed,
	xmlNode * current_cib, xmlNode result_cib, xmlNode diff,
	xmlNode ** output);

	xmlNode cib_create_op(int call_id, const char token, const char op, const char host,
	const char section, xmlNode data, int call_options,
	const char *user_name);

	void cib_native_callback(cib_t * cib, xmlNode * msg, int call_id, int rc);
	void cib_native_notify(gpointer data, gpointer user_data);
	int cib_native_register_notification(cib_t * cib, const char *callback, int enabled);
	gboolean cib_client_register_callback(cib_t * cib, int call_id, int timeout, gboolean only_success,
	void user_data, const char callback_name,
	void (callback) (xmlNode , int, int, xmlNode , void ));
	gboolean cib_client_register_callback_full(cib_t *cib, int call_id,
	int timeout, gboolean only_success,
	void *user_data,
	const char *callback_name,
	void (callback)(xmlNode , int, int,
	xmlNode , void ),
	void (free_func)(void ));

	int cib_process_query(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	int cib_process_erase(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	int cib_process_bump(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	int cib_process_replace(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	int cib_process_create(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	int cib_process_modify(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	int cib_process_delete(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	int cib_process_diff(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	int cib_process_upgrade(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	/*!
	* \internal
	* \brief Core function to manipulate with/query CIB/XML per xpath + arguments
	* \param[in] op, the operation to be performed:
	* <tt>CIB_OP_{CREATE,DELETE,MODIFY,QUERY,REPLACE}</tt>
	* \param[in] options, ORed flags per relevant \c cib_call_options enumeration:
	* <tt>cib_{multiple,no_children,xpath_address}</tt>
	* \param[in] section, xpath defining place of interest in
	* <tt>{existing,result}_cib</tt>
	* \param[in] req, UNUSED
	* \param[in] input, the input operand for
	* <tt>CIB_OP_{CREATE,MODIFY,REPLACE}</tt>
	* \param[in] existing_cib, the input operand (CIB) for \c CIB_OP_QUERY
	* \param[inout] result_cib, the operand and result for
	* <tt>CIB_OP_{CREATE,DELETE,MODIFY,REPLACE}</tt>
	* \param[out] answer, the result for \c CIB_OP_QUERY, structured per \c options
	*
	* \retval \c pcmk_ok (0) for success, different value for failure
	*/
	int cib_process_xpath(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer);

	gboolean cib_config_changed(xmlNode * last, xmlNode * next, xmlNode ** diff);
	gboolean update_results(xmlNode * failed, xmlNode * target, const char *operation, int return_code);
	int cib_update_counter(xmlNode * xml_obj, const char *field, gboolean reset);

	int cib_internal_op(cib_t * cib, const char op, const char host,
	const char section, xmlNode data,
	xmlNode ** output_data, int call_options, const char *user_name);


	int cib_file_read_and_verify(const char filename, const char sigfile,
	xmlNode **root);
	int cib_file_write_with_digest(xmlNode cib_root, const char cib_dirname,
	const char *cib_filename);

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Sat, Jan 25, 11:21 AM (1 d, 11 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1322338
Default Alt Text: (59 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions