No OneTemporary
Actions

Size

42 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/crm/common/util.h b/include/crm/common/util.h
	index 41d39994a7..1fab924cad 100644
	--- a/include/crm/common/util.h
	+++ b/include/crm/common/util.h
	@@ -1,199 +1,201 @@
	/*
	* Copyright 2004-2019 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 CRM_COMMON_UTIL__H
	# define CRM_COMMON_UTIL__H

	#ifdef __cplusplus
	extern "C" {
	#endif

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

	# include <sys/types.h>
	# include <stdlib.h>
	# include <stdbool.h>
	# include <stdint.h> // uint32_t
	# include <limits.h>
	# include <signal.h>
	# include <glib.h>

	# include <libxml/tree.h>

	# include <crm/lrmd.h>
	# include <crm/common/results.h>

	# define ONLINESTATUS "online" // Status of an online client
	# define OFFLINESTATUS "offline" // Status of an offline client

	+// public name/value pair functions (from nvpair.c)
	+int pcmk_scan_nvpair(const char input, char name, char *value);
	+
	/* public Pacemaker Remote functions (from remote.c) */
	int crm_default_remote_port(void);

	/* public string functions (from strings.c) */
	char crm_itoa_stack(int an_int, char buf, size_t len);
	gboolean crm_is_true(const char *s);
	int crm_str_to_boolean(const char s, int ret);
	long long crm_parse_ll(const char text, const char default_text);
	int crm_parse_int(const char text, const char default_text);
	char * crm_strip_trailing_newline(char *str);
	gboolean crm_str_eq(const char a, const char b, gboolean use_case);
	gboolean safe_str_neq(const char a, const char b);
	gboolean crm_strcase_equal(gconstpointer a, gconstpointer b);
	guint crm_strcase_hash(gconstpointer v);
	guint g_str_hash_traditional(gconstpointer v);
	char crm_strdup_printf(char const format, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
	-int pcmk_scan_nvpair(const char input, char name, char *value);

	# define safe_str_eq(a, b) crm_str_eq(a, b, FALSE)
	# define crm_str_hash g_str_hash_traditional

	static inline char *
	crm_itoa(int an_int)
	{
	return crm_strdup_printf("%d", an_int);
	}

	/*!
	* \brief Create hash table with dynamically allocated string keys/values
	*
	* \return Newly allocated hash table
	* \note It is the caller's responsibility to free the result, using
	* g_hash_table_destroy().
	*/
	static inline GHashTable *
	crm_str_table_new()
	{
	return g_hash_table_new_full(crm_str_hash, g_str_equal, free, free);
	}

	/*!
	* \brief Create hash table with case-insensitive dynamically allocated string keys/values
	*
	* \return Newly allocated hash table
	* \note It is the caller's responsibility to free the result, using
	* g_hash_table_destroy().
	*/
	static inline GHashTable *
	crm_strcase_table_new()
	{
	return g_hash_table_new_full(crm_strcase_hash, crm_strcase_equal, free, free);
	}

	GHashTable crm_str_table_dup(GHashTable old_table);

	# define crm_atoi(text, default_text) crm_parse_int(text, default_text)

	/* public I/O functions (from io.c) */
	void crm_build_path(const char *path_c, mode_t mode);

	long long crm_get_msec(const char *input);
	guint crm_parse_interval_spec(const char *input);
	int char2score(const char *score);
	char *score2char(int score);
	char score2char_stack(int score, char buf, size_t len);

	// deprecated
	#define crm_get_interval crm_parse_interval_spec

	/* public operation functions (from operations.c) */
	gboolean parse_op_key(const char key, char rsc_id, char *op_type,
	guint *interval_ms);
	gboolean decode_transition_key(const char key, char uuid, int action,
	int transition_id, int target_rc);
	gboolean decode_transition_magic(const char magic, char *uuid,
	int transition_id, int action_id,
	int op_status, int op_rc, int *target_rc);
	int rsc_op_expected_rc(lrmd_event_data_t *event);
	gboolean did_rsc_op_fail(lrmd_event_data_t *event, int target_rc);
	bool crm_op_needs_metadata(const char rsc_class, const char op);
	xmlNode crm_create_op_xml(xmlNode parent, const char *prefix,
	const char task, const char interval_spec,
	const char *timeout);
	#define CRM_DEFAULT_OP_TIMEOUT_S "20s"

	// Public resource agent functions (from agents.c)

	// Capabilities supported by a resource agent standard
	enum pcmk_ra_caps {
	pcmk_ra_cap_none = 0x000,
	pcmk_ra_cap_provider = 0x001, // Requires provider
	pcmk_ra_cap_status = 0x002, // Supports status instead of monitor
	pcmk_ra_cap_params = 0x004, // Supports parameters
	pcmk_ra_cap_unique = 0x008, // Supports unique clones
	pcmk_ra_cap_promotable = 0x010, // Supports promotable clones
	};

	uint32_t pcmk_get_ra_caps(const char *standard);
	char crm_generate_ra_key(const char standard, const char *provider,
	const char *type);
	int crm_parse_agent_spec(const char spec, char standard, char *provider,
	char **type);
	bool crm_provider_required(const char *standard); // deprecated


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

	/* coverity[+kill] */
	void crm_abort(const char file, const char function, int line,
	const char *condition, gboolean do_core, gboolean do_fork);

	static inline gboolean
	is_not_set(long long word, long long bit)
	{
	return ((word & bit) == 0);
	}

	static inline gboolean
	is_set(long long word, long long bit)
	{
	return ((word & bit) == bit);
	}

	static inline gboolean
	is_set_any(long long word, long long bit)
	{
	return ((word & bit) != 0);
	}

	static inline guint
	crm_hash_table_size(GHashTable * hashtable)
	{
	if (hashtable == NULL) {
	return 0;
	}
	return g_hash_table_size(hashtable);
	}

	char crm_meta_name(const char field);
	const char crm_meta_value(GHashTable hash, const char *field);

	char crm_md5sum(const char buffer);

	char *crm_generate_uuid(void);
	bool crm_is_daemon_name(const char *name);

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

	#ifdef HAVE_GNUTLS_GNUTLS_H
	void crm_gnutls_global_init(void);
	#endif

	bool pcmk_acl_required(const char *user);

	char *pcmk_hostname(void);

	#ifdef __cplusplus
	}
	#endif

	#endif
	diff --git a/lib/common/nvpair.c b/lib/common/nvpair.c
	index 5c0b96a3ce..1eaa857f14 100644
	--- a/lib/common/nvpair.c
	+++ b/lib/common/nvpair.c
	@@ -1,724 +1,783 @@
	/*
	* Copyright 2004-2019 Andrew Beekhof <andrew@beekhof.net>
	*
	* 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 <stdio.h>
	#include <sys/types.h>
	#include <string.h>
	#include <ctype.h>
	#include <glib.h>
	#include <libxml/tree.h>

	#include <crm/crm.h>
	#include <crm/msg_xml.h>
	#include <crm/common/xml.h>
	#include "crmcommon_private.h"

	/*
	* This file isolates handling of three types of name/value pairs:
	*
	* - pcmk_nvpair_t data type
	* - XML attributes (<TAG ... NAME=VALUE ...>)
	* - XML nvpair elements (<nvpair id=ID name=NAME value=VALUE>)
	*/

	// pcmk_nvpair_t handling

	/*!
	* \internal
	* \brief Allocate a new name/value pair
	*
	* \param[in] name New name (required)
	* \param[in] value New value
	*
	* \return Newly allocated name/value pair
	* \note The caller is responsible for freeing the result with
	* \c pcmk__free_nvpair().
	*/
	static pcmk_nvpair_t *
	pcmk__new_nvpair(const char name, const char value)
	{
	pcmk_nvpair_t *nvpair = NULL;

	CRM_ASSERT(name);

	nvpair = calloc(1, sizeof(pcmk_nvpair_t));
	CRM_ASSERT(nvpair);

	nvpair->name = strdup(name);
	nvpair->value = value? strdup(value) : NULL;
	return nvpair;
	}

	/*!
	* \internal
	* \brief Free a name/value pair
	*
	* \param[in] nvpair Name/value pair to free
	*/
	static void
	pcmk__free_nvpair(gpointer data)
	{
	if (data) {
	pcmk_nvpair_t *nvpair = data;

	free(nvpair->name);
	free(nvpair->value);
	free(nvpair);
	}
	}

	/*!
	* \brief Prepend a name/value pair to a list
	*
	* \param[in,out] nvpairs List to modify
	* \param[in] name New entry's name
	* \param[in] value New entry's value
	*
	* \return New head of list
	* \note The caller is responsible for freeing the list with
	* \c pcmk_free_nvpairs().
	*/
	GSList *
	pcmk_prepend_nvpair(GSList nvpairs, const char name, const char *value)
	{
	return g_slist_prepend(nvpairs, pcmk__new_nvpair(name, value));
	}

	/*!
	* \brief Free a list of name/value pairs
	*
	* \param[in] list List to free
	*/
	void
	pcmk_free_nvpairs(GSList *nvpairs)
	{
	g_slist_free_full(nvpairs, pcmk__free_nvpair);
	}

	/*!
	* \internal
	* \brief Compare two name/value pairs
	*
	* \param[in] a First name/value pair to compare
	* \param[in] b Second name/value pair to compare
	*
	* \return 0 if a == b, 1 if a > b, -1 if a < b
	*/
	static gint
	pcmk__compare_nvpair(gconstpointer a, gconstpointer b)
	{
	int rc = 0;
	const pcmk_nvpair_t *pair_a = a;
	const pcmk_nvpair_t *pair_b = b;

	CRM_ASSERT(a != NULL);
	CRM_ASSERT(pair_a->name != NULL);

	CRM_ASSERT(b != NULL);
	CRM_ASSERT(pair_b->name != NULL);

	rc = strcmp(pair_a->name, pair_b->name);
	if (rc < 0) {
	return -1;
	} else if (rc > 0) {
	return 1;
	}
	return 0;
	}

	/*!
	* \brief Sort a list of name/value pairs
	*
	* \param[in,out] list List to sort
	*
	* \return New head of list
	*/
	GSList *
	pcmk_sort_nvpairs(GSList *list)
	{
	return g_slist_sort(list, pcmk__compare_nvpair);
	}

	/*!
	* \brief Create a list of name/value pairs from an XML node's attributes
	*
	* \param[in] XML to parse
	*
	* \return New list of name/value pairs
	* \note It is the caller's responsibility to free the list with
	* \c pcmk_free_nvpairs().
	*/
	GSList *
	pcmk_xml_attrs2nvpairs(xmlNode *xml)
	{
	GSList *result = NULL;

	for (xmlAttrPtr iter = pcmk__first_xml_attr(xml); iter != NULL;
	iter = iter->next) {

	result = pcmk_prepend_nvpair(result,
	(const char *) iter->name,
	(const char *) pcmk__xml_attr_value(iter));
	}
	return result;
	}

	/*!
	* \internal
	* \brief Add an XML attribute corresponding to a name/value pair
	*
	* Suitable for glib list iterators, this function adds a NAME=VALUE
	* XML attribute based on a given name/value pair.
	*
	* \param[in] data Name/value pair
	* \param[out] user_data XML node to add attributes to
	*/
	static void
	pcmk__nvpair_add_xml_attr(gpointer data, gpointer user_data)
	{
	pcmk_nvpair_t *pair = data;
	xmlNode *parent = user_data;

	crm_xml_add(parent, pair->name, pair->value);
	}

	/*!
	* \brief Add XML attributes based on a list of name/value pairs
	*
	* \param[in] list List of name/value pairs
	* \param[in,out] xml XML node to add attributes to
	*/
	void
	pcmk_nvpairs2xml_attrs(GSList list, xmlNode xml)
	{
	g_slist_foreach(list, pcmk__nvpair_add_xml_attr, xml);
	}

	+// convenience function for name=value strings
	+
	+/*!
	+ * \brief Extract the name and value from an input string formatted as "name=value".
	+ * If unable to extract them, they are returned as NULL.
	+ *
	+ * \param[in] input The input string, likely from the command line
	+ * \param[out] name Everything before the first '=' in the input string
	+ * \param[out] value Everything after the first '=' in the input string
	+ *
	+ * \return 2 if both name and value could be extracted, 1 if only one could, and
	+ * and error code otherwise
	+ */
	+int
	+pcmk_scan_nvpair(const char input, char name, char *value)
	+{
	+#ifdef SSCANF_HAS_M
	+ *name = NULL;
	+ *value = NULL;
	+ if (sscanf(input, "%m[^=]=%ms", name, value) <= 0) {
	+ return -pcmk_err_bad_nvpair;
	+ }
	+#else
	+ char *sep = NULL;
	+ *name = NULL;
	+ *value = NULL;
	+
	+ sep = strstr(optarg, "=");
	+ if (sep == NULL) {
	+ return -pcmk_err_bad_nvpair;
	+ }
	+
	+ *name = strndup(input, sep-input);
	+
	+ if (*name == NULL) {
	+ return -ENOMEM;
	+ }
	+
	+ /* If the last char in optarg is =, the user gave no
	+ * value for the option. Leave it as NULL.
	+ */
	+ if (*(sep+1) != '\0') {
	+ *value = strdup(sep+1);
	+
	+ if (*value == NULL) {
	+ return -ENOMEM;
	+ }
	+ }
	+#endif
	+
	+ if (name != NULL && value != NULL) {
	+ return 2;
	+ } else if (name != NULL \|\| value != NULL) {
	+ return 1;
	+ } else {
	+ return -pcmk_err_bad_nvpair;
	+ }
	+}
	+
	// XML attribute handling

	/*!
	* \brief Create an XML attribute with specified name and value
	*
	* \param[in,out] node XML node to modify
	* \param[in] name Attribute name to set
	* \param[in] value Attribute value to set
	*
	* \return New value on success, \c NULL otherwise
	* \note This does nothing if node, name, or value are \c NULL or empty.
	*/
	const char *
	crm_xml_add(xmlNode node, const char name, const char *value)
	{
	bool dirty = FALSE;
	xmlAttr *attr = NULL;

	CRM_CHECK(node != NULL, return NULL);
	CRM_CHECK(name != NULL, return NULL);

	if (value == NULL) {
	return NULL;
	}
	#if XML_PARANOIA_CHECKS
	{
	const char *old_value = NULL;

	old_value = crm_element_value(node, name);

	/* Could be re-setting the same value */
	CRM_CHECK(old_value != value,
	crm_err("Cannot reset %s with crm_xml_add(%s)", name, value);
	return value);
	}
	#endif

	if (pcmk__tracking_xml_changes(node, FALSE)) {
	const char *old = crm_element_value(node, name);

	if (old == NULL \|\| value == NULL \|\| strcmp(old, value) != 0) {
	dirty = TRUE;
	}
	}

	if (dirty && (pcmk__check_acl(node, name, xpf_acl_create) == FALSE)) {
	crm_trace("Cannot add %s=%s to %s", name, value, node->name);
	return NULL;
	}

	attr = xmlSetProp(node, (const xmlChar )name, (const xmlChar )value);
	if (dirty) {
	pcmk__mark_xml_attr_dirty(attr);
	}

	CRM_CHECK(attr && attr->children && attr->children->content, return NULL);
	return (char *)attr->children->content;
	}

	/*!
	* \brief Replace an XML attribute with specified name and (possibly NULL) value
	*
	* \param[in,out] node XML node to modify
	* \param[in] name Attribute name to set
	* \param[in] value Attribute value to set
	*
	* \return New value on success, \c NULL otherwise
	* \note This does nothing if node or name is \c NULL or empty.
	*/
	const char *
	crm_xml_replace(xmlNode node, const char name, const char *value)
	{
	bool dirty = FALSE;
	xmlAttr *attr = NULL;
	const char *old_value = NULL;

	CRM_CHECK(node != NULL, return NULL);
	CRM_CHECK(name != NULL && name[0] != 0, return NULL);

	old_value = crm_element_value(node, name);

	/* Could be re-setting the same value */
	CRM_CHECK(old_value != value, return value);

	if (pcmk__check_acl(node, name, xpf_acl_write) == FALSE) {
	/* Create a fake object linked to doc->_private instead? */
	crm_trace("Cannot replace %s=%s to %s", name, value, node->name);
	return NULL;

	} else if (old_value && !value) {
	xml_remove_prop(node, name);
	return NULL;
	}

	if (pcmk__tracking_xml_changes(node, FALSE)) {
	if (!old_value \|\| !value \|\| !strcmp(old_value, value)) {
	dirty = TRUE;
	}
	}

	attr = xmlSetProp(node, (const xmlChar )name, (const xmlChar )value);
	if (dirty) {
	pcmk__mark_xml_attr_dirty(attr);
	}
	CRM_CHECK(attr && attr->children && attr->children->content, return NULL);
	return (char *) attr->children->content;
	}

	/*!
	* \brief Create an XML attribute with specified name and integer value
	*
	* This is like \c crm_xml_add() but taking an integer value.
	*
	* \param[in,out] node XML node to modify
	* \param[in] name Attribute name to set
	* \param[in] value Attribute value to set
	*
	* \return New value as string on success, \c NULL otherwise
	* \note This does nothing if node or name are \c NULL or empty.
	*/
	const char *
	crm_xml_add_int(xmlNode node, const char name, int value)
	{
	char *number = crm_itoa(value);
	const char *added = crm_xml_add(node, name, number);

	free(number);
	return added;
	}

	/*!
	* \brief Create an XML attribute with specified name and unsigned value
	*
	* This is like \c crm_xml_add() but taking a guint value.
	*
	* \param[in,out] node XML node to modify
	* \param[in] name Attribute name to set
	* \param[in] ms Attribute value to set
	*
	* \return New value as string on success, \c NULL otherwise
	* \note This does nothing if node or name are \c NULL or empty.
	*/
	const char *
	crm_xml_add_ms(xmlNode node, const char name, guint ms)
	{
	char *number = crm_strdup_printf("%u", ms);
	const char *added = crm_xml_add(node, name, number);

	free(number);
	return added;
	}

	/*!
	* \brief Retrieve the value of an XML attribute
	*
	* \param[in] data XML node to check
	* \param[in] name Attribute name to check
	*
	* \return Value of specified attribute (may be \c NULL)
	*/
	const char *
	crm_element_value(const xmlNode data, const char name)
	{
	xmlAttr *attr = NULL;

	if (data == NULL) {
	crm_err("Couldn't find %s in NULL", name ? name : "<null>");
	CRM_LOG_ASSERT(data != NULL);
	return NULL;

	} else if (name == NULL) {
	crm_err("Couldn't find NULL in %s", crm_element_name(data));
	return NULL;
	}

	/* The first argument to xmlHasProp() has always been const,
	* but libxml2 <2.9.2 didn't declare that, so cast it
	*/
	attr = xmlHasProp((xmlNode ) data, (const xmlChar )name);
	if (!attr \|\| !attr->children) {
	return NULL;
	}
	return (const char *) attr->children->content;
	}

	/*!
	* \brief Retrieve the integer value of an XML attribute
	*
	* This is like \c crm_element_value() but returning the value as an integer.
	*
	* \param[in] data XML node to check
	* \param[in] name Attribute name to check
	*
	* \return Integer value of specified attribute on success, -1 otherwise
	*/
	int
	crm_element_value_int(const xmlNode data, const char name, int *dest)
	{
	const char *value = NULL;

	CRM_CHECK(dest != NULL, return -1);
	value = crm_element_value(data, name);
	if (value) {
	*dest = crm_int_helper(value, NULL);
	return 0;
	}
	return -1;
	}

	/*!
	* \brief Retrieve the millisecond value of an XML attribute
	*
	* This is like \c crm_element_value() but returning the value as a guint.
	*
	* \param[in] data XML node to check
	* \param[in] name Attribute name to check
	* \param[out] dest Where to store attribute value
	*
	* \return \c pcmk_ok on success, -1 otherwise
	*/
	int
	crm_element_value_ms(const xmlNode data, const char name, guint *dest)
	{
	const char *value = NULL;

	CRM_CHECK(dest != NULL, return -1);
	value = crm_element_value(data, name);
	*dest = crm_parse_ms(value);
	return errno? -1 : 0;
	}

	/*!
	* \brief Retrieve the value of XML second/microsecond attributes as time
	*
	* This is like \c crm_element_value() but returning value as a struct timeval.
	*
	* \param[in] xml XML to parse
	* \param[in] name_sec Name of XML attribute for seconds
	* \param[in] name_usec Name of XML attribute for microseconds
	* \param[out] dest Where to store result
	*
	* \return \c pcmk_ok on success, -errno on error
	* \note Values default to 0 if XML or XML attribute does not exist
	*/
	int
	crm_element_value_timeval(const xmlNode xml, const char name_sec,
	const char name_usec, struct timeval dest)
	{
	const char *value_s = NULL;
	long long value_i = 0;

	CRM_CHECK(dest != NULL, return -EINVAL);
	dest->tv_sec = 0;
	dest->tv_usec = 0;

	if (xml == NULL) {
	return 0;
	}

	// Parse seconds
	value_s = crm_element_value(xml, name_sec);
	if (value_s) {
	value_i = crm_parse_ll(value_s, NULL);
	if (errno) {
	return -errno;
	}
	dest->tv_sec = (time_t) value_i;
	}

	// Parse microseconds
	value_s = crm_element_value(xml, name_usec);
	if (value_s) {
	value_i = crm_parse_ll(value_s, NULL);
	if (errno) {
	return -errno;
	}
	dest->tv_usec = (suseconds_t) value_i;
	}
	return 0;
	}

	/*!
	* \brief Retrieve a copy of the value of an XML attribute
	*
	* This is like \c crm_element_value() but allocating new memory for the result.
	*
	* \param[in] data XML node to check
	* \param[in] name Attribute name to check
	*
	* \return Value of specified attribute (may be \c NULL)
	* \note The caller is responsible for freeing the result.
	*/
	char *
	crm_element_value_copy(const xmlNode data, const char name)
	{
	char *value_copy = NULL;
	const char *value = crm_element_value(data, name);

	if (value != NULL) {
	value_copy = strdup(value);
	}
	return value_copy;
	}

	/*!
	* \brief Add hash table entry to XML as (possibly legacy) name/value
	*
	* Suitable for \c g_hash_table_foreach(), this function takes a hash table key
	* and value, with an XML node passed as user data, and adds an XML attribute
	* with the specified name and value if it does not already exist. If the key
	* name starts with a digit, this will instead add a \<param name=NAME
	* value=VALUE/> child to the XML (for legacy compatibility with heartbeat).
	*
	* \param[in] key Key of hash table entry
	* \param[in] value Value of hash table entry
	* \param[in] user_data XML node
	*/
	void
	hash2smartfield(gpointer key, gpointer value, gpointer user_data)
	{
	const char *name = key;
	const char *s_value = value;

	xmlNode *xml_node = user_data;

	if (isdigit(name[0])) {
	xmlNode *tmp = create_xml_node(xml_node, XML_TAG_PARAM);

	crm_xml_add(tmp, XML_NVPAIR_ATTR_NAME, name);
	crm_xml_add(tmp, XML_NVPAIR_ATTR_VALUE, s_value);

	} else if (crm_element_value(xml_node, name) == NULL) {
	crm_xml_add(xml_node, name, s_value);
	crm_trace("dumped: %s=%s", name, s_value);

	} else {
	crm_trace("duplicate: %s=%s", name, s_value);
	}
	}

	/*!
	* \brief Set XML attribute based on hash table entry
	*
	* Suitable for \c g_hash_table_foreach(), this function takes a hash table key
	* and value, with an XML node passed as user data, and adds an XML attribute
	* with the specified name and value if it does not already exist.
	*
	* \param[in] key Key of hash table entry
	* \param[in] value Value of hash table entry
	* \param[in] user_data XML node
	*/
	void
	hash2field(gpointer key, gpointer value, gpointer user_data)
	{
	const char *name = key;
	const char *s_value = value;

	xmlNode *xml_node = user_data;

	if (crm_element_value(xml_node, name) == NULL) {
	crm_xml_add(xml_node, name, s_value);

	} else {
	crm_trace("duplicate: %s=%s", name, s_value);
	}
	}

	/*!
	* \brief Set XML attribute based on hash table entry, as meta-attribute name
	*
	* Suitable for \c g_hash_table_foreach(), this function takes a hash table key
	* and value, with an XML node passed as user data, and adds an XML attribute
	* with the meta-attribute version of the specified name and value if it does
	* not already exist and if the name does not appear to be cluster-internal.
	*
	* \param[in] key Key of hash table entry
	* \param[in] value Value of hash table entry
	* \param[in] user_data XML node
	*/
	void
	hash2metafield(gpointer key, gpointer value, gpointer user_data)
	{
	char *crm_name = NULL;

	if (key == NULL \|\| value == NULL) {
	return;
	}

	/* Filter out cluster-generated attributes that contain a '#' or ':'
	* (like fail-count and last-failure).
	*/
	for (crm_name = key; *crm_name; ++crm_name) {
	if ((crm_name == '#') \|\| (crm_name == ':')) {
	return;
	}
	}

	crm_name = crm_meta_name(key);
	hash2field(crm_name, value, user_data);
	free(crm_name);
	}

	// nvpair handling

	/*!
	* \brief Create an XML name/value pair
	*
	* \param[in] parent If not \c NULL, make new XML node a child of this one
	* \param[in] id If not \c NULL, use this as ID (otherwise auto-generate)
	* \param[in] name Name to use
	* \param[in] value Value to use
	*
	* \return New XML object on success, \c NULL otherwise
	*/
	xmlNode *
	crm_create_nvpair_xml(xmlNode parent, const char id, const char *name,
	const char *value)
	{
	xmlNode *nvp;

	/* id can be NULL so we auto-generate one, and name can be NULL if this
	* will be used to delete a name/value pair by ID, but both can't be NULL
	*/
	CRM_CHECK(id \|\| name, return NULL);

	nvp = create_xml_node(parent, XML_CIB_TAG_NVPAIR);
	CRM_CHECK(nvp, return NULL);

	if (id) {
	crm_xml_add(nvp, XML_ATTR_ID, id);
	} else {
	const char *parent_id = ID(parent);

	crm_xml_set_id(nvp, "%s-%s",
	(parent_id? parent_id : XML_CIB_TAG_NVPAIR), name);
	}
	crm_xml_add(nvp, XML_NVPAIR_ATTR_NAME, name);
	crm_xml_add(nvp, XML_NVPAIR_ATTR_VALUE, value);
	return nvp;
	}

	/*!
	* \brief Add XML nvpair element based on hash table entry
	*
	* Suitable for \c g_hash_table_foreach(), this function takes a hash table key
	* and value, with an XML node passed as the user data, and adds an \c nvpair
	* XML element with the specified name and value.
	*
	* \param[in] key Key of hash table entry
	* \param[in] value Value of hash table entry
	* \param[in] user_data XML node
	*/
	void
	hash2nvpair(gpointer key, gpointer value, gpointer user_data)
	{
	const char *name = key;
	const char *s_value = value;
	xmlNode *xml_node = user_data;

	crm_create_nvpair_xml(xml_node, name, name, s_value);
	crm_trace("dumped: name=%s value=%s", name, s_value);
	}

	/*!
	* \brief Retrieve XML attributes as a hash table
	*
	* Given an XML element, this will look for any \<attributes> element child,
	* creating a hash table of (newly allocated string) name/value pairs taken
	* first from the attributes element's NAME=VALUE XML attributes, and then
	* from any \<param name=NAME value=VALUE> children of attributes.
	*
	* \param[in] XML node to parse
	*
	* \return Hash table with name/value pairs
	* \note It is the caller's responsibility to free the result using
	* \c g_hash_table_destroy().
	*/
	GHashTable *
	xml2list(xmlNode *parent)
	{
	xmlNode *child = NULL;
	xmlAttrPtr pIter = NULL;
	xmlNode *nvpair_list = NULL;
	GHashTable *nvpair_hash = crm_str_table_new();

	CRM_CHECK(parent != NULL, return nvpair_hash);

	nvpair_list = find_xml_node(parent, XML_TAG_ATTRS, FALSE);
	if (nvpair_list == NULL) {
	crm_trace("No attributes in %s", crm_element_name(parent));
	crm_log_xml_trace(parent, "No attributes for resource op");
	}

	crm_log_xml_trace(nvpair_list, "Unpacking");

	for (pIter = pcmk__first_xml_attr(nvpair_list); pIter != NULL;
	pIter = pIter->next) {

	const char p_name = (const char )pIter->name;
	const char *p_value = pcmk__xml_attr_value(pIter);

	crm_trace("Added %s=%s", p_name, p_value);

	g_hash_table_insert(nvpair_hash, strdup(p_name), strdup(p_value));
	}

	for (child = __xml_first_child(nvpair_list); child != NULL;
	child = __xml_next(child)) {

	if (strcmp((const char *)child->name, XML_TAG_PARAM) == 0) {
	const char *key = crm_element_value(child, XML_NVPAIR_ATTR_NAME);
	const char *value = crm_element_value(child, XML_NVPAIR_ATTR_VALUE);

	crm_trace("Added %s=%s", key, value);
	if (key != NULL && value != NULL) {
	g_hash_table_insert(nvpair_hash, strdup(key), strdup(value));
	}
	}
	}

	return nvpair_hash;
	}
	diff --git a/lib/common/strings.c b/lib/common/strings.c
	index 223a46b24e..9b53fe9378 100644
	--- a/lib/common/strings.c
	+++ b/lib/common/strings.c
	@@ -1,553 +1,497 @@
	/*
	* Copyright 2004-2018 Andrew Beekhof <andrew@beekhof.net>
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

	#ifndef _GNU_SOURCE
	# define _GNU_SOURCE
	#endif

	#include <stdio.h>
	#include <string.h>
	#include <stdlib.h>
	#include <limits.h>
	#include <bzlib.h>
	#include <sys/types.h>

	char *
	crm_itoa_stack(int an_int, char *buffer, size_t len)
	{
	if (buffer != NULL) {
	snprintf(buffer, len, "%d", an_int);
	}

	return buffer;
	}

	long long
	crm_int_helper(const char text, char *end_text)
	{
	long long result = -1;
	char *local_end_text = NULL;
	int saved_errno = 0;

	errno = 0;

	if (text != NULL) {
	#ifdef ANSI_ONLY
	if (end_text != NULL) {
	result = strtol(text, end_text, 10);
	} else {
	result = strtol(text, &local_end_text, 10);
	}
	#else
	if (end_text != NULL) {
	result = strtoll(text, end_text, 10);
	} else {
	result = strtoll(text, &local_end_text, 10);
	}
	#endif

	saved_errno = errno;
	if (errno == EINVAL) {
	crm_err("Conversion of %s failed", text);
	result = -1;

	} else if (errno == ERANGE) {
	crm_err("Conversion of %s was clipped: %lld", text, result);

	} else if (errno != 0) {
	crm_perror(LOG_ERR, "Conversion of %s failed", text);
	}

	if (local_end_text != NULL && local_end_text[0] != '\0') {
	crm_err("Characters left over after parsing '%s': '%s'", text, local_end_text);
	}

	errno = saved_errno;
	}
	return result;
	}

	/*!
	* \brief Parse a long long integer value from a string
	*
	* \param[in] text The string to parse
	* \param[in] default_text Default string to parse if text is NULL
	*
	* \return Parsed value on success, -1 (and set errno) on error
	*/
	long long
	crm_parse_ll(const char text, const char default_text)
	{
	if (text == NULL) {
	text = default_text;
	if (text == NULL) {
	crm_err("No default conversion value supplied");
	errno = EINVAL;
	return -1;
	}
	}
	return crm_int_helper(text, NULL);
	}

	/*!
	* \brief Parse an integer value from a string
	*
	* \param[in] text The string to parse
	* \param[in] default_text Default string to parse if text is NULL
	*
	* \return Parsed value on success, -1 (and set errno) on error
	*/
	int
	crm_parse_int(const char text, const char default_text)
	{
	long long result = crm_parse_ll(text, default_text);

	if ((result < INT_MIN) \|\| (result > INT_MAX)) {
	errno = ERANGE;
	return -1;
	}
	return (int) result;
	}

	/*!
	* \internal
	* \brief Parse a milliseconds value (without units) from a string
	*
	* \param[in] text String to parse
	*
	* \return Milliseconds on success, 0 otherwise (and errno will be set)
	*/
	guint
	crm_parse_ms(const char *text)
	{
	if (text) {
	long long ms = crm_int_helper(text, NULL);

	if ((ms < 0) \|\| (ms > G_MAXUINT)) {
	errno = ERANGE;
	}
	return errno? 0 : (guint) ms;
	}
	return 0;
	}

	gboolean
	safe_str_neq(const char a, const char b)
	{
	if (a == b) {
	return FALSE;

	} else if (a == NULL \|\| b == NULL) {
	return TRUE;

	} else if (strcasecmp(a, b) == 0) {
	return FALSE;
	}
	return TRUE;
	}

	gboolean
	crm_is_true(const char *s)
	{
	gboolean ret = FALSE;

	if (s != NULL) {
	crm_str_to_boolean(s, &ret);
	}
	return ret;
	}

	int
	crm_str_to_boolean(const char s, int ret)
	{
	if (s == NULL) {
	return -1;

	} else if (strcasecmp(s, "true") == 0
	\|\| strcasecmp(s, "on") == 0
	\|\| strcasecmp(s, "yes") == 0 \|\| strcasecmp(s, "y") == 0 \|\| strcasecmp(s, "1") == 0) {
	*ret = TRUE;
	return 1;

	} else if (strcasecmp(s, "false") == 0
	\|\| strcasecmp(s, "off") == 0
	\|\| strcasecmp(s, "no") == 0 \|\| strcasecmp(s, "n") == 0 \|\| strcasecmp(s, "0") == 0) {
	*ret = FALSE;
	return 1;
	}
	return -1;
	}

	char *
	crm_strip_trailing_newline(char *str)
	{
	int len;

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

	for (len = strlen(str) - 1; len >= 0 && str[len] == '\n'; len--) {
	str[len] = '\0';
	}

	return str;
	}

	gboolean
	crm_str_eq(const char a, const char b, gboolean use_case)
	{
	if (use_case) {
	return g_strcmp0(a, b) == 0;

	/* TODO - Figure out which calls, if any, really need to be case independent */
	} else if (a == b) {
	return TRUE;

	} else if (a == NULL \|\| b == NULL) {
	/* shouldn't be comparing NULLs */
	return FALSE;

	} else if (strcasecmp(a, b) == 0) {
	return TRUE;
	}
	return FALSE;
	}

	static inline const char * null2emptystr(const char *);
	static inline const char *
	null2emptystr(const char *input)
	{
	return (input == NULL) ? "" : input;
	}

	/*!
	* \brief Check whether a string starts with a certain sequence
	*
	* \param[in] str String to check
	* \param[in] match Sequence to match against beginning of \p str
	*
	* \return \c TRUE if \p str begins with match, \c FALSE otherwise
	* \note This is equivalent to !strncmp(s, prefix, strlen(prefix))
	* but is likely less efficient when prefix is a string literal
	* if the compiler optimizes away the strlen() at compile time,
	* and more efficient otherwise.
	*/
	bool
	crm_starts_with(const char str, const char prefix)
	{
	const char *s = str;
	const char *p = prefix;

	if (!s \|\| !p) {
	return FALSE;
	}
	while (s && p) {
	if (s++ != p++) {
	return FALSE;
	}
	}
	return (*p == 0);
	}

	static inline int crm_ends_with_internal(const char , const char , gboolean);
	static inline int
	crm_ends_with_internal(const char s, const char match, gboolean as_extension)
	{
	if ((s == NULL) \|\| (match == NULL)) {
	return 0;
	} else {
	size_t slen, mlen;

	if (match[0] != '\0'
	&& (as_extension /* following commented out for inefficiency:
	\|\| strchr(&match[1], match[0]) == NULL */))
	return !strcmp(null2emptystr(strrchr(s, match[0])), match);

	if ((mlen = strlen(match)) == 0)
	return 1;
	slen = strlen(s);
	return ((slen >= mlen) && !strcmp(s + slen - mlen, match));
	}
	}

	/*!
	* \internal
	* \brief Check whether a string ends with a certain sequence
	*
	* \param[in] s String to check
	* \param[in] match Sequence to match against end of \p s
	*
	* \return \c TRUE if \p s ends (verbatim, i.e., case sensitively)
	* with match (including empty string), \c FALSE otherwise
	*
	* \see crm_ends_with_ext()
	*/
	gboolean
	crm_ends_with(const char s, const char match)
	{
	return crm_ends_with_internal(s, match, FALSE);
	}

	/*!
	* \internal
	* \brief Check whether a string ends with a certain "extension"
	*
	* \param[in] s String to check
	* \param[in] match Extension to match against end of \p s, that is,
	* its first character must not occur anywhere
	* in the rest of that very sequence (example: file
	* extension where the last dot is its delimiter,
	* e.g., ".html"); incorrect results may be
	* returned otherwise.
	*
	* \return \c TRUE if \p s ends (verbatim, i.e., case sensitively)
	* with "extension" designated as \p match (including empty
	* string), \c FALSE otherwise
	*
	* \note Main incentive to prefer this function over \c crm_ends_with
	* where possible is the efficiency (at the cost of added
	* restriction on \p match as stated; the complexity class
	* remains the same, though: BigO(M+N) vs. BigO(M+2N)).
	*
	* \see crm_ends_with()
	*/
	gboolean
	crm_ends_with_ext(const char s, const char match)
	{
	return crm_ends_with_internal(s, match, TRUE);
	}

	/*
	* This re-implements g_str_hash as it was prior to glib2-2.28:
	*
	* http://git.gnome.org/browse/glib/commit/?id=354d655ba8a54b754cb5a3efb42767327775696c
	*
	* Note that the new g_str_hash is presumably a better hash (it's actually
	* a correct implementation of DJB's hash), but we need to preserve existing
	* behaviour, because the hash key ultimately determines the "sort" order
	* when iterating through GHashTables, which affects allocation of scores to
	* clone instances when iterating through rsc->allowed_nodes. It (somehow)
	* also appears to have some minor impact on the ordering of a few
	* pseudo_event IDs in the transition graph.
	*/
	guint
	g_str_hash_traditional(gconstpointer v)
	{
	const signed char *p;
	guint32 h = 0;

	for (p = v; *p != '\0'; p++)
	h = (h << 5) - h + *p;

	return h;
	}

	/* used with hash tables where case does not matter */
	gboolean
	crm_strcase_equal(gconstpointer a, gconstpointer b)
	{
	return crm_str_eq((const char ) a, (const char ) b, FALSE);
	}

	guint
	crm_strcase_hash(gconstpointer v)
	{
	const signed char *p;
	guint32 h = 0;

	for (p = v; *p != '\0'; p++)
	h = (h << 5) - h + g_ascii_tolower(*p);

	return h;
	}

	static void
	copy_str_table_entry(gpointer key, gpointer value, gpointer user_data)
	{
	if (key && value && user_data) {
	g_hash_table_insert((GHashTable*)user_data, strdup(key), strdup(value));
	}
	}

	GHashTable *
	crm_str_table_dup(GHashTable *old_table)
	{
	GHashTable *new_table = NULL;

	if (old_table) {
	new_table = crm_str_table_new();
	g_hash_table_foreach(old_table, copy_str_table_entry, new_table);
	}
	return new_table;
	}

	char *
	add_list_element(char list, const char value)
	{
	int len = 0;
	int last = 0;

	if (value == NULL) {
	return list;
	}
	if (list) {
	last = strlen(list);
	}
	len = last + 2; /* +1 space, +1 EOS */
	len += strlen(value);
	list = realloc_safe(list, len);
	sprintf(list + last, " %s", value);
	return list;
	}

	bool
	crm_compress_string(const char data, int length, int max, char result, unsigned int result_len)
	{
	int rc;
	char *compressed = NULL;
	char *uncompressed = strdup(data);
	#ifdef CLOCK_MONOTONIC
	struct timespec after_t;
	struct timespec before_t;
	#endif

	if(max == 0) {
	max = (length * 1.1) + 600; /* recommended size */
	}

	#ifdef CLOCK_MONOTONIC
	clock_gettime(CLOCK_MONOTONIC, &before_t);
	#endif

	compressed = calloc(max, sizeof(char));
	CRM_ASSERT(compressed);

	*result_len = max;
	rc = BZ2_bzBuffToBuffCompress(compressed, result_len, uncompressed, length, CRM_BZ2_BLOCKS, 0,
	CRM_BZ2_WORK);

	free(uncompressed);

	if (rc != BZ_OK) {
	crm_err("Compression of %d bytes failed: %s " CRM_XS " bzerror=%d",
	length, bz2_strerror(rc), rc);
	free(compressed);
	return FALSE;
	}

	#ifdef CLOCK_MONOTONIC
	clock_gettime(CLOCK_MONOTONIC, &after_t);

	crm_trace("Compressed %d bytes into %d (ratio %d:1) in %.0fms",
	length, result_len, length / (result_len),
	difftime (after_t.tv_sec, before_t.tv_sec) * 1000 +
	(after_t.tv_nsec - before_t.tv_nsec) / 1e6);
	#else
	crm_trace("Compressed %d bytes into %d (ratio %d:1)",
	length, result_len, length / (result_len));
	#endif

	*result = compressed;
	return TRUE;
	}

	/*!
	* \brief Compare two strings alphabetically (case-insensitive)
	*
	* \param[in] a First string to compare
	* \param[in] b Second string to compare
	*
	* \return 0 if strings are equal, -1 if a < b, 1 if a > b
	*
	* \note Usable as a GCompareFunc with g_list_sort().
	* NULL is considered less than non-NULL.
	*/
	gint
	crm_alpha_sort(gconstpointer a, gconstpointer b)
	{
	if (!a && !b) {
	return 0;
	} else if (!a) {
	return -1;
	} else if (!b) {
	return 1;
	}
	return strcasecmp(a, b);
	}

	char *
	crm_strdup_printf(char const *format, ...)
	{
	va_list ap;
	int len = 0;
	char *string = NULL;

	va_start(ap, format);
	len = vasprintf (&string, format, ap);
	CRM_ASSERT(len > 0);
	va_end(ap);
	return string;
	}
	-
	-/*!
	- * \brief Extract the name and value from an input string formatted as "name=value".
	- * If unable to extract them, they are returned as NULL.
	- *
	- * \param[in] input The input string, likely from the command line
	- * \param[out] name Everything before the first '=' in the input string
	- * \param[out] value Everything after the first '=' in the input string
	- *
	- * \return 2 if both name and value could be extracted, 1 if only one could, and
	- * and error code otherwise
	- */
	-int
	-pcmk_scan_nvpair(const char input, char name, char *value) {
	-#ifdef SSCANF_HAS_M
	- *name = NULL;
	- *value = NULL;
	- if (sscanf(input, "%m[^=]=%ms", name, value) <= 0) {
	- return -pcmk_err_bad_nvpair;
	- }
	-#else
	- char *sep = NULL;
	- *name = NULL;
	- *value = NULL;
	-
	- sep = strstr(optarg, "=");
	- if (sep == NULL) {
	- return -pcmk_err_bad_nvpair;
	- }
	-
	- *name = strndup(input, sep-input);
	-
	- if (*name == NULL) {
	- return -ENOMEM;
	- }
	-
	- /* If the last char in optarg is =, the user gave no
	- * value for the option. Leave it as NULL.
	- */
	- if (*(sep+1) != '\0') {
	- *value = strdup(sep+1);
	-
	- if (*value == NULL) {
	- return -ENOMEM;
	- }
	- }
	-#endif
	-
	- if (name != NULL && value != NULL) {
	- return 2;
	- } else if (name != NULL \|\| value != NULL) {
	- return 1;
	- } else {
	- return -pcmk_err_bad_nvpair;
	- }
	-}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Sep 23, 11:59 AM (2 h, 26 m ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2406804
Default Alt Text: (42 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions