No OneTemporary
Actions

Size

97 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/crm/common/util.h b/include/crm/common/util.h
	index 437768c168..a13317cec6 100644
	--- a/include/crm/common/util.h
	+++ b/include/crm/common/util.h
	@@ -1,121 +1,121 @@
	/*
	* Copyright 2004-2024 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#ifndef PCMK__CRM_COMMON_UTIL__H
	#define PCMK__CRM_COMMON_UTIL__H

	#include <sys/types.h> // gid_t, mode_t, size_t, time_t, uid_t
	#include <stdlib.h>
	#include <stdbool.h>
	#include <stdint.h> // uint32_t
	#include <limits.h>
	#include <signal.h>
	#include <glib.h>

	#include <crm/common/acl.h>
	#include <crm/common/actions.h>
	#include <crm/common/agents.h>
	#include <crm/common/results.h>
	#include <crm/common/scores.h>
	#include <crm/common/nvpair.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	/**
	* \file
	* \brief Utility functions
	* \ingroup core
	*/

	-/* public node attribute functions (from attrd_client.c) */
	+/* public node attribute functions (from attrs.c) */
	char pcmk_promotion_score_name(const char rsc_id);

	/* public Pacemaker Remote functions (from remote.c) */
	int crm_default_remote_port(void);

	/* public string functions (from strings.c) */

	// NOTE: sbd (as of at least 1.5.2) uses this
	gboolean crm_is_true(const char *s);

	int crm_str_to_boolean(const char s, int ret);

	// NOTE: sbd (as of at least 1.5.2) uses this
	long long crm_get_msec(const char *input);

	// NOTE: sbd (as of at least 1.5.2) uses this
	char crm_strdup_printf(char const format, ...) G_GNUC_PRINTF(1, 2);

	int pcmk_parse_interval_spec(const char input, guint result_ms);

	int compare_version(const char version1, const char version2);

	/*!
	* \brief Check whether any of specified flags are set in a flag group
	*
	* \param[in] flag_group The flag group being examined
	* \param[in] flags_to_check Which flags in flag_group should be checked
	*
	* \return true if \p flags_to_check is nonzero and any of its flags are set in
	* \p flag_group, or false otherwise
	*/
	static inline bool
	pcmk_any_flags_set(uint64_t flag_group, uint64_t flags_to_check)
	{
	return (flag_group & flags_to_check) != 0;
	}

	/*!
	* \brief Check whether all of specified flags are set in a flag group
	*
	* \param[in] flag_group The flag group being examined
	* \param[in] flags_to_check Which flags in flag_group should be checked
	*
	* \return true if \p flags_to_check is zero or all of its flags are set in
	* \p flag_group, or false otherwise
	*/
	static inline bool
	pcmk_all_flags_set(uint64_t flag_group, uint64_t flags_to_check)
	{
	return (flag_group & flags_to_check) == flags_to_check;
	}

	/*!
	* \brief Convenience alias for pcmk_all_flags_set(), to check single flag
	*/
	#define pcmk_is_set(g, f) pcmk_all_flags_set((g), (f))

	+void pcmk_common_cleanup(void);
	char crm_md5sum(const char buffer);
	-
	char *crm_generate_uuid(void);

	// This belongs in ipc.h but is here for backward compatibility
	bool crm_is_daemon_name(const char *name);

	int crm_user_lookup(const char name, uid_t uid, gid_t * gid);
	int pcmk_daemon_user(uid_t uid, gid_t gid);

	#ifdef HAVE_GNUTLS_GNUTLS_H
	void crm_gnutls_global_init(void);
	#endif

	bool pcmk_str_is_infinity(const char *s);
	bool pcmk_str_is_minus_infinity(const char *s);

	#if !defined(PCMK_ALLOW_DEPRECATED) \|\| (PCMK_ALLOW_DEPRECATED == 1)
	#include <crm/common/util_compat.h>
	#endif

	#ifdef __cplusplus
	}
	#endif

	#endif
	diff --git a/lib/common/mainloop.c b/lib/common/mainloop.c
	index 55a9394aa0..4d197e0f36 100644
	--- a/lib/common/mainloop.c
	+++ b/lib/common/mainloop.c
	@@ -1,1481 +1,1483 @@
	/*
	* Copyright 2004-2024 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

	#ifndef _GNU_SOURCE
	# define _GNU_SOURCE
	#endif

	#include <stdlib.h>
	#include <string.h>
	#include <signal.h>
	#include <errno.h>

	#include <sys/wait.h>

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

	#include <qb/qbarray.h>

	struct mainloop_child_s {
	pid_t pid;
	char *desc;
	unsigned timerid;
	gboolean timeout;
	void *privatedata;

	enum mainloop_child_flags flags;

	/* Called when a process dies */
	void (callback) (mainloop_child_t p, pid_t pid, int core, int signo, int exitcode);
	};

	struct trigger_s {
	GSource source;
	gboolean running;
	gboolean trigger;
	void *user_data;
	guint id;

	};

	struct mainloop_timer_s {
	guint id;
	guint period_ms;
	bool repeat;
	char *name;
	GSourceFunc cb;
	void *userdata;
	};

	static gboolean
	crm_trigger_prepare(GSource * source, gint * timeout)
	{
	crm_trigger_t trig = (crm_trigger_t ) source;

	/* cluster-glue's FD and IPC related sources make use of
	* g_source_add_poll() but do not set a timeout in their prepare
	* functions
	*
	* This means mainloop's poll() will block until an event for one
	* of these sources occurs - any /other/ type of source, such as
	* this one or g_idle_*, that doesn't use g_source_add_poll() is
	* S-O-L and won't be processed until there is something fd-based
	* happens.
	*
	* Luckily the timeout we can set here affects all sources and
	* puts an upper limit on how long poll() can take.
	*
	* So unconditionally set a small-ish timeout, not too small that
	* we're in constant motion, which will act as an upper bound on
	* how long the signal handling might be delayed for.
	*/
	timeout = 500; / Timeout in ms */

	return trig->trigger;
	}

	static gboolean
	crm_trigger_check(GSource * source)
	{
	crm_trigger_t trig = (crm_trigger_t ) source;

	return trig->trigger;
	}

	/*!
	* \internal
	* \brief GSource dispatch function for crm_trigger_t
	*
	* \param[in] source crm_trigger_t being dispatched
	* \param[in] callback Callback passed at source creation
	* \param[in,out] userdata User data passed at source creation
	*
	* \return G_SOURCE_REMOVE to remove source, G_SOURCE_CONTINUE to keep it
	*/
	static gboolean
	crm_trigger_dispatch(GSource *source, GSourceFunc callback, gpointer userdata)
	{
	gboolean rc = G_SOURCE_CONTINUE;
	crm_trigger_t trig = (crm_trigger_t ) source;

	if (trig->running) {
	/* Wait until the existing job is complete before starting the next one */
	return G_SOURCE_CONTINUE;
	}
	trig->trigger = FALSE;

	if (callback) {
	int callback_rc = callback(trig->user_data);

	if (callback_rc < 0) {
	crm_trace("Trigger handler %p not yet complete", trig);
	trig->running = TRUE;
	} else if (callback_rc == 0) {
	rc = G_SOURCE_REMOVE;
	}
	}
	return rc;
	}

	static void
	crm_trigger_finalize(GSource * source)
	{
	crm_trace("Trigger %p destroyed", source);
	}

	static GSourceFuncs crm_trigger_funcs = {
	crm_trigger_prepare,
	crm_trigger_check,
	crm_trigger_dispatch,
	crm_trigger_finalize,
	};

	static crm_trigger_t *
	mainloop_setup_trigger(GSource * source, int priority, int (*dispatch) (gpointer user_data),
	gpointer userdata)
	{
	crm_trigger_t *trigger = NULL;

	trigger = (crm_trigger_t *) source;

	trigger->id = 0;
	trigger->trigger = FALSE;
	trigger->user_data = userdata;

	if (dispatch) {
	g_source_set_callback(source, dispatch, trigger, NULL);
	}

	g_source_set_priority(source, priority);
	g_source_set_can_recurse(source, FALSE);

	trigger->id = g_source_attach(source, NULL);
	return trigger;
	}

	void
	mainloop_trigger_complete(crm_trigger_t * trig)
	{
	crm_trace("Trigger handler %p complete", trig);
	trig->running = FALSE;
	}

	/*!
	* \brief Create a trigger to be used as a mainloop source
	*
	* \param[in] priority Relative priority of source (lower number is higher priority)
	* \param[in] dispatch Trigger dispatch function (should return 0 to remove the
	* trigger from the mainloop, -1 if the trigger should be
	* kept but the job is still running and not complete, and
	* 1 if the trigger should be kept and the job is complete)
	* \param[in] userdata Pointer to pass to \p dispatch
	*
	* \return Newly allocated mainloop source for trigger
	*/
	crm_trigger_t *
	mainloop_add_trigger(int priority, int (*dispatch) (gpointer user_data),
	gpointer userdata)
	{
	GSource *source = NULL;

	pcmk__assert(sizeof(crm_trigger_t) > sizeof(GSource));
	source = g_source_new(&crm_trigger_funcs, sizeof(crm_trigger_t));

	return mainloop_setup_trigger(source, priority, dispatch, userdata);
	}

	void
	mainloop_set_trigger(crm_trigger_t * source)
	{
	if(source) {
	source->trigger = TRUE;
	}
	}

	gboolean
	mainloop_destroy_trigger(crm_trigger_t * source)
	{
	GSource *gs = NULL;

	if(source == NULL) {
	return TRUE;
	}

	gs = (GSource *)source;

	g_source_destroy(gs); /* Remove from mainloop, ref_count-- */
	g_source_unref(gs); /* The caller no longer carries a reference to source
	*
	* At this point the source should be free'd,
	* unless we're currently processing said
	* source, in which case mainloop holds an
	* additional reference and it will be free'd
	* once our processing completes
	*/
	return TRUE;
	}

	// Define a custom glib source for signal handling

	// Data structure for custom glib source
	typedef struct signal_s {
	crm_trigger_t trigger; // trigger that invoked source (must be first)
	void (*handler) (int sig); // signal handler
	int signal; // signal that was received
	} crm_signal_t;

	// Table to associate signal handlers with signal numbers
	static crm_signal_t *crm_signals[NSIG];

	/*!
	* \internal
	* \brief Dispatch an event from custom glib source for signals
	*
	* Given an signal event, clear the event trigger and call any registered
	* signal handler.
	*
	* \param[in] source glib source that triggered this dispatch
	* \param[in] callback (ignored)
	* \param[in] userdata (ignored)
	*/
	static gboolean
	crm_signal_dispatch(GSource *source, GSourceFunc callback, gpointer userdata)
	{
	crm_signal_t sig = (crm_signal_t ) source;

	if(sig->signal != SIGCHLD) {
	crm_notice("Caught '%s' signal "CRM_XS" %d (%s handler)",
	strsignal(sig->signal), sig->signal,
	(sig->handler? "invoking" : "no"));
	}

	sig->trigger.trigger = FALSE;
	if (sig->handler) {
	sig->handler(sig->signal);
	}
	return TRUE;
	}

	/*!
	* \internal
	* \brief Handle a signal by setting a trigger for signal source
	*
	* \param[in] sig Signal number that was received
	*
	* \note This is the true signal handler for the mainloop signal source, and
	* must be async-safe.
	*/
	static void
	mainloop_signal_handler(int sig)
	{
	if (sig > 0 && sig < NSIG && crm_signals[sig] != NULL) {
	mainloop_set_trigger((crm_trigger_t *) crm_signals[sig]);
	}
	}

	// Functions implementing our custom glib source for signal handling
	static GSourceFuncs crm_signal_funcs = {
	crm_trigger_prepare,
	crm_trigger_check,
	crm_signal_dispatch,
	crm_trigger_finalize,
	};

	/*!
	* \internal
	* \brief Set a true signal handler
	*
	* signal()-like interface to sigaction()
	*
	* \param[in] sig Signal number to register handler for
	* \param[in] dispatch Signal handler
	*
	* \return The previous value of the signal handler, or SIG_ERR on error
	* \note The dispatch function must be async-safe.
	*/
	sighandler_t
	crm_signal_handler(int sig, sighandler_t dispatch)
	{
	sigset_t mask;
	struct sigaction sa;
	struct sigaction old;

	if (sigemptyset(&mask) < 0) {
	crm_err("Could not set handler for signal %d: %s",
	sig, pcmk_rc_str(errno));
	return SIG_ERR;
	}

	memset(&sa, 0, sizeof(struct sigaction));
	sa.sa_handler = dispatch;
	sa.sa_flags = SA_RESTART;
	sa.sa_mask = mask;

	if (sigaction(sig, &sa, &old) < 0) {
	crm_err("Could not set handler for signal %d: %s",
	sig, pcmk_rc_str(errno));
	return SIG_ERR;
	}
	return old.sa_handler;
	}

	static void
	mainloop_destroy_signal_entry(int sig)
	{
	crm_signal_t *tmp = crm_signals[sig];

	- crm_signals[sig] = NULL;
	-
	- crm_trace("Destroying signal %d", sig);
	- mainloop_destroy_trigger((crm_trigger_t *) tmp);
	+ if (tmp != NULL) {
	+ crm_signals[sig] = NULL;
	+ crm_trace("Unregistering mainloop handler for signal %d", sig);
	+ mainloop_destroy_trigger((crm_trigger_t *) tmp);
	+ }
	}

	/*!
	* \internal
	* \brief Add a signal handler to a mainloop
	*
	* \param[in] sig Signal number to handle
	* \param[in] dispatch Signal handler function
	*
	* \note The true signal handler merely sets a mainloop trigger to call this
	* dispatch function via the mainloop. Therefore, the dispatch function
	* does not need to be async-safe.
	*/
	gboolean
	mainloop_add_signal(int sig, void (*dispatch) (int sig))
	{
	GSource *source = NULL;
	int priority = G_PRIORITY_HIGH - 1;

	if (sig == SIGTERM) {
	/* TERM is higher priority than other signals,
	* signals are higher priority than other ipc.
	* Yes, minus: smaller is "higher"
	*/
	priority--;
	}

	if (sig >= NSIG \|\| sig < 0) {
	crm_err("Signal %d is out of range", sig);
	return FALSE;

	} else if (crm_signals[sig] != NULL && crm_signals[sig]->handler == dispatch) {
	crm_trace("Signal handler for %d is already installed", sig);
	return TRUE;

	} else if (crm_signals[sig] != NULL) {
	crm_err("Different signal handler for %d is already installed", sig);
	return FALSE;
	}

	pcmk__assert(sizeof(crm_signal_t) > sizeof(GSource));
	source = g_source_new(&crm_signal_funcs, sizeof(crm_signal_t));

	crm_signals[sig] = (crm_signal_t *) mainloop_setup_trigger(source, priority, NULL, NULL);
	pcmk__assert(crm_signals[sig] != NULL);

	crm_signals[sig]->handler = dispatch;
	crm_signals[sig]->signal = sig;

	if (crm_signal_handler(sig, mainloop_signal_handler) == SIG_ERR) {
	mainloop_destroy_signal_entry(sig);
	return FALSE;
	}

	return TRUE;
	}

	gboolean
	mainloop_destroy_signal(int sig)
	{
	if (sig >= NSIG \|\| sig < 0) {
	crm_err("Signal %d is out of range", sig);
	return FALSE;

	} else if (crm_signal_handler(sig, NULL) == SIG_ERR) {
	crm_perror(LOG_ERR, "Could not uninstall signal handler for signal %d", sig);
	return FALSE;

	} else if (crm_signals[sig] == NULL) {
	return TRUE;
	}
	mainloop_destroy_signal_entry(sig);
	return TRUE;
	}

	static qb_array_t *gio_map = NULL;

	void
	mainloop_cleanup(void)
	{
	- if (gio_map) {
	+ if (gio_map != NULL) {
	qb_array_free(gio_map);
	+ gio_map = NULL;
	}

	for (int sig = 0; sig < NSIG; ++sig) {
	mainloop_destroy_signal_entry(sig);
	}
	}

	/*
	* libqb...
	*/
	struct gio_to_qb_poll {
	int32_t is_used;
	guint source;
	int32_t events;
	void *data;
	qb_ipcs_dispatch_fn_t fn;
	enum qb_loop_priority p;
	};

	static gboolean
	gio_read_socket(GIOChannel * gio, GIOCondition condition, gpointer data)
	{
	struct gio_to_qb_poll adaptor = (struct gio_to_qb_poll )data;
	gint fd = g_io_channel_unix_get_fd(gio);

	crm_trace("%p.%d %d", data, fd, condition);

	/* if this assert get's hit, then there is a race condition between
	* when we destroy a fd and when mainloop actually gives it up */
	pcmk__assert(adaptor->is_used > 0);

	return (adaptor->fn(fd, condition, adaptor->data) == 0);
	}

	static void
	gio_poll_destroy(gpointer data)
	{
	struct gio_to_qb_poll adaptor = (struct gio_to_qb_poll )data;

	adaptor->is_used--;
	pcmk__assert(adaptor->is_used >= 0);

	if (adaptor->is_used == 0) {
	crm_trace("Marking adaptor %p unused", adaptor);
	adaptor->source = 0;
	}
	}

	/*!
	* \internal
	* \brief Convert libqb's poll priority into GLib's one
	*
	* \param[in] prio libqb's poll priority (#QB_LOOP_MED assumed as fallback)
	*
	* \return best matching GLib's priority
	*/
	static gint
	conv_prio_libqb2glib(enum qb_loop_priority prio)
	{
	switch (prio) {
	case QB_LOOP_LOW: return G_PRIORITY_LOW;
	case QB_LOOP_HIGH: return G_PRIORITY_HIGH;
	default: return G_PRIORITY_DEFAULT; // QB_LOOP_MED
	}
	}

	/*!
	* \internal
	* \brief Convert libqb's poll priority to rate limiting spec
	*
	* \param[in] prio libqb's poll priority (#QB_LOOP_MED assumed as fallback)
	*
	* \return best matching rate limiting spec
	* \note This is the inverse of libqb's qb_ipcs_request_rate_limit().
	*/
	static enum qb_ipcs_rate_limit
	conv_libqb_prio2ratelimit(enum qb_loop_priority prio)
	{
	switch (prio) {
	case QB_LOOP_LOW: return QB_IPCS_RATE_SLOW;
	case QB_LOOP_HIGH: return QB_IPCS_RATE_FAST;
	default: return QB_IPCS_RATE_NORMAL; // QB_LOOP_MED
	}
	}

	static int32_t
	gio_poll_dispatch_update(enum qb_loop_priority p, int32_t fd, int32_t evts,
	void *data, qb_ipcs_dispatch_fn_t fn, int32_t add)
	{
	struct gio_to_qb_poll *adaptor;
	GIOChannel *channel;
	int32_t res = 0;

	res = qb_array_index(gio_map, fd, (void **)&adaptor);
	if (res < 0) {
	crm_err("Array lookup failed for fd=%d: %d", fd, res);
	return res;
	}

	crm_trace("Adding fd=%d to mainloop as adaptor %p", fd, adaptor);

	if (add && adaptor->source) {
	crm_err("Adaptor for descriptor %d is still in-use", fd);
	return -EEXIST;
	}
	if (!add && !adaptor->is_used) {
	crm_err("Adaptor for descriptor %d is not in-use", fd);
	return -ENOENT;
	}

	/* channel is created with ref_count = 1 */
	channel = g_io_channel_unix_new(fd);
	if (!channel) {
	crm_err("No memory left to add fd=%d", fd);
	return -ENOMEM;
	}

	if (adaptor->source) {
	g_source_remove(adaptor->source);
	adaptor->source = 0;
	}

	/* Because unlike the poll() API, glib doesn't tell us about HUPs by default */
	evts \|= (G_IO_HUP \| G_IO_NVAL \| G_IO_ERR);

	adaptor->fn = fn;
	adaptor->events = evts;
	adaptor->data = data;
	adaptor->p = p;
	adaptor->is_used++;
	adaptor->source =
	g_io_add_watch_full(channel, conv_prio_libqb2glib(p), evts,
	gio_read_socket, adaptor, gio_poll_destroy);

	/* Now that mainloop now holds a reference to channel,
	* thanks to g_io_add_watch_full(), drop ours from g_io_channel_unix_new().
	*
	* This means that channel will be free'd by:
	* g_main_context_dispatch()
	* -> g_source_destroy_internal()
	* -> g_source_callback_unref()
	* shortly after gio_poll_destroy() completes
	*/
	g_io_channel_unref(channel);

	crm_trace("Added to mainloop with gsource id=%d", adaptor->source);
	if (adaptor->source > 0) {
	return 0;
	}

	return -EINVAL;
	}

	static int32_t
	gio_poll_dispatch_add(enum qb_loop_priority p, int32_t fd, int32_t evts,
	void *data, qb_ipcs_dispatch_fn_t fn)
	{
	return gio_poll_dispatch_update(p, fd, evts, data, fn, QB_TRUE);
	}

	static int32_t
	gio_poll_dispatch_mod(enum qb_loop_priority p, int32_t fd, int32_t evts,
	void *data, qb_ipcs_dispatch_fn_t fn)
	{
	return gio_poll_dispatch_update(p, fd, evts, data, fn, QB_FALSE);
	}

	static int32_t
	gio_poll_dispatch_del(int32_t fd)
	{
	struct gio_to_qb_poll *adaptor;

	crm_trace("Looking for fd=%d", fd);
	if (qb_array_index(gio_map, fd, (void **)&adaptor) == 0) {
	if (adaptor->source) {
	g_source_remove(adaptor->source);
	adaptor->source = 0;
	}
	}
	return 0;
	}

	struct qb_ipcs_poll_handlers gio_poll_funcs = {
	.job_add = NULL,
	.dispatch_add = gio_poll_dispatch_add,
	.dispatch_mod = gio_poll_dispatch_mod,
	.dispatch_del = gio_poll_dispatch_del,
	};

	static enum qb_ipc_type
	pick_ipc_type(enum qb_ipc_type requested)
	{
	const char *env = pcmk__env_option(PCMK__ENV_IPC_TYPE);

	if (env && strcmp("shared-mem", env) == 0) {
	return QB_IPC_SHM;
	} else if (env && strcmp("socket", env) == 0) {
	return QB_IPC_SOCKET;
	} else if (env && strcmp("posix", env) == 0) {
	return QB_IPC_POSIX_MQ;
	} else if (env && strcmp("sysv", env) == 0) {
	return QB_IPC_SYSV_MQ;
	} else if (requested == QB_IPC_NATIVE) {
	/* We prefer shared memory because the server never blocks on
	* send. If part of a message fits into the socket, libqb
	* needs to block until the remainder can be sent also.
	* Otherwise the client will wait forever for the remaining
	* bytes.
	*/
	return QB_IPC_SHM;
	}
	return requested;
	}

	qb_ipcs_service_t *
	mainloop_add_ipc_server(const char *name, enum qb_ipc_type type,
	struct qb_ipcs_service_handlers *callbacks)
	{
	return mainloop_add_ipc_server_with_prio(name, type, callbacks, QB_LOOP_MED);
	}

	qb_ipcs_service_t *
	mainloop_add_ipc_server_with_prio(const char *name, enum qb_ipc_type type,
	struct qb_ipcs_service_handlers *callbacks,
	enum qb_loop_priority prio)
	{
	int rc = 0;
	qb_ipcs_service_t *server = NULL;

	if (gio_map == NULL) {
	gio_map = qb_array_create_2(64, sizeof(struct gio_to_qb_poll), 1);
	}

	server = qb_ipcs_create(name, 0, pick_ipc_type(type), callbacks);

	if (server == NULL) {
	crm_err("Could not create %s IPC server: %s (%d)",
	name, pcmk_rc_str(errno), errno);
	return NULL;
	}

	if (prio != QB_LOOP_MED) {
	qb_ipcs_request_rate_limit(server, conv_libqb_prio2ratelimit(prio));
	}

	/* All clients should use at least ipc_buffer_max as their buffer size */
	qb_ipcs_enforce_buffer_size(server, crm_ipc_default_buffer_size());
	qb_ipcs_poll_handlers_set(server, &gio_poll_funcs);

	rc = qb_ipcs_run(server);
	if (rc < 0) {
	crm_err("Could not start %s IPC server: %s (%d)", name, pcmk_strerror(rc), rc);
	return NULL; // qb_ipcs_run() destroys server on failure
	}

	return server;
	}

	void
	mainloop_del_ipc_server(qb_ipcs_service_t * server)
	{
	if (server) {
	qb_ipcs_destroy(server);
	}
	}

	struct mainloop_io_s {
	char *name;
	void *userdata;

	int fd;
	guint source;
	crm_ipc_t *ipc;
	GIOChannel *channel;

	int (dispatch_fn_ipc) (const char buffer, ssize_t length, gpointer userdata);
	int (*dispatch_fn_io) (gpointer userdata);
	void (*destroy_fn) (gpointer userdata);

	};

	/*!
	* \internal
	* \brief I/O watch callback function (GIOFunc)
	*
	* \param[in] gio I/O channel being watched
	* \param[in] condition I/O condition satisfied
	* \param[in] data User data passed when source was created
	*
	* \return G_SOURCE_REMOVE to remove source, G_SOURCE_CONTINUE to keep it
	*/
	static gboolean
	mainloop_gio_callback(GIOChannel *gio, GIOCondition condition, gpointer data)
	{
	gboolean rc = G_SOURCE_CONTINUE;
	mainloop_io_t *client = data;

	pcmk__assert(client->fd == g_io_channel_unix_get_fd(gio));

	if (condition & G_IO_IN) {
	if (client->ipc) {
	long read_rc = 0L;
	int max = 10;

	do {
	read_rc = crm_ipc_read(client->ipc);
	if (read_rc <= 0) {
	crm_trace("Could not read IPC message from %s: %s (%ld)",
	client->name, pcmk_strerror(read_rc), read_rc);

	} else if (client->dispatch_fn_ipc) {
	const char *buffer = crm_ipc_buffer(client->ipc);

	crm_trace("New %ld-byte IPC message from %s "
	"after I/O condition %d",
	read_rc, client->name, (int) condition);
	if (client->dispatch_fn_ipc(buffer, read_rc, client->userdata) < 0) {
	crm_trace("Connection to %s no longer required", client->name);
	rc = G_SOURCE_REMOVE;
	}
	}

	} while ((rc == G_SOURCE_CONTINUE) && (read_rc > 0) && --max > 0);

	} else {
	crm_trace("New I/O event for %s after I/O condition %d",
	client->name, (int) condition);
	if (client->dispatch_fn_io) {
	if (client->dispatch_fn_io(client->userdata) < 0) {
	crm_trace("Connection to %s no longer required", client->name);
	rc = G_SOURCE_REMOVE;
	}
	}
	}
	}

	if (client->ipc && !crm_ipc_connected(client->ipc)) {
	crm_err("Connection to %s closed " CRM_XS " client=%p condition=%d",
	client->name, client, condition);
	rc = G_SOURCE_REMOVE;

	} else if (condition & (G_IO_HUP \| G_IO_NVAL \| G_IO_ERR)) {
	crm_trace("The connection %s[%p] has been closed (I/O condition=%d)",
	client->name, client, condition);
	rc = G_SOURCE_REMOVE;

	} else if ((condition & G_IO_IN) == 0) {
	/*
	#define GLIB_SYSDEF_POLLIN =1
	#define GLIB_SYSDEF_POLLPRI =2
	#define GLIB_SYSDEF_POLLOUT =4
	#define GLIB_SYSDEF_POLLERR =8
	#define GLIB_SYSDEF_POLLHUP =16
	#define GLIB_SYSDEF_POLLNVAL =32

	typedef enum
	{
	G_IO_IN GLIB_SYSDEF_POLLIN,
	G_IO_OUT GLIB_SYSDEF_POLLOUT,
	G_IO_PRI GLIB_SYSDEF_POLLPRI,
	G_IO_ERR GLIB_SYSDEF_POLLERR,
	G_IO_HUP GLIB_SYSDEF_POLLHUP,
	G_IO_NVAL GLIB_SYSDEF_POLLNVAL
	} GIOCondition;

	A bitwise combination representing a condition to watch for on an event source.

	G_IO_IN There is data to read.
	G_IO_OUT Data can be written (without blocking).
	G_IO_PRI There is urgent data to read.
	G_IO_ERR Error condition.
	G_IO_HUP Hung up (the connection has been broken, usually for pipes and sockets).
	G_IO_NVAL Invalid request. The file descriptor is not open.
	*/
	crm_err("Strange condition: %d", condition);
	}

	/* G_SOURCE_REMOVE results in mainloop_gio_destroy() being called
	* just before the source is removed from mainloop
	*/
	return rc;
	}

	static void
	mainloop_gio_destroy(gpointer c)
	{
	mainloop_io_t *client = c;
	char *c_name = strdup(client->name);

	/* client->source is valid but about to be destroyed (ref_count == 0) in gmain.c
	* client->channel will still have ref_count > 0... should be == 1
	*/
	crm_trace("Destroying client %s[%p]", c_name, c);

	if (client->ipc) {
	crm_ipc_close(client->ipc);
	}

	if (client->destroy_fn) {
	void (*destroy_fn) (gpointer userdata) = client->destroy_fn;

	client->destroy_fn = NULL;
	destroy_fn(client->userdata);
	}

	if (client->ipc) {
	crm_ipc_t *ipc = client->ipc;

	client->ipc = NULL;
	crm_ipc_destroy(ipc);
	}

	crm_trace("Destroyed client %s[%p]", c_name, c);

	free(client->name); client->name = NULL;
	free(client);

	free(c_name);
	}

	/*!
	* \brief Connect to IPC and add it as a main loop source
	*
	* \param[in,out] ipc IPC connection to add
	* \param[in] priority Event source priority to use for connection
	* \param[in] userdata Data to register with callbacks
	* \param[in] callbacks Dispatch and destroy callbacks for connection
	* \param[out] source Newly allocated event source
	*
	* \return Standard Pacemaker return code
	*
	* \note On failure, the caller is still responsible for ipc. On success, the
	* caller should call mainloop_del_ipc_client() when source is no longer
	* needed, which will lead to the disconnection of the IPC later in the
	* main loop if it is connected. However the IPC disconnects,
	* mainloop_gio_destroy() will free ipc and source after calling the
	* destroy callback.
	*/
	int
	pcmk__add_mainloop_ipc(crm_ipc_t ipc, int priority, void userdata,
	const struct ipc_client_callbacks *callbacks,
	mainloop_io_t **source)
	{
	int rc = pcmk_rc_ok;
	int fd = -1;
	const char *ipc_name = NULL;

	CRM_CHECK((ipc != NULL) && (callbacks != NULL), return EINVAL);

	ipc_name = pcmk__s(crm_ipc_name(ipc), "Pacemaker");
	rc = pcmk__connect_generic_ipc(ipc);
	if (rc != pcmk_rc_ok) {
	crm_debug("Connection to %s failed: %s", ipc_name, pcmk_rc_str(rc));
	return rc;
	}

	rc = pcmk__ipc_fd(ipc, &fd);
	if (rc != pcmk_rc_ok) {
	crm_debug("Could not obtain file descriptor for %s IPC: %s",
	ipc_name, pcmk_rc_str(rc));
	crm_ipc_close(ipc);
	return rc;
	}

	*source = mainloop_add_fd(ipc_name, priority, fd, userdata, NULL);
	if (*source == NULL) {
	rc = errno;
	crm_ipc_close(ipc);
	return rc;
	}

	(*source)->ipc = ipc;
	(*source)->destroy_fn = callbacks->destroy;
	(*source)->dispatch_fn_ipc = callbacks->dispatch;
	return pcmk_rc_ok;
	}

	/*!
	* \brief Get period for mainloop timer
	*
	* \param[in] timer Timer
	*
	* \return Period in ms
	*/
	guint
	pcmk__mainloop_timer_get_period(const mainloop_timer_t *timer)
	{
	if (timer) {
	return timer->period_ms;
	}
	return 0;
	}

	mainloop_io_t *
	mainloop_add_ipc_client(const char *name, int priority, size_t max_size,
	void userdata, struct ipc_client_callbacks callbacks)
	{
	crm_ipc_t *ipc = crm_ipc_new(name, max_size);
	mainloop_io_t *source = NULL;
	int rc = pcmk__add_mainloop_ipc(ipc, priority, userdata, callbacks,
	&source);

	if (rc != pcmk_rc_ok) {
	if (crm_log_level == LOG_STDOUT) {
	fprintf(stderr, "Connection to %s failed: %s",
	name, pcmk_rc_str(rc));
	}
	crm_ipc_destroy(ipc);
	if (rc > 0) {
	errno = rc;
	} else {
	errno = ENOTCONN;
	}
	return NULL;
	}
	return source;
	}

	void
	mainloop_del_ipc_client(mainloop_io_t * client)
	{
	mainloop_del_fd(client);
	}

	crm_ipc_t *
	mainloop_get_ipc_client(mainloop_io_t * client)
	{
	if (client) {
	return client->ipc;
	}
	return NULL;
	}

	mainloop_io_t *
	mainloop_add_fd(const char name, int priority, int fd, void userdata,
	struct mainloop_fd_callbacks * callbacks)
	{
	mainloop_io_t *client = NULL;

	if (fd >= 0) {
	client = calloc(1, sizeof(mainloop_io_t));
	if (client == NULL) {
	return NULL;
	}
	client->name = strdup(name);
	client->userdata = userdata;

	if (callbacks) {
	client->destroy_fn = callbacks->destroy;
	client->dispatch_fn_io = callbacks->dispatch;
	}

	client->fd = fd;
	client->channel = g_io_channel_unix_new(fd);
	client->source =
	g_io_add_watch_full(client->channel, priority,
	(G_IO_IN \| G_IO_HUP \| G_IO_NVAL \| G_IO_ERR), mainloop_gio_callback,
	client, mainloop_gio_destroy);

	/* Now that mainloop now holds a reference to channel,
	* thanks to g_io_add_watch_full(), drop ours from g_io_channel_unix_new().
	*
	* This means that channel will be free'd by:
	* g_main_context_dispatch() or g_source_remove()
	* -> g_source_destroy_internal()
	* -> g_source_callback_unref()
	* shortly after mainloop_gio_destroy() completes
	*/
	g_io_channel_unref(client->channel);
	crm_trace("Added connection %d for %s[%p].%d", client->source, client->name, client, fd);
	} else {
	errno = EINVAL;
	}

	return client;
	}

	void
	mainloop_del_fd(mainloop_io_t * client)
	{
	if (client != NULL) {
	crm_trace("Removing client %s[%p]", client->name, client);
	if (client->source) {
	/* Results in mainloop_gio_destroy() being called just
	* before the source is removed from mainloop
	*/
	g_source_remove(client->source);
	}
	}
	}

	static GList *child_list = NULL;

	pid_t
	mainloop_child_pid(mainloop_child_t * child)
	{
	return child->pid;
	}

	const char *
	mainloop_child_name(mainloop_child_t * child)
	{
	return child->desc;
	}

	int
	mainloop_child_timeout(mainloop_child_t * child)
	{
	return child->timeout;
	}

	void *
	mainloop_child_userdata(mainloop_child_t * child)
	{
	return child->privatedata;
	}

	void
	mainloop_clear_child_userdata(mainloop_child_t * child)
	{
	child->privatedata = NULL;
	}

	/* good function name */
	static void
	child_free(mainloop_child_t *child)
	{
	if (child->timerid != 0) {
	crm_trace("Removing timer %d", child->timerid);
	g_source_remove(child->timerid);
	child->timerid = 0;
	}
	free(child->desc);
	free(child);
	}

	/* terrible function name */
	static int
	child_kill_helper(mainloop_child_t *child)
	{
	int rc;
	if (child->flags & mainloop_leave_pid_group) {
	crm_debug("Kill pid %d only. leave group intact.", child->pid);
	rc = kill(child->pid, SIGKILL);
	} else {
	crm_debug("Kill pid %d's group", child->pid);
	rc = kill(-child->pid, SIGKILL);
	}

	if (rc < 0) {
	if (errno != ESRCH) {
	crm_perror(LOG_ERR, "kill(%d, KILL) failed", child->pid);
	}
	return -errno;
	}
	return 0;
	}

	static gboolean
	child_timeout_callback(gpointer p)
	{
	mainloop_child_t *child = p;
	int rc = 0;

	child->timerid = 0;
	if (child->timeout) {
	crm_warn("%s process (PID %d) will not die!", child->desc, (int)child->pid);
	return FALSE;
	}

	rc = child_kill_helper(child);
	if (rc == -ESRCH) {
	/* Nothing left to do. pid doesn't exist */
	return FALSE;
	}

	child->timeout = TRUE;
	crm_debug("%s process (PID %d) timed out", child->desc, (int)child->pid);

	child->timerid = g_timeout_add(5000, child_timeout_callback, child);
	return FALSE;
	}

	static bool
	child_waitpid(mainloop_child_t *child, int flags)
	{
	int rc = 0;
	int core = 0;
	int signo = 0;
	int status = 0;
	int exitcode = 0;
	bool callback_needed = true;

	rc = waitpid(child->pid, &status, flags);
	if (rc == 0) { // WNOHANG in flags, and child status is not available
	crm_trace("Child process %d (%s) still active",
	child->pid, child->desc);
	callback_needed = false;

	} else if (rc != child->pid) {
	/* According to POSIX, possible conditions:
	* - child->pid was non-positive (process group or any child),
	* and rc is specific child
	* - errno ECHILD (pid does not exist or is not child)
	* - errno EINVAL (invalid flags)
	* - errno EINTR (caller interrupted by signal)
	*
	* @TODO Handle these cases more specifically.
	*/
	signo = SIGCHLD;
	exitcode = 1;
	crm_notice("Wait for child process %d (%s) interrupted: %s",
	child->pid, child->desc, pcmk_rc_str(errno));

	} else if (WIFEXITED(status)) {
	exitcode = WEXITSTATUS(status);
	crm_trace("Child process %d (%s) exited with status %d",
	child->pid, child->desc, exitcode);

	} else if (WIFSIGNALED(status)) {
	signo = WTERMSIG(status);
	crm_trace("Child process %d (%s) exited with signal %d (%s)",
	child->pid, child->desc, signo, strsignal(signo));

	#ifdef WCOREDUMP // AIX, SunOS, maybe others
	} else if (WCOREDUMP(status)) {
	core = 1;
	crm_err("Child process %d (%s) dumped core",
	child->pid, child->desc);
	#endif

	} else { // flags must contain WUNTRACED and/or WCONTINUED to reach this
	crm_trace("Child process %d (%s) stopped or continued",
	child->pid, child->desc);
	callback_needed = false;
	}

	if (callback_needed && child->callback) {
	child->callback(child, child->pid, core, signo, exitcode);
	}
	return callback_needed;
	}

	static void
	child_death_dispatch(int signal)
	{
	for (GList *iter = child_list; iter; ) {
	GList *saved = iter;
	mainloop_child_t *child = iter->data;

	iter = iter->next;
	if (child_waitpid(child, WNOHANG)) {
	crm_trace("Removing completed process %d from child list",
	child->pid);
	child_list = g_list_remove_link(child_list, saved);
	g_list_free(saved);
	child_free(child);
	}
	}
	}

	static gboolean
	child_signal_init(gpointer p)
	{
	crm_trace("Installed SIGCHLD handler");
	/* Do NOT use g_child_watch_add() and friends, they rely on pthreads */
	mainloop_add_signal(SIGCHLD, child_death_dispatch);

	/* In case they terminated before the signal handler was installed */
	child_death_dispatch(SIGCHLD);
	return FALSE;
	}

	gboolean
	mainloop_child_kill(pid_t pid)
	{
	GList *iter;
	mainloop_child_t *child = NULL;
	mainloop_child_t *match = NULL;
	/* It is impossible to block SIGKILL, this allows us to
	* call waitpid without WNOHANG flag.*/
	int waitflags = 0, rc = 0;

	for (iter = child_list; iter != NULL && match == NULL; iter = iter->next) {
	child = iter->data;
	if (pid == child->pid) {
	match = child;
	}
	}

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

	rc = child_kill_helper(match);
	if(rc == -ESRCH) {
	/* It's gone, but hasn't shown up in waitpid() yet. Wait until we get
	* SIGCHLD and let handler clean it up as normal (so we get the correct
	* return code/status). The blocking alternative would be to call
	* child_waitpid(match, 0).
	*/
	crm_trace("Waiting for signal that child process %d completed",
	match->pid);
	return TRUE;

	} else if(rc != 0) {
	/* If KILL for some other reason set the WNOHANG flag since we
	* can't be certain what happened.
	*/
	waitflags = WNOHANG;
	}

	if (!child_waitpid(match, waitflags)) {
	/* not much we can do if this occurs */
	return FALSE;
	}

	child_list = g_list_remove(child_list, match);
	child_free(match);
	return TRUE;
	}

	/* Create/Log a new tracked process
	* To track a process group, use -pid
	*
	* @TODO Using a non-positive pid (i.e. any child, or process group) would
	* likely not be useful since we will free the child after the first
	* completed process.
	*/
	void
	mainloop_child_add_with_flags(pid_t pid, int timeout, const char desc, void privatedata, enum mainloop_child_flags flags,
	void (callback) (mainloop_child_t p, pid_t pid, int core, int signo, int exitcode))
	{
	static bool need_init = TRUE;
	mainloop_child_t *child = pcmk__assert_alloc(1, sizeof(mainloop_child_t));

	child->pid = pid;
	child->timerid = 0;
	child->timeout = FALSE;
	child->privatedata = privatedata;
	child->callback = callback;
	child->flags = flags;
	child->desc = pcmk__str_copy(desc);

	if (timeout) {
	child->timerid = g_timeout_add(timeout, child_timeout_callback, child);
	}

	child_list = g_list_append(child_list, child);

	if(need_init) {
	need_init = FALSE;
	/* SIGCHLD processing has to be invoked from mainloop.
	* We do not want it to be possible to both add a child pid
	* to mainloop, and have the pid's exit callback invoked within
	* the same callstack. */
	g_timeout_add(1, child_signal_init, NULL);
	}
	}

	void
	mainloop_child_add(pid_t pid, int timeout, const char desc, void privatedata,
	void (callback) (mainloop_child_t p, pid_t pid, int core, int signo, int exitcode))
	{
	mainloop_child_add_with_flags(pid, timeout, desc, privatedata, 0, callback);
	}

	static gboolean
	mainloop_timer_cb(gpointer user_data)
	{
	int id = 0;
	bool repeat = FALSE;
	struct mainloop_timer_s *t = user_data;

	pcmk__assert(t != NULL);

	id = t->id;
	t->id = 0; /* Ensure it's unset during callbacks so that
	* mainloop_timer_running() works as expected
	*/

	if(t->cb) {
	crm_trace("Invoking callbacks for timer %s", t->name);
	repeat = t->repeat;
	if(t->cb(t->userdata) == FALSE) {
	crm_trace("Timer %s complete", t->name);
	repeat = FALSE;
	}
	}

	if(repeat) {
	/* Restore if repeating */
	t->id = id;
	}

	return repeat;
	}

	bool
	mainloop_timer_running(mainloop_timer_t *t)
	{
	if(t && t->id != 0) {
	return TRUE;
	}
	return FALSE;
	}

	void
	mainloop_timer_start(mainloop_timer_t *t)
	{
	mainloop_timer_stop(t);
	if(t && t->period_ms > 0) {
	crm_trace("Starting timer %s", t->name);
	t->id = g_timeout_add(t->period_ms, mainloop_timer_cb, t);
	}
	}

	void
	mainloop_timer_stop(mainloop_timer_t *t)
	{
	if(t && t->id != 0) {
	crm_trace("Stopping timer %s", t->name);
	g_source_remove(t->id);
	t->id = 0;
	}
	}

	guint
	mainloop_timer_set_period(mainloop_timer_t *t, guint period_ms)
	{
	guint last = 0;

	if(t) {
	last = t->period_ms;
	t->period_ms = period_ms;
	}

	if(t && t->id != 0 && last != t->period_ms) {
	mainloop_timer_start(t);
	}
	return last;
	}

	mainloop_timer_t *
	mainloop_timer_add(const char name, guint period_ms, bool repeat, GSourceFunc cb, void userdata)
	{
	mainloop_timer_t *t = pcmk__assert_alloc(1, sizeof(mainloop_timer_t));

	if (name != NULL) {
	t->name = crm_strdup_printf("%s-%u-%d", name, period_ms, repeat);
	} else {
	t->name = crm_strdup_printf("%p-%u-%d", t, period_ms, repeat);
	}
	t->id = 0;
	t->period_ms = period_ms;
	t->repeat = repeat;
	t->cb = cb;
	t->userdata = userdata;
	crm_trace("Created timer %s with %p %p", t->name, userdata, t->userdata);
	return t;
	}

	void
	mainloop_timer_del(mainloop_timer_t *t)
	{
	if(t) {
	crm_trace("Destroying timer %s", t->name);
	mainloop_timer_stop(t);
	free(t->name);
	free(t);
	}
	}

	/*
	* Helpers to make sure certain events aren't lost at shutdown
	*/

	static gboolean
	drain_timeout_cb(gpointer user_data)
	{
	bool timeout_popped = (bool) user_data;

	*timeout_popped = TRUE;
	return FALSE;
	}

	/*!
	* \brief Drain some remaining main loop events then quit it
	*
	* \param[in,out] mloop Main loop to drain and quit
	* \param[in] n Drain up to this many pending events
	*/
	void
	pcmk_quit_main_loop(GMainLoop *mloop, unsigned int n)
	{
	if ((mloop != NULL) && g_main_loop_is_running(mloop)) {
	GMainContext *ctx = g_main_loop_get_context(mloop);

	/* Drain up to n events in case some memory clean-up is pending
	* (helpful to reduce noise in valgrind output).
	*/
	for (int i = 0; (i < n) && g_main_context_pending(ctx); ++i) {
	g_main_context_dispatch(ctx);
	}
	g_main_loop_quit(mloop);
	}
	}

	/*!
	* \brief Process main loop events while a certain condition is met
	*
	* \param[in,out] mloop Main loop to process
	* \param[in] timer_ms Don't process longer than this amount of time
	* \param[in] check Function that returns true if events should be
	* processed
	*
	* \note This function is intended to be called at shutdown if certain important
	* events should not be missed. The caller would likely quit the main loop
	* or exit after calling this function. The check() function will be
	* passed the remaining timeout in milliseconds.
	*/
	void
	pcmk_drain_main_loop(GMainLoop mloop, guint timer_ms, bool (check)(guint))
	{
	bool timeout_popped = FALSE;
	guint timer = 0;
	GMainContext *ctx = NULL;

	CRM_CHECK(mloop && check, return);

	ctx = g_main_loop_get_context(mloop);
	if (ctx) {
	time_t start_time = time(NULL);

	timer = g_timeout_add(timer_ms, drain_timeout_cb, &timeout_popped);
	while (!timeout_popped
	&& check(timer_ms - (time(NULL) - start_time) * 1000)) {
	g_main_context_iteration(ctx, TRUE);
	}
	}
	if (!timeout_popped && (timer > 0)) {
	g_source_remove(timer);
	}
	}

	// Deprecated functions kept only for backward API compatibility
	// LCOV_EXCL_START

	#include <crm/common/mainloop_compat.h>

	gboolean
	crm_signal(int sig, void (*dispatch) (int sig))
	{
	return crm_signal_handler(sig, dispatch) != SIG_ERR;
	}

	// LCOV_EXCL_STOP
	// End deprecated API
	diff --git a/lib/common/results.c b/lib/common/results.c
	index 60306f6bd3..957725bfd3 100644
	--- a/lib/common/results.c
	+++ b/lib/common/results.c
	@@ -1,1256 +1,1246 @@
	/*
	* Copyright 2004-2024 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

	#ifndef _GNU_SOURCE
	# define _GNU_SOURCE
	#endif

	#include <bzlib.h>
	#include <errno.h>
	#include <netdb.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/types.h>
	#include <sys/wait.h>
	#include <qb/qbdefs.h>

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

	G_DEFINE_QUARK(pcmk-rc-error-quark, pcmk__rc_error)
	G_DEFINE_QUARK(pcmk-exitc-error-quark, pcmk__exitc_error)

	// General (all result code types)

	/*!
	* \brief Get the name and description of a given result code
	*
	* A result code can be interpreted as a member of any one of several families.
	*
	* \param[in] code The result code to look up
	* \param[in] type How \p code should be interpreted
	* \param[out] name Where to store the result code's name
	* \param[out] desc Where to store the result code's description
	*
	* \return Standard Pacemaker return code
	*/
	int
	pcmk_result_get_strings(int code, enum pcmk_result_type type, const char **name,
	const char **desc)
	{
	const char *code_name = NULL;
	const char *code_desc = NULL;

	switch (type) {
	case pcmk_result_legacy:
	code_name = pcmk_errorname(code);
	code_desc = pcmk_strerror(code);
	break;
	case pcmk_result_rc:
	code_name = pcmk_rc_name(code);
	code_desc = pcmk_rc_str(code);
	break;
	case pcmk_result_exitcode:
	code_name = crm_exit_name(code);
	code_desc = crm_exit_str((crm_exit_t) code);
	break;
	default:
	return pcmk_rc_undetermined;
	}

	if (name != NULL) {
	*name = code_name;
	}

	if (desc != NULL) {
	*desc = code_desc;
	}
	return pcmk_rc_ok;
	}

	/*!
	* \internal
	* \brief Get the lower and upper bounds of a result code family
	*
	* \param[in] type Type of result code
	* \param[out] lower Where to store the lower bound
	* \param[out] upper Where to store the upper bound
	*
	* \return Standard Pacemaker return code
	*
	* \note There is no true upper bound on standard Pacemaker return codes or
	* legacy return codes. All system \p errno values are valid members of
	* these result code families, and there is no global upper limit nor a
	* constant by which to refer to the highest \p errno value on a given
	* system.
	*/
	int
	pcmk__result_bounds(enum pcmk_result_type type, int lower, int upper)
	{
	pcmk__assert((lower != NULL) && (upper != NULL));

	switch (type) {
	case pcmk_result_legacy:
	*lower = pcmk_ok;
	*upper = 256; // should be enough for almost any system error code
	break;
	case pcmk_result_rc:
	*lower = pcmk_rc_error - pcmk__n_rc + 1;
	*upper = 256;
	break;
	case pcmk_result_exitcode:
	*lower = CRM_EX_OK;
	*upper = CRM_EX_MAX;
	break;
	default:
	*lower = 0;
	*upper = -1;
	return pcmk_rc_undetermined;
	}
	return pcmk_rc_ok;
	}

	// @COMPAT Legacy function return codes

	//! \deprecated Use standard return codes and pcmk_rc_name() instead
	const char *
	pcmk_errorname(int rc)
	{
	rc = abs(rc);
	switch (rc) {
	case pcmk_err_generic: return "pcmk_err_generic";
	case pcmk_err_no_quorum: return "pcmk_err_no_quorum";
	case pcmk_err_schema_validation: return "pcmk_err_schema_validation";
	case pcmk_err_transform_failed: return "pcmk_err_transform_failed";
	case pcmk_err_old_data: return "pcmk_err_old_data";
	case pcmk_err_diff_failed: return "pcmk_err_diff_failed";
	case pcmk_err_diff_resync: return "pcmk_err_diff_resync";
	case pcmk_err_cib_modified: return "pcmk_err_cib_modified";
	case pcmk_err_cib_backup: return "pcmk_err_cib_backup";
	case pcmk_err_cib_save: return "pcmk_err_cib_save";
	case pcmk_err_cib_corrupt: return "pcmk_err_cib_corrupt";
	case pcmk_err_multiple: return "pcmk_err_multiple";
	case pcmk_err_node_unknown: return "pcmk_err_node_unknown";
	case pcmk_err_already: return "pcmk_err_already";
	case pcmk_err_bad_nvpair: return "pcmk_err_bad_nvpair";
	case pcmk_err_unknown_format: return "pcmk_err_unknown_format";
	default: return pcmk_rc_name(rc); // system errno
	}
	}

	//! \deprecated Use standard return codes and pcmk_rc_str() instead
	const char *
	pcmk_strerror(int rc)
	{
	return pcmk_rc_str(pcmk_legacy2rc(rc));
	}

	// Standard Pacemaker API return codes

	/* This array is used only for nonzero values of pcmk_rc_e. Its values must be
	* kept in the exact reverse order of the enum value numbering (i.e. add new
	* values to the end of the array).
	*/
	static const struct pcmk__rc_info {
	const char *name;
	const char *desc;
	int legacy_rc;
	} pcmk__rcs[] = {
	{ "pcmk_rc_error",
	"Error",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_unknown_format",
	"Unknown output format",
	-pcmk_err_unknown_format,
	},
	{ "pcmk_rc_bad_nvpair",
	"Bad name/value pair given",
	-pcmk_err_bad_nvpair,
	},
	{ "pcmk_rc_already",
	"Already in requested state",
	-pcmk_err_already,
	},
	{ "pcmk_rc_node_unknown",
	"Node not found",
	-pcmk_err_node_unknown,
	},
	{ "pcmk_rc_multiple",
	"Resource active on multiple nodes",
	-pcmk_err_multiple,
	},
	{ "pcmk_rc_cib_corrupt",
	"Could not parse on-disk configuration",
	-pcmk_err_cib_corrupt,
	},
	{ "pcmk_rc_cib_save",
	"Could not save new configuration to disk",
	-pcmk_err_cib_save,
	},
	{ "pcmk_rc_cib_backup",
	"Could not archive previous configuration",
	-pcmk_err_cib_backup,
	},
	{ "pcmk_rc_cib_modified",
	"On-disk configuration was manually modified",
	-pcmk_err_cib_modified,
	},
	{ "pcmk_rc_diff_resync",
	"Application of update diff failed, requesting full refresh",
	-pcmk_err_diff_resync,
	},
	{ "pcmk_rc_diff_failed",
	"Application of update diff failed",
	-pcmk_err_diff_failed,
	},
	{ "pcmk_rc_old_data",
	"Update was older than existing configuration",
	-pcmk_err_old_data,
	},
	{ "pcmk_rc_transform_failed",
	"Schema transform failed",
	-pcmk_err_transform_failed,
	},
	{ "pcmk_rc_schema_unchanged",
	"Schema is already the latest available",
	-pcmk_err_schema_unchanged,
	},
	{ "pcmk_rc_schema_validation",
	"Update does not conform to the configured schema",
	-pcmk_err_schema_validation,
	},
	{ "pcmk_rc_no_quorum",
	"Operation requires quorum",
	-pcmk_err_no_quorum,
	},
	{ "pcmk_rc_ipc_unauthorized",
	"IPC server is blocked by unauthorized process",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_ipc_unresponsive",
	"IPC server is unresponsive",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_ipc_pid_only",
	"IPC server process is active but not accepting connections",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_op_unsatisfied",
	"Not applicable under current conditions",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_undetermined",
	"Result undetermined",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_before_range",
	"Result occurs before given range",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_within_range",
	"Result occurs within given range",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_after_range",
	"Result occurs after given range",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_no_output",
	"Output message produced no output",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_no_input",
	"Input file not available",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_underflow",
	"Value too small to be stored in data type",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_dot_error",
	"Error writing dot(1) file",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_graph_error",
	"Error writing graph file",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_invalid_transition",
	"Cluster simulation produced invalid transition",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_unpack_error",
	"Unable to parse CIB XML",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_duplicate_id",
	"Two or more XML elements have the same ID",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_disabled",
	"Disabled",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_bad_input",
	"Bad input value provided",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_bad_xml_patch",
	"Bad XML patch format",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_no_transaction",
	"No active transaction found",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_ns_resolution",
	"Nameserver resolution error",
	-pcmk_err_generic,
	},
	{ "pcmk_rc_compression",
	"Compression/decompression error",
	-pcmk_err_generic,
	},
	};

	/*!
	* \internal
	* \brief The number of <tt>enum pcmk_rc_e</tt> values, excluding \c pcmk_rc_ok
	*
	* This constant stores the number of negative standard Pacemaker return codes.
	* These represent Pacemaker-custom error codes. The count does not include
	* positive system error numbers, nor does it include \c pcmk_rc_ok (success).
	*/
	const size_t pcmk__n_rc = PCMK__NELEM(pcmk__rcs);

	/*!
	* \brief Get a return code constant name as a string
	*
	* \param[in] rc Integer return code to convert
	*
	* \return String of constant name corresponding to rc
	*/
	const char *
	pcmk_rc_name(int rc)
	{
	if ((rc <= pcmk_rc_error) && ((pcmk_rc_error - rc) < pcmk__n_rc)) {
	return pcmk__rcs[pcmk_rc_error - rc].name;
	}
	switch (rc) {
	case pcmk_rc_ok: return "pcmk_rc_ok";
	case E2BIG: return "E2BIG";
	case EACCES: return "EACCES";
	case EADDRINUSE: return "EADDRINUSE";
	case EADDRNOTAVAIL: return "EADDRNOTAVAIL";
	case EAFNOSUPPORT: return "EAFNOSUPPORT";
	case EAGAIN: return "EAGAIN";
	case EALREADY: return "EALREADY";
	case EBADF: return "EBADF";
	case EBADMSG: return "EBADMSG";
	case EBUSY: return "EBUSY";
	case ECANCELED: return "ECANCELED";
	case ECHILD: return "ECHILD";
	case ECOMM: return "ECOMM";
	case ECONNABORTED: return "ECONNABORTED";
	case ECONNREFUSED: return "ECONNREFUSED";
	case ECONNRESET: return "ECONNRESET";
	/* case EDEADLK: return "EDEADLK"; */
	case EDESTADDRREQ: return "EDESTADDRREQ";
	case EDOM: return "EDOM";
	case EDQUOT: return "EDQUOT";
	case EEXIST: return "EEXIST";
	case EFAULT: return "EFAULT";
	case EFBIG: return "EFBIG";
	case EHOSTDOWN: return "EHOSTDOWN";
	case EHOSTUNREACH: return "EHOSTUNREACH";
	case EIDRM: return "EIDRM";
	case EILSEQ: return "EILSEQ";
	case EINPROGRESS: return "EINPROGRESS";
	case EINTR: return "EINTR";
	case EINVAL: return "EINVAL";
	case EIO: return "EIO";
	case EISCONN: return "EISCONN";
	case EISDIR: return "EISDIR";
	case ELIBACC: return "ELIBACC";
	case ELOOP: return "ELOOP";
	case EMFILE: return "EMFILE";
	case EMLINK: return "EMLINK";
	case EMSGSIZE: return "EMSGSIZE";
	#ifdef EMULTIHOP // Not available on OpenBSD
	case EMULTIHOP: return "EMULTIHOP";
	#endif
	case ENAMETOOLONG: return "ENAMETOOLONG";
	case ENETDOWN: return "ENETDOWN";
	case ENETRESET: return "ENETRESET";
	case ENETUNREACH: return "ENETUNREACH";
	case ENFILE: return "ENFILE";
	case ENOBUFS: return "ENOBUFS";
	case ENODATA: return "ENODATA";
	case ENODEV: return "ENODEV";
	case ENOENT: return "ENOENT";
	case ENOEXEC: return "ENOEXEC";
	case ENOKEY: return "ENOKEY";
	case ENOLCK: return "ENOLCK";
	#ifdef ENOLINK // Not available on OpenBSD
	case ENOLINK: return "ENOLINK";
	#endif
	case ENOMEM: return "ENOMEM";
	case ENOMSG: return "ENOMSG";
	case ENOPROTOOPT: return "ENOPROTOOPT";
	case ENOSPC: return "ENOSPC";
	#ifdef ENOSR
	case ENOSR: return "ENOSR";
	#endif
	#ifdef ENOSTR
	case ENOSTR: return "ENOSTR";
	#endif
	case ENOSYS: return "ENOSYS";
	case ENOTBLK: return "ENOTBLK";
	case ENOTCONN: return "ENOTCONN";
	case ENOTDIR: return "ENOTDIR";
	case ENOTEMPTY: return "ENOTEMPTY";
	case ENOTSOCK: return "ENOTSOCK";
	#if ENOTSUP != EOPNOTSUPP
	case ENOTSUP: return "ENOTSUP";
	#endif
	case ENOTTY: return "ENOTTY";
	case ENOTUNIQ: return "ENOTUNIQ";
	case ENXIO: return "ENXIO";
	case EOPNOTSUPP: return "EOPNOTSUPP";
	case EOVERFLOW: return "EOVERFLOW";
	case EPERM: return "EPERM";
	case EPFNOSUPPORT: return "EPFNOSUPPORT";
	case EPIPE: return "EPIPE";
	case EPROTO: return "EPROTO";
	case EPROTONOSUPPORT: return "EPROTONOSUPPORT";
	case EPROTOTYPE: return "EPROTOTYPE";
	case ERANGE: return "ERANGE";
	case EREMOTE: return "EREMOTE";
	case EREMOTEIO: return "EREMOTEIO";
	case EROFS: return "EROFS";
	case ESHUTDOWN: return "ESHUTDOWN";
	case ESPIPE: return "ESPIPE";
	case ESOCKTNOSUPPORT: return "ESOCKTNOSUPPORT";
	case ESRCH: return "ESRCH";
	case ESTALE: return "ESTALE";
	case ETIME: return "ETIME";
	case ETIMEDOUT: return "ETIMEDOUT";
	case ETXTBSY: return "ETXTBSY";
	#ifdef EUNATCH
	case EUNATCH: return "EUNATCH";
	#endif
	case EUSERS: return "EUSERS";
	/* case EWOULDBLOCK: return "EWOULDBLOCK"; */
	case EXDEV: return "EXDEV";

	#ifdef EBADE // Not available on OS X
	case EBADE: return "EBADE";
	case EBADFD: return "EBADFD";
	case EBADSLT: return "EBADSLT";
	case EDEADLOCK: return "EDEADLOCK";
	case EBADR: return "EBADR";
	case EBADRQC: return "EBADRQC";
	case ECHRNG: return "ECHRNG";
	#ifdef EISNAM // Not available on OS X, Illumos, Solaris
	case EISNAM: return "EISNAM";
	case EKEYEXPIRED: return "EKEYEXPIRED";
	case EKEYREVOKED: return "EKEYREVOKED";
	#endif
	case EKEYREJECTED: return "EKEYREJECTED";
	case EL2HLT: return "EL2HLT";
	case EL2NSYNC: return "EL2NSYNC";
	case EL3HLT: return "EL3HLT";
	case EL3RST: return "EL3RST";
	case ELIBBAD: return "ELIBBAD";
	case ELIBMAX: return "ELIBMAX";
	case ELIBSCN: return "ELIBSCN";
	case ELIBEXEC: return "ELIBEXEC";
	#ifdef ENOMEDIUM // Not available on OS X, Illumos, Solaris
	case ENOMEDIUM: return "ENOMEDIUM";
	case EMEDIUMTYPE: return "EMEDIUMTYPE";
	#endif
	case ENONET: return "ENONET";
	case ENOPKG: return "ENOPKG";
	case EREMCHG: return "EREMCHG";
	case ERESTART: return "ERESTART";
	case ESTRPIPE: return "ESTRPIPE";
	#ifdef EUCLEAN // Not available on OS X, Illumos, Solaris
	case EUCLEAN: return "EUCLEAN";
	#endif
	case EXFULL: return "EXFULL";
	#endif // EBADE
	default: return "Unknown";
	}
	}

	/*!
	* \brief Get a user-friendly description of a return code
	*
	* \param[in] rc Integer return code to convert
	*
	* \return String description of rc
	*/
	const char *
	pcmk_rc_str(int rc)
	{
	if (rc == pcmk_rc_ok) {
	return "OK";
	}
	if ((rc <= pcmk_rc_error) && ((pcmk_rc_error - rc) < pcmk__n_rc)) {
	return pcmk__rcs[pcmk_rc_error - rc].desc;
	}
	if (rc < 0) {
	return "Error";
	}

	// Handle values that could be defined by system or by portability.h
	switch (rc) {
	#ifdef PCMK__ENOTUNIQ
	case ENOTUNIQ: return "Name not unique on network";
	#endif
	#ifdef PCMK__ECOMM
	case ECOMM: return "Communication error on send";
	#endif
	#ifdef PCMK__ELIBACC
	case ELIBACC: return "Can not access a needed shared library";
	#endif
	#ifdef PCMK__EREMOTEIO
	case EREMOTEIO: return "Remote I/O error";
	#endif
	#ifdef PCMK__ENOKEY
	case ENOKEY: return "Required key not available";
	#endif
	#ifdef PCMK__ENODATA
	case ENODATA: return "No data available";
	#endif
	#ifdef PCMK__ETIME
	case ETIME: return "Timer expired";
	#endif
	#ifdef PCMK__EKEYREJECTED
	case EKEYREJECTED: return "Key was rejected by service";
	#endif
	default: return strerror(rc);
	}
	}

	// This returns negative values for errors
	//! \deprecated Use standard return codes instead
	int
	pcmk_rc2legacy(int rc)
	{
	if (rc >= 0) {
	return -rc; // OK or system errno
	}
	if ((rc <= pcmk_rc_error) && ((pcmk_rc_error - rc) < pcmk__n_rc)) {
	return pcmk__rcs[pcmk_rc_error - rc].legacy_rc;
	}
	return -pcmk_err_generic;
	}

	//! \deprecated Use standard return codes instead
	int
	pcmk_legacy2rc(int legacy_rc)
	{
	legacy_rc = abs(legacy_rc);
	switch (legacy_rc) {
	case pcmk_err_no_quorum: return pcmk_rc_no_quorum;
	case pcmk_err_schema_validation: return pcmk_rc_schema_validation;
	case pcmk_err_schema_unchanged: return pcmk_rc_schema_unchanged;
	case pcmk_err_transform_failed: return pcmk_rc_transform_failed;
	case pcmk_err_old_data: return pcmk_rc_old_data;
	case pcmk_err_diff_failed: return pcmk_rc_diff_failed;
	case pcmk_err_diff_resync: return pcmk_rc_diff_resync;
	case pcmk_err_cib_modified: return pcmk_rc_cib_modified;
	case pcmk_err_cib_backup: return pcmk_rc_cib_backup;
	case pcmk_err_cib_save: return pcmk_rc_cib_save;
	case pcmk_err_cib_corrupt: return pcmk_rc_cib_corrupt;
	case pcmk_err_multiple: return pcmk_rc_multiple;
	case pcmk_err_node_unknown: return pcmk_rc_node_unknown;
	case pcmk_err_already: return pcmk_rc_already;
	case pcmk_err_bad_nvpair: return pcmk_rc_bad_nvpair;
	case pcmk_err_unknown_format: return pcmk_rc_unknown_format;
	case pcmk_err_generic: return pcmk_rc_error;
	case pcmk_ok: return pcmk_rc_ok;
	default: return legacy_rc; // system errno
	}
	}

	// Exit status codes

	const char *
	crm_exit_name(crm_exit_t exit_code)
	{
	switch (exit_code) {
	case CRM_EX_OK: return "CRM_EX_OK";
	case CRM_EX_ERROR: return "CRM_EX_ERROR";
	case CRM_EX_INVALID_PARAM: return "CRM_EX_INVALID_PARAM";
	case CRM_EX_UNIMPLEMENT_FEATURE: return "CRM_EX_UNIMPLEMENT_FEATURE";
	case CRM_EX_INSUFFICIENT_PRIV: return "CRM_EX_INSUFFICIENT_PRIV";
	case CRM_EX_NOT_INSTALLED: return "CRM_EX_NOT_INSTALLED";
	case CRM_EX_NOT_CONFIGURED: return "CRM_EX_NOT_CONFIGURED";
	case CRM_EX_NOT_RUNNING: return "CRM_EX_NOT_RUNNING";
	case CRM_EX_PROMOTED: return "CRM_EX_PROMOTED";
	case CRM_EX_FAILED_PROMOTED: return "CRM_EX_FAILED_PROMOTED";
	case CRM_EX_USAGE: return "CRM_EX_USAGE";
	case CRM_EX_DATAERR: return "CRM_EX_DATAERR";
	case CRM_EX_NOINPUT: return "CRM_EX_NOINPUT";
	case CRM_EX_NOUSER: return "CRM_EX_NOUSER";
	case CRM_EX_NOHOST: return "CRM_EX_NOHOST";
	case CRM_EX_UNAVAILABLE: return "CRM_EX_UNAVAILABLE";
	case CRM_EX_SOFTWARE: return "CRM_EX_SOFTWARE";
	case CRM_EX_OSERR: return "CRM_EX_OSERR";
	case CRM_EX_OSFILE: return "CRM_EX_OSFILE";
	case CRM_EX_CANTCREAT: return "CRM_EX_CANTCREAT";
	case CRM_EX_IOERR: return "CRM_EX_IOERR";
	case CRM_EX_TEMPFAIL: return "CRM_EX_TEMPFAIL";
	case CRM_EX_PROTOCOL: return "CRM_EX_PROTOCOL";
	case CRM_EX_NOPERM: return "CRM_EX_NOPERM";
	case CRM_EX_CONFIG: return "CRM_EX_CONFIG";
	case CRM_EX_FATAL: return "CRM_EX_FATAL";
	case CRM_EX_PANIC: return "CRM_EX_PANIC";
	case CRM_EX_DISCONNECT: return "CRM_EX_DISCONNECT";
	case CRM_EX_DIGEST: return "CRM_EX_DIGEST";
	case CRM_EX_NOSUCH: return "CRM_EX_NOSUCH";
	case CRM_EX_QUORUM: return "CRM_EX_QUORUM";
	case CRM_EX_UNSAFE: return "CRM_EX_UNSAFE";
	case CRM_EX_EXISTS: return "CRM_EX_EXISTS";
	case CRM_EX_MULTIPLE: return "CRM_EX_MULTIPLE";
	case CRM_EX_EXPIRED: return "CRM_EX_EXPIRED";
	case CRM_EX_NOT_YET_IN_EFFECT: return "CRM_EX_NOT_YET_IN_EFFECT";
	case CRM_EX_INDETERMINATE: return "CRM_EX_INDETERMINATE";
	case CRM_EX_UNSATISFIED: return "CRM_EX_UNSATISFIED";
	case CRM_EX_OLD: return "CRM_EX_OLD";
	case CRM_EX_TIMEOUT: return "CRM_EX_TIMEOUT";
	case CRM_EX_DEGRADED: return "CRM_EX_DEGRADED";
	case CRM_EX_DEGRADED_PROMOTED: return "CRM_EX_DEGRADED_PROMOTED";
	case CRM_EX_NONE: return "CRM_EX_NONE";
	case CRM_EX_MAX: return "CRM_EX_UNKNOWN";
	}
	return "CRM_EX_UNKNOWN";
	}

	const char *
	crm_exit_str(crm_exit_t exit_code)
	{
	switch (exit_code) {
	case CRM_EX_OK: return "OK";
	case CRM_EX_ERROR: return "Error occurred";
	case CRM_EX_INVALID_PARAM: return "Invalid parameter";
	case CRM_EX_UNIMPLEMENT_FEATURE: return "Unimplemented";
	case CRM_EX_INSUFFICIENT_PRIV: return "Insufficient privileges";
	case CRM_EX_NOT_INSTALLED: return "Not installed";
	case CRM_EX_NOT_CONFIGURED: return "Not configured";
	case CRM_EX_NOT_RUNNING: return "Not running";
	case CRM_EX_PROMOTED: return "Promoted";
	case CRM_EX_FAILED_PROMOTED: return "Failed in promoted role";
	case CRM_EX_USAGE: return "Incorrect usage";
	case CRM_EX_DATAERR: return "Invalid data given";
	case CRM_EX_NOINPUT: return "Input file not available";
	case CRM_EX_NOUSER: return "User does not exist";
	case CRM_EX_NOHOST: return "Host does not exist";
	case CRM_EX_UNAVAILABLE: return "Necessary service unavailable";
	case CRM_EX_SOFTWARE: return "Internal software bug";
	case CRM_EX_OSERR: return "Operating system error occurred";
	case CRM_EX_OSFILE: return "System file not available";
	case CRM_EX_CANTCREAT: return "Cannot create output file";
	case CRM_EX_IOERR: return "I/O error occurred";
	case CRM_EX_TEMPFAIL: return "Temporary failure, try again";
	case CRM_EX_PROTOCOL: return "Protocol violated";
	case CRM_EX_NOPERM: return "Insufficient privileges";
	case CRM_EX_CONFIG: return "Invalid configuration";
	case CRM_EX_FATAL: return "Fatal error occurred, will not respawn";
	case CRM_EX_PANIC: return "System panic required";
	case CRM_EX_DISCONNECT: return "Not connected";
	case CRM_EX_DIGEST: return "Digest mismatch";
	case CRM_EX_NOSUCH: return "No such object";
	case CRM_EX_QUORUM: return "Quorum required";
	case CRM_EX_UNSAFE: return "Operation not safe";
	case CRM_EX_EXISTS: return "Requested item already exists";
	case CRM_EX_MULTIPLE: return "Multiple items match request";
	case CRM_EX_EXPIRED: return "Requested item has expired";
	case CRM_EX_NOT_YET_IN_EFFECT: return "Requested item is not yet in effect";
	case CRM_EX_INDETERMINATE: return "Could not determine status";
	case CRM_EX_UNSATISFIED: return "Not applicable under current conditions";
	case CRM_EX_OLD: return "Update was older than existing configuration";
	case CRM_EX_TIMEOUT: return "Timeout occurred";
	case CRM_EX_DEGRADED: return "Service is active but might fail soon";
	case CRM_EX_DEGRADED_PROMOTED: return "Service is promoted but might fail soon";
	case CRM_EX_NONE: return "No exit status available";
	case CRM_EX_MAX: return "Error occurred";
	}
	if ((exit_code > 128) && (exit_code < CRM_EX_MAX)) {
	return "Interrupted by signal";
	}
	return "Unknown exit status";
	}

	/*!
	* \brief Map a function return code to the most similar exit code
	*
	* \param[in] rc Function return code
	*
	* \return Most similar exit code
	*/
	crm_exit_t
	pcmk_rc2exitc(int rc)
	{
	switch (rc) {
	case pcmk_rc_ok:
	case pcmk_rc_no_output: // quiet mode, or nothing to output
	return CRM_EX_OK;

	case pcmk_rc_no_quorum:
	return CRM_EX_QUORUM;

	case pcmk_rc_old_data:
	return CRM_EX_OLD;

	case pcmk_rc_schema_validation:
	case pcmk_rc_transform_failed:
	case pcmk_rc_unpack_error:
	return CRM_EX_CONFIG;

	case pcmk_rc_bad_nvpair:
	return CRM_EX_INVALID_PARAM;

	case EACCES:
	return CRM_EX_INSUFFICIENT_PRIV;

	case EBADF:
	case EINVAL:
	case EFAULT:
	case ENOSYS:
	case EOVERFLOW:
	case pcmk_rc_underflow:
	case pcmk_rc_compression:
	return CRM_EX_SOFTWARE;

	case EBADMSG:
	case EMSGSIZE:
	case ENOMSG:
	case ENOPROTOOPT:
	case EPROTO:
	case EPROTONOSUPPORT:
	case EPROTOTYPE:
	return CRM_EX_PROTOCOL;

	case ECOMM:
	case ENOMEM:
	return CRM_EX_OSERR;

	case ECONNABORTED:
	case ECONNREFUSED:
	case ECONNRESET:
	case ENOTCONN:
	return CRM_EX_DISCONNECT;

	case EEXIST:
	case pcmk_rc_already:
	return CRM_EX_EXISTS;

	case EIO:
	case pcmk_rc_dot_error:
	case pcmk_rc_graph_error:
	return CRM_EX_IOERR;

	case ENOTSUP:
	#if EOPNOTSUPP != ENOTSUP
	case EOPNOTSUPP:
	#endif
	return CRM_EX_UNIMPLEMENT_FEATURE;

	case ENOTUNIQ:
	case pcmk_rc_multiple:
	return CRM_EX_MULTIPLE;

	case ENODEV:
	case ENOENT:
	case ENXIO:
	case pcmk_rc_no_transaction:
	case pcmk_rc_unknown_format:
	return CRM_EX_NOSUCH;

	case pcmk_rc_node_unknown:
	case pcmk_rc_ns_resolution:
	return CRM_EX_NOHOST;

	case ETIME:
	case ETIMEDOUT:
	return CRM_EX_TIMEOUT;

	case EAGAIN:
	case EBUSY:
	return CRM_EX_UNSATISFIED;

	case pcmk_rc_before_range:
	return CRM_EX_NOT_YET_IN_EFFECT;

	case pcmk_rc_after_range:
	return CRM_EX_EXPIRED;

	case pcmk_rc_undetermined:
	return CRM_EX_INDETERMINATE;

	case pcmk_rc_op_unsatisfied:
	return CRM_EX_UNSATISFIED;

	case pcmk_rc_within_range:
	return CRM_EX_OK;

	case pcmk_rc_no_input:
	return CRM_EX_NOINPUT;

	case pcmk_rc_duplicate_id:
	return CRM_EX_MULTIPLE;

	case pcmk_rc_bad_input:
	case pcmk_rc_bad_xml_patch:
	return CRM_EX_DATAERR;

	default:
	return CRM_EX_ERROR;
	}
	}

	/*!
	* \brief Map a function return code to the most similar OCF exit code
	*
	* \param[in] rc Function return code
	*
	* \return Most similar OCF exit code
	*/
	enum ocf_exitcode
	pcmk_rc2ocf(int rc)
	{
	switch (rc) {
	case pcmk_rc_ok:
	return PCMK_OCF_OK;

	case pcmk_rc_bad_nvpair:
	return PCMK_OCF_INVALID_PARAM;

	case EACCES:
	return PCMK_OCF_INSUFFICIENT_PRIV;

	case ENOTSUP:
	#if EOPNOTSUPP != ENOTSUP
	case EOPNOTSUPP:
	#endif
	return PCMK_OCF_UNIMPLEMENT_FEATURE;

	default:
	return PCMK_OCF_UNKNOWN_ERROR;
	}
	}


	// Other functions

	/*!
	* \brief Map a getaddrinfo() return code to the most similar Pacemaker
	* return code
	*
	* \param[in] gai getaddrinfo() return code
	*
	* \return Most similar Pacemaker return code
	*/
	int
	pcmk__gaierror2rc(int gai)
	{
	switch (gai) {
	case 0:
	return pcmk_rc_ok;

	case EAI_AGAIN:
	return EAGAIN;

	case EAI_BADFLAGS:
	case EAI_SERVICE:
	return EINVAL;

	case EAI_FAMILY:
	return EAFNOSUPPORT;

	case EAI_MEMORY:
	return ENOMEM;

	case EAI_NONAME:
	return pcmk_rc_node_unknown;

	case EAI_SOCKTYPE:
	return ESOCKTNOSUPPORT;

	case EAI_SYSTEM:
	return errno;

	default:
	return pcmk_rc_ns_resolution;
	}
	}

	/*!
	* \brief Map a bz2 return code to the most similar Pacemaker return code
	*
	* \param[in] bz2 bz2 return code
	*
	* \return Most similar Pacemaker return code
	*/
	int
	pcmk__bzlib2rc(int bz2)
	{
	switch (bz2) {
	case BZ_OK:
	case BZ_RUN_OK:
	case BZ_FLUSH_OK:
	case BZ_FINISH_OK:
	case BZ_STREAM_END:
	return pcmk_rc_ok;

	case BZ_MEM_ERROR:
	return ENOMEM;

	case BZ_DATA_ERROR:
	case BZ_DATA_ERROR_MAGIC:
	case BZ_UNEXPECTED_EOF:
	return pcmk_rc_bad_input;

	case BZ_IO_ERROR:
	return EIO;

	case BZ_OUTBUFF_FULL:
	return EFBIG;

	default:
	return pcmk_rc_compression;
	}
	}

	crm_exit_t
	-crm_exit(crm_exit_t rc)
	+crm_exit(crm_exit_t exit_status)
	{
	/* A compiler could theoretically use any type for crm_exit_t, but an int
	* should always hold it, so cast to int to keep static analysis happy.
	*/
	- if ((((int) rc) < 0) \|\| (((int) rc) > CRM_EX_MAX)) {
	- rc = CRM_EX_ERROR;
	+ if ((((int) exit_status) < 0) \|\| (((int) exit_status) > CRM_EX_MAX)) {
	+ exit_status = CRM_EX_ERROR;
	}

	- mainloop_cleanup();
	- crm_xml_cleanup();
	-
	- free(pcmk__our_nodename);
	-
	- if (crm_system_name) {
	- crm_info("Exiting %s " CRM_XS " with status %d", crm_system_name, rc);
	- free(crm_system_name);
	- } else {
	- crm_trace("Exiting with status %d", rc);
	- }
	- pcmk__free_common_logger();
	- qb_log_fini(); // Don't log anything after this point
	-
	- exit(rc);
	+ crm_info("Exiting %s " CRM_XS " with status %d (%s: %s)",
	+ pcmk__s(crm_system_name, "process"), exit_status,
	+ crm_exit_name(exit_status), crm_exit_str(exit_status));
	+ pcmk_common_cleanup();
	+ exit(exit_status);
	}

	/*
	* External action results
	*/

	/*!
	* \internal
	* \brief Set the result of an action
	*
	* \param[out] result Where to set action result
	* \param[in] exit_status OCF exit status to set
	* \param[in] exec_status Execution status to set
	* \param[in] exit_reason Human-friendly description of event to set
	*/
	void
	pcmk__set_result(pcmk__action_result_t *result, int exit_status,
	enum pcmk_exec_status exec_status, const char *exit_reason)
	{
	if (result == NULL) {
	return;
	}

	result->exit_status = exit_status;
	result->execution_status = exec_status;

	if (!pcmk__str_eq(result->exit_reason, exit_reason, pcmk__str_none)) {
	free(result->exit_reason);
	result->exit_reason = (exit_reason == NULL)? NULL : strdup(exit_reason);
	}
	}


	/*!
	* \internal
	* \brief Set the result of an action, with a formatted exit reason
	*
	* \param[out] result Where to set action result
	* \param[in] exit_status OCF exit status to set
	* \param[in] exec_status Execution status to set
	* \param[in] format printf-style format for a human-friendly
	* description of reason for result
	* \param[in] ... arguments for \p format
	*/
	G_GNUC_PRINTF(4, 5)
	void
	pcmk__format_result(pcmk__action_result_t *result, int exit_status,
	enum pcmk_exec_status exec_status,
	const char *format, ...)
	{
	va_list ap;
	int len = 0;
	char *reason = NULL;

	if (result == NULL) {
	return;
	}

	result->exit_status = exit_status;
	result->execution_status = exec_status;

	if (format != NULL) {
	va_start(ap, format);
	len = vasprintf(&reason, format, ap);
	pcmk__assert(len > 0);
	va_end(ap);
	}
	free(result->exit_reason);
	result->exit_reason = reason;
	}

	/*!
	* \internal
	* \brief Set the output of an action
	*
	* \param[out] result Action result to set output for
	* \param[in] out Action output to set (must be dynamically
	* allocated)
	* \param[in] err Action error output to set (must be dynamically
	* allocated)
	*
	* \note \p result will take ownership of \p out and \p err, so the caller
	* should not free them.
	*/
	void
	pcmk__set_result_output(pcmk__action_result_t result, char out, char *err)
	{
	if (result == NULL) {
	return;
	}

	free(result->action_stdout);
	result->action_stdout = out;

	free(result->action_stderr);
	result->action_stderr = err;
	}

	/*!
	* \internal
	* \brief Clear a result's exit reason, output, and error output
	*
	* \param[in,out] result Result to reset
	*/
	void
	pcmk__reset_result(pcmk__action_result_t *result)
	{
	if (result == NULL) {
	return;
	}

	free(result->exit_reason);
	result->exit_reason = NULL;

	free(result->action_stdout);
	result->action_stdout = NULL;

	free(result->action_stderr);
	result->action_stderr = NULL;
	}

	/*!
	* \internal
	* \brief Copy the result of an action
	*
	* \param[in] src Result to copy
	* \param[out] dst Where to copy \p src to
	*/
	void
	pcmk__copy_result(const pcmk__action_result_t src, pcmk__action_result_t dst)
	{
	CRM_CHECK((src != NULL) && (dst != NULL), return);
	dst->exit_status = src->exit_status;
	dst->execution_status = src->execution_status;
	dst->exit_reason = pcmk__str_copy(src->exit_reason);
	dst->action_stdout = pcmk__str_copy(src->action_stdout);
	dst->action_stderr = pcmk__str_copy(src->action_stderr);
	}

	/*!
	* \internal
	* \brief Log a failed assertion
	*
	* \param[in] file File making the assertion
	* \param[in] function Function making the assertion
	* \param[in] line Line of file making the assertion
	* \param[in] assert_condition String representation of assertion
	*/
	static void
	log_assertion_as(const char file, const char function, int line,
	const char *assert_condition)
	{
	if (!pcmk__is_daemon) {
	crm_enable_stderr(TRUE); // Make sure command-line user sees message
	}
	crm_err("%s: Triggered fatal assertion at %s:%d : %s",
	function, file, line, assert_condition);
	}

	/* coverity[+kill] */
	/*!
	* \internal
	* \brief Log a failed assertion and abort
	*
	* \param[in] file File making the assertion
	* \param[in] function Function making the assertion
	* \param[in] line Line of file making the assertion
	* \param[in] assert_condition String representation of assertion
	*
	* \note This does not return
	*/
	_Noreturn void
	pcmk__abort_as(const char file, const char function, int line,
	const char *assert_condition)
	{
	log_assertion_as(file, function, line, assert_condition);
	abort();
	}

	/* coverity[+kill] */
	/*!
	* \internal
	* \brief Handle a failed assertion
	*
	* When called by a daemon, fork a child that aborts (to dump core), otherwise
	* abort the current process.
	*
	* \param[in] file File making the assertion
	* \param[in] function Function making the assertion
	* \param[in] line Line of file making the assertion
	* \param[in] assert_condition String representation of assertion
	*/
	static void
	fail_assert_as(const char file, const char function, int line,
	const char *assert_condition)
	{
	int status = 0;
	pid_t pid = 0;

	if (!pcmk__is_daemon) {
	pcmk__abort_as(file, function, line, assert_condition); // No return
	}

	pid = fork();
	switch (pid) {
	case -1: // Fork failed
	crm_warn("%s: Cannot dump core for non-fatal assertion at %s:%d "
	": %s", function, file, line, assert_condition);
	break;

	case 0: // Child process: just abort to dump core
	abort();
	break;

	default: // Parent process: wait for child
	crm_err("%s: Forked child [%d] to record non-fatal assertion at "
	"%s:%d : %s", function, pid, file, line, assert_condition);
	crm_write_blackbox(SIGTRAP, NULL);
	do {
	if (waitpid(pid, &status, 0) == pid) {
	return; // Child finished dumping core
	}
	} while (errno == EINTR);
	if (errno == ECHILD) {
	// crm_mon ignores SIGCHLD
	crm_trace("Cannot wait on forked child [%d] "
	"(SIGCHLD is probably ignored)", pid);
	} else {
	crm_err("Cannot wait on forked child [%d]: %s",
	pid, pcmk_rc_str(errno));
	}
	break;
	}
	}

	/* coverity[+kill] */
	void
	crm_abort(const char file, const char function, int line,
	const char *assert_condition, gboolean do_core, gboolean do_fork)
	{
	if (!do_fork) {
	pcmk__abort_as(file, function, line, assert_condition); // No return
	} else if (do_core) {
	fail_assert_as(file, function, line, assert_condition);
	} else {
	log_assertion_as(file, function, line, assert_condition);
	}
	}

	// Deprecated functions kept only for backward API compatibility
	// LCOV_EXCL_START

	#include <crm/common/results_compat.h>

	const char *
	bz2_strerror(int rc)
	{
	// See ftp://sources.redhat.com/pub/bzip2/docs/manual_3.html#SEC17
	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 "Data compression error";
	}

	crm_exit_t
	crm_errno2exit(int rc)
	{
	return pcmk_rc2exitc(pcmk_legacy2rc(rc));
	}

	// LCOV_EXCL_STOP
	// End deprecated API
	diff --git a/lib/common/utils.c b/lib/common/utils.c
	index 36d87aa265..9e44c227a1 100644
	--- a/lib/common/utils.c
	+++ b/lib/common/utils.c
	@@ -1,437 +1,459 @@
	/*
	* Copyright 2004-2024 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

	#ifndef _GNU_SOURCE
	# define _GNU_SOURCE
	#endif

	#include <sys/stat.h>
	#include <sys/utsname.h>

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

	#include <qb/qbdefs.h>

	#include <crm/crm.h>
	#include <crm/services.h>
	#include <crm/cib/internal.h>
	#include <crm/common/xml.h>
	#include <crm/common/util.h>
	#include <crm/common/ipc.h>
	#include <crm/common/iso8601.h>
	#include <crm/common/mainloop.h>
	#include <libxml2/libxml/relaxng.h>

	#include "crmcommon_private.h"

	CRM_TRACE_INIT_DATA(common);

	gboolean crm_config_error = FALSE;
	gboolean crm_config_warning = FALSE;
	char *crm_system_name = NULL;

	+/*!
	+ * \brief Free all memory used by libcrmcommon
	+ *
	+ * Free all global memory allocated by the libcrmcommon library. This should be
	+ * called before exiting a process that uses the library, and the process should
	+ * not call any libcrmcommon or libxml2 APIs after calling this one.
	+ */
	+void
	+pcmk_common_cleanup(void)
	+{
	+ // @TODO This isn't really everything, move all cleanup here
	+ mainloop_cleanup();
	+ crm_xml_cleanup();
	+ pcmk__free_common_logger();
	+ qb_log_fini(); // Don't log anything after this point
	+
	+ free(pcmk__our_nodename);
	+ pcmk__our_nodename = NULL;
	+ free(crm_system_name);
	+ crm_system_name = NULL;
	+}
	+
	bool
	pcmk__is_user_in_group(const char user, const char group)
	{
	struct group *grent;
	char **gr_mem;

	if (user == NULL \|\| group == NULL) {
	return false;
	}

	setgrent();
	while ((grent = getgrent()) != NULL) {
	if (grent->gr_mem == NULL) {
	continue;
	}

	if(strcmp(group, grent->gr_name) != 0) {
	continue;
	}

	gr_mem = grent->gr_mem;
	while (*gr_mem != NULL) {
	if (!strcmp(user, *gr_mem++)) {
	endgrent();
	return true;
	}
	}
	}
	endgrent();
	return false;
	}

	int
	crm_user_lookup(const char name, uid_t uid, gid_t * gid)
	{
	int rc = pcmk_ok;
	char *buffer = NULL;
	struct passwd pwd;
	struct passwd *pwentry = NULL;

	buffer = calloc(1, PCMK__PW_BUFFER_LEN);
	if (buffer == NULL) {
	return -ENOMEM;
	}

	rc = getpwnam_r(name, &pwd, buffer, PCMK__PW_BUFFER_LEN, &pwentry);
	if (pwentry) {
	if (uid) {
	*uid = pwentry->pw_uid;
	}
	if (gid) {
	*gid = pwentry->pw_gid;
	}
	crm_trace("User %s has uid=%d gid=%d", name, pwentry->pw_uid, pwentry->pw_gid);

	} else {
	rc = rc? -rc : -EINVAL;
	crm_info("User %s lookup: %s", name, pcmk_strerror(rc));
	}

	free(buffer);
	return rc;
	}

	/*!
	* \brief Get user and group IDs of pacemaker daemon user
	*
	* \param[out] uid If non-NULL, where to store daemon user ID
	* \param[out] gid If non-NULL, where to store daemon group ID
	*
	* \return pcmk_ok on success, -errno otherwise
	*/
	int
	pcmk_daemon_user(uid_t uid, gid_t gid)
	{
	static uid_t daemon_uid;
	static gid_t daemon_gid;
	static bool found = false;
	int rc = pcmk_ok;

	if (!found) {
	rc = crm_user_lookup(CRM_DAEMON_USER, &daemon_uid, &daemon_gid);
	if (rc == pcmk_ok) {
	found = true;
	}
	}
	if (found) {
	if (uid) {
	*uid = daemon_uid;
	}
	if (gid) {
	*gid = daemon_gid;
	}
	}
	return rc;
	}

	/*!
	* \internal
	* \brief Return the integer equivalent of a portion of a string
	*
	* \param[in] text Pointer to beginning of string portion
	* \param[out] end_text This will point to next character after integer
	*/
	static int
	version_helper(const char text, const char *end_text)
	{
	int atoi_result = -1;

	pcmk__assert(end_text != NULL);

	errno = 0;

	if (text != NULL && text[0] != 0) {
	/* seemingly sacrificing const-correctness -- because while strtol
	doesn't modify the input, it doesn't want to artificially taint the
	"end_text" pointer-to-pointer-to-first-char-in-string with constness
	in case the input wasn't actually constant -- by semantic definition
	not a single character will get modified so it shall be perfectly
	safe to make compiler happy with dropping "const" qualifier here */
	atoi_result = (int) strtol(text, (char **) end_text, 10);

	if (errno == EINVAL) {
	crm_err("Conversion of '%s' %c failed", text, text[0]);
	atoi_result = -1;
	}
	}
	return atoi_result;
	}

	/*
	* version1 < version2 : -1
	* version1 = version2 : 0
	* version1 > version2 : 1
	*/
	int
	compare_version(const char version1, const char version2)
	{
	int rc = 0;
	int lpc = 0;
	const char ver1_iter, ver2_iter;

	if (version1 == NULL && version2 == NULL) {
	return 0;
	} else if (version1 == NULL) {
	return -1;
	} else if (version2 == NULL) {
	return 1;
	}

	ver1_iter = version1;
	ver2_iter = version2;

	while (1) {
	int digit1 = 0;
	int digit2 = 0;

	lpc++;

	if (ver1_iter == ver2_iter) {
	break;
	}

	if (ver1_iter != NULL) {
	digit1 = version_helper(ver1_iter, &ver1_iter);
	}

	if (ver2_iter != NULL) {
	digit2 = version_helper(ver2_iter, &ver2_iter);
	}

	if (digit1 < digit2) {
	rc = -1;
	break;

	} else if (digit1 > digit2) {
	rc = 1;
	break;
	}

	if (ver1_iter != NULL && *ver1_iter == '.') {
	ver1_iter++;
	}
	if (ver1_iter != NULL && *ver1_iter == '\0') {
	ver1_iter = NULL;
	}

	if (ver2_iter != NULL && *ver2_iter == '.') {
	ver2_iter++;
	}
	if (ver2_iter != NULL && *ver2_iter == 0) {
	ver2_iter = NULL;
	}
	}

	if (rc == 0) {
	crm_trace("%s == %s (%d)", version1, version2, lpc);
	} else if (rc < 0) {
	crm_trace("%s < %s (%d)", version1, version2, lpc);
	} else if (rc > 0) {
	crm_trace("%s > %s (%d)", version1, version2, lpc);
	}

	return rc;
	}

	/*!
	* \internal
	* \brief Convert the current process to a daemon process
	*
	* Fork a child process, exit the parent, create a PID file with the current
	* process ID, and close the standard input/output/error file descriptors.
	* Exit instead if a daemon is already running and using the PID file.
	*
	* \param[in] name Daemon executable name
	* \param[in] pidfile File name to use as PID file
	*/
	void
	pcmk__daemonize(const char name, const char pidfile)
	{
	int rc;
	pid_t pid;

	/* Check before we even try... */
	rc = pcmk__pidfile_matches(pidfile, 1, name, &pid);
	if ((rc != pcmk_rc_ok) && (rc != ENOENT)) {
	crm_err("%s: already running [pid %lld in %s]",
	name, (long long) pid, pidfile);
	printf("%s: already running [pid %lld in %s]\n",
	name, (long long) pid, pidfile);
	crm_exit(CRM_EX_ERROR);
	}

	pid = fork();
	if (pid < 0) {
	fprintf(stderr, "%s: could not start daemon\n", name);
	crm_perror(LOG_ERR, "fork");
	crm_exit(CRM_EX_OSERR);

	} else if (pid > 0) {
	crm_exit(CRM_EX_OK);
	}

	rc = pcmk__lock_pidfile(pidfile, name);
	if (rc != pcmk_rc_ok) {
	crm_err("Could not lock '%s' for %s: %s " CRM_XS " rc=%d",
	pidfile, name, pcmk_rc_str(rc), rc);
	printf("Could not lock '%s' for %s: %s (%d)\n",
	pidfile, name, pcmk_rc_str(rc), rc);
	crm_exit(CRM_EX_ERROR);
	}

	umask(S_IWGRP \| S_IWOTH \| S_IROTH);

	close(STDIN_FILENO);
	pcmk__open_devnull(O_RDONLY); // stdin (fd 0)

	close(STDOUT_FILENO);
	pcmk__open_devnull(O_WRONLY); // stdout (fd 1)

	close(STDERR_FILENO);
	pcmk__open_devnull(O_WRONLY); // stderr (fd 2)
	}

	#ifdef HAVE_UUID_UUID_H
	# include <uuid/uuid.h>
	#endif

	char *
	crm_generate_uuid(void)
	{
	unsigned char uuid[16];
	char buffer = malloc(37); / Including NUL byte */

	pcmk__mem_assert(buffer);
	uuid_generate(uuid);
	uuid_unparse(uuid, buffer);
	return buffer;
	}

	#ifdef HAVE_GNUTLS_GNUTLS_H
	void
	crm_gnutls_global_init(void)
	{
	signal(SIGPIPE, SIG_IGN);
	gnutls_global_init();
	}
	#endif

	bool
	pcmk_str_is_infinity(const char *s) {
	return pcmk__str_any_of(s, PCMK_VALUE_INFINITY, PCMK_VALUE_PLUS_INFINITY,
	NULL);
	}

	bool
	pcmk_str_is_minus_infinity(const char *s) {
	return pcmk__str_eq(s, PCMK_VALUE_MINUS_INFINITY, pcmk__str_none);
	}

	/*!
	* \internal
	* \brief Sleep for given milliseconds
	*
	* \param[in] ms Time to sleep
	*
	* \note The full time might not be slept if a signal is received.
	*/
	void
	pcmk__sleep_ms(unsigned int ms)
	{
	// @TODO Impose a sane maximum sleep to avoid hanging a process for long
	//CRM_CHECK(ms <= MAX_SLEEP, ms = MAX_SLEEP);

	// Use sleep() for any whole seconds
	if (ms >= 1000) {
	sleep(ms / 1000);
	ms -= ms / 1000;
	}

	if (ms == 0) {
	return;
	}

	#if defined(HAVE_NANOSLEEP)
	// nanosleep() is POSIX-2008, so prefer that
	{
	struct timespec req = { .tv_sec = 0, .tv_nsec = (long) (ms * 1000000) };

	nanosleep(&req, NULL);
	}
	#elif defined(HAVE_USLEEP)
	// usleep() is widely available, though considered obsolete
	usleep((useconds_t) ms);
	#else
	// Otherwise use a trick with select() timeout
	{
	struct timeval tv = { .tv_sec = 0, .tv_usec = (suseconds_t) ms };

	select(0, NULL, NULL, NULL, &tv);
	}
	#endif
	}

	// Deprecated functions kept only for backward API compatibility
	// LCOV_EXCL_START

	#include <crm/common/util_compat.h>

	guint
	crm_parse_interval_spec(const char *input)
	{
	long long msec = -1;

	errno = 0;
	if (input == NULL) {
	return 0;

	} else if (input[0] == 'P') {
	crm_time_t *period_s = crm_time_parse_duration(input);

	if (period_s) {
	msec = 1000 * crm_time_get_seconds(period_s);
	crm_time_free(period_s);
	}

	} else {
	msec = crm_get_msec(input);
	}

	if (msec < 0) {
	crm_warn("Using 0 instead of '%s'", input);
	errno = EINVAL;
	return 0;
	}
	return (msec >= G_MAXUINT)? G_MAXUINT : (guint) msec;
	}

	char *
	pcmk_hostname(void)
	{
	struct utsname hostinfo;

	return (uname(&hostinfo) < 0)? NULL : strdup(hostinfo.nodename);
	}

	// LCOV_EXCL_STOP
	// End deprecated API

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jul 8, 6:02 PM (1 d, 2 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2002439
Default Alt Text: (97 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions