No OneTemporary
Actions

Size

40 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/cib/io.c b/cib/io.c
	index 71ddf3add8..401461f755 100644
	--- a/cib/io.c
	+++ b/cib/io.c
	@@ -1,777 +1,758 @@
	/*
	* 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/common/util.h>
	#include <crm/cluster.h>

	#define CIB_SERIES "cib"
	#define CIB_SERIES_MAX 100
	#define CIB_SERIES_BZIP FALSE /* Must be false due to the way archived
	* copies are created - ie. with calls to
	* link()
	*/

	extern const char *cib_root;

	#define CIB_WRITE_PARANOIA 0

	const char *local_resource_path[] = {
	XML_CIB_TAG_STATUS,
	};

	const char *resource_path[] = {
	XML_CIB_TAG_RESOURCES,
	};

	const char *node_path[] = {
	XML_CIB_TAG_NODES,
	};

	const char *constraint_path[] = {
	XML_CIB_TAG_CONSTRAINTS,
	};

	crm_trigger_t *cib_writer = NULL;
	gboolean initialized = FALSE;
	xmlNode *node_search = NULL;
	xmlNode *resource_search = NULL;
	xmlNode *constraint_search = NULL;
	xmlNode *status_search = NULL;

	extern int cib_status;

	int set_connected_peers(xmlNode * xml_obj);
	int write_cib_contents(gpointer p);
	extern void cib_cleanup(void);

	static gboolean
	validate_cib_digest(xmlNode * local_cib, const char *sigfile)
	{
	gboolean passed = FALSE;
	- char *digest = NULL;
	char *expected = crm_read_contents(sigfile);

	if (expected == NULL) {
	switch (errno) {
	case 0:
	crm_err("On-disk digest is empty");
	return FALSE;
	case ENOENT:
	crm_warn("No on-disk digest present");
	return TRUE;
	default:
	crm_perror(LOG_ERR, "Could not read on-disk digest from %s", sigfile);
	return FALSE;
	}
	}
	-
	- if (local_cib != NULL) {
	- digest = calculate_on_disk_digest(local_cib);
	- if (digest == NULL) {
	- crm_perror(LOG_ERR, "Could not calculate digest for comparison");
	- free(expected);
	- return FALSE;
	- }
	- }
	-
	- if (safe_str_eq(expected, digest)) {
	- crm_trace("Digest comparision passed: %s", digest);
	- passed = TRUE;
	- } else {
	- crm_err("Digest comparision failed: expected %s (%s), calculated %s",
	- expected, sigfile, digest);
	- }
	-
	- free(digest);
	+ passed = crm_digest_verify(local_cib, expected);
	free(expected);
	return passed;
	}

	static gboolean
	validate_on_disk_cib(const char filename, xmlNode * on_disk_cib)
	{
	int s_res = -1;
	struct stat buf;
	gboolean passed = TRUE;
	xmlNode *root = NULL;

	CRM_ASSERT(filename != NULL);

	s_res = stat(filename, &buf);
	if (s_res == 0) {
	char *sigfile = NULL;
	size_t fnsize;

	crm_trace("Reading cluster configuration from: %s", filename);
	root = filename2xml(filename);

	fnsize = strlen(filename) + 5;
	sigfile = calloc(1, fnsize);
	snprintf(sigfile, fnsize, "%s.sig", filename);
	if (validate_cib_digest(root, sigfile) == FALSE) {
	passed = FALSE;
	}
	free(sigfile);
	}

	if (on_disk_cib != NULL) {
	*on_disk_cib = root;
	} else {
	free_xml(root);
	}

	return passed;
	}

	static gboolean
	on_disk_cib_corrupt(const char *filename)
	{
	int s_res = -1;
	struct stat buf;
	gboolean corrupt = FALSE;

	CRM_ASSERT(filename != NULL);

	s_res = stat(filename, &buf);
	if (s_res == 0) {
	if (buf.st_size == 0) {
	crm_warn("Cluster configuration file %s is corrupt: size is zero", filename);
	corrupt = TRUE;
	}
	}

	return corrupt;
	}

	static int
	cib_rename(const char old, const char new)
	{
	int rc = 0;
	int automatic_fd = 0;
	char *automatic = NULL;

	if (new == NULL) {
	umask(S_IWGRP \| S_IWOTH \| S_IROTH);

	automatic = g_strdup_printf("%s/cib.auto.XXXXXX", cib_root);
	automatic_fd = mkstemp(automatic);
	new = automatic;

	crm_err("Archiving corrupt or unusable file %s as %s", old, automatic);
	}

	rc = rename(old, new);
	if (rc < 0) {
	crm_perror(LOG_ERR, "Couldn't rename %s as %s - Disabling disk writes and continuing", old,
	new);
	cib_writes_enabled = FALSE;
	}
	if (automatic_fd > 0) {
	close(automatic_fd);
	}
	free(automatic);
	return rc;
	}

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

	static xmlNode *
	retrieveCib(const char filename, const char sigfile, gboolean archive_invalid)
	{
	struct stat buf;
	xmlNode *root = NULL;

	crm_info("Reading cluster configuration from: %s (digest: %s)", filename, sigfile);

	if (stat(filename, &buf) != 0) {
	crm_warn("Cluster configuration not found: %s", filename);
	return NULL;
	}

	root = filename2xml(filename);
	if (root == NULL) {
	crm_err("%s exists but does NOT contain valid XML. ", filename);
	crm_warn("Continuing but %s will NOT used.", filename);

	} else if (validate_cib_digest(root, sigfile) == FALSE) {
	crm_err("Checksum of %s failed! Configuration contents ignored!", filename);
	crm_err("Usually this is caused by manual changes, "
	"please refer to http://clusterlabs.org/wiki/FAQ#cib_changes_detected");
	crm_warn("Continuing but %s will NOT used.", filename);
	free_xml(root);
	root = NULL;

	if (archive_invalid) {
	/* Archive the original files so the contents are not lost */
	cib_rename(filename, NULL);
	cib_rename(sigfile, NULL);
	}
	}
	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 = g_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(strstr(a->d_name, ".sig") != NULL) {
	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 = g_strdup_printf("%s/%s", cib_root, a[0]->d_name);
	char *b_path = g_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 (%u) vs. %s (%u) : %d", a[0]->d_name, a_age, b[0]->d_name, 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, TRUE);
	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 = g_strdup_printf("%s/%s", cib_root, namelist[lpc]->d_name);
	sigfile = crm_concat(filename, "sig", '.');

	root = retrieveCib(filename, sigfile, FALSE);
	if(root) {
	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("*********************************************************");
	crm_err("* Disabling disk writes to avoid confusing Valgrind *");
	crm_err("*********************************************************");
	}
	}

	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 DTD 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 reccomended 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 these and require the DC/CCM to update as needed */
	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 DTD or 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;
	node_search = NULL;
	resource_search = NULL;
	constraint_search = NULL;
	status_search = 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");
	}
	return -ENODATA;
	}

	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 pcmk_ok;
	}

	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;
	char *digest = NULL;
	xmlNode *cib_status_root = NULL;

	xmlNode *cib_local = NULL;
	xmlNode *cib_tmp = NULL;

	int tmp_cib_fd = 0;
	int tmp_digest_fd = 0;
	char *tmp_cib = NULL;
	char *tmp_digest = NULL;

	char *digest_file = NULL;
	char *primary_file = NULL;

	char *backup_file = NULL;
	char *backup_digest = NULL;

	const char *epoch = NULL;
	const char *admin_epoch = NULL;

	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);
	}

	epoch = crm_element_value(cib_local, XML_ATTR_GENERATION);
	admin_epoch = crm_element_value(cib_local, XML_ATTR_GENERATION_ADMIN);

	primary_file = crm_concat(cib_root, "cib.xml", '/');
	digest_file = crm_concat(primary_file, "sig", '.');

	/* Always write out with num_updates=0 */
	crm_xml_add(cib_local, XML_ATTR_NUMUPDATES, "0");

	/* check the admin didnt modify it underneath us */
	if (on_disk_cib_corrupt(primary_file) == FALSE
	&& validate_on_disk_cib(primary_file, NULL) == FALSE) {
	crm_err("%s was manually modified while the cluster was active!", primary_file);
	exit_rc = pcmk_err_cib_modified;
	goto cleanup;

	} else {
	int rc = 0;
	int seq = get_last_sequence(cib_root, CIB_SERIES);

	backup_file = generate_series_filename(cib_root, CIB_SERIES, seq, CIB_SERIES_BZIP);
	backup_digest = crm_concat(backup_file, "sig", '.');

	unlink(backup_file);
	unlink(backup_digest);

	rc = link(primary_file, backup_file);
	if (rc < 0) {
	rc = errno;
	switch(rc) {
	case ENOENT:
	/* No file to back up */
	goto writeout;
	break;
	default:
	exit_rc = pcmk_err_cib_backup;
	crm_err("Cannot link %s to %s: %s (%d)", primary_file, backup_file, pcmk_strerror(rc), rc);
	}
	goto cleanup;
	}

	rc = link(digest_file, backup_digest);
	if (rc < 0 && errno != ENOENT) {
	exit_rc = pcmk_err_cib_backup;
	crm_perror(LOG_ERR, "Cannot link %s to %s", digest_file, backup_digest);
	goto cleanup;
	}
	write_last_sequence(cib_root, CIB_SERIES, seq + 1, CIB_SERIES_MAX);
	crm_sync_directory(cib_root);

	crm_info("Archived previous version as %s", backup_file);
	}

	writeout:
	/* Given that we discard the status section on startup
	* there is no point writing it out in the first place
	* since users just get confused by it
	*
	* So delete the status section before we write it out
	*/
	crm_debug("Writing CIB to disk");
	if (p == NULL) {
	cib_status_root = find_xml_node(cib_local, XML_CIB_TAG_STATUS, TRUE);
	CRM_LOG_ASSERT(cib_status_root != NULL);

	if (cib_status_root != NULL) {
	free_xml(cib_status_root);
	}
	}

	tmp_cib = g_strdup_printf("%s/cib.XXXXXX", cib_root);
	tmp_digest = g_strdup_printf("%s/cib.XXXXXX", cib_root);

	umask(S_IWGRP \| S_IWOTH \| S_IROTH);

	tmp_cib_fd = mkstemp(tmp_cib);
	if (tmp_cib_fd < 0 \|\| write_xml_fd(cib_local, tmp_cib, tmp_cib_fd, FALSE) <= 0) {
	crm_err("Changes couldn't be written to %s", tmp_cib);
	exit_rc = pcmk_err_cib_save;
	goto cleanup;
	}

	/* Must calculate the digest after writing as write_xml_file() updates the last-written field */
	digest = calculate_on_disk_digest(cib_local);
	CRM_ASSERT(digest != NULL);
	crm_info("Wrote version %s.%s.0 of the CIB to disk (digest: %s)",
	admin_epoch ? admin_epoch : "0", epoch ? epoch : "0", digest);

	tmp_digest_fd = mkstemp(tmp_digest);
	if ((tmp_digest_fd < 0) \|\| (crm_write_sync(tmp_digest_fd, digest) < 0)) {
	crm_perror(LOG_ERR, "Could not write digest to file %s", tmp_digest);
	exit_rc = pcmk_err_cib_save;
	goto cleanup;
	}
	crm_debug("Wrote digest %s to disk", digest);
	cib_tmp = retrieveCib(tmp_cib, tmp_digest, FALSE);
	CRM_ASSERT(cib_tmp != NULL);
	crm_sync_directory(cib_root);

	crm_debug("Activating %s", tmp_cib);
	cib_rename(tmp_cib, primary_file);
	cib_rename(tmp_digest, digest_file);
	crm_sync_directory(cib_root);

	cleanup:
	free(backup_digest);
	free(primary_file);
	free(backup_file);
	free(digest_file);
	free(digest);
	free(tmp_digest);
	free(tmp_cib);

	free_xml(cib_tmp);
	free_xml(cib_local);

	if (p == NULL) {
	/* exit() could potentially affect the parent by closing things it shouldn't
	* Use _exit instead
	*/
	_exit(exit_rc);
	}
	return exit_rc;
	}
	diff --git a/include/crm_internal.h b/include/crm_internal.h
	index 9ef899e74b..5457ee77db 100644
	--- a/include/crm_internal.h
	+++ b/include/crm_internal.h
	@@ -1,353 +1,355 @@
	/* crm_internal.h */

	/*
	* Copyright (C) 2006 - 2008
	* 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 program 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
	*/

	#ifndef CRM_INTERNAL__H
	# define CRM_INTERNAL__H

	# include <config.h>
	# include <portability.h>

	# include <glib.h>
	# include <stdbool.h>
	# include <libxml/tree.h>

	# include <crm/lrmd.h>
	# include <crm/common/logging.h>
	# include <crm/common/io.h>
	# include <crm/common/ipcs.h>

	/* Dynamic loading of libraries */
	void find_library_function(void handle, const char lib, const char *fn, int fatal);
	void convert_const_pointer(const void ptr);

	/* For ACLs */
	char *uid2username(uid_t uid);
	void determine_request_user(const char user, xmlNode request, const char *field);
	const char crm_acl_get_set_user(xmlNode request, const char field, const char peer_user);

	# if ENABLE_ACL
	# include <string.h>
	static inline gboolean
	is_privileged(const char *user)
	{
	if (user == NULL) {
	return FALSE;
	} else if (strcmp(user, CRM_DAEMON_USER) == 0) {
	return TRUE;
	} else if (strcmp(user, "root") == 0) {
	return TRUE;
	}
	return FALSE;
	}
	# endif

	/* CLI option processing*/
	# ifdef HAVE_GETOPT_H
	# include <getopt.h>
	# else
	# define no_argument 0
	# define required_argument 1
	# endif

	# define pcmk_option_default 0x00000
	# define pcmk_option_hidden 0x00001
	# define pcmk_option_paragraph 0x00002
	# define pcmk_option_example 0x00004

	struct crm_option {
	/* Fields from 'struct option' in getopt.h */
	/* name of long option */
	const char *name;
	/*
	* one of no_argument, required_argument, and optional_argument:
	* whether option takes an argument
	*/
	int has_arg;
	/* if not NULL, set flag to val when option found /
	int *flag;
	/* if flag not NULL, value to set flag to; else return value /
	int val;

	/* Custom fields */
	const char *desc;
	long flags;
	};

	void crm_set_options(const char short_options, const char usage, struct crm_option *long_options,
	const char *app_desc);
	int crm_get_option(int argc, char *argv, int index);
	int crm_get_option_long(int argc, char *argv, int index, const char **longname);
	int crm_help(char cmd, int exit_code);

	/* Cluster Option Processing */
	typedef struct pe_cluster_option_s {
	const char *name;
	const char *alt_name;
	const char *type;
	const char *values;
	const char *default_value;

	gboolean(is_valid) (const char );

	const char *description_short;
	const char *description_long;

	} pe_cluster_option;

	const char cluster_option(GHashTable options, gboolean(validate) (const char ),
	const char name, const char old_name, const char *def_value);

	const char get_cluster_pref(GHashTable options, pe_cluster_option * option_list, int len,
	const char *name);

	void config_metadata(const char name, const char version, const char *desc_short,
	const char desc_long, pe_cluster_option option_list, int len);

	void verify_all_options(GHashTable * options, pe_cluster_option * option_list, int len);
	gboolean check_time(const char *value);
	gboolean check_timer(const char *value);
	gboolean check_boolean(const char *value);
	gboolean check_number(const char *value);
	gboolean check_quorum(const char *value);
	gboolean check_utilization(const char *value);

	/* Shared PE/crmd functionality */
	void filter_action_parameters(xmlNode * param_set, const char *version);
	void filter_reload_parameters(xmlNode * param_set, const char *restart_string);

	/* Resource operation updates */
	xmlNode create_operation_update(xmlNode parent, lrmd_event_data_t * event,
	const char caller_version, int target_rc, const char origin,
	int level);

	/* char2score */
	extern int node_score_red;
	extern int node_score_green;
	extern int node_score_yellow;
	extern int node_score_infinity;

	/* Assorted convenience functions */
	static inline int
	crm_strlen_zero(const char *s)
	{
	return !s \|\| *s == '\0';
	}

	char add_list_element(char list, const char *value);

	int crm_pid_active(long pid);
	void crm_make_daemon(const char name, gboolean daemonize, const char pidfile);

	char generate_op_key(const char rsc_id, const char *op_type, int interval);
	char generate_notify_key(const char rsc_id, const char notify_type, const char op_type);
	char generate_transition_magic_v202(const char transition_key, int op_status);
	char generate_transition_magic(const char transition_key, int op_status, int op_rc);
	char generate_transition_key(int action, int transition_id, int target_rc, const char node);

	static inline long long
	crm_clear_bit(const char function, const char target, long long word, long long bit)
	{
	long long rc = (word & ~bit);

	if (rc == word) {
	/* Unchanged */
	} else if (target) {
	crm_trace("Bit 0x%.8llx for %s cleared by %s", bit, target, function);
	} else {
	crm_trace("Bit 0x%.8llx cleared by %s", bit, function);
	}

	return rc;
	}

	static inline long long
	crm_set_bit(const char function, const char target, long long word, long long bit)
	{
	long long rc = (word \| bit);

	if (rc == word) {
	/* Unchanged */
	} else if (target) {
	crm_trace("Bit 0x%.8llx for %s set by %s", bit, target, function);
	} else {
	crm_trace("Bit 0x%.8llx set by %s", bit, function);
	}

	return rc;
	}

	# define set_bit(word, bit) word = crm_set_bit(__FUNCTION__, NULL, word, bit)
	# define clear_bit(word, bit) word = crm_clear_bit(__FUNCTION__, NULL, word, bit)

	void g_hash_destroy_str(gpointer data);

	long long crm_int_helper(const char text, char *end_text);
	char crm_concat(const char prefix, const char *suffix, char join);
	char generate_hash_key(const char crm_msg_reference, const char *sys);

	bool crm_compress_string(const char data, int length, int max, char *result,
	unsigned int *result_len);

	/! remote tcp/tls helper functions /
	typedef struct crm_remote_s crm_remote_t;

	int crm_remote_send(crm_remote_t * remote, xmlNode * msg);
	int crm_remote_ready(crm_remote_t * remote, int total_timeout /ms / );
	gboolean crm_remote_recv(crm_remote_t * remote, int total_timeout /ms / , int *disconnected);
	xmlNode crm_remote_parse_buffer(crm_remote_t remote);
	int crm_remote_tcp_connect(const char *host, int port);
	int crm_remote_tcp_connect_async(const char host, int port, int timeout, /ms */
	int timer_id, void userdata, void (callback) (void userdata, int sock));

	# ifdef HAVE_GNUTLS_GNUTLS_H
	/*!
	* \internal
	* \brief Initiate the client handshake after establishing the tcp socket.
	* \note This is a blocking function, it will block until the entire handshake
	* is complete or until the timeout period is reached.
	* \retval 0 success
	* \retval negative, failure
	*/
	int crm_initiate_client_tls_handshake(crm_remote_t * remote, int timeout_ms);

	/*!
	* \internal
	* \brief Create client or server session for anon DH encryption credentials
	* \param sock, the socket the session will use for transport
	* \param type, GNUTLS_SERVER or GNUTLS_CLIENT
	* \param credentials, gnutls_anon_server_credentials_t or gnutls_anon_client_credentials_t
	*
	* \retval gnutls_session_t * on success
	* \retval NULL on failure
	*/
	void crm_create_anon_tls_session(int sock, int type, void credentials);

	/*!
	* \internal
	* \brief Create client or server session for PSK credentials
	* \param sock, the socket the session will use for transport
	* \param type, GNUTLS_SERVER or GNUTLS_CLIENT
	* \param credentials, gnutls_psk_server_credentials_t or gnutls_osk_client_credentials_t
	*
	* \retval gnutls_session_t * on success
	* \retval NULL on failure
	*/
	void create_psk_tls_session(int csock, int type, void credentials);
	# endif

	# define REMOTE_MSG_TERMINATOR "\r\n\r\n"

	const char daemon_option(const char option);
	void set_daemon_option(const char option, const char value);
	gboolean daemon_option_enabled(const char daemon, const char option);
	void strip_text_nodes(xmlNode * xml);
	void pcmk_panic(const char *origin);
	void sysrq_init(void);
	pid_t pcmk_locate_sbd(void);
	int crm_pidfile_inuse(const char *filename, long mypid);
	int crm_read_pidfile(const char *filename);

	# define crm_config_err(fmt...) { crm_config_error = TRUE; crm_err(fmt); }
	# define crm_config_warn(fmt...) { crm_config_warning = TRUE; crm_warn(fmt); }

	# define attrd_channel T_ATTRD
	# define F_ATTRD_KEY "attr_key"
	# define F_ATTRD_ATTRIBUTE "attr_name"
	# define F_ATTRD_REGEX "attr_regex"
	# define F_ATTRD_TASK "task"
	# define F_ATTRD_VALUE "attr_value"
	# define F_ATTRD_SET "attr_set"
	# define F_ATTRD_IS_REMOTE "attr_is_remote"
	# define F_ATTRD_SECTION "attr_section"
	# define F_ATTRD_DAMPEN "attr_dampening"
	# define F_ATTRD_IGNORE_LOCALLY "attr_ignore_locally"
	# define F_ATTRD_HOST "attr_host"
	# define F_ATTRD_HOST_ID "attr_host_id"
	# define F_ATTRD_USER "attr_user"
	# define F_ATTRD_WRITER "attr_writer"
	# define F_ATTRD_VERSION "attr_version"

	# if SUPPORT_COROSYNC
	# if CS_USES_LIBQB
	# include <qb/qbipc_common.h>
	# include <corosync/corotypes.h>
	typedef struct qb_ipc_request_header cs_ipc_header_request_t;
	typedef struct qb_ipc_response_header cs_ipc_header_response_t;
	# else
	# include <corosync/corodefs.h>
	# include <corosync/coroipcc.h>
	# include <corosync/coroipc_types.h>
	static inline int
	qb_to_cs_error(int a)
	{
	return a;
	}

	typedef coroipc_request_header_t cs_ipc_header_request_t;
	typedef coroipc_response_header_t cs_ipc_header_response_t;
	# endif
	# else
	typedef struct {
	int size __attribute__ ((aligned(8)));
	int id __attribute__ ((aligned(8)));
	} __attribute__ ((aligned(8))) cs_ipc_header_request_t;

	typedef struct {
	int size __attribute__ ((aligned(8)));
	int id __attribute__ ((aligned(8)));
	int error __attribute__ ((aligned(8)));
	} __attribute__ ((aligned(8))) cs_ipc_header_response_t;

	# endif

	void
	attrd_ipc_server_init(qb_ipcs_service_t *ipcs, struct qb_ipcs_service_handlers cb);
	void
	stonith_ipc_server_init(qb_ipcs_service_t *ipcs, struct qb_ipcs_service_handlers cb);

	qb_ipcs_service_t *
	crmd_ipc_server_init(struct qb_ipcs_service_handlers *cb);

	void cib_ipc_servers_init(qb_ipcs_service_t **ipcs_ro,
	qb_ipcs_service_t **ipcs_rw,
	qb_ipcs_service_t **ipcs_shm,
	struct qb_ipcs_service_handlers *ro_cb,
	struct qb_ipcs_service_handlers *rw_cb);

	void cib_ipc_servers_destroy(qb_ipcs_service_t *ipcs_ro,
	qb_ipcs_service_t *ipcs_rw,
	qb_ipcs_service_t *ipcs_shm);

	static inline void realloc_safe(void ptr, size_t size)
	{
	void *ret = realloc(ptr, size);

	if(ret == NULL) {
	abort();
	}

	return ret;
	}

	void crm_xml_dump(xmlNode * data, int options, char *buffer, int offset, int *max, int depth);
	void crm_buffer_add_char(char *buffer, int offset, int *max, char c);

	+gboolean crm_digest_verify(xmlNode input, const char expected);
	+
	#endif /* CRM_INTERNAL__H */
	diff --git a/lib/common/digest.c b/lib/common/digest.c
	index ebd5259092..b8494e9d77 100644
	--- a/lib/common/digest.c
	+++ b/lib/common/digest.c
	@@ -1,161 +1,185 @@
	/*
	* Copyright (C) 2015 Andrew Beekhof <andrew@beekhof.net>
	*
	* 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., 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 <crm/crm.h>
	#include <crm/msg_xml.h>
	#include <crm/common/xml.h>

	#define BEST_EFFORT_STATUS 0

	static char *
	dump_xml_for_digest(xmlNode * an_xml_node)
	{
	char *buffer = NULL;
	int offset = 0, max = 0;

	/* for compatability with the old result which is used for v1 digests */
	crm_buffer_add_char(&buffer, &offset, &max, ' ');
	crm_xml_dump(an_xml_node, 0, &buffer, &offset, &max, 0);
	crm_buffer_add_char(&buffer, &offset, &max, '\n');

	return buffer;
	}

	/* "c048eae664dba840e1d2060f00299e9d" */
	static char *
	calculate_xml_digest_v1(xmlNode * input, gboolean sort, gboolean ignored)
	{
	char *digest = NULL;
	char *buffer = NULL;
	xmlNode *copy = NULL;

	if (sort) {
	crm_trace("Sorting xml...");
	copy = sorted_xml(input, NULL, TRUE);
	crm_trace("Done");
	input = copy;
	}

	buffer = dump_xml_for_digest(input);
	CRM_CHECK(buffer != NULL && strlen(buffer) > 0, free_xml(copy);
	free(buffer);
	return NULL);

	digest = crm_md5sum(buffer);
	crm_log_xml_trace(input, "digest:source");

	free(buffer);
	free_xml(copy);
	return digest;
	}

	static char *
	calculate_xml_digest_v2(xmlNode * source, gboolean do_filter)
	{
	char *digest = NULL;
	char *buffer = NULL;
	int offset, max;

	static struct qb_log_callsite *digest_cs = NULL;

	crm_trace("Begin digest %s", do_filter?"filtered":"");
	if (do_filter && BEST_EFFORT_STATUS) {
	/* Exclude the status calculation from the digest
	*
	* This doesn't mean it wont be sync'd, we just wont be paranoid
	* about it being an _exact_ copy
	*
	* We don't need it to be exact, since we throw it away and regenerate
	* from our peers whenever a new DC is elected anyway
	*
	* Importantly, this reduces the amount of XML to copy+export as
	* well as the amount of data for MD5 needs to operate on
	*/

	} else {
	crm_xml_dump(source, do_filter ? xml_log_option_filtered : 0, &buffer, &offset, &max, 0);
	}

	CRM_ASSERT(buffer != NULL);
	digest = crm_md5sum(buffer);

	if (digest_cs == NULL) {
	digest_cs = qb_log_callsite_get(__func__, __FILE__, "cib-digest", LOG_TRACE, __LINE__,
	crm_trace_nonlog);
	}
	if (digest_cs && digest_cs->targets) {
	char *trace_file = crm_concat("/tmp/digest", digest, '-');

	crm_trace("Saving %s.%s.%s to %s",
	crm_element_value(source, XML_ATTR_GENERATION_ADMIN),
	crm_element_value(source, XML_ATTR_GENERATION),
	crm_element_value(source, XML_ATTR_NUMUPDATES), trace_file);
	save_xml_to_file(source, "digest input", trace_file);
	free(trace_file);
	}

	free(buffer);
	crm_trace("End digest");
	return digest;
	}

	char *
	calculate_on_disk_digest(xmlNode * input)
	{
	/* Always use the v1 format for on-disk digests
	* a) its a compatability nightmare
	* b) we only use this once at startup, all other
	* invocations are in a separate child process
	*/
	return calculate_xml_digest_v1(input, FALSE, FALSE);
	}

	char *
	calculate_operation_digest(xmlNode * input, const char *version)
	{
	/* We still need the sorting for parameter digests */
	return calculate_xml_digest_v1(input, TRUE, FALSE);
	}

	char *
	calculate_xml_versioned_digest(xmlNode * input, gboolean sort, gboolean do_filter,
	const char *version)
	{
	/*
	* The sorting associated with v1 digest creation accounted for 23% of
	* the CIB's CPU usage on the server. v2 drops this.
	*
	* The filtering accounts for an additional 2.5% and we may want to
	* remove it in future.
	*
	* v2 also uses the xmlBuffer contents directly to avoid additional copying
	*/
	if (version == NULL \|\| compare_version("3.0.5", version) > 0) {
	crm_trace("Using v1 digest algorithm for %s", crm_str(version));
	return calculate_xml_digest_v1(input, sort, do_filter);
	}
	crm_trace("Using v2 digest algorithm for %s", crm_str(version));
	return calculate_xml_digest_v2(input, do_filter);
	}
	+
	+gboolean
	+crm_digest_verify(xmlNode input, const char expected)
	+{
	+ char *calculated = NULL;
	+ gboolean passed;
	+
	+ if (input != NULL) {
	+ calculated = calculate_on_disk_digest(input);
	+ if (calculated == NULL) {
	+ crm_perror(LOG_ERR, "Could not calculate digest for comparison");
	+ return FALSE;
	+ }
	+ }
	+ passed = safe_str_eq(expected, calculated);
	+ if (passed) {
	+ crm_trace("Digest comparison passed: %s", calculated);
	+ } else {
	+ crm_err("Digest comparison failed: expected %s, calculated %s",
	+ expected, calculated);
	+ }
	+ free(calculated);
	+ return passed;
	+}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jul 8, 6:44 PM (2 h, 24 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2002788
Default Alt Text: (40 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions