No OneTemporary
Actions

Size

82 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/cluster/crmcluster_private.h b/lib/cluster/crmcluster_private.h
	index 6f733f16d9..9fda73367c 100644
	--- a/lib/cluster/crmcluster_private.h
	+++ b/lib/cluster/crmcluster_private.h
	@@ -1,72 +1,80 @@
	/*
	* Copyright 2020-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__CRMCLUSTER_PRIVATE__H
	-# define PCMK__CRMCLUSTER_PRIVATE__H
	+#ifndef PCMK__CLUSTER_CRMCLUSTER_PRIVATE__H
	+#define PCMK__CLUSTER_CRMCLUSTER_PRIVATE__H

	/* This header is for the sole use of libcrmcluster, so that functions can be
	* declared with G_GNUC_INTERNAL for efficiency.
	*/

	#include <stdbool.h> // bool
	#include <stdint.h> // uint32_t, uint64_t

	#include <glib.h> // G_GNUC_INTERNAL, gboolean
	#include <libxml/tree.h> // xmlNode

	#if SUPPORT_COROSYNC
	#include <corosync/cpg.h> // cpg_handle_t
	#endif // SUPPORT_COROSYNC

	#include <crm/cluster.h> // pcmk_cluster_t
	#include <crm/cluster/internal.h> // pcmk__node_status_t

	+#ifdef __cplusplus
	+extern "C" {
	+#endif
	+
	G_GNUC_INTERNAL
	void pcmk__cluster_set_quorum(bool quorate);

	#if SUPPORT_COROSYNC

	G_GNUC_INTERNAL
	bool pcmk__corosync_is_active(void);

	G_GNUC_INTERNAL
	bool pcmk__corosync_has_nodelist(void);

	G_GNUC_INTERNAL
	char pcmk__corosync_uuid(const pcmk__node_status_t peer);

	G_GNUC_INTERNAL
	char pcmk__corosync_name(uint64_t /cmap_handle_t */ cmap_handle,
	uint32_t nodeid);

	G_GNUC_INTERNAL
	int pcmk__corosync_connect(pcmk_cluster_t *cluster);

	G_GNUC_INTERNAL
	void pcmk__corosync_disconnect(pcmk_cluster_t *cluster);

	G_GNUC_INTERNAL
	bool pcmk__corosync_is_peer_active(const pcmk__node_status_t *node);

	G_GNUC_INTERNAL
	int pcmk__cpg_connect(pcmk_cluster_t *cluster);

	G_GNUC_INTERNAL
	void pcmk__cpg_disconnect(pcmk_cluster_t *cluster);

	G_GNUC_INTERNAL
	uint32_t pcmk__cpg_local_nodeid(cpg_handle_t handle);

	G_GNUC_INTERNAL
	bool pcmk__cpg_send_xml(const xmlNode msg, const pcmk__node_status_t node,
	enum crm_ais_msg_types dest);

	#endif // SUPPORT_COROSYNC

	-#endif // PCMK__CRMCLUSTER_PRIVATE__H
	+#ifdef __cplusplus
	+}
	+#endif
	+
	+#endif // PCMK__CLUSTER_CRMCLUSTER_PRIVATE__H
	diff --git a/lib/common/crmcommon_private.h b/lib/common/crmcommon_private.h
	index 8a5cb13b2b..74b44f61a0 100644
	--- a/lib/common/crmcommon_private.h
	+++ b/lib/common/crmcommon_private.h
	@@ -1,428 +1,446 @@
	/*
	* Copyright 2018-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 CRMCOMMON_PRIVATE__H
	-# define CRMCOMMON_PRIVATE__H
	+#ifndef PCMK__COMMON_CRMCOMMON_PRIVATE__H
	+#define PCMK__COMMON_CRMCOMMON_PRIVATE__H

	/* This header is for the sole use of libcrmcommon, so that functions can be
	* declared with G_GNUC_INTERNAL for efficiency.
	*/

	#include <stdint.h> // uint8_t, uint32_t
	#include <stdbool.h> // bool
	#include <sys/types.h> // size_t
	-#include <glib.h> // gchar, GList
	+
	+#include <glib.h> // G_GNUC_INTERNAL, G_GNUC_PRINTF, gchar, etc.
	#include <libxml/tree.h> // xmlNode, xmlAttr
	#include <qb/qbipcc.h> // struct qb_ipc_response_header

	+#include <crm/common/ipc.h> // pcmk_ipc_api_t, crm_ipc_t, etc.
	+#include <crm/common/iso8601.h> // crm_time_t
	+#include <crm/common/logging.h> // LOG_NEVER
	+#include <crm/common/mainloop.h> // mainloop_io_t
	+#include <crm/common/output_internal.h> // pcmk__output_t
	+#include <crm/common/results.h> // crm_exit_t
	+#include <crm/common/rules.h> // pcmk_rule_input_t
	+#include <crm/common/xml.h> // pcmkXmlStr
	+#include <crm/common/xml_internal.h> // enum xml_private_flags
	+
	+#ifdef __cplusplus
	+extern "C" {
	+#endif
	+
	// Decent chunk size for processing large amounts of data
	#define PCMK__BUFFER_SIZE 4096

	#if defined(PCMK__UNIT_TESTING)
	#undef G_GNUC_INTERNAL
	#define G_GNUC_INTERNAL
	#endif

	/* When deleting portions of an XML tree, we keep a record so we can know later
	* (e.g. when checking differences) that something was deleted.
	*/
	typedef struct pcmk__deleted_xml_s {
	gchar *path;
	int position;
	} pcmk__deleted_xml_t;

	typedef struct xml_node_private_s {
	uint32_t check;
	uint32_t flags;
	} xml_node_private_t;

	typedef struct xml_doc_private_s {
	uint32_t check;
	uint32_t flags;
	char *user;
	GList *acls;
	GList *deleted_objs; // List of pcmk__deleted_xml_t
	} xml_doc_private_t;

	// XML entity references

	#define PCMK__XML_ENTITY_AMP "&"
	#define PCMK__XML_ENTITY_GT ">"
	#define PCMK__XML_ENTITY_LT "<"
	#define PCMK__XML_ENTITY_QUOT """

	//! libxml2 supports only XML version 1.0, at least as of libxml2-2.12.5
	#define PCMK__XML_VERSION ((pcmkXmlStr) "1.0")

	#define pcmk__set_xml_flags(xml_priv, flags_to_set) do { \
	(xml_priv)->flags = pcmk__set_flags_as(__func__, __LINE__, \
	LOG_NEVER, "XML", "XML node", (xml_priv)->flags, \
	(flags_to_set), #flags_to_set); \
	} while (0)

	#define pcmk__clear_xml_flags(xml_priv, flags_to_clear) do { \
	(xml_priv)->flags = pcmk__clear_flags_as(__func__, __LINE__, \
	LOG_NEVER, "XML", "XML node", (xml_priv)->flags, \
	(flags_to_clear), #flags_to_clear); \
	} while (0)

	G_GNUC_INTERNAL
	bool pcmk__tracking_xml_changes(xmlNode *xml, bool lazy);

	G_GNUC_INTERNAL
	void pcmk__xml_mark_created(xmlNode *xml);

	G_GNUC_INTERNAL
	int pcmk__xml_position(const xmlNode *xml,
	enum xml_private_flags ignore_if_set);

	G_GNUC_INTERNAL
	xmlNode pcmk__xml_match(const xmlNode haystack, const xmlNode *needle,
	bool exact);

	G_GNUC_INTERNAL
	void pcmk__xml_update(xmlNode parent, xmlNode target, xmlNode *update,
	uint32_t flags, bool as_diff);

	G_GNUC_INTERNAL
	xmlNode pcmk__xc_match(const xmlNode root, const xmlNode *search_comment,
	bool exact);

	G_GNUC_INTERNAL
	void pcmk__xc_update(xmlNode parent, xmlNode target, xmlNode *update);

	G_GNUC_INTERNAL
	void pcmk__free_acls(GList *acls);

	G_GNUC_INTERNAL
	void pcmk__unpack_acl(xmlNode source, xmlNode target, const char *user);

	G_GNUC_INTERNAL
	bool pcmk__is_user_in_group(const char user, const char group);

	G_GNUC_INTERNAL
	void pcmk__apply_acl(xmlNode *xml);

	G_GNUC_INTERNAL
	void pcmk__apply_creation_acl(xmlNode *xml, bool check_top);

	G_GNUC_INTERNAL
	void pcmk__mark_xml_attr_dirty(xmlAttr *a);

	G_GNUC_INTERNAL
	bool pcmk__xa_filterable(const char *name);

	G_GNUC_INTERNAL
	void pcmk__log_xmllib_err(void ctx, const char fmt, ...)
	G_GNUC_PRINTF(2, 3);

	G_GNUC_INTERNAL
	void pcmk__mark_xml_node_dirty(xmlNode *xml);

	G_GNUC_INTERNAL
	bool pcmk__marked_as_deleted(xmlAttrPtr a, void *user_data);

	G_GNUC_INTERNAL
	void pcmk__dump_xml_attr(const xmlAttr attr, GString buffer);

	G_GNUC_INTERNAL
	int pcmk__xe_set_score(xmlNode target, const char name, const char *value);

	G_GNUC_INTERNAL
	bool pcmk__xml_is_name_start_char(const char utf8, int len);

	G_GNUC_INTERNAL
	bool pcmk__xml_is_name_char(const char utf8, int len);

	/*
	* Date/times
	*/

	// For use with pcmk__add_time_from_xml()
	enum pcmk__time_component {
	pcmk__time_unknown,
	pcmk__time_years,
	pcmk__time_months,
	pcmk__time_weeks,
	pcmk__time_days,
	pcmk__time_hours,
	pcmk__time_minutes,
	pcmk__time_seconds,
	};

	G_GNUC_INTERNAL
	const char *pcmk__time_component_attr(enum pcmk__time_component component);

	G_GNUC_INTERNAL
	int pcmk__add_time_from_xml(crm_time_t *t, enum pcmk__time_component component,
	const xmlNode *xml);

	G_GNUC_INTERNAL
	void pcmk__set_time_if_earlier(crm_time_t target, const crm_time_t source);


	/*
	* IPC
	*/

	#define PCMK__IPC_VERSION 1

	#define PCMK__CONTROLD_API_MAJOR "1"
	#define PCMK__CONTROLD_API_MINOR "0"

	// IPC behavior that varies by daemon
	typedef struct pcmk__ipc_methods_s {
	/*!
	* \internal
	* \brief Allocate any private data needed by daemon IPC
	*
	* \param[in,out] api IPC API connection
	*
	* \return Standard Pacemaker return code
	*/
	int (new_data)(pcmk_ipc_api_t api);

	/*!
	* \internal
	* \brief Free any private data used by daemon IPC
	*
	* \param[in,out] api_data Data allocated by new_data() method
	*/
	void (free_data)(void api_data);

	/*!
	* \internal
	* \brief Perform daemon-specific handling after successful connection
	*
	* Some daemons require clients to register before sending any other
	* commands. The controller requires a CRM_OP_HELLO (with no reply), and
	* the CIB manager, executor, and fencer require a CRM_OP_REGISTER (with a
	* reply). Ideally this would be consistent across all daemons, but for now
	* this allows each to do its own authorization.
	*
	* \param[in,out] api IPC API connection
	*
	* \return Standard Pacemaker return code
	*/
	int (post_connect)(pcmk_ipc_api_t api);

	/*!
	* \internal
	* \brief Check whether an IPC request results in a reply
	*
	* \param[in,out] api IPC API connection
	* \param[in] request IPC request XML
	*
	* \return true if request would result in an IPC reply, false otherwise
	*/
	bool (reply_expected)(pcmk_ipc_api_t api, const xmlNode *request);

	/*!
	* \internal
	* \brief Perform daemon-specific handling of an IPC message
	*
	* \param[in,out] api IPC API connection
	* \param[in,out] msg Message read from IPC connection
	*
	* \return true if more IPC reply messages should be expected
	*/
	bool (dispatch)(pcmk_ipc_api_t api, xmlNode *msg);

	/*!
	* \internal
	* \brief Perform daemon-specific handling of an IPC disconnect
	*
	* \param[in,out] api IPC API connection
	*/
	void (post_disconnect)(pcmk_ipc_api_t api);
	} pcmk__ipc_methods_t;

	// Implementation of pcmk_ipc_api_t
	struct pcmk_ipc_api_s {
	enum pcmk_ipc_server server; // Daemon this IPC API instance is for
	enum pcmk_ipc_dispatch dispatch_type; // How replies should be dispatched
	size_t ipc_size_max; // maximum IPC buffer size
	crm_ipc_t *ipc; // IPC connection
	mainloop_io_t *mainloop_io; // If using mainloop, I/O source for IPC
	bool free_on_disconnect; // Whether disconnect should free object
	pcmk_ipc_callback_t cb; // Caller-registered callback (if any)
	void *user_data; // Caller-registered data (if any)
	void *api_data; // For daemon-specific use
	pcmk__ipc_methods_t *cmds; // Behavior that varies by daemon
	};

	typedef struct pcmk__ipc_header_s {
	struct qb_ipc_response_header qb;
	uint32_t size_uncompressed;
	uint32_t size_compressed;
	uint32_t flags;
	uint8_t version;
	} pcmk__ipc_header_t;

	G_GNUC_INTERNAL
	int pcmk__send_ipc_request(pcmk_ipc_api_t api, const xmlNode request);

	G_GNUC_INTERNAL
	void pcmk__call_ipc_callback(pcmk_ipc_api_t *api,
	enum pcmk_ipc_event event_type,
	crm_exit_t status, void *event_data);

	G_GNUC_INTERNAL
	unsigned int pcmk__ipc_buffer_size(unsigned int max);

	G_GNUC_INTERNAL
	bool pcmk__valid_ipc_header(const pcmk__ipc_header_t *header);

	G_GNUC_INTERNAL
	pcmk__ipc_methods_t *pcmk__attrd_api_methods(void);

	G_GNUC_INTERNAL
	pcmk__ipc_methods_t *pcmk__controld_api_methods(void);

	G_GNUC_INTERNAL
	pcmk__ipc_methods_t *pcmk__pacemakerd_api_methods(void);

	G_GNUC_INTERNAL
	pcmk__ipc_methods_t *pcmk__schedulerd_api_methods(void);


	/*
	* Logging
	*/

	//! XML is newly created
	#define PCMK__XML_PREFIX_CREATED "++"

	//! XML has been deleted
	#define PCMK__XML_PREFIX_DELETED "--"

	//! XML has been modified
	#define PCMK__XML_PREFIX_MODIFIED "+ "

	//! XML has been moved
	#define PCMK__XML_PREFIX_MOVED "+~"

	/*
	* Output
	*/
	G_GNUC_INTERNAL
	int pcmk__bare_output_new(pcmk__output_t *out, const char fmt_name,
	const char filename, char *argv);

	G_GNUC_INTERNAL
	void pcmk__register_option_messages(pcmk__output_t *out);

	G_GNUC_INTERNAL
	void pcmk__register_patchset_messages(pcmk__output_t *out);

	G_GNUC_INTERNAL
	bool pcmk__output_text_get_fancy(pcmk__output_t *out);

	/*
	* Rules
	*/

	// How node attribute values may be compared in rules
	enum pcmk__comparison {
	pcmk__comparison_unknown,
	pcmk__comparison_defined,
	pcmk__comparison_undefined,
	pcmk__comparison_eq,
	pcmk__comparison_ne,
	pcmk__comparison_lt,
	pcmk__comparison_lte,
	pcmk__comparison_gt,
	pcmk__comparison_gte,
	};

	// How node attribute values may be parsed in rules
	enum pcmk__type {
	pcmk__type_unknown,
	pcmk__type_string,
	pcmk__type_integer,
	pcmk__type_number,
	pcmk__type_version,
	};

	// Where to obtain reference value for a node attribute comparison
	enum pcmk__reference_source {
	pcmk__source_unknown,
	pcmk__source_literal,
	pcmk__source_instance_attrs,
	pcmk__source_meta_attrs,
	};

	G_GNUC_INTERNAL
	enum pcmk__comparison pcmk__parse_comparison(const char *op);

	G_GNUC_INTERNAL
	enum pcmk__type pcmk__parse_type(const char *type, enum pcmk__comparison op,
	const char value1, const char value2);

	G_GNUC_INTERNAL
	enum pcmk__reference_source pcmk__parse_source(const char *source);

	G_GNUC_INTERNAL
	int pcmk__cmp_by_type(const char value1, const char value2,
	enum pcmk__type type);

	G_GNUC_INTERNAL
	int pcmk__unpack_duration(const xmlNode duration, const crm_time_t start,
	crm_time_t **end);

	G_GNUC_INTERNAL
	int pcmk__evaluate_date_spec(const xmlNode date_spec, const crm_time_t now);

	G_GNUC_INTERNAL
	int pcmk__evaluate_attr_expression(const xmlNode *expression,
	const pcmk_rule_input_t *rule_input);

	G_GNUC_INTERNAL
	int pcmk__evaluate_rsc_expression(const xmlNode *expr,
	const pcmk_rule_input_t *rule_input);

	G_GNUC_INTERNAL
	int pcmk__evaluate_op_expression(const xmlNode *expr,
	const pcmk_rule_input_t *rule_input);


	/*
	* Utils
	*/
	#define PCMK__PW_BUFFER_LEN 500


	/*
	* Schemas
	*/
	typedef struct {
	unsigned char v[2];
	} pcmk__schema_version_t;

	enum pcmk__schema_validator {
	pcmk__schema_validator_none,
	pcmk__schema_validator_rng
	};

	typedef struct {
	int schema_index;
	char *name;
	char *transform;
	void *cache;
	enum pcmk__schema_validator validator;
	pcmk__schema_version_t version;
	char *transform_enter;
	bool transform_onleave;
	} pcmk__schema_t;

	G_GNUC_INTERNAL
	GList *pcmk__find_x_0_schema(void);

	+#ifdef __cplusplus
	+}
	+#endif

	-#endif // CRMCOMMON_PRIVATE__H
	+#endif // PCMK__COMMON_CRMCOMMON_PRIVATE__H
	diff --git a/lib/common/mock_private.h b/lib/common/mock_private.h
	index 3beeda466c..272714f187 100644
	--- a/lib/common/mock_private.h
	+++ b/lib/common/mock_private.h
	@@ -1,84 +1,97 @@
	/*
	* Copyright 2021-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 MOCK_PRIVATE__H
	-# define MOCK_PRIVATE__H
	+#ifndef PCMK__COMMON_MOCK_PRIVATE__H
	+#define PCMK__COMMON_MOCK_PRIVATE__H

	-#include <pwd.h>
	-#include <stdbool.h>
	-#include <stdio.h>
	+#include <pwd.h> // struct passwd
	+#include <stdbool.h> // bool
	+#include <stdio.h> // FILE
	#include <stdlib.h>
	#include <string.h>
	-#include <sys/types.h>
	+#include <sys/types.h> // pid_t, size_t
	#include <sys/utsname.h>
	#include <unistd.h>
	-#include <grp.h>
	+#include <grp.h> // struct group
	+
	+#include <crm/common/results.h> // _Noreturn
	+
	+#ifdef __cplusplus
	+extern "C" {
	+
	+// C++ doesn't support the restrict keyword
	+#define restrict
	+#endif

	/* This header is for the sole use of libcrmcommon_test and unit tests */

	_Noreturn void __real_abort(void);
	_Noreturn void __wrap_abort(void);

	extern bool pcmk__mock_calloc;
	void *__real_calloc(size_t nmemb, size_t size);
	void *__wrap_calloc(size_t nmemb, size_t size);

	extern bool pcmk__mock_fopen;
	FILE __real_fopen(const char pathname, const char *mode);
	FILE __wrap_fopen(const char pathname, const char *mode);
	#ifdef HAVE_FOPEN64
	FILE __real_fopen64(const char pathname, const char *mode);
	FILE __wrap_fopen64(const char pathname, const char *mode);
	#endif

	extern bool pcmk__mock_getenv;
	char __real_getenv(const char name);
	char __wrap_getenv(const char name);

	extern bool pcmk__mock_realloc;
	void __real_realloc(void ptr, size_t size);
	void __wrap_realloc(void ptr, size_t size);

	extern bool pcmk__mock_setenv;
	int __real_setenv(const char name, const char value, int overwrite);
	int __wrap_setenv(const char name, const char value, int overwrite);

	extern bool pcmk__mock_unsetenv;
	int __real_unsetenv(const char *name);
	int __wrap_unsetenv(const char *name);

	extern bool pcmk__mock_getpid;
	pid_t __real_getpid(void);
	pid_t __wrap_getpid(void);

	extern bool pcmk__mock_grent;
	void __real_setgrent(void);
	void __wrap_setgrent(void);
	struct group * __wrap_getgrent(void);
	struct group * __real_getgrent(void);
	void __wrap_endgrent(void);
	void __real_endgrent(void);

	extern bool pcmk__mock_getpwnam_r;
	int __real_getpwnam_r(const char name, struct passwd pwd,
	char buf, size_t buflen, struct passwd *result);
	int __wrap_getpwnam_r(const char name, struct passwd pwd,
	char buf, size_t buflen, struct passwd *result);

	extern bool pcmk__mock_readlink;
	ssize_t __real_readlink(const char restrict path, char restrict buf,
	size_t bufsize);
	ssize_t __wrap_readlink(const char restrict path, char restrict buf,
	size_t bufsize);

	extern bool pcmk__mock_strdup;
	char __real_strdup(const char s);
	char __wrap_strdup(const char s);

	-#endif // MOCK_PRIVATE__H
	+#ifdef __cplusplus
	+}
	+#endif
	+
	+#endif // PCMK__COMMON_MOCK_PRIVATE__H
	diff --git a/lib/fencing/fencing_private.h b/lib/fencing/fencing_private.h
	index 506e7f7464..1155143861 100644
	--- a/lib/fencing/fencing_private.h
	+++ b/lib/fencing/fencing_private.h
	@@ -1,51 +1,66 @@
	/*
	- * Copyright 2018-2021 the Pacemaker project contributors
	+ * Copyright 2018-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__FENCING_PRIVATE__H
	-# define PCMK__FENCING_PRIVATE__H
	+#ifndef PCMK__FENCING_FENCING_PRIVATE__H
	+#define PCMK__FENCING_FENCING_PRIVATE__H
	+
	+#include <stdbool.h> // bool
	+
	+#include <glib.h> // G_GNUC_INTERNAL, GHashTable
	+
	+#include <crm/stonith-ng.h> // stonith_t, stonith_key_value_t
	+#include <crm/fencing/internal.h> // stonith_action_t
	+
	+#ifdef __cplusplus
	+extern "C" {
	+#endif

	G_GNUC_INTERNAL
	int stonith__execute(stonith_action_t *action);

	// Utilities from st_rhcs.c

	G_GNUC_INTERNAL
	int stonith__list_rhcs_agents(stonith_key_value_t **devices);

	G_GNUC_INTERNAL
	int stonith__rhcs_metadata(const char agent, int timeout, char *output);

	G_GNUC_INTERNAL
	bool stonith__agent_is_rhcs(const char *agent);

	G_GNUC_INTERNAL
	int stonith__rhcs_validate(stonith_t st, int call_options, const char target,
	const char agent, GHashTable params,
	const char *host_arg, int timeout,
	char output, char error_output);

	#ifdef HAVE_STONITH_STONITH_H
	// Utilities from st_lha.c

	G_GNUC_INTERNAL
	int stonith__list_lha_agents(stonith_key_value_t **devices);

	G_GNUC_INTERNAL
	int stonith__lha_metadata(const char agent, int timeout, char *output);

	G_GNUC_INTERNAL
	bool stonith__agent_is_lha(const char *agent);

	G_GNUC_INTERNAL
	int stonith__lha_validate(stonith_t st, int call_options, const char target,
	const char agent, GHashTable params,
	int timeout, char output, char error_output);
	#endif

	-#endif // PCMK__FENCING_PRIVATE__H
	+#ifdef __cplusplus
	+}
	+#endif
	+
	+#endif // PCMK__FENCING_FENCING_PRIVATE__H
	diff --git a/lib/pacemaker/libpacemaker_private.h b/lib/pacemaker/libpacemaker_private.h
	index d1c87c84cb..fbbe93bcd3 100644
	--- a/lib/pacemaker/libpacemaker_private.h
	+++ b/lib/pacemaker/libpacemaker_private.h
	@@ -1,1165 +1,1174 @@
	/*
	* Copyright 2021-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__LIBPACEMAKER_PRIVATE__H
	-# define PCMK__LIBPACEMAKER_PRIVATE__H
	+#ifndef PCMK__PACEMAKER_LIBPACEMAKER_PRIVATE__H
	+#define PCMK__PACEMAKER_LIBPACEMAKER_PRIVATE__H

	/* This header is for the sole use of libpacemaker, so that functions can be
	* declared with G_GNUC_INTERNAL for efficiency.
	*/

	#include <stdio.h> // NULL
	#include <stdint.h> // uint32_t
	#include <stdbool.h> // bool, false
	#include <glib.h> // guint, gpointer, GList, GHashTable
	#include <libxml/tree.h> // xmlNode

	#include <crm/common/scheduler.h> // pcmk_action_t, pcmk_node_t, etc.
	#include <crm/common/scheduler_internal.h> // pcmk__location_t, etc.
	#include <crm/cib.h> // cib_t
	#include <crm/lrmd_events.h> // lrmd_event_data_t
	#include <crm/pengine/internal.h> // pe__const_top_resource(), etc.
	#include <pacemaker.h> // pcmk_injections_t
	#include <pacemaker-internal.h> // pcmk__colocation_t

	+#ifdef __cplusplus
	+extern "C" {
	+#endif
	+
	// Colocation flags
	enum pcmk__coloc_flags {
	pcmk__coloc_none = 0U,

	// Primary is affected even if already active
	pcmk__coloc_influence = (1U << 0),

	// Colocation was explicitly configured in CIB
	pcmk__coloc_explicit = (1U << 1),
	};

	// Flags to modify the behavior of add_colocated_node_scores()
	enum pcmk__coloc_select {
	// With no other flags, apply all "with this" colocations
	pcmk__coloc_select_default = 0,

	// Apply "this with" colocations instead of "with this" colocations
	pcmk__coloc_select_this_with = (1 << 0),

	// Apply only colocations with non-negative scores
	pcmk__coloc_select_nonnegative = (1 << 1),

	// Apply only colocations with at least one matching node
	pcmk__coloc_select_active = (1 << 2),
	};

	// Flags the update_ordered_actions() method can return
	enum pcmk__updated {
	pcmk__updated_none = 0, // Nothing changed
	pcmk__updated_first = (1 << 0), // First action was updated
	pcmk__updated_then = (1 << 1), // Then action was updated
	};

	#define pcmk__set_updated_flags(au_flags, action, flags_to_set) do { \
	au_flags = pcmk__set_flags_as(__func__, __LINE__, \
	LOG_TRACE, "Action update", \
	(action)->uuid, au_flags, \
	(flags_to_set), #flags_to_set); \
	} while (0)

	#define pcmk__clear_updated_flags(au_flags, action, flags_to_clear) do { \
	au_flags = pcmk__clear_flags_as(__func__, __LINE__, \
	LOG_TRACE, "Action update", \
	(action)->uuid, au_flags, \
	(flags_to_clear), #flags_to_clear); \
	} while (0)

	// Resource assignment methods
	struct pcmk__assignment_methods {
	/*!
	* \internal
	* \brief Assign a resource to a node
	*
	* \param[in,out] rsc Resource to assign to a node
	* \param[in] prefer Node to prefer, if all else is equal
	* \param[in] stop_if_fail If \c true and \p rsc can't be assigned to a
	* node, set next role to stopped and update
	* existing actions (if \p rsc is not a
	* primitive, this applies to its primitive
	* descendants instead)
	*
	* \return Node that \p rsc is assigned to, if assigned entirely to one node
	*
	* \note If \p stop_if_fail is \c false, then \c pcmk__unassign_resource()
	* can completely undo the assignment. A successful assignment can be
	* either undone or left alone as final. A failed assignment has the
	* same effect as calling pcmk__unassign_resource(); there are no side
	* effects on roles or actions.
	*/
	pcmk_node_t (assign)(pcmk_resource_t rsc, const pcmk_node_t prefer,
	bool stop_if_fail);

	/*!
	* \internal
	* \brief Create all actions needed for a given resource
	*
	* \param[in,out] rsc Resource to create actions for
	*/
	void (create_actions)(pcmk_resource_t rsc);

	/*!
	* \internal
	* \brief Schedule any probes needed for a resource on a node
	*
	* \param[in,out] rsc Resource to create probe for
	* \param[in,out] node Node to create probe on
	*
	* \return true if any probe was created, otherwise false
	*/
	bool (create_probe)(pcmk_resource_t rsc, pcmk_node_t *node);

	/*!
	* \internal
	* \brief Create implicit constraints needed for a resource
	*
	* \param[in,out] rsc Resource to create implicit constraints for
	*/
	void (internal_constraints)(pcmk_resource_t rsc);

	/*!
	* \internal
	* \brief Apply a colocation's score to node scores or resource priority
	*
	* Given a colocation constraint, apply its score to the dependent's
	* allowed node scores (if we are still placing resources) or priority (if
	* we are choosing promotable clone instance roles).
	*
	* \param[in,out] dependent Dependent resource in colocation
	* \param[in] primary Primary resource in colocation
	* \param[in] colocation Colocation constraint to apply
	* \param[in] for_dependent true if called on behalf of dependent
	*/
	void (apply_coloc_score)(pcmk_resource_t dependent,
	const pcmk_resource_t *primary,
	const pcmk__colocation_t *colocation,
	bool for_dependent);

	/*!
	* \internal
	* \brief Create list of all resources in colocations with a given resource
	*
	* Given a resource, create a list of all resources involved in mandatory
	* colocations with it, whether directly or via chained colocations.
	*
	* \param[in] rsc Resource to add to colocated list
	* \param[in] orig_rsc Resource originally requested
	* \param[in,out] colocated_rscs Existing list
	*
	* \return List of given resource and all resources involved in colocations
	*
	* \note This function is recursive; top-level callers should pass NULL as
	* \p colocated_rscs and \p orig_rsc, and the desired resource as
	* \p rsc. The recursive calls will use other values.
	*/
	GList (colocated_resources)(const pcmk_resource_t *rsc,
	const pcmk_resource_t *orig_rsc,
	GList *colocated_rscs);

	/*!
	* \internal
	* \brief Add colocations affecting a resource as primary to a list
	*
	* Given a resource being assigned (\p orig_rsc) and a resource somewhere in
	* its chain of ancestors (\p rsc, which may be \p orig_rsc), get
	* colocations that affect the ancestor as primary and should affect the
	* resource, and add them to a given list.
	*
	* \param[in] rsc Resource whose colocations should be added
	* \param[in] orig_rsc Affected resource (\p rsc or a descendant)
	* \param[in,out] list List of colocations to add to
	*
	* \note All arguments should be non-NULL.
	* \note The pcmk__with_this_colocations() wrapper should usually be used
	* instead of using this method directly.
	*/
	void (with_this_colocations)(const pcmk_resource_t rsc,
	const pcmk_resource_t *orig_rsc,
	GList **list);

	/*!
	* \internal
	* \brief Add colocations affecting a resource as dependent to a list
	*
	* Given a resource being assigned (\p orig_rsc) and a resource somewhere in
	* its chain of ancestors (\p rsc, which may be \p orig_rsc), get
	* colocations that affect the ancestor as dependent and should affect the
	* resource, and add them to a given list.
	*
	*
	* \param[in] rsc Resource whose colocations should be added
	* \param[in] orig_rsc Affected resource (\p rsc or a descendant)
	* \param[in,out] list List of colocations to add to
	*
	* \note All arguments should be non-NULL.
	* \note The pcmk__this_with_colocations() wrapper should usually be used
	* instead of using this method directly.
	*/
	void (this_with_colocations)(const pcmk_resource_t rsc,
	const pcmk_resource_t *orig_rsc,
	GList **list);

	/*!
	* \internal
	* \brief Update nodes with scores of colocated resources' nodes
	*
	* Given a table of nodes and a resource, update the nodes' scores with the
	* scores of the best nodes matching the attribute used for each of the
	* resource's relevant colocations.
	*
	* \param[in,out] source_rsc Resource whose node scores to add
	* \param[in] target_rsc Resource on whose behalf to update \p *nodes
	* \param[in] log_id Resource ID for logs (if \c NULL, use
	* \p source_rsc ID)
	* \param[in,out] nodes Nodes to update (set initial contents to
	* \c NULL to copy allowed nodes from
	* \p source_rsc)
	* \param[in] colocation Original colocation constraint (used to get
	* configured primary resource's stickiness, and
	* to get colocation node attribute; if \c NULL,
	* <tt>source_rsc</tt>'s own matching node scores
	* will not be added, and \p *nodes must be
	* \c NULL as well)
	* \param[in] factor Incorporate scores multiplied by this factor
	* \param[in] flags Bitmask of enum pcmk__coloc_select values
	*
	* \note \c NULL \p target_rsc, \c NULL \p *nodes, \c NULL \p colocation,
	* and the \c pcmk__coloc_select_this_with flag are used together (and
	* only by \c cmp_resources()).
	* \note The caller remains responsible for freeing \p *nodes.
	*/
	void (add_colocated_node_scores)(pcmk_resource_t source_rsc,
	const pcmk_resource_t *target_rsc,
	const char log_id, GHashTable *nodes,
	const pcmk__colocation_t *colocation,
	float factor, uint32_t flags);

	/*!
	* \internal
	* \brief Apply a location constraint to a resource's allowed node scores
	*
	* \param[in,out] rsc Resource to apply constraint to
	* \param[in,out] location Location constraint to apply
	*/
	void (apply_location)(pcmk_resource_t rsc, pcmk__location_t *location);

	/*!
	* \internal
	* \brief Return action flags for a given resource action
	*
	* \param[in,out] action Action to get flags for
	* \param[in] node If not NULL, limit effects to this node
	*
	* \return Flags appropriate to \p action on \p node
	* \note For primitives, this will be the same as action->flags regardless
	* of node. For collective resources, the flags can differ due to
	* multiple instances possibly being involved.
	*/
	uint32_t (action_flags)(pcmk_action_t action, const pcmk_node_t *node);

	/*!
	* \internal
	* \brief Update two actions according to an ordering between them
	*
	* Given information about an ordering of two actions, update the actions'
	* flags (and runnable_before members if appropriate) as appropriate for the
	* ordering. Effects may cascade to other orderings involving the actions as
	* well.
	*
	* \param[in,out] first 'First' action in an ordering
	* \param[in,out] then 'Then' action in an ordering
	* \param[in] node If not NULL, limit scope of ordering to this
	* node (only used when interleaving instances)
	* \param[in] flags Action flags for \p first for ordering purposes
	* \param[in] filter Action flags to limit scope of certain updates
	* (may include pcmk__action_optional to affect
	* only mandatory actions and
	* pcmk__action_runnable to affect only runnable
	* actions)
	* \param[in] type Group of enum pcmk__action_relation_flags
	* \param[in,out] scheduler Scheduler data
	*
	* \return Group of enum pcmk__updated flags indicating what was updated
	*/
	uint32_t (update_ordered_actions)(pcmk_action_t first,
	pcmk_action_t *then,
	const pcmk_node_t *node, uint32_t flags,
	uint32_t filter, uint32_t type,
	pcmk_scheduler_t *scheduler);

	/*!
	* \internal
	* \brief Output a summary of scheduled actions for a resource
	*
	* \param[in,out] rsc Resource to output actions for
	*/
	void (output_actions)(pcmk_resource_t rsc);

	/*!
	* \internal
	* \brief Add a resource's actions to the transition graph
	*
	* \param[in,out] rsc Resource whose actions should be added
	*/
	void (add_actions_to_graph)(pcmk_resource_t rsc);

	/*!
	* \internal
	* \brief Add meta-attributes relevant to transition graph actions to XML
	*
	* If a given resource supports variant-specific meta-attributes that are
	* needed for transition graph actions, add them to a given XML element.
	*
	* \param[in] rsc Resource whose meta-attributes should be added
	* \param[in,out] xml Transition graph action attributes XML to add to
	*/
	void (add_graph_meta)(const pcmk_resource_t rsc, xmlNode *xml);

	/*!
	* \internal
	* \brief Add a resource's utilization to a table of utilization values
	*
	* This function is used when summing the utilization of a resource and all
	* resources colocated with it, to determine whether a node has sufficient
	* capacity. Given a resource and a table of utilization values, it will add
	* the resource's utilization to the existing values, if the resource has
	* not yet been assigned to a node.
	*
	* \param[in] rsc Resource with utilization to add
	* \param[in] orig_rsc Resource being assigned (for logging only)
	* \param[in] all_rscs List of all resources that will be summed
	* \param[in,out] utilization Table of utilization values to add to
	*/
	void (add_utilization)(const pcmk_resource_t rsc,
	const pcmk_resource_t orig_rsc, GList all_rscs,
	GHashTable *utilization);

	/*!
	* \internal
	* \brief Apply a shutdown lock for a resource, if appropriate
	*
	* \param[in,out] rsc Resource to check for shutdown lock
	*/
	void (shutdown_lock)(pcmk_resource_t rsc);
	};

	// Actions (pcmk_sched_actions.c)

	G_GNUC_INTERNAL
	void pcmk__update_action_for_orderings(pcmk_action_t *action,
	pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	uint32_t pcmk__update_ordered_actions(pcmk_action_t first, pcmk_action_t then,
	const pcmk_node_t *node, uint32_t flags,
	uint32_t filter, uint32_t type,
	pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	void pcmk__log_action(const char pre_text, const pcmk_action_t action,
	bool details);

	G_GNUC_INTERNAL
	pcmk_action_t pcmk__new_cancel_action(pcmk_resource_t rsc, const char *name,
	guint interval_ms,
	const pcmk_node_t *node);

	G_GNUC_INTERNAL
	pcmk_action_t pcmk__new_shutdown_action(pcmk_node_t node);

	G_GNUC_INTERNAL
	bool pcmk__action_locks_rsc_to_node(const pcmk_action_t *action);

	G_GNUC_INTERNAL
	void pcmk__deduplicate_action_inputs(pcmk_action_t *action);

	G_GNUC_INTERNAL
	void pcmk__output_actions(pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	bool pcmk__check_action_config(pcmk_resource_t rsc, pcmk_node_t node,
	const xmlNode *xml_op);

	G_GNUC_INTERNAL
	void pcmk__handle_rsc_config_changes(pcmk_scheduler_t *scheduler);


	// Recurring actions (pcmk_sched_recurring.c)

	G_GNUC_INTERNAL
	void pcmk__create_recurring_actions(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__schedule_cancel(pcmk_resource_t rsc, const char call_id,
	const char *task, guint interval_ms,
	const pcmk_node_t node, const char reason);

	G_GNUC_INTERNAL
	void pcmk__reschedule_recurring(pcmk_resource_t rsc, const char task,
	guint interval_ms, pcmk_node_t *node);

	G_GNUC_INTERNAL
	bool pcmk__action_is_recurring(const pcmk_action_t *action);


	// Producing transition graphs (pcmk_graph_producer.c)

	G_GNUC_INTERNAL
	bool pcmk__graph_has_loop(const pcmk_action_t *init_action,
	const pcmk_action_t *action,
	pcmk__related_action_t *input);

	G_GNUC_INTERNAL
	void pcmk__add_rsc_actions_to_graph(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__create_graph(pcmk_scheduler_t *scheduler);


	// Fencing (pcmk_sched_fencing.c)

	G_GNUC_INTERNAL
	void pcmk__order_vs_fence(pcmk_action_t *stonith_op,
	pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	void pcmk__order_vs_unfence(const pcmk_resource_t rsc, pcmk_node_t node,
	pcmk_action_t *action,
	enum pcmk__action_relation_flags order);

	G_GNUC_INTERNAL
	void pcmk__fence_guest(pcmk_node_t *node);

	G_GNUC_INTERNAL
	bool pcmk__node_unfenced(const pcmk_node_t *node);

	G_GNUC_INTERNAL
	void pcmk__order_restart_vs_unfence(gpointer data, gpointer user_data);


	// Injected scheduler inputs (pcmk_sched_injections.c)

	+G_GNUC_INTERNAL
	void pcmk__inject_scheduler_input(pcmk_scheduler_t scheduler, cib_t cib,
	const pcmk_injections_t *injections);


	// Constraints of any type (pcmk_sched_constraints.c)

	G_GNUC_INTERNAL
	pcmk_resource_t pcmk__find_constraint_resource(GList rsc_list,
	const char *id);

	G_GNUC_INTERNAL
	xmlNode pcmk__expand_tags_in_sets(xmlNode xml_obj,
	const pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	bool pcmk__valid_resource_or_tag(const pcmk_scheduler_t *scheduler,
	const char id, pcmk_resource_t *rsc,
	pcmk__idref_t **tag);

	G_GNUC_INTERNAL
	bool pcmk__tag_to_set(xmlNode xml_obj, xmlNode rsc_set, const char attr,
	bool convert_rsc, const pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	void pcmk__create_internal_constraints(pcmk_scheduler_t *scheduler);


	// Location constraints

	G_GNUC_INTERNAL
	void pcmk__unpack_location(xmlNode xml_obj, pcmk_scheduler_t scheduler);

	G_GNUC_INTERNAL
	pcmk__location_t pcmk__new_location(const char id, pcmk_resource_t *rsc,
	int node_score, const char *discover_mode,
	pcmk_node_t *foo_node);

	G_GNUC_INTERNAL
	void pcmk__apply_locations(pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	void pcmk__apply_location(pcmk_resource_t rsc, pcmk__location_t constraint);


	// Colocation constraints (pcmk_sched_colocation.c)

	enum pcmk__coloc_affects {
	pcmk__coloc_affects_nothing = 0,
	pcmk__coloc_affects_location,
	pcmk__coloc_affects_role,
	};

	G_GNUC_INTERNAL
	const char pcmk__colocation_node_attr(const pcmk_node_t node,
	const char *attr,
	const pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	enum pcmk__coloc_affects pcmk__colocation_affects(const pcmk_resource_t
	*dependent,
	const pcmk_resource_t
	*primary,
	const pcmk__colocation_t
	*colocation,
	bool preview);

	G_GNUC_INTERNAL
	void pcmk__apply_coloc_to_scores(pcmk_resource_t *dependent,
	const pcmk_resource_t *primary,
	const pcmk__colocation_t *colocation);

	G_GNUC_INTERNAL
	void pcmk__apply_coloc_to_priority(pcmk_resource_t *dependent,
	const pcmk_resource_t *primary,
	const pcmk__colocation_t *colocation);

	G_GNUC_INTERNAL
	void pcmk__add_colocated_node_scores(pcmk_resource_t *source_rsc,
	const pcmk_resource_t *target_rsc,
	const char log_id, GHashTable *nodes,
	const pcmk__colocation_t *colocation,
	float factor, uint32_t flags);

	G_GNUC_INTERNAL
	void pcmk__add_dependent_scores(gpointer data, gpointer user_data);

	G_GNUC_INTERNAL
	void pcmk__colocation_intersect_nodes(pcmk_resource_t *dependent,
	const pcmk_resource_t *primary,
	const pcmk__colocation_t *colocation,
	const GList *primary_nodes,
	bool merge_scores);

	G_GNUC_INTERNAL
	void pcmk__unpack_colocation(xmlNode xml_obj, pcmk_scheduler_t scheduler);

	G_GNUC_INTERNAL
	void pcmk__add_this_with(GList *list, const pcmk__colocation_t colocation,
	const pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__add_this_with_list(GList *list, GList addition,
	const pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__add_with_this(GList *list, const pcmk__colocation_t colocation,
	const pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__add_with_this_list(GList *list, GList addition,
	const pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	GList pcmk__with_this_colocations(const pcmk_resource_t rsc);

	G_GNUC_INTERNAL
	GList pcmk__this_with_colocations(const pcmk_resource_t rsc);

	G_GNUC_INTERNAL
	void pcmk__new_colocation(const char id, const char node_attr, int score,
	pcmk_resource_t dependent, pcmk_resource_t primary,
	const char dependent_role, const char primary_role,
	uint32_t flags);

	G_GNUC_INTERNAL
	void pcmk__block_colocation_dependents(pcmk_action_t *action);

	/*!
	* \internal
	* \brief Check whether colocation's dependent preferences should be considered
	*
	* \param[in] colocation Colocation constraint
	* \param[in] rsc Primary instance (normally this will be
	* colocation->primary, which NULL will be treated as,
	* but for clones or bundles with multiple instances
	* this can be a particular instance)
	*
	* \return true if colocation influence should be effective, otherwise false
	*/
	static inline bool
	pcmk__colocation_has_influence(const pcmk__colocation_t *colocation,
	const pcmk_resource_t *rsc)
	{
	if (rsc == NULL) {
	rsc = colocation->primary;
	}

	/* A bundle replica colocates its remote connection with its container,
	* using a finite score so that the container can run on Pacemaker Remote
	* nodes.
	*
	* Moving a connection is lightweight and does not interrupt the service,
	* while moving a container is heavyweight and does interrupt the service,
	* so don't move a clean, active container based solely on the preferences
	* of its connection.
	*
	* This also avoids problematic scenarios where two containers want to
	* perpetually swap places.
	*/
	if (pcmk_is_set(colocation->dependent->flags,
	pcmk__rsc_remote_nesting_allowed)
	&& !pcmk_is_set(rsc->flags, pcmk__rsc_failed)
	&& pcmk__list_of_1(rsc->priv->active_nodes)) {
	return false;
	}

	/* The dependent in a colocation influences the primary's location
	* if the PCMK_XA_INFLUENCE option is true or the primary is not yet active.
	*/
	return pcmk_is_set(colocation->flags, pcmk__coloc_influence)
	\|\| (rsc->priv->active_nodes == NULL);
	}


	// Ordering constraints (pcmk_sched_ordering.c)

	G_GNUC_INTERNAL
	void pcmk__new_ordering(pcmk_resource_t first_rsc, char first_task,
	pcmk_action_t first_action, pcmk_resource_t then_rsc,
	char then_task, pcmk_action_t then_action,
	uint32_t flags, pcmk_scheduler_t *sched);

	G_GNUC_INTERNAL
	void pcmk__unpack_ordering(xmlNode xml_obj, pcmk_scheduler_t scheduler);

	G_GNUC_INTERNAL
	void pcmk__disable_invalid_orderings(pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	void pcmk__order_stops_before_shutdown(pcmk_node_t *node,
	pcmk_action_t *shutdown_op);

	G_GNUC_INTERNAL
	void pcmk__apply_orderings(pcmk_scheduler_t *sched);

	G_GNUC_INTERNAL
	void pcmk__order_after_each(pcmk_action_t after, GList list);


	/*!
	* \internal
	* \brief Create a new ordering between two resource actions
	*
	* \param[in,out] first_rsc Resource for 'first' action
	* \param[in,out] first_task Action key for 'first' action
	* \param[in] then_rsc Resource for 'then' action
	* \param[in,out] then_task Action key for 'then' action
	* \param[in] flags Group of enum pcmk__action_relation_flags
	*/
	#define pcmk__order_resource_actions(first_rsc, first_task, \
	then_rsc, then_task, flags) \
	pcmk__new_ordering((first_rsc), \
	pcmk__op_key((first_rsc)->id, (first_task), 0), \
	NULL, \
	(then_rsc), \
	pcmk__op_key((then_rsc)->id, (then_task), 0), \
	NULL, (flags), (first_rsc)->priv->scheduler)

	#define pcmk__order_starts(rsc1, rsc2, flags) \
	pcmk__order_resource_actions((rsc1), PCMK_ACTION_START, \
	(rsc2), PCMK_ACTION_START, (flags))

	#define pcmk__order_stops(rsc1, rsc2, flags) \
	pcmk__order_resource_actions((rsc1), PCMK_ACTION_STOP, \
	(rsc2), PCMK_ACTION_STOP, (flags))


	// Ticket constraints (pcmk_sched_tickets.c)

	G_GNUC_INTERNAL
	void pcmk__unpack_rsc_ticket(xmlNode xml_obj, pcmk_scheduler_t scheduler);


	// Promotable clone resources (pcmk_sched_promotable.c)

	G_GNUC_INTERNAL
	void pcmk__add_promotion_scores(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__require_promotion_tickets(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__set_instance_roles(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__create_promotable_actions(pcmk_resource_t *clone);

	G_GNUC_INTERNAL
	void pcmk__promotable_restart_ordering(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__order_promotable_instances(pcmk_resource_t *clone);

	G_GNUC_INTERNAL
	void pcmk__update_dependent_with_promotable(const pcmk_resource_t *primary,
	pcmk_resource_t *dependent,
	const pcmk__colocation_t
	*colocation);

	G_GNUC_INTERNAL
	void pcmk__update_promotable_dependent_priority(const pcmk_resource_t *primary,
	pcmk_resource_t *dependent,
	const pcmk__colocation_t
	*colocation);


	// Pacemaker Remote nodes (pcmk_sched_remote.c)

	G_GNUC_INTERNAL
	bool pcmk__is_failed_remote_node(const pcmk_node_t *node);

	G_GNUC_INTERNAL
	void pcmk__order_remote_connection_actions(pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	bool pcmk__rsc_corresponds_to_guest(const pcmk_resource_t *rsc,
	const pcmk_node_t *node);

	G_GNUC_INTERNAL
	pcmk_node_t pcmk__connection_host_for_action(const pcmk_action_t action);

	G_GNUC_INTERNAL
	void pcmk__substitute_remote_addr(pcmk_resource_t rsc, GHashTable params);

	G_GNUC_INTERNAL
	void pcmk__add_guest_meta_to_xml(xmlNode *args_xml,
	const pcmk_action_t *action);


	// Primitives (pcmk_sched_primitive.c)

	G_GNUC_INTERNAL
	pcmk_node_t pcmk__primitive_assign(pcmk_resource_t rsc,
	const pcmk_node_t *prefer,
	bool stop_if_fail);

	G_GNUC_INTERNAL
	void pcmk__primitive_create_actions(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__primitive_internal_constraints(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	uint32_t pcmk__primitive_action_flags(pcmk_action_t *action,
	const pcmk_node_t *node);

	G_GNUC_INTERNAL
	void pcmk__primitive_apply_coloc_score(pcmk_resource_t *dependent,
	const pcmk_resource_t *primary,
	const pcmk__colocation_t *colocation,
	bool for_dependent);

	G_GNUC_INTERNAL
	void pcmk__with_primitive_colocations(const pcmk_resource_t *rsc,
	const pcmk_resource_t *orig_rsc,
	GList **list);

	G_GNUC_INTERNAL
	void pcmk__primitive_with_colocations(const pcmk_resource_t *rsc,
	const pcmk_resource_t *orig_rsc,
	GList **list);

	G_GNUC_INTERNAL
	void pcmk__schedule_cleanup(pcmk_resource_t rsc, const pcmk_node_t node,
	bool optional);

	G_GNUC_INTERNAL
	void pcmk__primitive_add_graph_meta(const pcmk_resource_t rsc, xmlNode xml);

	G_GNUC_INTERNAL
	void pcmk__primitive_add_utilization(const pcmk_resource_t *rsc,
	const pcmk_resource_t *orig_rsc,
	GList all_rscs, GHashTable utilization);

	G_GNUC_INTERNAL
	void pcmk__primitive_shutdown_lock(pcmk_resource_t *rsc);


	// Groups (pcmk_sched_group.c)

	G_GNUC_INTERNAL
	pcmk_node_t pcmk__group_assign(pcmk_resource_t rsc, const pcmk_node_t *prefer,
	bool stop_if_fail);

	G_GNUC_INTERNAL
	void pcmk__group_create_actions(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__group_internal_constraints(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__group_apply_coloc_score(pcmk_resource_t *dependent,
	const pcmk_resource_t *primary,
	const pcmk__colocation_t *colocation,
	bool for_dependent);

	G_GNUC_INTERNAL
	void pcmk__with_group_colocations(const pcmk_resource_t *rsc,
	const pcmk_resource_t *orig_rsc,
	GList **list);

	G_GNUC_INTERNAL
	void pcmk__group_with_colocations(const pcmk_resource_t *rsc,
	const pcmk_resource_t *orig_rsc,
	GList **list);

	G_GNUC_INTERNAL
	void pcmk__group_add_colocated_node_scores(pcmk_resource_t *source_rsc,
	const pcmk_resource_t *target_rsc,
	const char *log_id,
	GHashTable **nodes,
	const pcmk__colocation_t *colocation,
	float factor, uint32_t flags);

	G_GNUC_INTERNAL
	void pcmk__group_apply_location(pcmk_resource_t *rsc,
	pcmk__location_t *location);

	G_GNUC_INTERNAL
	uint32_t pcmk__group_action_flags(pcmk_action_t *action,
	const pcmk_node_t *node);

	G_GNUC_INTERNAL
	uint32_t pcmk__group_update_ordered_actions(pcmk_action_t *first,
	pcmk_action_t *then,
	const pcmk_node_t *node,
	uint32_t flags, uint32_t filter,
	uint32_t type,
	pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	GList pcmk__group_colocated_resources(const pcmk_resource_t rsc,
	const pcmk_resource_t *orig_rsc,
	GList *colocated_rscs);

	G_GNUC_INTERNAL
	void pcmk__group_add_utilization(const pcmk_resource_t *rsc,
	const pcmk_resource_t *orig_rsc,
	GList all_rscs, GHashTable utilization);

	G_GNUC_INTERNAL
	void pcmk__group_shutdown_lock(pcmk_resource_t *rsc);


	// Clones (pcmk_sched_clone.c)

	G_GNUC_INTERNAL
	pcmk_node_t pcmk__clone_assign(pcmk_resource_t rsc, const pcmk_node_t *prefer,
	bool stop_if_fail);

	G_GNUC_INTERNAL
	void pcmk__clone_create_actions(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	bool pcmk__clone_create_probe(pcmk_resource_t rsc, pcmk_node_t node);

	G_GNUC_INTERNAL
	void pcmk__clone_internal_constraints(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__clone_apply_coloc_score(pcmk_resource_t *dependent,
	const pcmk_resource_t *primary,
	const pcmk__colocation_t *colocation,
	bool for_dependent);

	G_GNUC_INTERNAL
	void pcmk__with_clone_colocations(const pcmk_resource_t *rsc,
	const pcmk_resource_t *orig_rsc,
	GList **list);

	G_GNUC_INTERNAL
	void pcmk__clone_with_colocations(const pcmk_resource_t *rsc,
	const pcmk_resource_t *orig_rsc,
	GList **list);

	G_GNUC_INTERNAL
	void pcmk__clone_apply_location(pcmk_resource_t *rsc,
	pcmk__location_t *constraint);

	G_GNUC_INTERNAL
	uint32_t pcmk__clone_action_flags(pcmk_action_t *action,
	const pcmk_node_t *node);

	G_GNUC_INTERNAL
	void pcmk__clone_add_actions_to_graph(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__clone_add_graph_meta(const pcmk_resource_t rsc, xmlNode xml);

	G_GNUC_INTERNAL
	void pcmk__clone_add_utilization(const pcmk_resource_t *rsc,
	const pcmk_resource_t *orig_rsc,
	GList all_rscs, GHashTable utilization);

	G_GNUC_INTERNAL
	void pcmk__clone_shutdown_lock(pcmk_resource_t *rsc);

	// Bundles (pcmk_sched_bundle.c)

	G_GNUC_INTERNAL
	pcmk_node_t pcmk__bundle_assign(pcmk_resource_t rsc,
	const pcmk_node_t *prefer, bool stop_if_fail);

	G_GNUC_INTERNAL
	void pcmk__bundle_create_actions(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	bool pcmk__bundle_create_probe(pcmk_resource_t rsc, pcmk_node_t node);

	G_GNUC_INTERNAL
	void pcmk__bundle_internal_constraints(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__bundle_apply_coloc_score(pcmk_resource_t *dependent,
	const pcmk_resource_t *primary,
	const pcmk__colocation_t *colocation,
	bool for_dependent);

	G_GNUC_INTERNAL
	void pcmk__with_bundle_colocations(const pcmk_resource_t *rsc,
	const pcmk_resource_t *orig_rsc,
	GList **list);

	G_GNUC_INTERNAL
	void pcmk__bundle_with_colocations(const pcmk_resource_t *rsc,
	const pcmk_resource_t *orig_rsc,
	GList **list);

	G_GNUC_INTERNAL
	void pcmk__bundle_apply_location(pcmk_resource_t *rsc,
	pcmk__location_t *constraint);

	G_GNUC_INTERNAL
	uint32_t pcmk__bundle_action_flags(pcmk_action_t *action,
	const pcmk_node_t *node);

	G_GNUC_INTERNAL
	void pcmk__output_bundle_actions(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__bundle_add_actions_to_graph(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__bundle_add_utilization(const pcmk_resource_t *rsc,
	const pcmk_resource_t *orig_rsc,
	GList all_rscs, GHashTable utilization);

	G_GNUC_INTERNAL
	void pcmk__bundle_shutdown_lock(pcmk_resource_t *rsc);


	// Clone instances or bundle replica containers (pcmk_sched_instances.c)

	G_GNUC_INTERNAL
	void pcmk__assign_instances(pcmk_resource_t collective, GList instances,
	int max_total, int max_per_node);

	G_GNUC_INTERNAL
	void pcmk__create_instance_actions(pcmk_resource_t rsc, GList instances);

	G_GNUC_INTERNAL
	bool pcmk__instance_matches(const pcmk_resource_t *instance,
	const pcmk_node_t *node, enum rsc_role_e role,
	bool current);

	G_GNUC_INTERNAL
	pcmk_resource_t pcmk__find_compatible_instance(const pcmk_resource_t match_rsc,
	const pcmk_resource_t *rsc,
	enum rsc_role_e role,
	bool current);

	G_GNUC_INTERNAL
	uint32_t pcmk__instance_update_ordered_actions(pcmk_action_t *first,
	pcmk_action_t *then,
	const pcmk_node_t *node,
	uint32_t flags, uint32_t filter,
	uint32_t type,
	pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	uint32_t pcmk__collective_action_flags(pcmk_action_t *action,
	const GList *instances,
	const pcmk_node_t *node);


	// Injections (pcmk_injections.c)

	G_GNUC_INTERNAL
	xmlNode pcmk__inject_node(cib_t cib_conn, const char node, const char uuid);

	G_GNUC_INTERNAL
	xmlNode pcmk__inject_node_state_change(cib_t cib_conn, const char *node,
	bool up);

	G_GNUC_INTERNAL
	xmlNode pcmk__inject_resource_history(pcmk__output_t out, xmlNode *cib_node,
	const char *resource,
	const char *lrm_name,
	const char *rclass,
	const char *rtype,
	const char *rprovider);

	G_GNUC_INTERNAL
	void pcmk__inject_failcount(pcmk__output_t out, cib_t cib_conn,
	xmlNode cib_node, const char resource,
	const char *task, guint interval_ms, int rc);

	G_GNUC_INTERNAL
	xmlNode pcmk__inject_action_result(xmlNode cib_resource,
	lrmd_event_data_t op, const char node,
	int target_rc);


	// Nodes (pcmk_sched_nodes.c)

	G_GNUC_INTERNAL
	bool pcmk__node_available(const pcmk_node_t *node, bool consider_score,
	bool consider_guest);

	G_GNUC_INTERNAL
	bool pcmk__any_node_available(GHashTable *nodes);

	G_GNUC_INTERNAL
	GHashTable pcmk__copy_node_table(GHashTable nodes);

	G_GNUC_INTERNAL
	void pcmk__copy_node_tables(const pcmk_resource_t rsc, GHashTable *copy);

	G_GNUC_INTERNAL
	void pcmk__restore_node_tables(pcmk_resource_t rsc, GHashTable backup);

	G_GNUC_INTERNAL
	GList pcmk__sort_nodes(GList nodes, pcmk_node_t *active_node);

	G_GNUC_INTERNAL
	void pcmk__apply_node_health(pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	pcmk_node_t pcmk__top_allowed_node(const pcmk_resource_t rsc,
	const pcmk_node_t *node);


	// Functions applying to more than one variant (pcmk_sched_resource.c)

	G_GNUC_INTERNAL
	void pcmk__set_assignment_methods(pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	bool pcmk__rsc_agent_changed(pcmk_resource_t rsc, pcmk_node_t node,
	const xmlNode *rsc_entry, bool active_on_node);

	G_GNUC_INTERNAL
	GList pcmk__rscs_matching_id(const char id,
	const pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	GList pcmk__colocated_resources(const pcmk_resource_t rsc,
	const pcmk_resource_t *orig_rsc,
	GList *colocated_rscs);

	G_GNUC_INTERNAL
	void pcmk__noop_add_graph_meta(const pcmk_resource_t rsc, xmlNode xml);

	G_GNUC_INTERNAL
	void pcmk__output_resource_actions(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	bool pcmk__assign_resource(pcmk_resource_t rsc, pcmk_node_t node, bool force,
	bool stop_if_fail);

	G_GNUC_INTERNAL
	void pcmk__unassign_resource(pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	bool pcmk__threshold_reached(pcmk_resource_t rsc, const pcmk_node_t node,
	pcmk_resource_t **failed);

	G_GNUC_INTERNAL
	void pcmk__sort_resources(pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	gint pcmk__cmp_instance(gconstpointer a, gconstpointer b);

	G_GNUC_INTERNAL
	gint pcmk__cmp_instance_number(gconstpointer a, gconstpointer b);


	// Functions related to probes (pcmk_sched_probes.c)

	G_GNUC_INTERNAL
	bool pcmk__probe_rsc_on_node(pcmk_resource_t rsc, pcmk_node_t node);

	G_GNUC_INTERNAL
	void pcmk__order_probes(pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	bool pcmk__probe_resource_list(GList rscs, pcmk_node_t node);

	G_GNUC_INTERNAL
	void pcmk__schedule_probes(pcmk_scheduler_t *scheduler);


	// Functions related to live migration (pcmk_sched_migration.c)

	void pcmk__create_migration_actions(pcmk_resource_t *rsc,
	const pcmk_node_t *current);

	void pcmk__abort_dangling_migration(void data, void user_data);

	bool pcmk__rsc_can_migrate(const pcmk_resource_t *rsc,
	const pcmk_node_t *current);

	void pcmk__order_migration_equivalents(pcmk__action_relation_t *order);


	// Functions related to node utilization (pcmk_sched_utilization.c)

	G_GNUC_INTERNAL
	int pcmk__compare_node_capacities(const pcmk_node_t *node1,
	const pcmk_node_t *node2);

	G_GNUC_INTERNAL
	void pcmk__consume_node_capacity(GHashTable *current_utilization,
	const pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__release_node_capacity(GHashTable *current_utilization,
	const pcmk_resource_t *rsc);

	G_GNUC_INTERNAL
	const pcmk_node_t pcmk__ban_insufficient_capacity(pcmk_resource_t rsc);

	G_GNUC_INTERNAL
	void pcmk__create_utilization_constraints(pcmk_resource_t *rsc,
	const GList *allowed_nodes);

	G_GNUC_INTERNAL
	void pcmk__show_node_capacities(const char desc, pcmk_scheduler_t scheduler);


	// Functions related to the scheduler (pcmk_scheduler.c)

	G_GNUC_INTERNAL
	int pcmk__init_scheduler(pcmk__output_t out, xmlNodePtr input, const crm_time_t date,
	pcmk_scheduler_t **scheduler);


	// General setup functions (pcmk_setup.c)

	G_GNUC_INTERNAL
	int pcmk__setup_output_cib_sched(pcmk__output_t out, cib_t cib,
	pcmk_scheduler_t scheduler, xmlNode xml);

	-#endif // PCMK__LIBPACEMAKER_PRIVATE__H
	+#ifdef __cplusplus
	+}
	+#endif
	+
	+#endif // PCMK__PACEMAKER_LIBPACEMAKER_PRIVATE__H
	diff --git a/lib/pengine/pe_status_private.h b/lib/pengine/pe_status_private.h
	index 02feceba6e..431f450ad4 100644
	--- a/lib/pengine/pe_status_private.h
	+++ b/lib/pengine/pe_status_private.h
	@@ -1,131 +1,140 @@
	/*
	* Copyright 2018-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 PE_STATUS_PRIVATE__H
	-# define PE_STATUS_PRIVATE__H
	+#ifndef PCMK__PENGINE_PE_STATUS_PRIVATE__H
	+#define PCMK__PENGINE_PE_STATUS_PRIVATE__H

	/* This header is for the sole use of libpe_status, so that functions can be
	* declared with G_GNUC_INTERNAL for efficiency.
	*/

	+#include <glib.h> // G_GNUC_INTERNAL, GSList, GList, etc.
	+#include <libxml/tree.h> // xmlNode
	+
	+#include <crm/common/digest_internal.h> // pcmk__op_digest_t
	+#include <crm/common/scheduler_types.h> // pcmk_action_t, etc.
	+
	+#ifdef __cplusplus
	+extern "C" {
	+#endif
	+
	#if defined(PCMK__UNIT_TESTING)
	#undef G_GNUC_INTERNAL
	#define G_GNUC_INTERNAL
	#endif

	-#include <glib.h> // GSList, GList, GHashTable
	-#include <libxml/tree.h> // xmlNode
	-
	-#include <crm/pengine/status.h> // pcmk_action_t, pcmk_resource_t, etc.
	-
	typedef struct notify_data_s {
	GSList *keys; // Environment variable name/value pairs

	const char *action;

	pcmk_action_t *pre;
	pcmk_action_t *post;
	pcmk_action_t *pre_done;
	pcmk_action_t *post_done;

	GList active; / notify_entry_t* */
	GList inactive; / notify_entry_t* */
	GList start; / notify_entry_t* */
	GList stop; / notify_entry_t* */
	GList demote; / notify_entry_t* */
	GList promote; / notify_entry_t* */
	GList promoted; / notify_entry_t* */
	GList unpromoted; / notify_entry_t* */
	GHashTable *allowed_nodes;
	} notify_data_t;

	G_GNUC_INTERNAL
	pcmk_resource_t pe__create_clone_child(pcmk_resource_t rsc,
	- pcmk_scheduler_t *scheduler);
	+ pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	void pe__create_action_notifications(pcmk_resource_t *rsc,
	notify_data_t *n_data);

	G_GNUC_INTERNAL
	void pe__free_action_notification_data(notify_data_t *n_data);

	G_GNUC_INTERNAL
	notify_data_t pe__action_notif_pseudo_ops(pcmk_resource_t rsc,
	const char *task,
	pcmk_action_t *action,
	pcmk_action_t *complete);

	G_GNUC_INTERNAL
	void pe__force_anon(const char standard, pcmk_resource_t rsc, const char *rid,
	pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	gint pe__cmp_rsc_priority(gconstpointer a, gconstpointer b);

	G_GNUC_INTERNAL
	gboolean pe__unpack_resource(xmlNode xml_obj, pcmk_resource_t *rsc,
	pcmk_resource_t *parent,
	pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	gboolean unpack_remote_nodes(xmlNode *xml_resources,
	pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	gboolean unpack_resources(const xmlNode *xml_resources,
	pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	gboolean unpack_config(xmlNode config, pcmk_scheduler_t scheduler);

	G_GNUC_INTERNAL
	gboolean unpack_nodes(xmlNode xml_nodes, pcmk_scheduler_t scheduler);

	G_GNUC_INTERNAL
	gboolean unpack_tags(xmlNode xml_tags, pcmk_scheduler_t scheduler);

	G_GNUC_INTERNAL
	gboolean unpack_status(xmlNode status, pcmk_scheduler_t scheduler);

	G_GNUC_INTERNAL
	pcmk__op_digest_t pe__compare_fencing_digest(pcmk_resource_t rsc,
	const char *agent,
	pcmk_node_t *node,
	pcmk_scheduler_t *scheduler);

	G_GNUC_INTERNAL
	void pe__unpack_node_health_scores(pcmk_scheduler_t *scheduler);

	// Primitive resource methods

	G_GNUC_INTERNAL
	unsigned int pe__primitive_max_per_node(const pcmk_resource_t *rsc);

	// Group resource methods

	G_GNUC_INTERNAL
	unsigned int pe__group_max_per_node(const pcmk_resource_t *rsc);

	// Clone resource methods

	G_GNUC_INTERNAL
	unsigned int pe__clone_max_per_node(const pcmk_resource_t *rsc);

	// Bundle resource methods

	G_GNUC_INTERNAL
	pcmk_node_t pe__bundle_active_node(const pcmk_resource_t rsc,
	unsigned int *count_all,
	unsigned int *count_clean);

	G_GNUC_INTERNAL
	unsigned int pe__bundle_max_per_node(const pcmk_resource_t *rsc);

	-#endif // PE_STATUS_PRIVATE__H
	+#ifdef __cplusplus
	+}
	+#endif
	+
	+#endif // PCMK__PENGINE_PE_STATUS_PRIVATE__H
	diff --git a/lib/services/pcmk-dbus.h b/lib/services/pcmk-dbus.h
	index a9d0cbc942..56dd5d691b 100644
	--- a/lib/services/pcmk-dbus.h
	+++ b/lib/services/pcmk-dbus.h
	@@ -1,45 +1,56 @@
	/*
	- * Copyright 2014-2022 the Pacemaker project contributors
	+ * Copyright 2014-2024 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	-#ifndef PCMK_DBUS__H
	-# define PCMK_DBUS__H
	+#ifndef PCMK__SERVICES_PCMK_DBUS__H
	+#define PCMK__SERVICES_PCMK_DBUS__H

	-# include <dbus/dbus.h>
	+#include <stdbool.h> // bool

	-# ifndef DBUS_TIMEOUT_USE_DEFAULT
	-# define DBUS_TIMEOUT_USE_DEFAULT -1
	-# endif
	+#include <dbus/dbus.h> // DBUS_TIMEOUT_USE_DEFAULT, DBusConnection, etc.
	+#include <glib.h> // G_GNUC_INTERNAL, gchar
	+
	+#ifndef DBUS_TIMEOUT_USE_DEFAULT
	+#define DBUS_TIMEOUT_USE_DEFAULT -1
	+#endif
	+
	+#ifdef __cplusplus
	+extern "C" {
	+#endif

	G_GNUC_INTERNAL
	DBusConnection *pcmk_dbus_connect(void);

	G_GNUC_INTERNAL
	void pcmk_dbus_disconnect(DBusConnection *connection);

	G_GNUC_INTERNAL
	DBusPendingCall pcmk_dbus_send(DBusMessage msg, DBusConnection *connection,
	void(done)(DBusPendingCall pending, void user_data), void user_data, int timeout);

	G_GNUC_INTERNAL
	DBusMessage pcmk_dbus_send_recv(DBusMessage msg, DBusConnection connection, DBusError error, int timeout);

	G_GNUC_INTERNAL
	bool pcmk_dbus_type_check(DBusMessage msg, DBusMessageIter field, int expected, const char *function, int line);

	G_GNUC_INTERNAL
	char *pcmk_dbus_get_property(
	DBusConnection connection, const char target, const char obj, const gchar iface, const char *name,
	void (callback)(const char name, const char value, void userdata), void *userdata,
	DBusPendingCall **pending, int timeout);

	G_GNUC_INTERNAL
	bool pcmk_dbus_find_error(const DBusPendingCall pending, DBusMessage reply,
	DBusError *error);

	-#endif /* PCMK_DBUS__H */
	+#ifdef __cplusplus
	+}
	+#endif
	+
	+#endif // PCMK__SERVICES_PCMK_DBUS__H
	diff --git a/lib/services/services_lsb.h b/lib/services/services_lsb.h
	index 817483335f..a021290c8d 100644
	--- a/lib/services/services_lsb.h
	+++ b/lib/services/services_lsb.h
	@@ -1,21 +1,34 @@
	/*
	- * Copyright 2010-2022 the Pacemaker project contributors
	+ * Copyright 2010-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 SERVICES_LSB__H
	-# define SERVICES_LSB__H
	+#ifndef PCMK__SERVICES_SERVICES_LSB__H
	+#define PCMK__SERVICES_SERVICES_LSB__H
	+
	+#include <glib.h> // G_GNUC_INTERNAL, GList
	+
	+#include <crm/common/results.h> // enum ocf_exitcode
	+#include <crm/services.h> // svc_action_t
	+
	+#ifdef __cplusplus
	+extern "C" {
	+#endif

	G_GNUC_INTERNAL int services__get_lsb_metadata(const char type, char *output);
	G_GNUC_INTERNAL GList *services__list_lsb_agents(void);
	G_GNUC_INTERNAL bool services__lsb_agent_exists(const char *agent);
	G_GNUC_INTERNAL int services__lsb_prepare(svc_action_t *op);

	G_GNUC_INTERNAL
	enum ocf_exitcode services__lsb2ocf(const char *action, int exit_status);

	+#ifdef __cplusplus
	+}
	#endif
	+
	+#endif // PCMK__SERVICES_SERVICES_LSB__H
	diff --git a/lib/services/services_nagios.h b/lib/services/services_nagios.h
	index 2e447e0328..58768a89f5 100644
	--- a/lib/services/services_nagios.h
	+++ b/lib/services/services_nagios.h
	@@ -1,28 +1,41 @@
	/*
	- * Copyright 2010-2021 the Pacemaker project contributors
	+ * Copyright 2010-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 SERVICES_NAGIOS__H
	-# define SERVICES_NAGIOS__H
	+#ifndef PCMK__SERVICES_SERVICES_NAGIOS__H
	+#define PCMK__SERVICES_SERVICES_NAGIOS__H
	+
	+#include <glib.h> // G_GNUC_INTERNAL, GList, gboolean
	+
	+#include <crm/common/results.h> // enum ocf_exitcode
	+#include <crm/services.h> // svc_action_t
	+
	+#ifdef __cplusplus
	+extern "C" {
	+#endif

	G_GNUC_INTERNAL
	int services__nagios_prepare(svc_action_t *op);

	G_GNUC_INTERNAL
	enum ocf_exitcode services__nagios2ocf(int exit_status);

	G_GNUC_INTERNAL
	GList *services__list_nagios_agents(void);

	G_GNUC_INTERNAL
	gboolean services__nagios_agent_exists(const char *agent);

	G_GNUC_INTERNAL
	int services__get_nagios_metadata(const char type, char *output);

	+#ifdef __cplusplus
	+}
	#endif
	+
	+#endif // PCMK__SERVICES_SERVICES_NAGIOS__H
	diff --git a/lib/services/services_ocf.h b/lib/services/services_ocf.h
	index 1c40552723..bc57d4e68f 100644
	--- a/lib/services/services_ocf.h
	+++ b/lib/services/services_ocf.h
	@@ -1,31 +1,42 @@
	/*
	* Copyright 2010-2011 Red Hat, Inc.
	- * Later changes copyright 2012-2021 the Pacemaker project contributors
	+ * Later changes copyright 2012-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__SERVICES_OCF__H
	-#define PCMK__SERVICES_OCF__H
	+#ifndef PCMK__SERVICES_SERVICES_OCF__H
	+#define PCMK__SERVICES_SERVICES_OCF__H

	-#include <glib.h>
	+#include <glib.h> // G_GNUC_INTERNAL, GList, gboolean
	+
	+#include <crm/common/results.h> // enum ocf_exitcode
	+#include <crm/services.h> // svc_action_t
	+
	+#ifdef __cplusplus
	+extern "C" {
	+#endif

	G_GNUC_INTERNAL
	GList *resources_os_list_ocf_providers(void);

	G_GNUC_INTERNAL
	GList resources_os_list_ocf_agents(const char provider);

	G_GNUC_INTERNAL
	gboolean services__ocf_agent_exists(const char provider, const char agent);

	G_GNUC_INTERNAL
	int services__ocf_prepare(svc_action_t *op);

	G_GNUC_INTERNAL
	enum ocf_exitcode services__ocf2ocf(int exit_status);

	-#endif // PCMK__SERVICES_OCF__H
	+#ifdef __cplusplus
	+}
	+#endif
	+
	+#endif // PCMK__SERVICES_SERVICES_OCF__H
	diff --git a/lib/services/services_private.h b/lib/services/services_private.h
	index 48269b8030..b6ccb9893c 100644
	--- a/lib/services/services_private.h
	+++ b/lib/services/services_private.h
	@@ -1,101 +1,112 @@
	/*
	* Copyright 2010-2011 Red Hat, Inc.
	- * Later changes copyright 2012-2022 the Pacemaker project contributors
	+ * Later changes copyright 2012-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 SERVICES_PRIVATE__H
	-# define SERVICES_PRIVATE__H
	+#ifndef PCMK__SERVICES_SERVICES_PRIVATE__H
	+#define PCMK__SERVICES_SERVICES_PRIVATE__H

	-# include <glib.h>
	-# include "crm/services.h"
	+#include <unistd.h> // uid_t, gid_t

	+#include <glib.h> // G_GNUC_INTERNAL, gboolean, guint, etc.
	#if HAVE_DBUS
	-# include <dbus/dbus.h>
	+#include <dbus/dbus.h> // DBusPendingCall
	+#endif
	+
	+#include <crm/common/mainloop.h> // mainloop_io_t
	+#include <crm/services.h> // svc_action_t
	+
	+#ifdef __cplusplus
	+extern "C" {
	#endif

	#define MAX_ARGC 255
	struct svc_action_private_s {
	char *exec;
	char *exit_reason;
	char *args[MAX_ARGC];

	uid_t uid;
	gid_t gid;

	guint repeat_timer;
	void (callback) (svc_action_t op);
	void (fork_callback) (svc_action_t op);

	int stderr_fd;
	mainloop_io_t *stderr_gsource;

	int stdout_fd;
	mainloop_io_t *stdout_gsource;

	int stdin_fd;
	#if HAVE_DBUS
	DBusPendingCall* pending;
	unsigned timerid;
	#endif
	};

	G_GNUC_INTERNAL
	const char services__action_kind(const svc_action_t action);

	G_GNUC_INTERNAL
	GList services_os_get_single_directory_list(const char root, gboolean files,
	gboolean executable);

	G_GNUC_INTERNAL
	GList services_os_get_directory_list(const char root, gboolean files, gboolean executable);

	G_GNUC_INTERNAL
	int services__execute_file(svc_action_t *op);

	G_GNUC_INTERNAL
	gboolean cancel_recurring_action(svc_action_t * op);

	G_GNUC_INTERNAL
	gboolean recurring_action_timer(gpointer data);

	G_GNUC_INTERNAL
	int services__finalize_async_op(svc_action_t *op);

	G_GNUC_INTERNAL
	int services__generic_error(const svc_action_t *op);

	G_GNUC_INTERNAL
	int services__not_installed_error(const svc_action_t *op);

	G_GNUC_INTERNAL
	int services__authorization_error(const svc_action_t *op);

	G_GNUC_INTERNAL
	int services__configuration_error(const svc_action_t *op, bool is_fatal);

	G_GNUC_INTERNAL
	void services__handle_exec_error(svc_action_t * op, int error);

	G_GNUC_INTERNAL
	void services__set_cancelled(svc_action_t *action);

	G_GNUC_INTERNAL
	void services_add_inflight_op(svc_action_t *op);

	G_GNUC_INTERNAL
	void services_untrack_op(const svc_action_t *op);

	G_GNUC_INTERNAL
	gboolean is_op_blocked(const char *rsc);

	#if HAVE_DBUS
	G_GNUC_INTERNAL
	void services_set_op_pending(svc_action_t op, DBusPendingCall pending);
	#endif

	-#endif /* SERVICES_PRIVATE__H */
	+#ifdef __cplusplus
	+}
	+#endif
	+
	+#endif // PCMK__SERVICES_SERVICES_PRIVATE__H
	diff --git a/lib/services/systemd.h b/lib/services/systemd.h
	index 0d3dbe6d7f..333bbaa6cd 100644
	--- a/lib/services/systemd.h
	+++ b/lib/services/systemd.h
	@@ -1,30 +1,38 @@
	/*
	- * Copyright 2012-2021 the Pacemaker project contributors
	+ * Copyright 2012-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 SYSTEMD__H
	-# define SYSTEMD__H
	+#ifndef PCMK__SERVICES_SYSTEMD__H
	+#define PCMK__SERVICES_SYSTEMD__H

	-# include <glib.h>
	-# include "crm/services.h"
	+#include <glib.h>
	+#include "crm/services.h"
	+
	+#ifdef __cplusplus
	+extern "C" {
	+#endif

	G_GNUC_INTERNAL GList *systemd_unit_listall(void);

	G_GNUC_INTERNAL
	int services__systemd_prepare(svc_action_t *op);

	G_GNUC_INTERNAL
	enum ocf_exitcode services__systemd2ocf(int exit_status);

	G_GNUC_INTERNAL
	int services__execute_systemd(svc_action_t *op);

	G_GNUC_INTERNAL gboolean systemd_unit_exists(const gchar * name);
	G_GNUC_INTERNAL void systemd_cleanup(void);

	-#endif /* SYSTEMD__H */
	+#ifdef __cplusplus
	+}
	+#endif
	+
	+#endif // PCMK__SERVICES_SYSTEMD__H
	diff --git a/lib/services/upstart.h b/lib/services/upstart.h
	index b6c4effc07..75419a47b1 100644
	--- a/lib/services/upstart.h
	+++ b/lib/services/upstart.h
	@@ -1,31 +1,39 @@
	/*
	* Copyright 2010 Senko Rasic <senko.rasic@dobarkod.hr>
	* Copyright 2010 Ante Karamatic <ivoks@init.hr>
	- * Later changes copyright 2012-2021 the Pacemaker project contributors
	+ * Later changes copyright 2012-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 UPSTART__H
	-# define UPSTART__H
	+#ifndef PCMK__SERVICES_UPSTART__H
	+#define PCMK__SERVICES_UPSTART__H

	-# include <glib.h>
	-# include "crm/services.h"
	+#include <glib.h>
	+#include "crm/services.h"
	+
	+#ifdef __cplusplus
	+extern "C" {
	+#endif

	G_GNUC_INTERNAL GList *upstart_job_listall(void);

	G_GNUC_INTERNAL
	int services__upstart_prepare(svc_action_t *op);

	G_GNUC_INTERNAL
	enum ocf_exitcode services__upstart2ocf(int exit_status);

	G_GNUC_INTERNAL
	int services__execute_upstart(svc_action_t *op);

	G_GNUC_INTERNAL gboolean upstart_job_exists(const gchar * name);
	G_GNUC_INTERNAL void upstart_cleanup(void);

	-#endif /* UPSTART__H */
	+#ifdef __cplusplus
	+}
	+#endif
	+
	+#endif // PCMK__SERVICES_UPSTART__H

File Metadata

Mime Type: text/x-diff
Expires: Wed, Jun 25, 6:07 AM (20 h, 7 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1952378
Default Alt Text: (82 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions