No OneTemporary
Actions

Size

21 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/crm/crm.h b/include/crm/crm.h
	index 0944eb6517..7d2d208ee0 100644
	--- a/include/crm/crm.h
	+++ b/include/crm/crm.h
	@@ -1,155 +1,154 @@
	/*
	* 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_CRM__H
	# define PCMK__CRM_CRM__H

	# include <crm_config.h>
	# include <stdlib.h>
	# include <glib.h>
	# include <stdbool.h>

	# include <string.h>

	# include <libxml/tree.h>

	#include <crm/common/options.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	/**
	* \file
	* \brief A dumping ground
	* \ingroup core
	*/

	#ifndef PCMK_ALLOW_DEPRECATED
	/*!
	* \brief Allow use of deprecated Pacemaker APIs
	*
	* By default, external code using Pacemaker headers is allowed to use
	* deprecated Pacemaker APIs. If PCMK_ALLOW_DEPRECATED is defined to 0 before
	* including any Pacemaker headers, deprecated APIs will be unusable. It is
	* strongly recommended to leave this unchanged for production and release
	* builds, to avoid breakage when users upgrade to new Pacemaker releases that
	* deprecate more APIs. This should be defined to 0 only for development and
	* testing builds when desiring to check for usage of currently deprecated APIs.
	*/
	#define PCMK_ALLOW_DEPRECATED 1
	#endif

	/*!
	* The CRM feature set assists with compatibility in mixed-version clusters.
	* The major version number increases when nodes with different versions
	* would not work (rolling upgrades are not allowed). The minor version
	* number increases when mixed-version clusters are allowed only during
	* rolling upgrades (a node with the oldest feature set will be elected DC). The
	* minor-minor version number is ignored, but allows resource agents to detect
	* cluster support for various features.
	*
	* The feature set also affects the processing of old saved CIBs (such as for
	* many scheduler regression tests).
	*
	* Particular feature points currently tested by Pacemaker code:
	*
	* >=3.2.0: DC supports PCMK_EXEC_INVALID and PCMK_EXEC_NOT_CONNECTED
	* >=3.19.0: DC supports PCMK__CIB_REQUEST_COMMIT_TRANSACT
	*/
	# define CRM_FEATURE_SET "3.19.7"

	/* Pacemaker's CPG protocols use fixed-width binary fields for the sender and
	* recipient of a CPG message. This imposes an arbitrary limit on cluster node
	* names.
	*/
	//! \brief Maximum length of a Corosync cluster node name (in bytes)
	#define MAX_NAME 256

	# define CRM_META "CRM_meta"

	// NOTE: sbd (as of at least 1.5.2) uses this
	extern char *crm_system_name;

	/* Sub-systems */
	# define CRM_SYSTEM_DC "dc"
	#define CRM_SYSTEM_DCIB "dcib" // Primary instance of CIB manager
	# define CRM_SYSTEM_CIB "cib"
	# define CRM_SYSTEM_CRMD "crmd"
	# define CRM_SYSTEM_LRMD "lrmd"
	# define CRM_SYSTEM_PENGINE "pengine"
	# define CRM_SYSTEM_TENGINE "tengine"
	-# define CRM_SYSTEM_STONITHD "stonithd"
	# define CRM_SYSTEM_MCP "pacemakerd"

	// Names of internally generated node attributes
	// @TODO Replace these with PCMK_NODE_ATTR_*
	# define CRM_ATTR_UNAME "#uname"
	# define CRM_ATTR_ID "#id"
	# define CRM_ATTR_KIND "#kind"
	# define CRM_ATTR_ROLE "#role"
	# define CRM_ATTR_IS_DC "#is_dc"
	# define CRM_ATTR_CLUSTER_NAME "#cluster-name"
	# define CRM_ATTR_SITE_NAME "#site-name"
	# define CRM_ATTR_UNFENCED "#node-unfenced"
	# define CRM_ATTR_DIGESTS_ALL "#digests-all"
	# define CRM_ATTR_DIGESTS_SECURE "#digests-secure"
	# define CRM_ATTR_PROTOCOL "#attrd-protocol"
	# define CRM_ATTR_FEATURE_SET "#feature-set"

	/* Valid operations */
	# define CRM_OP_NOOP "noop"
	# define CRM_OP_JOIN_ANNOUNCE "join_announce"
	# define CRM_OP_JOIN_OFFER "join_offer"
	# define CRM_OP_JOIN_REQUEST "join_request"
	# define CRM_OP_JOIN_ACKNAK "join_ack_nack"
	# define CRM_OP_JOIN_CONFIRM "join_confirm"
	# define CRM_OP_PING "ping"
	# define CRM_OP_NODE_INFO "node-info"
	# define CRM_OP_THROTTLE "throttle"
	# define CRM_OP_VOTE "vote"
	# define CRM_OP_NOVOTE "no-vote"
	# define CRM_OP_HELLO "hello"
	# define CRM_OP_PECALC "pe_calc"
	# define CRM_OP_QUIT "quit"
	# define CRM_OP_SHUTDOWN_REQ "req_shutdown"
	# define CRM_OP_SHUTDOWN PCMK_ACTION_DO_SHUTDOWN
	# define CRM_OP_REGISTER "register"
	# define CRM_OP_IPC_FWD "ipc_fwd"
	# define CRM_OP_INVOKE_LRM "lrm_invoke"
	# define CRM_OP_LRM_REFRESH "lrm_refresh" //!< Deprecated since 1.1.10
	# define CRM_OP_LRM_DELETE PCMK_ACTION_LRM_DELETE
	# define CRM_OP_LRM_FAIL "lrm_fail"
	# define CRM_OP_PROBED "probe_complete"
	# define CRM_OP_REPROBE "probe_again"
	# define CRM_OP_CLEAR_FAILCOUNT PCMK_ACTION_CLEAR_FAILCOUNT
	# define CRM_OP_REMOTE_STATE "remote_state"
	# define CRM_OP_RM_NODE_CACHE "rm_node_cache"
	# define CRM_OP_MAINTENANCE_NODES PCMK_ACTION_MAINTENANCE_NODES

	/* Possible cluster membership states */
	# define CRMD_JOINSTATE_DOWN "down"
	# define CRMD_JOINSTATE_PENDING "pending"
	# define CRMD_JOINSTATE_MEMBER "member"
	# define CRMD_JOINSTATE_NACK "banned"

	# include <crm/common/actions.h>
	# include <crm/common/cib.h>
	# include <crm/common/logging.h>
	# include <crm/common/util.h>

	#ifdef __cplusplus
	}
	#endif

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

	#endif
	diff --git a/include/crm/crm_compat.h b/include/crm/crm_compat.h
	index c53ebc5400..de9dd739bb 100644
	--- a/include/crm/crm_compat.h
	+++ b/include/crm/crm_compat.h
	@@ -1,42 +1,45 @@
	/*
	* 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_CRM_COMPAT__H
	#define PCMK__CRM_CRM_COMPAT__H

	#include <glib.h> // GList

	#include <crm/common/scores.h> // PCMK_SCORE_INFINITY

	#ifdef __cplusplus
	extern "C" {
	#endif

	/**
	* \file
	* \brief Deprecated Pacemaker utilities
	* \ingroup core
	* \deprecated Do not include this header directly. The utilities in this
	* header, and the header itself, will be removed in a future
	* release.
	*/

	+//! \deprecated Do not use (will be removed in a future release)
	+#define CRM_SYSTEM_STONITHD "stonithd"
	+
	// NOTE: sbd (as of at least 1.5.2) uses this
	//! \deprecated Use PCMK_SCORE_INFINITY instead
	#define CRM_SCORE_INFINITY PCMK_SCORE_INFINITY

	// NOTE: sbd (as of at least 1.5.2) uses this
	//! \deprecated Use GList * instead
	typedef GList *GListPtr;

	#ifdef __cplusplus
	}
	#endif

	#endif // PCMK__CRM_CRM_COMPAT__H
	diff --git a/lib/common/utils.c b/lib/common/utils.c
	index 13b3ed3d5e..f736492159 100644
	--- a/lib/common/utils.c
	+++ b/lib/common/utils.c
	@@ -1,540 +1,540 @@
	/*
	* 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>

	#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 <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;

	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;

	CRM_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 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
	*/
	static _Noreturn void
	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) {
	abort_as(file, function, line, assert_condition); // does not 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) {
	abort_as(file, function, line, assert_condition);
	} else if (do_core) {
	fail_assert_as(file, function, line, assert_condition);
	} else {
	log_assertion_as(file, function, line, assert_condition);
	}
	}

	/*!
	* \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 " QB_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;
	}

	void
	crm_gnutls_global_init(void)
	{
	signal(SIGPIPE, SIG_IGN);
	gnutls_global_init();
	}

	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>

	/*!
	* \brief Check whether string represents a client name used by cluster daemons
	*
	* \param[in] name String to check
	*
	* \return true if name is standard client name used by daemons, false otherwise
	*
	* \note This is provided by the client, and so cannot be used by itself as a
	* secure means of authentication.
	*/
	bool
	crm_is_daemon_name(const char *name)
	{
	return pcmk__str_any_of(name,
	"attrd",
	CRM_SYSTEM_CIB,
	CRM_SYSTEM_CRMD,
	CRM_SYSTEM_DC,
	CRM_SYSTEM_LRMD,
	CRM_SYSTEM_MCP,
	CRM_SYSTEM_PENGINE,
	- CRM_SYSTEM_STONITHD,
	CRM_SYSTEM_TENGINE,
	"pacemaker-attrd",
	"pacemaker-based",
	"pacemaker-controld",
	"pacemaker-execd",
	"pacemaker-fenced",
	"pacemaker-remoted",
	"pacemaker-schedulerd",
	"stonith-ng",
	+ "stonithd",
	NULL);
	}

	// LCOV_EXCL_STOP
	// End deprecated API

File Metadata

Mime Type: text/x-diff
Expires: Sat, Jan 25, 12:16 PM (20 h, 7 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1322526
Default Alt Text: (21 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions