No OneTemporary
Actions

Size

52 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/common/logging.c b/lib/common/logging.c
	index 3867a4eae3..ecdc353b3c 100644
	--- a/lib/common/logging.c
	+++ b/lib/common/logging.c
	@@ -1,967 +1,970 @@
	/*
	* Copyright (C) 2004 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 <sys/param.h>
	#include <sys/types.h>
	#include <sys/wait.h>
	#include <sys/stat.h>
	#include <sys/utsname.h>

	#include <stdio.h>
	#include <unistd.h>
	#include <string.h>
	#include <stdlib.h>
	#include <limits.h>
	#include <ctype.h>
	#include <pwd.h>
	#include <grp.h>
	#include <time.h>
	#include <libgen.h>
	#include <signal.h>
	#include <bzlib.h>

	#include <qb/qbdefs.h>

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

	unsigned int crm_log_priority = LOG_NOTICE;
	unsigned int crm_log_level = LOG_INFO;
	static gboolean crm_tracing_enabled(void);
	unsigned int crm_trace_nonlog = 0;

	#ifdef HAVE_G_LOG_SET_DEFAULT_HANDLER
	GLogFunc glib_log_default;

	static void
	crm_glib_handler(const gchar * log_domain, GLogLevelFlags flags, const gchar * message,
	gpointer user_data)
	{
	int log_level = LOG_WARNING;
	GLogLevelFlags msg_level = (flags & G_LOG_LEVEL_MASK);

	switch (msg_level) {
	case G_LOG_LEVEL_CRITICAL:
	/* log and record how we got here */
	crm_abort(__FILE__, __PRETTY_FUNCTION__, __LINE__, message, TRUE, TRUE);
	return;

	case G_LOG_LEVEL_ERROR:
	log_level = LOG_ERR;
	break;
	case G_LOG_LEVEL_MESSAGE:
	log_level = LOG_NOTICE;
	break;
	case G_LOG_LEVEL_INFO:
	log_level = LOG_INFO;
	break;
	case G_LOG_LEVEL_DEBUG:
	log_level = LOG_DEBUG;
	break;

	case G_LOG_LEVEL_WARNING:
	case G_LOG_FLAG_RECURSION:
	case G_LOG_FLAG_FATAL:
	case G_LOG_LEVEL_MASK:
	log_level = LOG_WARNING;
	break;
	}

	do_crm_log(log_level, "%s: %s", log_domain, message);
	}
	#endif

	#ifndef NAME_MAX
	# define NAME_MAX 256
	#endif

	static void
	crm_trigger_blackbox(int nsig)
	{
	crm_write_blackbox(nsig, NULL);
	}

	const char *
	daemon_option(const char *option)
	{
	char env_name[NAME_MAX];
	const char *value = NULL;

	snprintf(env_name, NAME_MAX, "PCMK_%s", option);
	value = getenv(env_name);
	if (value != NULL) {
	crm_trace("Found %s = %s", env_name, value);
	return value;
	}

	snprintf(env_name, NAME_MAX, "HA_%s", option);
	value = getenv(env_name);
	if (value != NULL) {
	crm_trace("Found %s = %s", env_name, value);
	return value;
	}

	crm_trace("Nothing found for %s", option);
	return NULL;
	}

	void
	set_daemon_option(const char option, const char value)
	{
	char env_name[NAME_MAX];

	snprintf(env_name, NAME_MAX, "PCMK_%s", option);
	if (value) {
	crm_trace("Setting %s to %s", env_name, value);
	setenv(env_name, value, 1);
	} else {
	crm_trace("Unsetting %s", env_name);
	unsetenv(env_name);
	}

	snprintf(env_name, NAME_MAX, "HA_%s", option);
	if (value) {
	crm_trace("Setting %s to %s", env_name, value);
	setenv(env_name, value, 1);
	} else {
	crm_trace("Unsetting %s", env_name);
	unsetenv(env_name);
	}
	}

	gboolean
	daemon_option_enabled(const char daemon, const char option)
	{
	const char *value = daemon_option(option);

	if (value != NULL && crm_is_true(value)) {
	return TRUE;

	} else if (value != NULL && strstr(value, daemon)) {
	return TRUE;
	}

	return FALSE;
	}

	void
	crm_log_deinit(void)
	{
	#ifdef HAVE_G_LOG_SET_DEFAULT_HANDLER
	g_log_set_default_handler(glib_log_default, NULL);
	#endif
	}

	#define FMT_MAX 256
	static void
	set_format_string(int method, const char *daemon)
	{
	int offset = 0;
	char fmt[FMT_MAX];

	if (method > QB_LOG_STDERR) {
	/* When logging to a file */
	struct utsname res;

	if (uname(&res) == 0) {
	offset +=
	snprintf(fmt + offset, FMT_MAX - offset, "%%t [%d] %s %10s: ", getpid(),
	res.nodename, daemon);
	} else {
	offset += snprintf(fmt + offset, FMT_MAX - offset, "%%t [%d] %10s: ", getpid(), daemon);
	}
	}

	if (crm_tracing_enabled() && method >= QB_LOG_STDERR) {
	offset += snprintf(fmt + offset, FMT_MAX - offset, "(%%-12f:%%5l %%g) %%-7p: %%n: ");
	} else {
	offset += snprintf(fmt + offset, FMT_MAX - offset, "%%g %%-7p: %%n: ");
	}

	if (method == QB_LOG_SYSLOG) {
	offset += snprintf(fmt + offset, FMT_MAX - offset, "%%b");
	} else {
	offset += snprintf(fmt + offset, FMT_MAX - offset, "\t%%b");
	}
	qb_log_format_set(method, fmt);
	}

	gboolean
	crm_add_logfile(const char *filename)
	{
	struct stat parent;
	int fd = 0, rc = 0;
	FILE *logfile = NULL;
	char *parent_dir = NULL;
	char *filename_cp;

	static gboolean have_logfile = FALSE;

	if (filename == NULL && have_logfile == FALSE) {
	filename = "/var/log/pacemaker.log";
	}

	if (filename == NULL) {
	return FALSE; /* Nothing to do */
	}

	/* Check the parent directory */
	filename_cp = strdup(filename);
	parent_dir = dirname(filename_cp);
	rc = stat(parent_dir, &parent);

	if (rc != 0) {
	crm_err("Directory '%s' does not exist: logging to '%s' is disabled", parent_dir, filename);
	free(filename_cp);
	return FALSE;
	}
	free(filename_cp);

	errno = 0;
	logfile = fopen(filename, "a");
	if(logfile == NULL) {
	crm_err("%s (%d): Logging to '%s' as uid=%u, gid=%u is disabled",
	pcmk_strerror(errno), errno, filename, geteuid(), getegid());
	return FALSE;
	}

	/* Check/Set permissions if we're root */
	if (geteuid() == 0) {
	struct stat st;
	uid_t pcmk_uid = 0;
	gid_t pcmk_gid = 0;
	gboolean fix = FALSE;
	int logfd = fileno(logfile);

	rc = fstat(logfd, &st);
	if (rc < 0) {
	crm_perror(LOG_WARNING, "Cannot stat %s", filename);
	fclose(logfile);
	return FALSE;
	}

	if(crm_user_lookup(CRM_DAEMON_USER, &pcmk_uid, &pcmk_gid) == 0) {
	if (st.st_gid != pcmk_gid) {
	/* Wrong group */
	fix = TRUE;
	} else if ((st.st_mode & S_IRWXG) != (S_IRGRP \| S_IWGRP)) {
	/* Not read/writable by the correct group */
	fix = TRUE;
	}
	}

	if (fix) {
	rc = fchown(logfd, pcmk_uid, pcmk_gid);
	if (rc < 0) {
	crm_warn("Cannot change the ownership of %s to user %s and gid %d",
	filename, CRM_DAEMON_USER, pcmk_gid);
	}

	rc = fchmod(logfd, S_IRUSR \| S_IWUSR \| S_IRGRP \| S_IWGRP);
	if (rc < 0) {
	crm_warn("Cannot change the mode of %s to rw-rw----", filename);
	}

	fprintf(logfile, "Set r/w permissions for uid=%d, gid=%d on %s\n",
	pcmk_uid, pcmk_gid, filename);
	if (fflush(logfile) < 0 \|\| fsync(logfd) < 0) {
	crm_err("Couldn't write out logfile: %s", filename);
	}
	}
	}

	/* Close and reopen with libqb */
	fclose(logfile);
	fd = qb_log_file_open(filename);

	if (fd < 0) {
	crm_perror(LOG_WARNING, "Couldn't send additional logging to %s", filename);
	return FALSE;
	}

	crm_notice("Additional logging available in %s", filename);
	qb_log_ctl(fd, QB_LOG_CONF_ENABLED, QB_TRUE);

	/* Enable callsites */
	crm_update_callsites();
	have_logfile = TRUE;
	return TRUE;
	}

	static int blackbox_trigger = 0;
	static char *blackbox_file_prefix = NULL;

	static void
	blackbox_logger(int32_t t, struct qb_log_callsite cs, time_t timestamp, const char msg)
	{
	if(cs && cs->priority < LOG_ERR) {
	crm_write_blackbox(SIGABRT, cs); /* Bypass the over-dumping logic */
	} else {
	crm_write_blackbox(0, cs);
	}
	}

	void
	crm_enable_blackbox(int nsig)
	{
	if (blackbox_file_prefix == NULL) {
	pid_t pid = getpid();

	blackbox_file_prefix = malloc(NAME_MAX);
	snprintf(blackbox_file_prefix, NAME_MAX, "%s/%s-%d", CRM_BLACKBOX_DIR, crm_system_name,
	pid);
	}

	if (qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
	qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_SIZE, 5 * 1024 * 1024); /* Any size change drops existing entries */
	qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_TRUE); /* Setting the size seems to disable it */

	crm_notice("Initiated blackbox recorder: %s", blackbox_file_prefix);
	crm_signal(SIGSEGV, crm_trigger_blackbox);
	crm_update_callsites();

	/* Original meanings from signal(7)
	*
	* Signal Value Action Comment
	* SIGTRAP 5 Core Trace/breakpoint trap
	*
	* Our usage is as similar as possible
	*/
	mainloop_add_signal(SIGTRAP, crm_trigger_blackbox);

	blackbox_trigger = qb_log_custom_open(blackbox_logger, NULL, NULL, NULL);
	qb_log_ctl(blackbox_trigger, QB_LOG_CONF_ENABLED, QB_TRUE);
	crm_info("Trigger: %d is %d %d", blackbox_trigger,
	qb_log_ctl(blackbox_trigger, QB_LOG_CONF_STATE_GET, 0), QB_LOG_STATE_ENABLED);

	crm_update_callsites();
	}
	}

	void
	crm_write_blackbox(int nsig, struct qb_log_callsite *cs)
	{
	static int counter = 1;
	static time_t last = 0;

	char buffer[NAME_MAX];
	time_t now = time(NULL);

	if (blackbox_file_prefix == NULL) {
	return;
	}

	switch (nsig) {
	case 0:
	case SIGABRT:
	case SIGTRAP:
	/* The graceful case - such as assertion failure or user request */

	if (nsig == 0 && now == last) {
	/* Prevent over-dumping */
	return;
	}

	snprintf(buffer, NAME_MAX, "%s.%d", blackbox_file_prefix, counter++);
	if (nsig == SIGTRAP) {
	crm_notice("Blackbox dump requested, please see %s for contents", buffer);

	} else if (cs) {
	syslog(LOG_NOTICE,
	"Problem detected at %s:%d (%s), please see %s for additional details",
	cs->function, cs->lineno, cs->filename, buffer);
	} else {
	crm_notice("Problem detected, please see %s for additional details", buffer);
	}

	last = now;
	qb_log_blackbox_write_to_file(buffer);

	/* Flush the existing contents
	* A size change would also work
	*/
	qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
	qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_TRUE);
	break;

	default:
	/* Do as little as possible, just try to get what we have out
	* We logged the filename when the blackbox was enabled
	*/
	crm_signal(nsig, SIG_DFL);
	qb_log_blackbox_write_to_file(blackbox_file_prefix);
	qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
	raise(nsig);
	break;
	}
	}

	gboolean
	crm_log_cli_init(const char *entity)
	{
	return crm_log_init(entity, LOG_ERR, FALSE, FALSE, 0, NULL, TRUE);
	}

	static const char *
	crm_quark_to_string(uint32_t tag)
	{
	const char *text = g_quark_to_string(tag);

	if (text) {
	return text;
	}
	return "";
	}

	static void
	crm_log_filter_source(int source, const char trace_files, const char trace_fns,
	const char trace_fmts, const char trace_tags, const char *trace_blackbox,
	struct qb_log_callsite *cs)
	{
	if (qb_log_ctl(source, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
	return;
	} else if (cs->tags != crm_trace_nonlog && source == QB_LOG_BLACKBOX) {
	/* Blackbox gets everything if enabled */
	qb_bit_set(cs->targets, source);

	} else if (source == blackbox_trigger && blackbox_trigger > 0) {
	/* Should this log message result in the blackbox being dumped */
	if (cs->priority <= LOG_ERR) {
	qb_bit_set(cs->targets, source);

	} else if (trace_blackbox) {
	char *key = g_strdup_printf("%s:%d", cs->function, cs->lineno);

	if (strstr(trace_blackbox, key) != NULL) {
	qb_bit_set(cs->targets, source);
	}
	free(key);
	}

	} else if (source == QB_LOG_SYSLOG) { /* No tracing to syslog */
	if (cs->priority <= crm_log_priority && cs->priority <= crm_log_level) {
	qb_bit_set(cs->targets, source);
	}
	/* Log file tracing options... */
	} else if (cs->priority <= crm_log_level) {
	qb_bit_set(cs->targets, source);
	} else if (trace_files && strstr(trace_files, cs->filename) != NULL) {
	qb_bit_set(cs->targets, source);
	} else if (trace_fns && strstr(trace_fns, cs->function) != NULL) {
	qb_bit_set(cs->targets, source);
	} else if (trace_fmts && strstr(trace_fmts, cs->format) != NULL) {
	qb_bit_set(cs->targets, source);
	} else if (trace_tags
	&& cs->tags != 0
	&& cs->tags != crm_trace_nonlog && g_quark_to_string(cs->tags) != NULL) {
	qb_bit_set(cs->targets, source);
	}
	}

	static void
	crm_log_filter(struct qb_log_callsite *cs)
	{
	int lpc = 0;
	static int need_init = 1;
	static const char *trace_fns = NULL;
	static const char *trace_tags = NULL;
	static const char *trace_fmts = NULL;
	static const char *trace_files = NULL;
	static const char *trace_blackbox = NULL;

	if (need_init) {
	need_init = 0;
	trace_fns = getenv("PCMK_trace_functions");
	trace_fmts = getenv("PCMK_trace_formats");
	trace_tags = getenv("PCMK_trace_tags");
	trace_files = getenv("PCMK_trace_files");
	trace_blackbox = getenv("PCMK_trace_blackbox");

	if (trace_tags != NULL) {
	uint32_t tag;
	char token[500];
	const char *offset = NULL;
	const char *next = trace_tags;

	do {
	offset = next;
	next = strchrnul(offset, ',');
	snprintf(token, 499, "%.*s", (int)(next - offset), offset);

	tag = g_quark_from_string(token);
	crm_info("Created GQuark %u from token '%s' in '%s'", tag, token, trace_tags);

	if (next[0] != 0) {
	next++;
	}

	} while (next != NULL && next[0] != 0);
	}
	}

	cs->targets = 0; /* Reset then find targets to enable */
	for (lpc = QB_LOG_SYSLOG; lpc < QB_LOG_TARGET_MAX; lpc++) {
	crm_log_filter_source(lpc, trace_files, trace_fns, trace_fmts, trace_tags, trace_blackbox,
	cs);
	}
	}

	gboolean
	crm_is_callsite_active(struct qb_log_callsite *cs, int level, int tags)
	{
	gboolean refilter = FALSE;

	if (cs == NULL) {
	return FALSE;
	}

	if (cs->priority != level) {
	cs->priority = level;
	refilter = TRUE;
	}

	if (cs->tags != tags) {
	cs->tags = tags;
	refilter = TRUE;
	}

	if (refilter) {
	crm_log_filter(cs);
	}

	if (cs->targets == 0) {
	return FALSE;
	}
	return TRUE;
	}

	void
	crm_update_callsites(void)
	{
	static gboolean log = TRUE;

	if (log) {
	log = FALSE;
	crm_debug
	("Enabling callsites based on priority=%d, files=%s, functions=%s, formats=%s, tags=%s",
	crm_log_level, getenv("PCMK_trace_files"), getenv("PCMK_trace_functions"),
	getenv("PCMK_trace_formats"), getenv("PCMK_trace_tags"));
	}
	qb_log_filter_fn_set(crm_log_filter);
	}

	static gboolean
	crm_tracing_enabled(void)
	{
	if (crm_log_level >= LOG_TRACE) {
	return TRUE;
	} else if (getenv("PCMK_trace_files") \|\| getenv("PCMK_trace_functions")
	\|\| getenv("PCMK_trace_formats") \|\| getenv("PCMK_trace_tags")) {
	return TRUE;
	}
	return FALSE;
	}

	static int
	crm_priority2int(const char *name)
	{
	struct syslog_names {
	const char *name;
	int priority;
	};
	static struct syslog_names p_names[] = {
	{"emerg", LOG_EMERG},
	{"alert", LOG_ALERT},
	{"crit", LOG_CRIT},
	{"error", LOG_ERR},
	{"warning", LOG_WARNING},
	{"notice", LOG_NOTICE},
	{"info", LOG_INFO},
	{"debug", LOG_DEBUG},
	{NULL, -1}
	};
	int lpc;

	for (lpc = 0; name != NULL && p_names[lpc].name != NULL; lpc++) {
	if (crm_str_eq(p_names[lpc].name, name, TRUE)) {
	return p_names[lpc].priority;
	}
	}
	return crm_log_priority;
	}

	gboolean
	crm_log_init(const char *entity, int level, gboolean daemon, gboolean to_stderr,
	int argc, char **argv, gboolean quiet)
	{
	int lpc = 0;
	const char *logfile = daemon_option("debugfile");
	const char *facility = daemon_option("logfacility");
	const char *f_copy = facility;

	if (crm_trace_nonlog == 0) {
	crm_trace_nonlog = g_quark_from_static_string("Pacemaker non-logging tracepoint");
	}

	umask(S_IWGRP \| S_IWOTH \| S_IROTH);

	/* Redirect messages from glib functions to our handler */
	#ifdef HAVE_G_LOG_SET_DEFAULT_HANDLER
	glib_log_default = g_log_set_default_handler(crm_glib_handler, NULL);
	#endif

	/* and for good measure... - this enum is a bit field (!) */
	g_log_set_always_fatal((GLogLevelFlags) 0); /value out of range /

	if (facility == NULL) {
	facility = "daemon";

	} else if (safe_str_eq(facility, "none")) {
	facility = "daemon";
	quiet = TRUE;
	}

	if (entity) {
	+ free(crm_system_name);
	crm_system_name = strdup(entity);

	} else if (argc > 0 && argv != NULL) {
	char *mutable = strdup(argv[0]);
	char *modified = basename(mutable);

	if (strstr(modified, "lt-") == crm_system_name) {
	modified += 3;
	}
	+
	+ free(crm_system_name);
	crm_system_name = strdup(modified);
	free(mutable);

	} else if (crm_system_name == NULL) {
	crm_system_name = strdup("Unknown");
	}

	setenv("PCMK_service", crm_system_name, 1);

	if (daemon_option_enabled(crm_system_name, "debug")) {
	/* Override the default setting */
	level = LOG_DEBUG;
	}

	if (daemon_option_enabled(crm_system_name, "stderr")) {
	/* Override the default setting */
	to_stderr = TRUE;
	}

	crm_log_priority = crm_priority2int(daemon_option("logpriority"));

	crm_log_level = level;
	qb_log_init(crm_system_name, qb_log_facility2int(facility), level);
	qb_log_tags_stringify_fn_set(crm_quark_to_string);

	/* Set default format strings */
	for (lpc = QB_LOG_SYSLOG; lpc < QB_LOG_TARGET_MAX; lpc++) {
	set_format_string(lpc, crm_system_name);
	}

	crm_enable_stderr(to_stderr);

	if (logfile) {
	crm_add_logfile(logfile);
	}

	if (daemon_option_enabled(crm_system_name, "blackbox")) {
	crm_enable_blackbox(0);
	}

	crm_trace("Quiet: %d, facility %s", quiet, f_copy);
	daemon_option("debugfile");
	daemon_option("logfacility");

	if (quiet) {
	/* Nuke any syslog activity */
	facility = NULL;
	qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_FALSE);
	}

	if (daemon) {
	set_daemon_option("logfacility", facility);
	}

	if (daemon && crm_tracing_enabled()
	&& qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED
	&& qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
	/* Make sure tracing goes somewhere */
	crm_add_logfile(NULL);
	}

	crm_update_callsites();

	/* Ok, now we can start logging... */
	if (quiet == FALSE && daemon == FALSE) {
	crm_log_args(argc, argv);
	}

	if (daemon) {
	const char *user = getenv("USER");

	if (user != NULL && safe_str_neq(user, "root") && safe_str_neq(user, CRM_DAEMON_USER)) {
	crm_trace("Not switching to corefile directory for %s", user);
	daemon = FALSE;
	}
	}

	if (daemon) {
	int user = getuid();
	const char *base = CRM_CORE_DIR;
	struct passwd *pwent = getpwuid(user);

	if (pwent == NULL) {
	crm_perror(LOG_ERR, "Cannot get name for uid: %d", user);

	} else if (safe_str_neq(pwent->pw_name, "root")
	&& safe_str_neq(pwent->pw_name, CRM_DAEMON_USER)) {
	crm_trace("Don't change active directory for regular user: %s", pwent->pw_name);

	} else if (chdir(base) < 0) {
	crm_perror(LOG_INFO, "Cannot change active directory to %s", base);

	} else {
	crm_info("Changed active directory to %s/%s", base, pwent->pw_name);
	#if 0
	{
	char path[512];

	snprintf(path, 512, "%s-%d", crm_system_name, getpid());
	mkdir(path, 0750);
	chdir(path);
	crm_info("Changed active directory to %s/%s/%s", base, pwent->pw_name, path);
	}
	#endif
	}
	mainloop_add_signal(SIGUSR1, crm_enable_blackbox);
	}

	crm_xml_init(); /* Sets buffer allocation strategy */
	return TRUE;
	}

	/* returns the old value */
	unsigned int
	set_crm_log_level(unsigned int level)
	{
	unsigned int old = crm_log_level;

	crm_log_level = level;
	crm_update_callsites();
	crm_trace("New log level: %d", level);
	return old;
	}

	void
	crm_enable_stderr(int enable)
	{
	if (enable && qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
	qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_TRUE);
	crm_update_callsites();

	} else if (enable == FALSE) {
	qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_FALSE);
	}
	}

	void
	crm_bump_log_level(int argc, char **argv)
	{
	static int args = TRUE;
	int level = crm_log_level;

	if (args && argc > 1) {
	crm_log_args(argc, argv);
	}

	if (qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_STATE_GET, 0) == QB_LOG_STATE_ENABLED) {
	set_crm_log_level(level + 1);
	}

	/* Enable after potentially logging the argstring, not before */
	crm_enable_stderr(TRUE);
	}

	unsigned int
	get_crm_log_level(void)
	{
	return crm_log_level;
	}

	#define ARGS_FMT "Invoked: %s"
	void
	crm_log_args(int argc, char **argv)
	{
	int lpc = 0;
	int len = 0;
	int restore = FALSE;
	int existing_len = 0;
	int line = __LINE__;
	static int logged = 0;

	char *arg_string = NULL;
	struct qb_log_callsite *args_cs =
	qb_log_callsite_get(__func__, __FILE__, ARGS_FMT, LOG_NOTICE, line, 0);

	if (argc == 0 \|\| argv == NULL \|\| logged) {
	return;
	}

	logged = 1;
	qb_bit_set(args_cs->targets, QB_LOG_SYSLOG); /* Turn on syslog too */

	restore = qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_STATE_GET, 0);
	qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_TRUE);

	for (; lpc < argc; lpc++) {
	if (argv[lpc] == NULL) {
	break;
	}

	len = 2 + strlen(argv[lpc]); /* +1 space, +1 EOS */
	arg_string = realloc(arg_string, len + existing_len);
	existing_len += sprintf(arg_string + existing_len, "%s ", argv[lpc]);
	}

	qb_log_from_external_source(__func__, __FILE__, ARGS_FMT, LOG_NOTICE, line, 0, arg_string);
	qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, restore);

	free(arg_string);
	}

	const char *
	pcmk_strerror(int rc)
	{
	int error = rc;

	if (rc < 0) {
	error = 0 - rc;
	}

	if (error == 0) {
	return "OK";
	} else if (error < PCMK_ERROR_OFFSET) {
	return strerror(error);
	}

	switch (error) {
	case pcmk_err_generic:
	return "Generic Pacemaker error";
	case pcmk_err_no_quorum:
	return "Operation requires quorum";
	case pcmk_err_dtd_validation:
	return "Update does not conform to the configured schema";
	case pcmk_err_transform_failed:
	return "Schema transform failed";
	case pcmk_err_old_data:
	return "Update was older than existing configuration";
	case pcmk_err_diff_failed:
	return "Application of an update diff failed";
	case pcmk_err_diff_resync:
	return "Application of an update diff failed, requesting a full refresh";
	case pcmk_err_cib_modified:
	return "The on-disk configuration was manually modified";
	case pcmk_err_cib_backup:
	return "Could not archive the previous configuration";
	case pcmk_err_cib_save:
	return "Could not save the new configuration to disk";

	/* The following cases will only be hit on systems for which they are non-standard */
	/* coverity[dead_error_condition] False positive on non-Linux */
	case ENOTUNIQ:
	return "Name not unique on network";
	/* coverity[dead_error_condition] False positive on non-Linux */
	case ECOMM:
	return "Communication error on send";
	/* coverity[dead_error_condition] False positive on non-Linux */
	case ELIBACC:
	return "Can not access a needed shared library";
	/* coverity[dead_error_condition] False positive on non-Linux */
	case EREMOTEIO:
	return "Remote I/O error";
	/* coverity[dead_error_condition] False positive on non-Linux */
	case EUNATCH:
	return "Protocol driver not attached";
	/* coverity[dead_error_condition] False positive on non-Linux */
	case ENOKEY:
	return "Required key not available";
	}

	crm_err("Unknown error code: %d", rc);
	return "Unknown error";
	}

	const char *
	bz2_strerror(int rc)
	{
	/* http://www.bzip.org/1.0.3/html/err-handling.html */
	switch (rc) {
	case BZ_OK:
	case BZ_RUN_OK:
	case BZ_FLUSH_OK:
	case BZ_FINISH_OK:
	case BZ_STREAM_END:
	return "Ok";
	case BZ_CONFIG_ERROR:
	return "libbz2 has been improperly compiled on your platform";
	case BZ_SEQUENCE_ERROR:
	return "library functions called in the wrong order";
	case BZ_PARAM_ERROR:
	return "parameter is out of range or otherwise incorrect";
	case BZ_MEM_ERROR:
	return "memory allocation failed";
	case BZ_DATA_ERROR:
	return "data integrity error is detected during decompression";
	case BZ_DATA_ERROR_MAGIC:
	return "the compressed stream does not start with the correct magic bytes";
	case BZ_IO_ERROR:
	return "error reading or writing in the compressed file";
	case BZ_UNEXPECTED_EOF:
	return "compressed file finishes before the logical end of stream is detected";
	case BZ_OUTBUFF_FULL:
	return "output data will not fit into the buffer provided";
	}
	return "Unknown error";
	}

	void
	crm_log_output_fn(const char file, const char function, int line, int level, const char *prefix,
	const char *output)
	{
	const char *next = NULL;
	const char *offset = NULL;

	if (output) {
	next = output;
	do {
	offset = next;
	next = strchrnul(offset, '\n');
	do_crm_log_alias(level, file, function, line, "%s [ %.*s ]", prefix,
	(int)(next - offset), offset);
	if (next[0] != 0) {
	next++;
	}

	} while (next != NULL && next[0] != 0);
	}
	}
	diff --git a/tools/cibadmin.c b/tools/cibadmin.c
	index 8676f0c3a1..03dc489d01 100644
	--- a/tools/cibadmin.c
	+++ b/tools/cibadmin.c
	@@ -1,638 +1,638 @@

	/*
	* 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 <crm/crm.h>

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

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

	#include <crm/msg_xml.h>
	#include <crm/common/xml.h>
	#include <crm/common/ipc.h>
	#include <crm/cib/internal.h>

	int exit_code = pcmk_ok;
	int message_timer_id = -1;
	int message_timeout_ms = 30;

	GMainLoop *mainloop = NULL;

	const char *host = NULL;
	void usage(const char *cmd, int exit_status);
	int do_init(void);
	int do_work(xmlNode * input, int command_options, xmlNode ** output);

	gboolean admin_message_timeout(gpointer data);
	void cib_connection_destroy(gpointer user_data);
	void cibadmin_op_callback(xmlNode * msg, int call_id, int rc, xmlNode * output, void *user_data);

	int command_options = 0;
	const char *cib_action = NULL;

	typedef struct str_list_s {
	int num_items;
	char *value;
	struct str_list_s *next;
	} str_list_t;

	char *obj_type = NULL;
	char *status = NULL;
	char *migrate_from = NULL;
	char *migrate_res = NULL;
	char *subtype = NULL;
	char *reset = NULL;

	int request_id = 0;
	int operation_status = 0;
	cib_t *the_cib = NULL;
	gboolean force_flag = FALSE;
	gboolean quiet = FALSE;
	int bump_log_num = 0;

	/* INDENT-OFF */
	static struct crm_option long_options[] = {
	{"help", 0, 0, '?', "\tThis text"},
	{"version", 0, 0, '$', "\tVersion information" },
	{"verbose", 0, 0, 'V', "\tIncrease debug output\n"},

	{"-spacer-", 0, 0, '-', "Commands:"},
	{"upgrade", 0, 0, 'u', "\tUpgrade the configuration to the latest syntax"},
	{"query", 0, 0, 'Q', "\tQuery the contents of the CIB"},
	{"erase", 0, 0, 'E', "\tErase the contents of the whole CIB"},
	{"bump", 0, 0, 'B', "\tIncrease the CIB's epoch value by 1"},
	{"create", 0, 0, 'C', "\tCreate an object in the CIB. Will fail if the object already exists."},
	{"modify", 0, 0, 'M', "\tFind the object somewhere in the CIB's XML tree and update it. Fails if the object does not exist unless -c is specified"},
	{"patch", 0, 0, 'P', "\tSupply an update in the form of an xml diff (See also: crm_diff)"},
	{"replace", 0, 0, 'R', "\tRecursivly replace an object in the CIB"},
	{"delete", 0, 0, 'D', "\tDelete the first object matching the supplied criteria, Eg. <op id=\"rsc1_op1\" name=\"monitor\"/>"},
	{"-spacer-", 0, 0, '-', "\n\tThe tagname and all attributes must match in order for the element to be deleted"},
	{"delete-all", 0, 0, 'd', "\tWhen used with --xpath, remove all matching objects in the configuration instead of just the first one"},
	{"md5-sum", 0, 0, '5', "\tCalculate the on-disk CIB digest"},
	{"md5-sum-versioned", 0, 0, '6', "\tCalculate an on-the-wire versioned CIB digest"},
	{"sync", 0, 0, 'S', "\t(Advanced) Force a refresh of the CIB to all nodes\n"},
	{"make-slave", 0, 0, 'r', NULL, 1},
	{"make-master", 0, 0, 'w', NULL, 1},
	{"is-master", 0, 0, 'm', NULL, 1},
	{"empty", 0, 0, 'a', "\tOutput an empty CIB"},
	{"blank", 0, 0, 'a', NULL, 1},

	{"-spacer-",1, 0, '-', "\nAdditional options:"},
	{"force", 0, 0, 'f'},
	{"timeout", 1, 0, 't', "Time (in seconds) to wait before declaring the operation failed"},
	{"sync-call", 0, 0, 's', "Wait for call to complete before returning"},
	{"local", 0, 0, 'l', "\tCommand takes effect locally. Should only be used for queries"},
	{"allow-create",0, 0, 'c', "(Advanced) Allow the target of a --modify,-M operation to be created if they do not exist"},
	{"no-children", 0, 0, 'n', "(Advanced) When querying an object, do not return include its children in the result\n"},
	{"no-bcast", 0, 0, 'b', NULL, 1},

	{"-spacer-", 0, 0, '-', "Data:"},
	{"xml-text", 1, 0, 'X', "Retrieve XML from the supplied string"},
	{"xml-file", 1, 0, 'x', "Retrieve XML from the named file"},
	{"xml-pipe", 0, 0, 'p', "Retrieve XML from stdin\n"},

	{"scope", 1, 0, 'o', "Limit the scope of the operation to a specific section of the CIB."},
	{"-spacer-", 0, 0, '-', "\tValid values are: nodes, resources, constraints, crm_config, rsc_defaults, op_defaults, status"},

	{"xpath", 1, 0, 'A', "A valid XPath to use instead of --scope,-o"},
	{"node-path", 0, 0, 'e', "When performing XPath queries, return the address of any matches found."},
	{"-spacer-", 0, 0, '-', " Eg: /cib/configuration/resources/master[@id='ms_RH1_SCS']/primitive[@id='prm_RH1_SCS']", pcmk_option_paragraph},
	{"node", 1, 0, 'N', "(Advanced) Send command to the specified host\n"},
	{"-space-", 0, 0, '!', NULL, 1},

	{"-spacer-", 0, 0, '-', "\nExamples:\n"},
	{"-spacer-", 0, 0, '-', "Query the configuration from the local node:", pcmk_option_paragraph},
	{"-spacer-", 0, 0, '-', " cibadmin --query --local", pcmk_option_example},

	{"-spacer-", 0, 0, '-', "Query the just the cluster options configuration:", pcmk_option_paragraph},
	{"-spacer-", 0, 0, '-', " cibadmin --query --scope crm_config", pcmk_option_example},

	{"-spacer-", 0, 0, '-', "Query all 'target-role' settings:", pcmk_option_paragraph},
	{"-spacer-", 0, 0, '-', " cibadmin --query --xpath \"//nvpair[@name='target-role']\"", pcmk_option_example},

	{"-spacer-", 0, 0, '-', "Remove all 'is-managed' settings:", pcmk_option_paragraph},
	{"-spacer-", 0, 0, '-', " cibadmin --delete-all --xpath \"//nvpair[@name='is-managed']\"", pcmk_option_example},

	{"-spacer-", 0, 0, '-', "Remove the resource named 'old':", pcmk_option_paragraph},
	{"-spacer-", 0, 0, '-', " cibadmin --delete --xml-text '<primitive id=\"old\"/>'", pcmk_option_example},

	{"-spacer-", 0, 0, '-', "Remove all resources from the configuration:", pcmk_option_paragraph},
	{"-spacer-", 0, 0, '-', " cibadmin --replace --scope resources --xml-text '<resources/>'", pcmk_option_example},

	{"-spacer-", 0, 0, '-', "Replace the complete configuration with the contents of $HOME/pacemaker.xml:", pcmk_option_paragraph},
	{"-spacer-", 0, 0, '-', " cibadmin --replace --xml-file $HOME/pacemaker.xml", pcmk_option_example},

	{"-spacer-", 0, 0, '-', "Replace the constraints section of the configuration with the contents of $HOME/constraints.xml:", pcmk_option_paragraph},
	{"-spacer-", 0, 0, '-', " cibadmin --replace --scope constraints --xml-file $HOME/constraints.xml", pcmk_option_example},

	{"-spacer-", 0, 0, '-', "Increase the configuration version to prevent old configurations from being loaded accidentally:", pcmk_option_paragraph},
	{"-spacer-", 0, 0, '-', " cibadmin --modify --xml-text '<cib admin_epoch=\"admin_epoch++\"/>'", pcmk_option_example},

	{"-spacer-", 0, 0, '-', "Edit the configuration with your favorite $EDITOR:", pcmk_option_paragraph},
	{"-spacer-", 0, 0, '-', " cibadmin --query > $HOME/local.xml", pcmk_option_example},
	{"-spacer-", 0, 0, '-', " $EDITOR $HOME/local.xml", pcmk_option_example},
	{"-spacer-", 0, 0, '-', " cibadmin --replace --xml-file $HOME/local.xml", pcmk_option_example},

	{"-spacer-", 0, 0, '-', "SEE ALSO:"},
	{"-spacer-", 0, 0, '-', " crm(8), pcs(8), crm_shadow(8)"},

	/* Legacy options */
	{"host", 1, 0, 'h', NULL, 1},
	{"force-quorum", 0, 0, 'f', NULL, 1},
	{"obj_type", 1, 0, 'o', NULL, 1},
	{F_CRM_DATA, 1, 0, 'X', NULL, 1},
	{CIB_OP_ERASE, 0, 0, 'E', NULL, 1},
	{CIB_OP_QUERY, 0, 0, 'Q', NULL, 1},
	{CIB_OP_CREATE, 0, 0, 'C', NULL, 1},
	{CIB_OP_REPLACE, 0, 0, 'R', NULL, 1},
	{CIB_OP_UPDATE, 0, 0, 'U', NULL, 1},
	{CIB_OP_MODIFY, 0, 0, 'M', NULL, 1},
	{CIB_OP_DELETE, 0, 0, 'D', NULL, 1},
	{CIB_OP_BUMP, 0, 0, 'B', NULL, 1},
	{CIB_OP_SYNC, 0, 0, 'S', NULL, 1},
	{CIB_OP_SLAVE, 0, 0, 'r', NULL, 1},
	{CIB_OP_MASTER, 0, 0, 'w', NULL, 1},
	{CIB_OP_ISMASTER,0, 0, 'm', NULL, 1},

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

	static void
	print_xml_output(xmlNode * xml)
	{
	char *buffer;

	if (!xml) {
	return;
	} else if (xml->type != XML_ELEMENT_NODE) {
	return;
	}

	if (command_options & cib_xpath_address) {
	const char *id = crm_element_value(xml, XML_ATTR_ID);

	if (safe_str_eq((const char *)xml->name, "xpath-query")) {
	xmlNode *child = NULL;

	for (child = xml->children; child; child = child->next) {
	print_xml_output(child);
	}

	} else {
	printf("%s\n", id);
	}

	} else {
	buffer = dump_xml_formatted(xml);
	fprintf(stdout, "%s", crm_str(buffer));
	free(buffer);
	}
	}

	int
	main(int argc, char **argv)
	{
	int argerr = 0;
	int flag;
	const char *source = NULL;
	char *admin_input_xml = NULL;
	char *admin_input_file = NULL;
	gboolean dangerous_cmd = FALSE;
	gboolean admin_input_stdin = FALSE;
	xmlNode *output = NULL;
	xmlNode *input = NULL;

	int option_index = 0;

	crm_system_name = strdup("cibadmin");
	crm_set_options(NULL, "command [options] [data]", long_options,
	"Provides direct access to the cluster configuration."
	"\n\nAllows the configuration, or sections of it, to be queried, modified, replaced and deleted."
	"\n\nWhere necessary, XML data will be obtained using the -X, -x, or -p options\n");

	if (argc < 2) {
	crm_help('?', EX_USAGE);
	}

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

	switch (flag) {
	case 't':
	message_timeout_ms = atoi(optarg);
	if (message_timeout_ms < 1) {
	message_timeout_ms = 30;
	}
	break;
	case 'A':
	obj_type = strdup(optarg);
	command_options \|= cib_xpath;
	break;
	case 'e':
	command_options \|= cib_xpath_address;
	break;
	case 'u':
	cib_action = CIB_OP_UPGRADE;
	dangerous_cmd = TRUE;
	break;
	case 'E':
	cib_action = CIB_OP_ERASE;
	dangerous_cmd = TRUE;
	break;
	case 'Q':
	cib_action = CIB_OP_QUERY;
	quiet = TRUE;
	break;
	case 'P':
	cib_action = CIB_OP_APPLY_DIFF;
	break;
	case 'S':
	cib_action = CIB_OP_SYNC;
	break;
	case 'U':
	case 'M':
	cib_action = CIB_OP_MODIFY;
	break;
	case 'R':
	cib_action = CIB_OP_REPLACE;
	break;
	case 'C':
	cib_action = CIB_OP_CREATE;
	break;
	case 'D':
	cib_action = CIB_OP_DELETE;
	break;
	case '5':
	cib_action = "md5-sum";
	break;
	case '6':
	cib_action = "md5-sum-versioned";
	break;
	case 'c':
	command_options \|= cib_can_create;
	break;
	case 'n':
	command_options \|= cib_no_children;
	break;
	case 'm':
	cib_action = CIB_OP_ISMASTER;
	command_options \|= cib_scope_local;
	break;
	case 'B':
	cib_action = CIB_OP_BUMP;
	break;
	case 'r':
	dangerous_cmd = TRUE;
	cib_action = CIB_OP_SLAVE;
	break;
	case 'w':
	dangerous_cmd = TRUE;
	cib_action = CIB_OP_MASTER;
	command_options \|= cib_scope_local;
	break;
	case 'V':
	command_options = command_options \| cib_verbose;
	bump_log_num++;
	break;
	case '?':
	case '$':
	case '!':
	crm_help(flag, EX_OK);
	break;
	case 'o':
	crm_trace("Option %c => %s", flag, optarg);
	obj_type = strdup(optarg);
	break;
	case 'X':
	crm_trace("Option %c => %s", flag, optarg);
	admin_input_xml = strdup(optarg);
	break;
	case 'x':
	crm_trace("Option %c => %s", flag, optarg);
	admin_input_file = strdup(optarg);
	break;
	case 'p':
	admin_input_stdin = TRUE;
	break;
	case 'N':
	case 'h':
	host = strdup(optarg);
	break;
	case 'l':
	command_options \|= cib_scope_local;
	break;
	case 'd':
	cib_action = CIB_OP_DELETE;
	command_options \|= cib_multiple;
	dangerous_cmd = TRUE;
	break;
	case 'b':
	dangerous_cmd = TRUE;
	command_options \|= cib_inhibit_bcast;
	command_options \|= cib_scope_local;
	break;
	case 's':
	command_options \|= cib_sync_call;
	break;
	case 'f':
	force_flag = TRUE;
	command_options \|= cib_quorum_override;
	break;
	case 'a':
	output = createEmptyCib();
	crm_xml_add(output, XML_ATTR_CRM_VERSION, CRM_FEATURE_SET);
	if (optind >= argc) {
	crm_xml_add(output, XML_ATTR_VALIDATION, LATEST_SCHEMA_VERSION);
	} else {
	crm_xml_add(output, XML_ATTR_VALIDATION, argv[optind]);
	}
	crm_xml_add_int(output, XML_ATTR_GENERATION_ADMIN, 1);
	crm_xml_add_int(output, XML_ATTR_GENERATION, 0);
	crm_xml_add_int(output, XML_ATTR_NUMUPDATES, 0);

	admin_input_xml = dump_xml_formatted(output);
	fprintf(stdout, "%s\n", crm_str(admin_input_xml));
	goto bail;
	break;
	default:
	printf("Argument code 0%o (%c)" " is not (?yet?) supported\n", flag, flag);
	++argerr;
	break;
	}
	}

	if (bump_log_num > 0) {
	quiet = FALSE;
	}
	crm_log_init(NULL, LOG_CRIT, FALSE, FALSE, argc, argv, quiet);
	while (bump_log_num > 0) {
	crm_bump_log_level(argc, argv);
	bump_log_num--;
	}

	if (optind < argc) {
	printf("non-option ARGV-elements: ");
	while (optind < argc)
	printf("%s ", argv[optind++]);
	printf("\n");
	crm_help('?', EX_USAGE);
	}

	if (optind > argc \|\| cib_action == NULL) {
	++argerr;
	}

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

	if (dangerous_cmd && force_flag == FALSE) {
	fprintf(stderr, "The supplied command is considered dangerous."
	" To prevent accidental destruction of the cluster,"
	" the --force flag is required in order to proceed.\n");
	fflush(stderr);
	exit_code = -EINVAL;
	goto bail;
	}

	if (admin_input_file != NULL) {
	input = filename2xml(admin_input_file);
	source = admin_input_file;

	} else if (admin_input_xml != NULL) {
	source = "input string";
	input = string2xml(admin_input_xml);

	} else if (admin_input_stdin) {
	source = "STDIN";
	input = stdin2xml();
	}

	if (input != NULL) {
	crm_log_xml_debug(input, "[admin input]");

	} else if (source) {
	fprintf(stderr, "Couldn't parse input from %s.\n", source);
	exit_code = -EINVAL;
	goto bail;
	}

	if (safe_str_eq(cib_action, "md5-sum")) {
	char *digest = NULL;

	if (input == NULL) {
	fprintf(stderr, "Please supply XML to process with -X, -x or -p\n");
	exit_code = -EINVAL;
	goto bail;
	}

	digest = calculate_on_disk_digest(input);
	fprintf(stderr, "Digest: ");
	fprintf(stdout, "%s\n", crm_str(digest));
	free(digest);
	goto bail;

	} else if (safe_str_eq(cib_action, "md5-sum-versioned")) {
	char *digest = NULL;
	const char *version = NULL;

	if (input == NULL) {
	fprintf(stderr, "Please supply XML to process with -X, -x or -p\n");
	exit_code = -EINVAL;
	goto bail;
	}

	version = crm_element_value(input, XML_ATTR_CRM_VERSION);
	digest = calculate_xml_versioned_digest(input, FALSE, TRUE, version);
	fprintf(stderr, "Versioned (%s) digest: ", version);
	fprintf(stdout, "%s\n", crm_str(digest));
	free(digest);
	goto bail;
	}

	exit_code = do_init();
	if (exit_code != pcmk_ok) {
	crm_err("Init failed, could not perform requested operations");
	fprintf(stderr, "Init failed, could not perform requested operations\n");
	- return -exit_code;
	+ return crm_exit(-exit_code);
	}

	exit_code = do_work(input, command_options, &output);
	if (exit_code > 0) {
	/* wait for the reply by creating a mainloop and running it until
	* the callbacks are invoked...
	*/
	request_id = exit_code;

	the_cib->cmds->register_callback(the_cib, request_id, message_timeout_ms, FALSE, NULL,
	"cibadmin_op_callback", cibadmin_op_callback);

	mainloop = g_main_new(FALSE);

	crm_trace("%s waiting for reply from the local CIB", crm_system_name);

	crm_info("Starting mainloop");
	g_main_run(mainloop);

	} else if (exit_code < 0) {
	crm_err("Call failed: %s", pcmk_strerror(exit_code));
	fprintf(stderr, "Call failed: %s\n", pcmk_strerror(exit_code));
	operation_status = exit_code;

	if (exit_code == -pcmk_err_dtd_validation) {
	if (crm_str_eq(cib_action, CIB_OP_UPGRADE, TRUE)) {
	xmlNode *obj = NULL;
	int version = 0, rc = 0;

	rc = the_cib->cmds->query(the_cib, NULL, &obj, command_options);
	if (rc == pcmk_ok) {
	update_validation(&obj, &version, TRUE, FALSE);
	}

	} else if (output) {
	validate_xml_verbose(output);
	}
	}
	}

	if (output != NULL) {
	print_xml_output(output);
	free_xml(output);
	}

	crm_trace("%s exiting normally", crm_system_name);

	free_xml(input);
	free(admin_input_xml);
	free(admin_input_file);
	the_cib->cmds->signoff(the_cib);
	cib_delete(the_cib);
	bail:
	return crm_exit(-exit_code);
	}

	int
	do_work(xmlNode * input, int call_options, xmlNode ** output)
	{
	/* construct the request */
	the_cib->call_timeout = message_timeout_ms;
	if (strcasecmp(CIB_OP_REPLACE, cib_action) == 0
	&& safe_str_eq(crm_element_name(input), XML_TAG_CIB)) {
	xmlNode *status = get_object_root(XML_CIB_TAG_STATUS, input);

	if (status == NULL) {
	create_xml_node(input, XML_CIB_TAG_STATUS);
	}
	}

	if (strcasecmp(CIB_OP_SYNC, cib_action) == 0) {
	crm_trace("Performing %s op...", cib_action);
	return the_cib->cmds->sync_from(the_cib, host, obj_type, call_options);

	} else if (strcasecmp(CIB_OP_SLAVE, cib_action) == 0 && (call_options ^ cib_scope_local)) {
	crm_trace("Performing %s op on all nodes...", cib_action);
	return the_cib->cmds->set_slave_all(the_cib, call_options);

	} else if (strcasecmp(CIB_OP_MASTER, cib_action) == 0) {
	crm_trace("Performing %s op on all nodes...", cib_action);
	return the_cib->cmds->set_master(the_cib, call_options);

	} else if (cib_action != NULL) {
	crm_trace("Passing \"%s\" to variant_op...", cib_action);
	return cib_internal_op(the_cib, cib_action, host, obj_type, input, output, call_options,
	NULL);

	} else {
	crm_err("You must specify an operation");
	}
	return -EINVAL;
	}

	int
	do_init(void)
	{
	int rc = pcmk_ok;

	the_cib = cib_new();
	rc = the_cib->cmds->signon(the_cib, crm_system_name, cib_command);
	if (rc != pcmk_ok) {
	crm_err("Signon to CIB failed: %s", pcmk_strerror(rc));
	fprintf(stderr, "Signon to CIB failed: %s\n", pcmk_strerror(rc));
	}

	return rc;
	}

	void
	cib_connection_destroy(gpointer user_data)
	{
	crm_err("Connection to the CIB terminated... exiting");
	g_main_quit(mainloop);
	return;
	}

	void
	cibadmin_op_callback(xmlNode * msg, int call_id, int rc, xmlNode * output, void *user_data)
	{
	exit_code = rc;

	if (safe_str_eq(cib_action, CIB_OP_ISMASTER) && rc != pcmk_ok) {
	crm_info("CIB on %s is _not_ the master instance", host ? host : "localhost");
	fprintf(stderr, "CIB on %s is _not_ the master instance\n", host ? host : "localhost");

	} else if (safe_str_eq(cib_action, CIB_OP_ISMASTER)) {
	crm_info("CIB on %s _is_ the master instance", host ? host : "localhost");
	fprintf(stderr, "CIB on %s _is_ the master instance\n", host ? host : "localhost");

	} else if (rc != 0) {
	crm_warn("Call %s failed (%d): %s", cib_action, rc, pcmk_strerror(rc));
	fprintf(stderr, "Call %s failed (%d): %s\n", cib_action, rc, pcmk_strerror(rc));
	print_xml_output(output);

	} else if (safe_str_eq(cib_action, CIB_OP_QUERY) && output == NULL) {
	crm_err("Output expected in query response");
	crm_log_xml_err(msg, "no output");

	} else if (output == NULL) {
	crm_info("Call passed");

	} else {
	crm_info("Call passed");
	print_xml_output(output);
	}

	if (call_id == request_id) {
	g_main_quit(mainloop);

	} else {
	crm_info("Message was not the response we were looking for (%d vs. %d", call_id,
	request_id);
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 26, 5:18 PM (16 h, 42 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1959212
Default Alt Text: (52 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions