No OneTemporary
Actions

Size

55 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/daemons/based/based_messages.c b/daemons/based/based_messages.c
	index f605176ea4..812b70a300 100644
	--- a/daemons/based/based_messages.c
	+++ b/daemons/based/based_messages.c
	@@ -1,520 +1,521 @@
	/*
	* 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 General Public License version 2
	* or later (GPLv2+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

	#include <stdio.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <time.h>

	#include <sys/param.h>
	#include <sys/types.h>

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

	#include <crm/crm.h>
	#include <crm/cib/internal.h>

	#include <crm/common/xml.h>
	#include <crm/common/ipc_internal.h>
	#include <crm/common/xml_internal.h>
	#include <crm/cluster/internal.h>

	#include <pacemaker-based.h>

	/* Maximum number of diffs to ignore while waiting for a resync */
	#define MAX_DIFF_RETRY 5

	bool based_is_primary = false;

	xmlNode *the_cib = NULL;

	int
	cib_process_shutdown_req(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	const char *host = crm_element_value(req, PCMK__XA_SRC);

	*answer = NULL;

	if (crm_element_value(req, PCMK__XA_CIB_ISREPLYTO) == NULL) {
	crm_info("Peer %s is requesting to shut down", host);
	return pcmk_ok;
	}

	if (cib_shutdown_flag == FALSE) {
	crm_err("Peer %s mistakenly thinks we wanted to shut down", host);
	return -EINVAL;
	}

	crm_info("Peer %s has acknowledged our shutdown request", host);
	terminate_cib(__func__, 0);
	return pcmk_ok;
	}

	// @COMPAT: Remove when PCMK__CIB_REQUEST_NOOP is removed
	int
	cib_process_noop(const char op, int options, const char section, xmlNode *req,
	xmlNode input, xmlNode existing_cib, xmlNode **result_cib,
	xmlNode **answer)
	{
	crm_trace("Processing \"%s\" event", op);
	*answer = NULL;
	return pcmk_ok;
	}

	int
	cib_process_readwrite(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	int result = pcmk_ok;

	crm_trace("Processing \"%s\" event", op);

	+ // @COMPAT Pacemaker Remote clients <3.0.0 may send this
	if (pcmk__str_eq(op, PCMK__CIB_REQUEST_IS_PRIMARY, pcmk__str_none)) {
	if (based_is_primary) {
	result = pcmk_ok;
	} else {
	result = -EPERM;
	}
	return result;
	}

	if (pcmk__str_eq(op, PCMK__CIB_REQUEST_PRIMARY, pcmk__str_none)) {
	if (!based_is_primary) {
	crm_info("We are now in R/W mode");
	based_is_primary = true;
	} else {
	crm_debug("We are still in R/W mode");
	}

	} else if (based_is_primary) {
	crm_info("We are now in R/O mode");
	based_is_primary = false;
	}

	return result;
	}

	/* Set to 1 when a sync is requested, incremented when a diff is ignored,
	* reset to 0 when a sync is received
	*/
	static int sync_in_progress = 0;

	void
	send_sync_request(const char *host)
	{
	xmlNode *sync_me = pcmk__xe_create(NULL, "sync-me");
	pcmk__node_status_t *peer = NULL;

	crm_info("Requesting re-sync from %s", (host? host : "all peers"));
	sync_in_progress = 1;

	crm_xml_add(sync_me, PCMK__XA_T, PCMK__VALUE_CIB);
	crm_xml_add(sync_me, PCMK__XA_CIB_OP, PCMK__CIB_REQUEST_SYNC_TO_ONE);
	crm_xml_add(sync_me, PCMK__XA_CIB_DELEGATED_FROM, OUR_NODENAME);

	if (host != NULL) {
	peer = pcmk__get_node(0, host, NULL, pcmk__node_search_cluster_member);
	}
	pcmk__cluster_send_message(peer, pcmk_ipc_based, sync_me);
	pcmk__xml_free(sync_me);
	}

	int
	cib_process_ping(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	const char *host = crm_element_value(req, PCMK__XA_SRC);
	const char *seq = crm_element_value(req, PCMK__XA_CIB_PING_ID);
	char *digest = pcmk__digest_xml(the_cib, true);

	xmlNode *wrapper = NULL;

	crm_trace("Processing \"%s\" event %s from %s", op, seq, host);
	*answer = pcmk__xe_create(NULL, PCMK__XE_PING_RESPONSE);

	crm_xml_add(*answer, PCMK_XA_CRM_FEATURE_SET, CRM_FEATURE_SET);
	crm_xml_add(*answer, PCMK__XA_DIGEST, digest);
	crm_xml_add(*answer, PCMK__XA_CIB_PING_ID, seq);

	wrapper = pcmk__xe_create(*answer, PCMK__XE_CIB_CALLDATA);

	if (the_cib != NULL) {
	pcmk__if_tracing(
	{
	/* Append additional detail so the receiver can log the
	* differences
	*/
	pcmk__xml_copy(wrapper, the_cib);
	},
	{
	// Always include at least the version details
	const char name = (const char ) the_cib->name;
	xmlNode *shallow = pcmk__xe_create(wrapper, name);

	pcmk__xe_copy_attrs(shallow, the_cib, pcmk__xaf_none);
	}
	);
	}

	crm_info("Reporting our current digest to %s: %s for %s.%s.%s",
	host, digest,
	crm_element_value(existing_cib, PCMK_XA_ADMIN_EPOCH),
	crm_element_value(existing_cib, PCMK_XA_EPOCH),
	crm_element_value(existing_cib, PCMK_XA_NUM_UPDATES));

	free(digest);

	return pcmk_ok;
	}

	int
	cib_process_sync(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	return sync_our_cib(req, TRUE);
	}

	int
	cib_process_upgrade_server(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	int rc = pcmk_ok;

	*answer = NULL;

	if (crm_element_value(req, PCMK__XA_CIB_SCHEMA_MAX) != NULL) {
	/* The originator of an upgrade request sends it to the DC, without
	* PCMK__XA_CIB_SCHEMA_MAX. If an upgrade is needed, the DC
	* re-broadcasts the request with PCMK__XA_CIB_SCHEMA_MAX, and each node
	* performs the upgrade (and notifies its local clients) here.
	*/
	return cib_process_upgrade(
	op, options, section, req, input, existing_cib, result_cib, answer);

	} else {
	xmlNode *scratch = pcmk__xml_copy(NULL, existing_cib);
	const char *host = crm_element_value(req, PCMK__XA_SRC);
	const char *original_schema = NULL;
	const char *new_schema = NULL;
	const char *client_id = crm_element_value(req, PCMK__XA_CIB_CLIENTID);
	const char *call_opts = crm_element_value(req, PCMK__XA_CIB_CALLOPT);
	const char *call_id = crm_element_value(req, PCMK__XA_CIB_CALLID);

	crm_trace("Processing \"%s\" event", op);
	original_schema = crm_element_value(existing_cib,
	PCMK_XA_VALIDATE_WITH);
	rc = pcmk__update_schema(&scratch, NULL, true, true);
	rc = pcmk_rc2legacy(rc);
	new_schema = crm_element_value(scratch, PCMK_XA_VALIDATE_WITH);

	if (pcmk__cmp_schemas_by_name(new_schema, original_schema) > 0) {
	xmlNode *up = pcmk__xe_create(NULL, __func__);

	rc = pcmk_ok;
	crm_notice("Upgrade request from %s verified", host);

	crm_xml_add(up, PCMK__XA_T, PCMK__VALUE_CIB);
	crm_xml_add(up, PCMK__XA_CIB_OP, PCMK__CIB_REQUEST_UPGRADE);
	crm_xml_add(up, PCMK__XA_CIB_SCHEMA_MAX, new_schema);
	crm_xml_add(up, PCMK__XA_CIB_DELEGATED_FROM, host);
	crm_xml_add(up, PCMK__XA_CIB_CLIENTID, client_id);
	crm_xml_add(up, PCMK__XA_CIB_CALLOPT, call_opts);
	crm_xml_add(up, PCMK__XA_CIB_CALLID, call_id);

	pcmk__cluster_send_message(NULL, pcmk_ipc_based, up);

	pcmk__xml_free(up);

	} else if(rc == pcmk_ok) {
	rc = -pcmk_err_schema_unchanged;
	}

	if (rc != pcmk_ok) {
	// Notify originating peer so it can notify its local clients
	pcmk__node_status_t *origin = NULL;

	origin = pcmk__search_node_caches(0, host,
	pcmk__node_search_cluster_member);

	crm_info("Rejecting upgrade request from %s: %s "
	QB_XS " rc=%d peer=%s", host, pcmk_strerror(rc), rc,
	(origin? origin->name : "lost"));

	if (origin) {
	xmlNode *up = pcmk__xe_create(NULL, __func__);

	crm_xml_add(up, PCMK__XA_T, PCMK__VALUE_CIB);
	crm_xml_add(up, PCMK__XA_CIB_OP, PCMK__CIB_REQUEST_UPGRADE);
	crm_xml_add(up, PCMK__XA_CIB_DELEGATED_FROM, host);
	crm_xml_add(up, PCMK__XA_CIB_ISREPLYTO, host);
	crm_xml_add(up, PCMK__XA_CIB_CLIENTID, client_id);
	crm_xml_add(up, PCMK__XA_CIB_CALLOPT, call_opts);
	crm_xml_add(up, PCMK__XA_CIB_CALLID, call_id);
	crm_xml_add_int(up, PCMK__XA_CIB_UPGRADE_RC, rc);
	if (!pcmk__cluster_send_message(origin, pcmk_ipc_based, up)) {
	crm_warn("Could not send CIB upgrade result to %s", host);
	}
	pcmk__xml_free(up);
	}
	}
	pcmk__xml_free(scratch);
	}
	return rc;
	}

	int
	cib_process_sync_one(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	return sync_our_cib(req, FALSE);
	}

	int
	cib_server_process_diff(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	int rc = pcmk_ok;

	if (sync_in_progress > MAX_DIFF_RETRY) {
	/* Don't ignore diffs forever; the last request may have been lost.
	* If the diff fails, we'll ask for another full resync.
	*/
	sync_in_progress = 0;
	}

	// The primary instance should never ignore a diff
	if (sync_in_progress && !based_is_primary) {
	int diff_add_updates = 0;
	int diff_add_epoch = 0;
	int diff_add_admin_epoch = 0;

	int diff_del_updates = 0;
	int diff_del_epoch = 0;
	int diff_del_admin_epoch = 0;

	cib_diff_version_details(input,
	&diff_add_admin_epoch, &diff_add_epoch, &diff_add_updates,
	&diff_del_admin_epoch, &diff_del_epoch, &diff_del_updates);

	sync_in_progress++;
	crm_notice("Not applying diff %d.%d.%d -> %d.%d.%d (sync in progress)",
	diff_del_admin_epoch, diff_del_epoch, diff_del_updates,
	diff_add_admin_epoch, diff_add_epoch, diff_add_updates);
	return -pcmk_err_diff_resync;
	}

	rc = cib_process_diff(op, options, section, req, input, existing_cib, result_cib, answer);
	crm_trace("result: %s (%d), %s", pcmk_strerror(rc), rc,
	(based_is_primary? "primary": "secondary"));

	if ((rc == -pcmk_err_diff_resync) && !based_is_primary) {
	pcmk__xml_free(*result_cib);
	*result_cib = NULL;
	send_sync_request(NULL);

	} else if (rc == -pcmk_err_diff_resync) {
	rc = -pcmk_err_diff_failed;
	if (options & cib_force_diff) {
	crm_warn("Not requesting full refresh in R/W mode");
	}
	}

	return rc;
	}

	int
	cib_process_replace_svr(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	int rc =
	cib_process_replace(op, options, section, req, input, existing_cib, result_cib, answer);

	if ((rc == pcmk_ok) && pcmk__xe_is(input, PCMK_XE_CIB)) {
	sync_in_progress = 0;
	}
	return rc;
	}

	// @COMPAT: Remove when PCMK__CIB_REQUEST_ABS_DELETE is removed
	int
	cib_process_delete_absolute(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	return -EINVAL;
	}

	static xmlNode *
	cib_msg_copy(xmlNode *msg)
	{
	static const char *field_list[] = {
	PCMK__XA_T,
	PCMK__XA_CIB_CLIENTID,
	PCMK__XA_CIB_CALLOPT,
	PCMK__XA_CIB_CALLID,
	PCMK__XA_CIB_OP,
	PCMK__XA_CIB_ISREPLYTO,
	PCMK__XA_CIB_SECTION,
	PCMK__XA_CIB_HOST,
	PCMK__XA_CIB_RC,
	PCMK__XA_CIB_DELEGATED_FROM,
	PCMK__XA_CIB_UPDATE,
	PCMK__XA_CIB_CLIENTNAME,
	PCMK__XA_CIB_USER,
	PCMK__XA_CIB_NOTIFY_TYPE,
	PCMK__XA_CIB_NOTIFY_ACTIVATE,
	};

	xmlNode *copy = pcmk__xe_create(NULL, PCMK__XE_COPY);

	for (int lpc = 0; lpc < PCMK__NELEM(field_list); lpc++) {
	const char *field = field_list[lpc];
	const char *value = crm_element_value(msg, field);

	if (value != NULL) {
	crm_xml_add(copy, field, value);
	}
	}

	return copy;
	}

	int
	sync_our_cib(xmlNode * request, gboolean all)
	{
	int result = pcmk_ok;
	char *digest = NULL;
	const char *host = crm_element_value(request, PCMK__XA_SRC);
	const char *op = crm_element_value(request, PCMK__XA_CIB_OP);
	pcmk__node_status_t *peer = NULL;
	xmlNode *replace_request = NULL;
	xmlNode *wrapper = NULL;

	CRM_CHECK(the_cib != NULL, return -EINVAL);
	CRM_CHECK(all \|\| (host != NULL), return -EINVAL);

	crm_debug("Syncing CIB to %s", all ? "all peers" : host);

	replace_request = cib_msg_copy(request);

	if (host != NULL) {
	crm_xml_add(replace_request, PCMK__XA_CIB_ISREPLYTO, host);
	}
	if (all) {
	pcmk__xe_remove_attr(replace_request, PCMK__XA_CIB_HOST);
	}

	crm_xml_add(replace_request, PCMK__XA_CIB_OP, PCMK__CIB_REQUEST_REPLACE);

	// @TODO Keep for tracing, or drop?
	crm_xml_add(replace_request, PCMK__XA_ORIGINAL_CIB_OP, op);

	pcmk__xe_set_bool_attr(replace_request, PCMK__XA_CIB_UPDATE, true);

	crm_xml_add(replace_request, PCMK_XA_CRM_FEATURE_SET, CRM_FEATURE_SET);
	digest = pcmk__digest_xml(the_cib, true);
	crm_xml_add(replace_request, PCMK__XA_DIGEST, digest);

	wrapper = pcmk__xe_create(replace_request, PCMK__XE_CIB_CALLDATA);
	pcmk__xml_copy(wrapper, the_cib);

	if (!all) {
	peer = pcmk__get_node(0, host, NULL, pcmk__node_search_cluster_member);
	}
	if (!pcmk__cluster_send_message(peer, pcmk_ipc_based, replace_request)) {
	result = -ENOTCONN;
	}
	pcmk__xml_free(replace_request);
	free(digest);
	return result;
	}

	int
	cib_process_commit_transaction(const char op, int options, const char section,
	xmlNode req, xmlNode input,
	xmlNode existing_cib, xmlNode *result_cib,
	xmlNode **answer)
	{
	/* On success, our caller will activate *result_cib locally, trigger a
	* replace notification if appropriate, and sync *result_cib to all nodes.
	* On failure, our caller will free *result_cib.
	*/
	int rc = pcmk_rc_ok;
	const char *client_id = crm_element_value(req, PCMK__XA_CIB_CLIENTID);
	const char *origin = crm_element_value(req, PCMK__XA_SRC);
	pcmk__client_t *client = pcmk__find_client_by_id(client_id);

	rc = based_commit_transaction(input, client, origin, result_cib);

	if (rc != pcmk_rc_ok) {
	char *source = based_transaction_source_str(client, origin);

	crm_err("Could not commit transaction for %s: %s",
	source, pcmk_rc_str(rc));
	free(source);
	}
	return pcmk_rc2legacy(rc);
	}

	int
	cib_process_schemas(const char op, int options, const char section, xmlNode *req,
	xmlNode input, xmlNode existing_cib, xmlNode **result_cib,
	xmlNode **answer)
	{
	xmlNode *wrapper = NULL;
	xmlNode *data = NULL;

	const char *after_ver = NULL;
	GList *schemas = NULL;
	GList *already_included = NULL;

	*answer = pcmk__xe_create(NULL, PCMK__XA_SCHEMAS);

	wrapper = pcmk__xe_first_child(req, PCMK__XE_CIB_CALLDATA, NULL, NULL);
	data = pcmk__xe_first_child(wrapper, NULL, NULL, NULL);
	if (data == NULL) {
	crm_warn("No data specified in request");
	return -EPROTO;
	}

	after_ver = crm_element_value(data, PCMK_XA_VERSION);
	if (after_ver == NULL) {
	crm_warn("No version specified in request");
	return -EPROTO;
	}

	/* The client requested all schemas after the latest one we know about, which
	* means the client is fully up-to-date. Return a properly formatted reply
	* with no schemas.
	*/
	if (pcmk__str_eq(after_ver, pcmk__highest_schema_name(), pcmk__str_none)) {
	return pcmk_ok;
	}

	schemas = pcmk__schema_files_later_than(after_ver);

	for (GList *iter = schemas; iter != NULL; iter = iter->next) {
	pcmk__build_schema_xml_node(*answer, iter->data, &already_included);
	}

	g_list_free_full(schemas, free);
	g_list_free_full(already_included, free);
	return pcmk_ok;
	}
	diff --git a/include/crm/cib/cib_types.h b/include/crm/cib/cib_types.h
	index 3ba76e70fd..8f3d4da428 100644
	--- a/include/crm/cib/cib_types.h
	+++ b/include/crm/cib/cib_types.h
	@@ -1,363 +1,360 @@
	/*
	* 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_CIB_CIB_TYPES__H
	# define PCMK__CRM_CIB_CIB_TYPES__H

	# include <glib.h> // gboolean, GList
	# include <libxml/tree.h> // xmlNode
	# include <crm/common/ipc.h>
	# include <crm/common/xml.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	/**
	* \file
	* \brief Data types for Cluster Information Base access
	* \ingroup cib
	*/

	enum cib_variant {
	cib_undefined = 0,
	cib_native = 1,
	cib_file = 2,
	cib_remote = 3,
	};

	enum cib_state {
	// NOTE: sbd (as of at least 1.5.2) uses this value
	cib_connected_command,

	// NOTE: sbd (as of at least 1.5.2) uses this value
	cib_connected_query,

	cib_disconnected
	};

	enum cib_conn_type {
	cib_command,

	// NOTE: sbd (as of at least 1.5.2) uses this value
	cib_query,

	cib_no_connection,
	cib_command_nonblocking,
	};

	enum cib_call_options {
	cib_none = 0,
	cib_verbose = (1 << 0), //!< Prefer stderr to logs
	cib_xpath = (1 << 1),
	cib_multiple = (1 << 2),
	cib_can_create = (1 << 3),
	cib_discard_reply = (1 << 4),
	cib_no_children = (1 << 5),
	cib_xpath_address = (1 << 6),

	#if !defined(PCMK_ALLOW_DEPRECATED) \|\| (PCMK_ALLOW_DEPRECATED == 1)
	// NOTE: sbd (as of at least 1.5.2) uses this value
	//! \deprecated This value will be removed in a future release
	cib_scope_local = (1 << 8),
	#endif // !defined(PCMK_ALLOW_DEPRECATED) \|\| (PCMK_ALLOW_DEPRECATED == 1)

	cib_dryrun = (1 << 9),

	/*!
	* \brief Process request when the client commits the active transaction
	*
	* Add the request to the client's active transaction instead of processing
	* it immediately. If the client has no active transaction, or if the
	* request is not supported in transactions, the call will fail.
	*
	* The request is added to the transaction synchronously, and the return
	* value indicates whether it was added successfully.
	*
	* Refer to \p cib_api_operations_t:init_transaction() and
	* \p cib_api_operations_t:end_transaction() for more details on CIB
	* transactions.
	*/
	cib_transaction = (1 << 10),

	/*!
	* \brief Treat new attribute values as atomic score updates where possible
	*
	* This option takes effect when updating XML attributes. For an attribute
	* named \c "name", if the new value is \c "name++" or \c "name+=X" for some
	* score \c X, the new value is set as follows:
	* * If attribute \c "name" is not already set to some value in the element
	* being updated, the new value is set as a literal string.
	* * If the new value is \c "name++", then the attribute is set to its
	* existing value (parsed as a score) plus 1.
	* * If the new value is \c "name+=X" for some score \c X, then the
	* attribute is set to its existing value plus \c X, where the existing
	* value and \c X are parsed and added as scores.
	*
	* Scores are integer values capped at \c INFINITY and \c -INFINITY. Refer
	* to Pacemaker Explained and to the \c char2score() function for more
	* details on scores, including how they're parsed and added.
	*
	* Note: This is implemented only for modify operations.
	*/
	cib_score_update = (1 << 11),

	// NOTE: sbd (as of at least 1.5.2) uses this value
	cib_sync_call = (1 << 12),

	cib_no_mtime = (1 << 13),
	cib_inhibit_notify = (1 << 16),
	cib_force_diff = (1 << 28),
	};

	typedef struct cib_s cib_t;

	typedef struct cib_api_operations_s {
	// NOTE: sbd (as of at least 1.5.2) uses this
	// @COMPAT At compatibility break, drop name (always use crm_system_name)
	int (signon) (cib_t cib, const char *name, enum cib_conn_type type);

	// NOTE: sbd (as of at least 1.5.2) uses this
	int (signoff) (cib_t cib);

	int (free) (cib_t cib);

	// NOTE: sbd (as of at least 1.5.2) uses this
	int (add_notify_callback) (cib_t cib, const char *event,
	void (callback) (const char event,
	xmlNode *msg));

	// NOTE: sbd (as of at least 1.5.2) uses this
	int (del_notify_callback) (cib_t cib, const char *event,
	void (callback) (const char event,
	xmlNode *msg));
	// NOTE: sbd (as of at least 1.5.2) uses this
	int (set_connection_dnotify) (cib_t cib,
	void (*dnotify) (gpointer user_data));

	// NOTE: sbd (as of at least 1.5.2) uses this
	//! \deprecated This method will be removed and should not be used
	int (noop) (cib_t cib, int call_options);

	int (ping) (cib_t cib, xmlNode **output_data, int call_options);

	// NOTE: sbd (as of at least 1.5.2) uses this
	int (query) (cib_t cib, const char section, xmlNode *output_data,
	int call_options);

	int (query_from) (cib_t cib, const char host, const char section,
	xmlNode **output_data, int call_options);

	- //! \deprecated This method will be removed and should not be used
	- int (is_master) (cib_t cib);
	-
	//! \deprecated Use the set_primary() method instead
	int (set_master) (cib_t cib, int call_options);

	//! \deprecated Use the set_secondary() method instead
	int (set_slave) (cib_t cib, int call_options);

	//! \deprecated This method will be removed and should not be used
	int (set_slave_all) (cib_t cib, int call_options);

	int (sync) (cib_t cib, const char *section, int call_options);
	int (sync_from) (cib_t cib, const char host, const char section,
	int call_options);
	int (upgrade) (cib_t cib, int call_options);
	int (bump_epoch) (cib_t cib, int call_options);

	/*!
	* The \c <failed> element in the reply to a failed creation call is
	* deprecated since 2.1.8.
	*/
	int (create) (cib_t cib, const char section, xmlNode data,
	int call_options);
	int (modify) (cib_t cib, const char section, xmlNode data,
	int call_options);

	//! \deprecated Use the \p modify() method instead
	int (update) (cib_t cib, const char section, xmlNode data,
	int call_options);

	int (replace) (cib_t cib, const char section, xmlNode data,
	int call_options);
	int (remove) (cib_t cib, const char section, xmlNode data,
	int call_options);
	int (erase) (cib_t cib, xmlNode **output_data, int call_options);

	//! \deprecated This method does nothing and should not be called
	int (delete_absolute) (cib_t cib, const char section, xmlNode data,
	int call_options);

	//! \deprecated This method is not implemented and should not be used
	int (quit) (cib_t cib, int call_options);

	int (register_notification) (cib_t cib, const char *callback,
	int enabled);
	gboolean (register_callback) (cib_t cib, int call_id, int timeout,
	gboolean only_success, void *user_data,
	const char *callback_name,
	void (callback) (xmlNode, int, int,
	xmlNode, void ));
	gboolean (register_callback_full)(cib_t cib, int call_id, int timeout,
	gboolean only_success, void *user_data,
	const char *callback_name,
	void (callback)(xmlNode , int, int,
	xmlNode , void ),
	void (free_func)(void ));

	/*!
	* \brief Set the local CIB manager as the cluster's primary instance
	*
	* \param[in,out] cib CIB connection
	* \param[in] call_options Group of enum cib_call_options flags
	*
	* \return Legacy Pacemaker return code (in particular, pcmk_ok on success)
	*/
	int (set_primary)(cib_t cib, int call_options);

	/*!
	* \brief Set the local CIB manager as a secondary instance
	*
	* \param[in,out] cib CIB connection
	* \param[in] call_options Group of enum cib_call_options flags
	*
	* \return Legacy Pacemaker return code (in particular, pcmk_ok on success)
	*/
	int (set_secondary)(cib_t cib, int call_options);

	/*!
	* \brief Get the given CIB connection's unique client identifier(s)
	*
	* These can be used to check whether this client requested the action that
	* triggered a CIB notification.
	*
	* \param[in] cib CIB connection
	* \param[out] async_id If not \p NULL, where to store asynchronous client
	* ID
	* \param[out] sync_id If not \p NULL, where to store synchronous client
	* ID
	*
	* \return Legacy Pacemaker return code
	*
	* \note Some variants may have only one client for both asynchronous and
	* synchronous requests.
	*/
	int (client_id)(const cib_t cib, const char **async_id,
	const char **sync_id);

	/*!
	* \brief Initiate an atomic CIB transaction for this client
	*
	* If the client has initiated a transaction and a new request's call
	* options contain \p cib_transaction, the new request is appended to the
	* transaction for later processing.
	*
	* Supported requests are those that meet the following conditions:
	* * can be processed synchronously (with any changes applied to a working
	* CIB copy)
	* * are not queries
	* * do not involve other nodes
	* * do not affect the state of pacemaker-based itself
	*
	* Currently supported CIB API functions include:
	* * \p bump_epoch()
	* * \p create()
	* * \p erase()
	* * \p modify()
	* * \p remove()
	* * \p replace()
	* * \p upgrade()
	*
	* Because the transaction is atomic, individual requests do not trigger
	* callbacks or notifications when they are processed, and they do not
	* receive output XML. The commit request itself can trigger callbacks and
	* notifications if any are registered.
	*
	* An \c init_transaction() call is always synchronous.
	*
	* \param[in,out] cib CIB connection
	*
	* \return Legacy Pacemaker return code
	*/
	int (init_transaction)(cib_t cib);

	/*!
	* \brief End and optionally commit this client's CIB transaction
	*
	* When a client commits a transaction, all requests in the transaction are
	* processed in a FIFO manner until either a request fails or all requests
	* have been processed. Changes are applied to a working copy of the CIB.
	* If a request fails, the transaction and working CIB copy are discarded,
	* and an error is returned. If all requests succeed, the working CIB copy
	* replaces the initial CIB copy.
	*
	* Callbacks and notifications can be triggered by the commit request itself
	* but not by the individual requests in a transaction.
	*
	* An \c end_transaction() call with \p commit set to \c false is always
	* synchronous.
	*
	* \param[in,out] cib CIB connection
	* \param[in] commit If \p true, commit transaction; otherwise,
	* discard it
	* \param[in] call_options Group of <tt>enum cib_call_options</tt>
	* flags
	*
	* \return Legacy Pacemaker return code
	*/
	int (end_transaction)(cib_t cib, bool commit, int call_options);

	/*!
	* \brief Set the user as whom all CIB requests via methods will be executed
	*
	* By default, the value of the \c CIB_user environment variable is used if
	* set. Otherwise, the current effective user is used.
	*
	* \param[in,out] cib CIB connection
	* \param[in] user Name of user whose permissions to use when
	* processing requests
	*/
	void (set_user)(cib_t cib, const char *user);

	int (fetch_schemas)(cib_t cib, xmlNode *output_data, const char after_ver,
	int call_options);
	} cib_api_operations_t;

	struct cib_s {
	// NOTE: sbd (as of at least 1.5.2) uses this
	enum cib_state state;

	enum cib_conn_type type;
	enum cib_variant variant;

	int call_id;
	int call_timeout;
	void *variant_opaque;
	void *delegate_fn;

	GList *notify_list;

	//! \deprecated This method will be removed in a future release
	void (op_callback) (const xmlNode msg, int call_id, int rc,
	xmlNode *output);

	// NOTE: sbd (as of at least 1.5.2) uses this
	cib_api_operations_t *cmds;

	xmlNode *transaction;

	char *user;
	};

	#ifdef __cplusplus
	}
	#endif

	#endif // PCMK__CRM_CIB_CIB_TYPES__H
	diff --git a/lib/cib/cib_client.c b/lib/cib/cib_client.c
	index 8093941066..da9b397148 100644
	--- a/lib/cib/cib_client.c
	+++ b/lib/cib/cib_client.c
	@@ -1,822 +1,812 @@
	/*
	* 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 <unistd.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <stdarg.h>
	#include <string.h>
	#include <pwd.h>

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

	#include <glib.h>

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

	static GHashTable *cib_op_callback_table = NULL;

	#define op_common(cib) do { \
	if(cib == NULL) { \
	return -EINVAL; \
	} else if(cib->delegate_fn == NULL) { \
	return -EPROTONOSUPPORT; \
	} \
	} while(0)

	static gint
	ciblib_GCompareFunc(gconstpointer a, gconstpointer b)
	{
	int rc = 0;
	const cib_notify_client_t *a_client = a;
	const cib_notify_client_t *b_client = b;

	CRM_CHECK(a_client->event != NULL && b_client->event != NULL, return 0);
	rc = strcmp(a_client->event, b_client->event);
	if (rc == 0) {
	if (a_client->callback == b_client->callback) {
	return 0;
	} else if (((long)a_client->callback) < ((long)b_client->callback)) {
	crm_trace("callbacks for %s are not equal: %p < %p",
	a_client->event, a_client->callback, b_client->callback);
	return -1;
	}
	crm_trace("callbacks for %s are not equal: %p > %p",
	a_client->event, a_client->callback, b_client->callback);
	return 1;
	}
	return rc;
	}

	static int
	cib_client_add_notify_callback(cib_t * cib, const char *event,
	void (callback) (const char event,
	xmlNode * msg))
	{
	GList *list_item = NULL;
	cib_notify_client_t *new_client = NULL;

	if ((cib->variant != cib_native) && (cib->variant != cib_remote)) {
	return -EPROTONOSUPPORT;
	}

	crm_trace("Adding callback for %s events (%d)",
	event, g_list_length(cib->notify_list));

	new_client = pcmk__assert_alloc(1, sizeof(cib_notify_client_t));
	new_client->event = event;
	new_client->callback = callback;

	list_item = g_list_find_custom(cib->notify_list, new_client,
	ciblib_GCompareFunc);

	if (list_item != NULL) {
	crm_warn("Callback already present");
	free(new_client);
	return -EINVAL;

	} else {
	cib->notify_list = g_list_append(cib->notify_list, new_client);

	cib->cmds->register_notification(cib, event, 1);

	crm_trace("Callback added (%d)", g_list_length(cib->notify_list));
	}
	return pcmk_ok;
	}

	static int
	get_notify_list_event_count(cib_t cib, const char event)
	{
	int count = 0;

	for (GList *iter = g_list_first(cib->notify_list); iter != NULL;
	iter = iter->next) {
	cib_notify_client_t client = (cib_notify_client_t ) iter->data;

	if (strcmp(client->event, event) == 0) {
	count++;
	}
	}
	crm_trace("event(%s) count : %d", event, count);
	return count;
	}

	static int
	cib_client_del_notify_callback(cib_t cib, const char event,
	void (callback) (const char event,
	xmlNode *msg))
	{
	GList *list_item = NULL;
	cib_notify_client_t *new_client = NULL;

	if (cib->variant != cib_native && cib->variant != cib_remote) {
	return -EPROTONOSUPPORT;
	}

	if (get_notify_list_event_count(cib, event) == 0) {
	crm_debug("The callback of the event does not exist(%s)", event);
	return pcmk_ok;
	}

	crm_debug("Removing callback for %s events", event);

	new_client = pcmk__assert_alloc(1, sizeof(cib_notify_client_t));
	new_client->event = event;
	new_client->callback = callback;

	list_item = g_list_find_custom(cib->notify_list, new_client, ciblib_GCompareFunc);

	if (list_item != NULL) {
	cib_notify_client_t *list_client = list_item->data;

	cib->notify_list = g_list_remove(cib->notify_list, list_client);
	free(list_client);

	crm_trace("Removed callback");

	} else {
	crm_trace("Callback not present");
	}

	if (get_notify_list_event_count(cib, event) == 0) {
	/* When there is not the registration of the event, the processing turns off a notice. */
	cib->cmds->register_notification(cib, event, 0);
	}

	free(new_client);
	return pcmk_ok;
	}

	static gboolean
	cib_async_timeout_handler(gpointer data)
	{
	struct timer_rec_s *timer = data;

	crm_debug("Async call %d timed out after %ds",
	timer->call_id, timer->timeout);
	cib_native_callback(timer->cib, NULL, timer->call_id, -ETIME);

	// We remove the handler in remove_cib_op_callback()
	return G_SOURCE_CONTINUE;
	}

	static gboolean
	cib_client_register_callback_full(cib_t *cib, int call_id, int timeout,
	gboolean only_success, void *user_data,
	const char *callback_name,
	void (callback)(xmlNode , int, int,
	xmlNode , void ),
	void (free_func)(void ))
	{
	cib_callback_client_t *blob = NULL;

	if (call_id < 0) {
	if (only_success == FALSE) {
	callback(NULL, call_id, call_id, NULL, user_data);
	} else {
	crm_warn("CIB call failed: %s", pcmk_strerror(call_id));
	}
	if (user_data && free_func) {
	free_func(user_data);
	}
	return FALSE;
	}

	blob = pcmk__assert_alloc(1, sizeof(cib_callback_client_t));
	blob->id = callback_name;
	blob->only_success = only_success;
	blob->user_data = user_data;
	blob->callback = callback;
	blob->free_func = free_func;

	if (timeout > 0) {
	struct timer_rec_s *async_timer =
	pcmk__assert_alloc(1, sizeof(struct timer_rec_s));

	blob->timer = async_timer;

	async_timer->cib = cib;
	async_timer->call_id = call_id;
	async_timer->timeout = timeout * 1000;
	async_timer->ref = g_timeout_add(async_timer->timeout,
	cib_async_timeout_handler,
	async_timer);
	}

	crm_trace("Adding callback %s for call %d", callback_name, call_id);
	pcmk__intkey_table_insert(cib_op_callback_table, call_id, blob);

	return TRUE;
	}

	static gboolean
	cib_client_register_callback(cib_t *cib, int call_id, int timeout,
	gboolean only_success, void *user_data,
	const char *callback_name,
	void (callback) (xmlNode , int, int, xmlNode *,
	void *))
	{
	return cib_client_register_callback_full(cib, call_id, timeout,
	only_success, user_data,
	callback_name, callback, NULL);
	}

	static int
	cib_client_noop(cib_t * cib, int call_options)
	{
	op_common(cib);
	return cib_internal_op(cib, PCMK__CIB_REQUEST_NOOP, NULL, NULL, NULL, NULL,
	call_options, cib->user);
	}

	static int
	cib_client_ping(cib_t * cib, xmlNode ** output_data, int call_options)
	{
	op_common(cib);
	return cib_internal_op(cib, CRM_OP_PING, NULL, NULL, NULL, output_data,
	call_options, cib->user);
	}

	static int
	cib_client_query(cib_t * cib, const char section, xmlNode * output_data, int call_options)
	{
	return cib->cmds->query_from(cib, NULL, section, output_data, call_options);
	}

	static int
	cib_client_query_from(cib_t * cib, const char host, const char section,
	xmlNode ** output_data, int call_options)
	{
	op_common(cib);
	return cib_internal_op(cib, PCMK__CIB_REQUEST_QUERY, host, section, NULL,
	output_data, call_options, cib->user);
	}

	-static int
	-is_primary(cib_t *cib)
	-{
	- op_common(cib);
	- return cib_internal_op(cib, PCMK__CIB_REQUEST_IS_PRIMARY, NULL, NULL, NULL,
	- NULL, cib_sync_call, cib->user);
	-}
	-
	static int
	set_secondary(cib_t *cib, int call_options)
	{
	op_common(cib);
	return cib_internal_op(cib, PCMK__CIB_REQUEST_SECONDARY, NULL, NULL, NULL,
	NULL, call_options, cib->user);
	}

	static int
	set_all_secondary(cib_t * cib, int call_options)
	{
	return -EPROTONOSUPPORT;
	}

	static int
	set_primary(cib_t *cib, int call_options)
	{
	op_common(cib);
	return cib_internal_op(cib, PCMK__CIB_REQUEST_PRIMARY, NULL, NULL, NULL,
	NULL, call_options, cib->user);
	}

	static int
	cib_client_bump_epoch(cib_t * cib, int call_options)
	{
	op_common(cib);
	return cib_internal_op(cib, PCMK__CIB_REQUEST_BUMP, NULL, NULL, NULL, NULL,
	call_options, cib->user);
	}

	static int
	cib_client_upgrade(cib_t * cib, int call_options)
	{
	op_common(cib);
	return cib_internal_op(cib, PCMK__CIB_REQUEST_UPGRADE, NULL, NULL, NULL,
	NULL, call_options, cib->user);
	}

	static int
	cib_client_sync(cib_t * cib, const char *section, int call_options)
	{
	return cib->cmds->sync_from(cib, NULL, section, call_options);
	}

	static int
	cib_client_sync_from(cib_t * cib, const char host, const char section, int call_options)
	{
	op_common(cib);
	return cib_internal_op(cib, PCMK__CIB_REQUEST_SYNC_TO_ALL, host, section,
	NULL, NULL, call_options, cib->user);
	}

	static int
	cib_client_create(cib_t * cib, const char section, xmlNode data, int call_options)
	{
	op_common(cib);
	return cib_internal_op(cib, PCMK__CIB_REQUEST_CREATE, NULL, section, data,
	NULL, call_options, cib->user);
	}

	static int
	cib_client_modify(cib_t * cib, const char section, xmlNode data, int call_options)
	{
	op_common(cib);
	return cib_internal_op(cib, PCMK__CIB_REQUEST_MODIFY, NULL, section, data,
	NULL, call_options, cib->user);
	}

	static int
	cib_client_replace(cib_t * cib, const char section, xmlNode data, int call_options)
	{
	op_common(cib);
	return cib_internal_op(cib, PCMK__CIB_REQUEST_REPLACE, NULL, section, data,
	NULL, call_options, cib->user);
	}

	static int
	cib_client_delete(cib_t * cib, const char section, xmlNode data, int call_options)
	{
	op_common(cib);
	return cib_internal_op(cib, PCMK__CIB_REQUEST_DELETE, NULL, section, data,
	NULL, call_options, cib->user);
	}

	static int
	cib_client_delete_absolute(cib_t * cib, const char section, xmlNode data, int call_options)
	{
	op_common(cib);
	return cib_internal_op(cib, PCMK__CIB_REQUEST_ABS_DELETE, NULL, section,
	data, NULL, call_options, cib->user);
	}

	static int
	cib_client_erase(cib_t * cib, xmlNode ** output_data, int call_options)
	{
	op_common(cib);
	return cib_internal_op(cib, PCMK__CIB_REQUEST_ERASE, NULL, NULL, NULL,
	output_data, call_options, cib->user);
	}

	static int
	cib_client_init_transaction(cib_t *cib)
	{
	int rc = pcmk_rc_ok;

	op_common(cib);

	if (cib->transaction != NULL) {
	// A client can have at most one transaction at a time
	rc = pcmk_rc_already;
	}

	if (rc == pcmk_rc_ok) {
	cib->transaction = pcmk__xe_create(NULL, PCMK__XE_CIB_TRANSACTION);
	}

	if (rc != pcmk_rc_ok) {
	const char *client_id = NULL;

	cib->cmds->client_id(cib, NULL, &client_id);
	crm_err("Failed to initialize CIB transaction for client %s: %s",
	client_id, pcmk_rc_str(rc));
	}
	return pcmk_rc2legacy(rc);
	}

	static int
	cib_client_end_transaction(cib_t *cib, bool commit, int call_options)
	{
	const char *client_id = NULL;
	int rc = pcmk_ok;

	op_common(cib);
	cib->cmds->client_id(cib, NULL, &client_id);
	client_id = pcmk__s(client_id, "(unidentified)");

	if (commit) {
	if (cib->transaction == NULL) {
	rc = pcmk_rc_no_transaction;

	crm_err("Failed to commit transaction for CIB client %s: %s",
	client_id, pcmk_rc_str(rc));
	return pcmk_rc2legacy(rc);
	}
	rc = cib_internal_op(cib, PCMK__CIB_REQUEST_COMMIT_TRANSACT, NULL, NULL,
	cib->transaction, NULL, call_options, cib->user);

	} else {
	// Discard always succeeds
	if (cib->transaction != NULL) {
	crm_trace("Discarded transaction for CIB client %s", client_id);
	} else {
	crm_trace("No transaction found for CIB client %s", client_id);
	}
	}
	pcmk__xml_free(cib->transaction);
	cib->transaction = NULL;
	return rc;
	}

	static int
	cib_client_fetch_schemas(cib_t cib, xmlNode output_data, const char after_ver,
	int call_options)
	{
	xmlNode *data = pcmk__xe_create(NULL, PCMK__XA_SCHEMA);
	int rc = pcmk_ok;

	crm_xml_add(data, PCMK_XA_VERSION, after_ver);

	rc = cib_internal_op(cib, PCMK__CIB_REQUEST_SCHEMAS, NULL, NULL, data,
	output_data, call_options, NULL);
	pcmk__xml_free(data);
	return rc;
	}

	static void
	cib_client_set_user(cib_t cib, const char user)
	{
	pcmk__str_update(&(cib->user), user);
	}

	static void
	cib_destroy_op_callback(gpointer data)
	{
	cib_callback_client_t *blob = data;

	if (blob->timer && blob->timer->ref > 0) {
	g_source_remove(blob->timer->ref);
	}
	free(blob->timer);

	if (blob->user_data && blob->free_func) {
	blob->free_func(blob->user_data);
	}

	free(blob);
	}

	static void
	destroy_op_callback_table(void)
	{
	if (cib_op_callback_table != NULL) {
	g_hash_table_destroy(cib_op_callback_table);
	cib_op_callback_table = NULL;
	}
	}

	char *
	get_shadow_file(const char *suffix)
	{
	char *cib_home = NULL;
	char *fullname = NULL;
	char *name = crm_strdup_printf("shadow.%s", suffix);
	const char *dir = getenv("CIB_shadow_dir");

	if (dir == NULL) {
	uid_t uid = geteuid();
	struct passwd *pwent = getpwuid(uid);
	const char *user = NULL;

	if (pwent) {
	user = pwent->pw_name;
	} else {
	user = getenv("USER");
	crm_perror(LOG_ERR,
	"Assuming %s because cannot get user details for user ID %d",
	(user? user : "unprivileged user"), uid);
	}

	if (pcmk__strcase_any_of(user, "root", CRM_DAEMON_USER, NULL)) {
	dir = CRM_CONFIG_DIR;

	} else {
	const char *home = NULL;

	if ((home = getenv("HOME")) == NULL) {
	if (pwent) {
	home = pwent->pw_dir;
	}
	}

	dir = pcmk__get_tmpdir();
	if (home && home[0] == '/') {
	int rc = 0;

	cib_home = crm_strdup_printf("%s/.cib", home);

	rc = mkdir(cib_home, 0700);
	if (rc < 0 && errno != EEXIST) {
	crm_perror(LOG_ERR, "Couldn't create user-specific shadow directory: %s",
	cib_home);
	errno = 0;

	} else {
	dir = cib_home;
	}
	}
	}
	}

	fullname = crm_strdup_printf("%s/%s", dir, name);
	free(cib_home);
	free(name);

	return fullname;
	}

	cib_t *
	cib_shadow_new(const char *shadow)
	{
	cib_t *new_cib = NULL;
	char *shadow_file = NULL;

	CRM_CHECK(shadow != NULL, return NULL);

	shadow_file = get_shadow_file(shadow);
	new_cib = cib_file_new(shadow_file);
	free(shadow_file);

	return new_cib;
	}

	/*!
	* \brief Create a new CIB connection object, ignoring any active shadow CIB
	*
	* Create a new live, file, or remote CIB connection object based on the values
	* of CIB-related environment variables (CIB_file, CIB_port, CIB_server,
	* CIB_user, and CIB_passwd). The object will not be connected.
	*
	* \return Newly allocated CIB connection object
	* \note The CIB API does not fully support opening multiple CIB connection
	* objects simultaneously, so the returned object should be treated as a
	* singleton.
	*/
	cib_t *
	cib_new_no_shadow(void)
	{
	const char *shadow = getenv("CIB_shadow");
	cib_t *cib = NULL;

	unsetenv("CIB_shadow");
	cib = cib_new();

	if (shadow != NULL) {
	setenv("CIB_shadow", shadow, 1);
	}
	return cib;
	}

	/*!
	* \brief Create a new CIB connection object
	*
	* Create a new live, remote, file, or shadow file CIB connection object based
	* on the values of CIB-related environment variables (CIB_shadow, CIB_file,
	* CIB_port, CIB_server, CIB_user, and CIB_passwd). The object will not be
	* connected.
	*
	* \return Newly allocated CIB connection object
	* \note The CIB API does not fully support opening multiple CIB connection
	* objects simultaneously, so the returned object should be treated as a
	* singleton.
	*/
	/* @TODO Ensure all APIs support multiple simultaneous CIB connection objects
	* (at least cib_free_callbacks() currently does not).
	*/
	cib_t *
	cib_new(void)
	{
	const char *value = getenv("CIB_shadow");
	int port;

	if (value && value[0] != 0) {
	return cib_shadow_new(value);
	}

	value = getenv("CIB_file");
	if (value) {
	return cib_file_new(value);
	}

	value = getenv("CIB_port");
	if (value) {
	gboolean encrypted = TRUE;
	const char *server = getenv("CIB_server");
	const char *user = getenv("CIB_user");
	const char *pass = getenv("CIB_passwd");

	/* We don't ensure port is valid (>= 0) because cib_new() currently
	* can't return NULL in practice, and introducing a NULL return here
	* could cause core dumps that would previously just cause signon()
	* failures.
	*/
	pcmk__scan_port(value, &port);

	value = getenv("CIB_encrypted");
	if (value && crm_is_true(value) == FALSE) {
	crm_info("Disabling TLS");
	encrypted = FALSE;
	}

	if (user == NULL) {
	user = CRM_DAEMON_USER;
	crm_info("Defaulting to user: %s", user);
	}

	if (server == NULL) {
	server = "localhost";
	crm_info("Defaulting to localhost");
	}

	return cib_remote_new(server, user, pass, port, encrypted);
	}

	return cib_native_new();
	}

	/*!
	* \internal
	* \brief Create a generic CIB connection instance
	*
	* \return Newly allocated and initialized cib_t instance
	*
	* \note This is called by each variant's cib_*_new() function before setting
	* variant-specific values.
	*/
	cib_t *
	cib_new_variant(void)
	{
	cib_t *new_cib = NULL;

	new_cib = calloc(1, sizeof(cib_t));

	if (new_cib == NULL) {
	return NULL;
	}

	remove_cib_op_callback(0, TRUE); /* remove all */

	new_cib->call_id = 1;
	new_cib->variant = cib_undefined;

	new_cib->type = cib_no_connection;
	new_cib->state = cib_disconnected;

	new_cib->op_callback = NULL;
	new_cib->variant_opaque = NULL;
	new_cib->notify_list = NULL;

	/* the rest will get filled in by the variant constructor */
	new_cib->cmds = calloc(1, sizeof(cib_api_operations_t));

	if (new_cib->cmds == NULL) {
	free(new_cib);
	return NULL;
	}

	new_cib->cmds->add_notify_callback = cib_client_add_notify_callback;
	new_cib->cmds->del_notify_callback = cib_client_del_notify_callback;
	new_cib->cmds->register_callback = cib_client_register_callback;
	new_cib->cmds->register_callback_full = cib_client_register_callback_full;

	new_cib->cmds->noop = cib_client_noop; // Deprecated method
	new_cib->cmds->ping = cib_client_ping;
	new_cib->cmds->query = cib_client_query;
	new_cib->cmds->sync = cib_client_sync;

	new_cib->cmds->query_from = cib_client_query_from;
	new_cib->cmds->sync_from = cib_client_sync_from;

	- new_cib->cmds->is_master = is_primary; // Deprecated method
	-
	new_cib->cmds->set_primary = set_primary;
	new_cib->cmds->set_master = set_primary; // Deprecated method

	new_cib->cmds->set_secondary = set_secondary;
	new_cib->cmds->set_slave = set_secondary; // Deprecated method

	new_cib->cmds->set_slave_all = set_all_secondary; // Deprecated method

	new_cib->cmds->upgrade = cib_client_upgrade;
	new_cib->cmds->bump_epoch = cib_client_bump_epoch;

	new_cib->cmds->create = cib_client_create;
	new_cib->cmds->modify = cib_client_modify;
	new_cib->cmds->update = cib_client_modify; // Deprecated method
	new_cib->cmds->replace = cib_client_replace;
	new_cib->cmds->remove = cib_client_delete;
	new_cib->cmds->erase = cib_client_erase;

	// Deprecated method
	new_cib->cmds->delete_absolute = cib_client_delete_absolute;

	new_cib->cmds->init_transaction = cib_client_init_transaction;
	new_cib->cmds->end_transaction = cib_client_end_transaction;

	new_cib->cmds->set_user = cib_client_set_user;

	new_cib->cmds->fetch_schemas = cib_client_fetch_schemas;

	return new_cib;
	}

	void
	cib_free_notify(cib_t *cib)
	{

	if (cib) {
	GList *list = cib->notify_list;

	while (list != NULL) {
	cib_notify_client_t *client = g_list_nth_data(list, 0);

	list = g_list_remove(list, client);
	free(client);
	}
	cib->notify_list = NULL;
	}
	}

	/*!
	* \brief Free all callbacks for a CIB connection
	*
	* \param[in,out] cib CIB connection to clean up
	*/
	void
	cib_free_callbacks(cib_t *cib)
	{
	cib_free_notify(cib);

	destroy_op_callback_table();
	}

	/*!
	* \brief Free all memory used by CIB connection
	*
	* \param[in,out] cib CIB connection to delete
	*/
	void
	cib_delete(cib_t *cib)
	{
	cib_free_callbacks(cib);
	if (cib) {
	cib->cmds->free(cib);
	}
	}

	void
	remove_cib_op_callback(int call_id, gboolean all_callbacks)
	{
	if (all_callbacks) {
	destroy_op_callback_table();
	cib_op_callback_table = pcmk__intkey_table(cib_destroy_op_callback);
	} else {
	pcmk__intkey_table_remove(cib_op_callback_table, call_id);
	}
	}

	int
	num_cib_op_callbacks(void)
	{
	if (cib_op_callback_table == NULL) {
	return 0;
	}
	return g_hash_table_size(cib_op_callback_table);
	}

	static void
	cib_dump_pending_op(gpointer key, gpointer value, gpointer user_data)
	{
	int call = GPOINTER_TO_INT(key);
	cib_callback_client_t *blob = value;

	crm_debug("Call %d (%s): pending", call, pcmk__s(blob->id, "without ID"));
	}

	void
	cib_dump_pending_callbacks(void)
	{
	if (cib_op_callback_table == NULL) {
	return;
	}
	return g_hash_table_foreach(cib_op_callback_table, cib_dump_pending_op, NULL);
	}

	cib_callback_client_t*
	cib__lookup_id (int call_id)
	{
	return pcmk__intkey_table_lookup(cib_op_callback_table, call_id);
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Nov 23, 2:39 PM (1 d, 46 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1016395
Default Alt Text: (55 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions