#include <corosync/corotypes.h>
#include <qb/qbdefs.h>
-#include <corosync/list.h>
+#include <qb/qblist.h>
#include <corosync/icmap.h>
#define ICMAP_MAX_VALUE_LEN (16*1024)
char value[];
};
-static qb_map_t *icmap_map;
+struct icmap_map {
+ qb_map_t *qb_map;
+};
+
+static icmap_map_t icmap_global_map;
struct icmap_track {
char *key_name;
int32_t track_type;
icmap_notify_fn_t notify_fn;
void *user_data;
- struct list_head list;
+ struct qb_list_head list;
};
struct icmap_ro_access_item {
char *key_name;
int prefix;
- struct list_head list;
+ struct qb_list_head list;
};
-DECLARE_LIST_INIT(icmap_ro_access_item_list_head);
-DECLARE_LIST_INIT(icmap_track_list_head);
+QB_LIST_DECLARE (icmap_ro_access_item_list_head);
+QB_LIST_DECLARE (icmap_track_list_head);
/*
* Static functions declarations
*/
static int icmap_check_value_len(const void *value, size_t value_len, icmap_value_types_t type);
-/*
- * Returns length of value of given type, or 0 for string and binary data type
- */
-static size_t icmap_get_valuetype_len(icmap_value_types_t type);
-
-/*
- * Converts track type of icmap to qb
- */
-static int32_t icmap_tt_to_qbtt(int32_t track_type);
-
-/*
- * Convert track type of qb to icmap
- */
-static int32_t icmap_qbtt_to_tt(int32_t track_type);
-
/*
* Checks if item has same value as value with value_len and given type. Returns 0 if not, otherwise !0.
*/
/*
* Helper for getting integer and float value with given type for key key_name and store it in value.
*/
-static cs_error_t icmap_get_int(
+static cs_error_t icmap_get_int_r(
+ const icmap_map_t map,
const char *key_name,
void *value,
icmap_value_types_t type);
+/*
+ * Return raw item value data. Internal function used by icmap_get_r which does most
+ * of arguments validity checks but doesn't copy data (it returns raw item data
+ * pointer). It's not very safe tho it's static.
+ */
+static cs_error_t icmap_get_ref_r(
+ const icmap_map_t map,
+ const char *key_name,
+ void **value,
+ size_t *value_len,
+ icmap_value_types_t *type);
+
/*
* Function implementation
*/
-static int32_t icmap_tt_to_qbtt(int32_t track_type)
+int32_t icmap_tt_to_qbtt(int32_t track_type)
{
int32_t res = 0;
res |= QB_MAP_NOTIFY_RECURSIVE;
}
- return (track_type);
+ return (res);
}
-static int32_t icmap_qbtt_to_tt(int32_t track_type)
+int32_t icmap_qbtt_to_tt(int32_t track_type)
{
int32_t res = 0;
res |= ICMAP_TRACK_PREFIX;
}
- return (track_type);
+ return (res);
}
static void icmap_map_free_cb(uint32_t event,
}
}
-cs_error_t icmap_init(void)
+cs_error_t icmap_init_r(icmap_map_t *result)
{
int32_t err;
- icmap_map = qb_trie_create();
- if (icmap_map == NULL)
+ *result = malloc(sizeof(struct icmap_map));
+ if (*result == NULL) {
+ return (CS_ERR_NO_MEMORY);
+ }
+
+ (*result)->qb_map = qb_trie_create();
+ if ((*result)->qb_map == NULL) {
+ free(*result);
return (CS_ERR_INIT);
+ }
- err = qb_map_notify_add(icmap_map, NULL, icmap_map_free_cb, QB_MAP_NOTIFY_FREE, NULL);
+ err = qb_map_notify_add((*result)->qb_map, NULL, icmap_map_free_cb, QB_MAP_NOTIFY_FREE, NULL);
return (qb_to_cs_error(err));
}
+cs_error_t icmap_init(void)
+{
+ return (icmap_init_r(&icmap_global_map));
+}
+
static void icmap_set_ro_access_free(void)
{
- struct list_head *iter = icmap_ro_access_item_list_head.next;
+ struct qb_list_head *iter, *tmp_iter;
struct icmap_ro_access_item *icmap_ro_ai;
- while (iter != &icmap_ro_access_item_list_head) {
- icmap_ro_ai = list_entry(iter, struct icmap_ro_access_item, list);
- list_del(&icmap_ro_ai->list);
+ qb_list_for_each_safe(iter, tmp_iter, &icmap_ro_access_item_list_head) {
+ icmap_ro_ai = qb_list_entry(iter, struct icmap_ro_access_item, list);
+ qb_list_del(&icmap_ro_ai->list);
free(icmap_ro_ai->key_name);
free(icmap_ro_ai);
- iter = icmap_ro_access_item_list_head.next;
}
}
static void icmap_del_all_track(void)
{
- struct list_head *iter = icmap_track_list_head.next;
+ struct qb_list_head *iter, *tmp_iter;
struct icmap_track *icmap_track;
- while (iter != &icmap_track_list_head) {
- icmap_track = list_entry(iter, struct icmap_track, list);
+ qb_list_for_each_safe(iter, tmp_iter, &icmap_track_list_head) {
+ icmap_track = qb_list_entry(iter, struct icmap_track, list);
+
icmap_track_delete(icmap_track);
- iter = icmap_track_list_head.next;
}
}
+void icmap_fini_r(const icmap_map_t map)
+{
+
+ qb_map_destroy(map->qb_map);
+ free(map);
+
+ return;
+}
+
void icmap_fini(void)
{
+
icmap_del_all_track();
/*
* catch 22 warning:
* -> qb_map_notify_del_2(icmap_map, NULL, icmap_map_free_cb, QB_MAP_NOTIFY_FREE, NULL);
* and we cannot call it after map_destroy. joy! :)
*/
- qb_map_destroy(icmap_map);
+ icmap_fini_r(icmap_global_map);
icmap_set_ro_access_free();
- return;
+
+ return ;
+}
+
+icmap_map_t icmap_get_global_map(void)
+{
+
+ return (icmap_global_map);
}
static int icmap_is_valid_name_char(char c)
return (0);
}
-static size_t icmap_get_valuetype_len(icmap_value_types_t type)
+size_t icmap_get_valuetype_len(icmap_value_types_t type)
{
size_t res = 0;
}
if (type == ICMAP_VALUETYPE_STRING) {
- if (value_len > strlen((const char *)value)) {
+ /*
+ * value_len can be shorter then real string length, but never
+ * longer (+ 1 is because of 0 at the end of string)
+ */
+ if (value_len > strlen((const char *)value) + 1) {
return (-1);
} else {
return (0);
return (0);
}
-cs_error_t icmap_set(
+int icmap_key_value_eq(
+ const icmap_map_t map1,
+ const char *key_name1,
+ const icmap_map_t map2,
+ const char *key_name2)
+{
+ struct icmap_item *item1, *item2;
+
+ if (map1 == NULL || key_name1 == NULL || map2 == NULL || key_name2 == NULL) {
+ return (0);
+ }
+
+ item1 = qb_map_get(map1->qb_map, key_name1);
+ item2 = qb_map_get(map2->qb_map, key_name2);
+
+ if (item1 == NULL || item2 == NULL) {
+ return (0);
+ }
+
+ return (icmap_item_eq(item1, item2->value, item2->value_len, item2->type));
+}
+
+cs_error_t icmap_set_r(
+ const icmap_map_t map,
const char *key_name,
const void *value,
size_t value_len,
return (CS_ERR_INVALID_PARAM);
}
- item = qb_map_get(icmap_map, key_name);
+ item = qb_map_get(map->qb_map, key_name);
if (item != NULL) {
/*
* Check that key is really changed
((char *)new_item->value)[new_value_len - 1] = 0;
}
- qb_map_put(icmap_map, new_item->key_name, new_item);
+ qb_map_put(map->qb_map, new_item->key_name, new_item);
return (CS_OK);
}
+cs_error_t icmap_set(
+ const char *key_name,
+ const void *value,
+ size_t value_len,
+ icmap_value_types_t type)
+{
+
+ return (icmap_set_r(icmap_global_map, key_name, value, value_len, type));
+}
+
+cs_error_t icmap_set_int8_r(const icmap_map_t map, const char *key_name, int8_t value)
+{
+
+ return (icmap_set_r(map, key_name, &value, sizeof(value), ICMAP_VALUETYPE_INT8));
+}
+
+cs_error_t icmap_set_uint8_r(const icmap_map_t map, const char *key_name, uint8_t value)
+{
+
+ return (icmap_set_r(map, key_name, &value, sizeof(value), ICMAP_VALUETYPE_UINT8));
+}
+
+cs_error_t icmap_set_int16_r(const icmap_map_t map, const char *key_name, int16_t value)
+{
+
+ return (icmap_set_r(map,key_name, &value, sizeof(value), ICMAP_VALUETYPE_INT16));
+}
+
+cs_error_t icmap_set_uint16_r(const icmap_map_t map, const char *key_name, uint16_t value)
+{
+
+ return (icmap_set_r(map, key_name, &value, sizeof(value), ICMAP_VALUETYPE_UINT16));
+}
+
+cs_error_t icmap_set_int32_r(const icmap_map_t map, const char *key_name, int32_t value)
+{
+
+ return (icmap_set_r(map, key_name, &value, sizeof(value), ICMAP_VALUETYPE_INT32));
+}
+
+cs_error_t icmap_set_uint32_r(const icmap_map_t map, const char *key_name, uint32_t value)
+{
+
+ return (icmap_set_r(map, key_name, &value, sizeof(value), ICMAP_VALUETYPE_UINT32));
+}
+
+cs_error_t icmap_set_int64_r(const icmap_map_t map, const char *key_name, int64_t value)
+{
+
+ return (icmap_set_r(map, key_name, &value, sizeof(value), ICMAP_VALUETYPE_INT64));
+}
+
+cs_error_t icmap_set_uint64_r(const icmap_map_t map, const char *key_name, uint64_t value)
+{
+
+ return (icmap_set_r(map, key_name, &value, sizeof(value), ICMAP_VALUETYPE_UINT64));
+}
+
+cs_error_t icmap_set_float_r(const icmap_map_t map, const char *key_name, float value)
+{
+
+ return (icmap_set_r(map, key_name, &value, sizeof(value), ICMAP_VALUETYPE_FLOAT));
+}
+
+cs_error_t icmap_set_double_r(const icmap_map_t map, const char *key_name, double value)
+{
+
+ return (icmap_set_r(map, key_name, &value, sizeof(value), ICMAP_VALUETYPE_DOUBLE));
+}
+
+cs_error_t icmap_set_string_r(const icmap_map_t map, const char *key_name, const char *value)
+{
+
+ if (value == NULL) {
+ return (CS_ERR_INVALID_PARAM);
+ }
+
+ return (icmap_set_r(map, key_name, value, strlen(value), ICMAP_VALUETYPE_STRING));
+}
+
cs_error_t icmap_set_int8(const char *key_name, int8_t value)
{
- return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_INT8));
+ return (icmap_set_int8_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_uint8(const char *key_name, uint8_t value)
{
- return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_UINT8));
+ return (icmap_set_uint8_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_int16(const char *key_name, int16_t value)
{
- return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_INT16));
+ return (icmap_set_int16_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_uint16(const char *key_name, uint16_t value)
{
- return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_UINT16));
+ return (icmap_set_uint16_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_int32(const char *key_name, int32_t value)
{
- return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_INT32));
+ return (icmap_set_int32_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_uint32(const char *key_name, uint32_t value)
{
- return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_UINT32));
+ return (icmap_set_uint32_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_int64(const char *key_name, int64_t value)
{
- return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_INT64));
+ return (icmap_set_int64_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_uint64(const char *key_name, uint64_t value)
{
- return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_UINT64));
+ return (icmap_set_uint64_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_float(const char *key_name, float value)
{
- return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_FLOAT));
+ return (icmap_set_float_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_double(const char *key_name, double value)
{
- return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_DOUBLE));
+ return (icmap_set_double_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_string(const char *key_name, const char *value)
{
- if (value == NULL) {
- return (CS_ERR_INVALID_PARAM);
- }
-
- return (icmap_set(key_name, value, strlen(value), ICMAP_VALUETYPE_STRING));
+ return (icmap_set_string_r(icmap_global_map, key_name, value));
}
-cs_error_t icmap_delete(const char *key_name)
+cs_error_t icmap_delete_r(const icmap_map_t map, const char *key_name)
{
struct icmap_item *item;
return (CS_ERR_INVALID_PARAM);
}
- item = qb_map_get(icmap_map, key_name);
+ item = qb_map_get(map->qb_map, key_name);
if (item == NULL) {
return (CS_ERR_NOT_EXIST);
}
- if (qb_map_rm(icmap_map, item->key_name) != QB_TRUE) {
+ if (qb_map_rm(map->qb_map, item->key_name) != QB_TRUE) {
return (CS_ERR_NOT_EXIST);
}
return (CS_OK);
}
-cs_error_t icmap_get(
+cs_error_t icmap_delete(const char *key_name)
+{
+
+ return (icmap_delete_r(icmap_global_map, key_name));
+}
+
+static cs_error_t icmap_get_ref_r(
+ const icmap_map_t map,
const char *key_name,
- void *value,
+ void **value,
size_t *value_len,
icmap_value_types_t *type)
{
return (CS_ERR_INVALID_PARAM);
}
- item = qb_map_get(icmap_map, key_name);
+ item = qb_map_get(map->qb_map, key_name);
if (item == NULL) {
return (CS_ERR_NOT_EXIST);
}
*type = item->type;
}
+ if (value_len != NULL) {
+ *value_len = item->value_len;
+ }
+
+ if (value != NULL) {
+ *value = item->value;
+ }
+
+ return (CS_OK);
+}
+
+cs_error_t icmap_get_r(
+ const icmap_map_t map,
+ const char *key_name,
+ void *value,
+ size_t *value_len,
+ icmap_value_types_t *type)
+{
+ cs_error_t res;
+ void *tmp_value;
+ size_t tmp_value_len;
+
+ res = icmap_get_ref_r(map, key_name, &tmp_value, &tmp_value_len, type);
+ if (res != CS_OK) {
+ return (res);
+ }
+
if (value == NULL) {
if (value_len != NULL) {
- *value_len = item->value_len;
+ *value_len = tmp_value_len;
}
} else {
- if (value_len == NULL || *value_len < item->value_len) {
+ if (value_len == NULL || *value_len < tmp_value_len) {
return (CS_ERR_INVALID_PARAM);
}
- *value_len = item->value_len;
+ *value_len = tmp_value_len;
- memcpy(value, item->value, item->value_len);
+ memcpy(value, tmp_value, tmp_value_len);
}
return (CS_OK);
}
-static cs_error_t icmap_get_int(
+cs_error_t icmap_get(
+ const char *key_name,
+ void *value,
+ size_t *value_len,
+ icmap_value_types_t *type)
+{
+
+ return (icmap_get_r(icmap_global_map, key_name, value, value_len, type));
+}
+
+cs_error_t icmap_get_string_r(icmap_map_t map, const char *key_name, char **str)
+{
+ cs_error_t res;
+ size_t str_len;
+ icmap_value_types_t type;
+
+ res = icmap_get_r(map, key_name, NULL, &str_len, &type);
+ if (res != CS_OK || type != ICMAP_VALUETYPE_STRING) {
+ if (res == CS_OK) {
+ res = CS_ERR_INVALID_PARAM;
+ }
+
+ goto return_error;
+ }
+
+ *str = malloc(str_len);
+ if (*str == NULL) {
+ res = CS_ERR_NO_MEMORY;
+
+ goto return_error;
+ }
+
+ res = icmap_get_r(map, key_name, *str, &str_len, &type);
+ if (res != CS_OK) {
+ free(*str);
+ goto return_error;
+ }
+
+ return (CS_OK);
+
+return_error:
+ return (res);
+}
+
+static cs_error_t icmap_get_int_r(
+ const icmap_map_t map,
const char *key_name,
void *value,
icmap_value_types_t type)
key_size = sizeof(key_value);
memset(key_value, 0, key_size);
- err = icmap_get(key_name, key_value, &key_size, &key_type);
+ err = icmap_get_r(map, key_name, key_value, &key_size, &key_type);
if (err != CS_OK)
return (err);
return (CS_OK);
}
-cs_error_t icmap_get_int8(const char *key_name, int8_t *i8)
+cs_error_t icmap_get_int8_r(const icmap_map_t map, const char *key_name, int8_t *i8)
{
- return (icmap_get_int(key_name, i8, ICMAP_VALUETYPE_INT8));
+ return (icmap_get_int_r(map, key_name, i8, ICMAP_VALUETYPE_INT8));
}
-cs_error_t icmap_get_uint8(const char *key_name, uint8_t *u8)
+cs_error_t icmap_get_uint8_r(const icmap_map_t map, const char *key_name, uint8_t *u8)
{
- return (icmap_get_int(key_name, u8, ICMAP_VALUETYPE_UINT8));
+ return (icmap_get_int_r(map, key_name, u8, ICMAP_VALUETYPE_UINT8));
}
-cs_error_t icmap_get_int16(const char *key_name, int16_t *i16)
+cs_error_t icmap_get_int16_r(const icmap_map_t map, const char *key_name, int16_t *i16)
{
- return (icmap_get_int(key_name, i16, ICMAP_VALUETYPE_INT16));
+ return (icmap_get_int_r(map, key_name, i16, ICMAP_VALUETYPE_INT16));
}
-cs_error_t icmap_get_uint16(const char *key_name, uint16_t *u16)
+cs_error_t icmap_get_uint16_r(const icmap_map_t map, const char *key_name, uint16_t *u16)
{
- return (icmap_get_int(key_name, u16, ICMAP_VALUETYPE_UINT16));
+ return (icmap_get_int_r(map, key_name, u16, ICMAP_VALUETYPE_UINT16));
}
-cs_error_t icmap_get_int32(const char *key_name, int32_t *i32)
+cs_error_t icmap_get_int32_r(const icmap_map_t map, const char *key_name, int32_t *i32)
{
- return (icmap_get_int(key_name, i32, ICMAP_VALUETYPE_INT32));
+ return (icmap_get_int_r(map, key_name, i32, ICMAP_VALUETYPE_INT32));
}
-cs_error_t icmap_get_uint32(const char *key_name, uint32_t *u32)
+cs_error_t icmap_get_uint32_r(const icmap_map_t map, const char *key_name, uint32_t *u32)
{
- return (icmap_get_int(key_name, u32, ICMAP_VALUETYPE_UINT32));
+ return (icmap_get_int_r(map, key_name, u32, ICMAP_VALUETYPE_UINT32));
}
-cs_error_t icmap_get_int64(const char *key_name, int64_t *i64)
+cs_error_t icmap_get_int64_r(const icmap_map_t map, const char *key_name, int64_t *i64)
{
- return(icmap_get_int(key_name, i64, ICMAP_VALUETYPE_INT64));
+ return(icmap_get_int_r(map, key_name, i64, ICMAP_VALUETYPE_INT64));
}
-cs_error_t icmap_get_uint64(const char *key_name, uint64_t *u64)
+cs_error_t icmap_get_uint64_r(const icmap_map_t map, const char *key_name, uint64_t *u64)
{
- return (icmap_get_int(key_name, u64, ICMAP_VALUETYPE_UINT64));
+ return (icmap_get_int_r(map, key_name, u64, ICMAP_VALUETYPE_UINT64));
}
-cs_error_t icmap_get_float(const char *key_name, float *flt)
+cs_error_t icmap_get_float_r(const icmap_map_t map, const char *key_name, float *flt)
{
- return (icmap_get_int(key_name, flt, ICMAP_VALUETYPE_FLOAT));
+ return (icmap_get_int_r(map, key_name, flt, ICMAP_VALUETYPE_FLOAT));
}
-cs_error_t icmap_get_double(const char *key_name, double *dbl)
+cs_error_t icmap_get_double_r(const icmap_map_t map, const char *key_name, double *dbl)
{
- return (icmap_get_int(key_name, dbl, ICMAP_VALUETYPE_DOUBLE));
+ return (icmap_get_int_r(map, key_name, dbl, ICMAP_VALUETYPE_DOUBLE));
}
cs_error_t icmap_get_string(const char *key_name, char **str)
{
- cs_error_t res;
- size_t str_len;
- icmap_value_types_t type;
- res = icmap_get(key_name, NULL, &str_len, &type);
- if (res != CS_OK || type != ICMAP_VALUETYPE_STRING) {
- if (res == CS_OK) {
- res = CS_ERR_INVALID_PARAM;
- }
+ return (icmap_get_string_r(icmap_global_map, key_name, str));
+}
- goto return_error;
- }
+cs_error_t icmap_get_int8(const char *key_name, int8_t *i8)
+{
- *str = malloc(str_len);
- if (*str == NULL) {
- res = CS_ERR_NO_MEMORY;
+ return (icmap_get_int8_r(icmap_global_map, key_name, i8));
+}
- goto return_error;
- }
+cs_error_t icmap_get_uint8(const char *key_name, uint8_t *u8)
+{
- res = icmap_get(key_name, *str, &str_len, &type);
- if (res != CS_OK) {
- free(*str);
- goto return_error;
- }
+ return (icmap_get_uint8_r(icmap_global_map, key_name, u8));
+}
- return (CS_OK);
+cs_error_t icmap_get_int16(const char *key_name, int16_t *i16)
+{
-return_error:
- return (res);
+ return (icmap_get_int16_r(icmap_global_map, key_name, i16));
}
-cs_error_t icmap_adjust_int(
+cs_error_t icmap_get_uint16(const char *key_name, uint16_t *u16)
+{
+
+ return (icmap_get_uint16_r(icmap_global_map, key_name, u16));
+}
+
+cs_error_t icmap_get_int32(const char *key_name, int32_t *i32)
+{
+
+ return (icmap_get_int32_r(icmap_global_map, key_name, i32));
+}
+
+cs_error_t icmap_get_uint32(const char *key_name, uint32_t *u32)
+{
+
+ return (icmap_get_uint32_r(icmap_global_map, key_name, u32));
+}
+
+cs_error_t icmap_get_int64(const char *key_name, int64_t *i64)
+{
+
+ return(icmap_get_int64_r(icmap_global_map, key_name, i64));
+}
+
+cs_error_t icmap_get_uint64(const char *key_name, uint64_t *u64)
+{
+
+ return (icmap_get_uint64_r(icmap_global_map, key_name, u64));
+}
+
+cs_error_t icmap_get_float(const char *key_name, float *flt)
+{
+
+ return (icmap_get_float_r(icmap_global_map, key_name, flt));
+}
+
+cs_error_t icmap_get_double(const char *key_name, double *dbl)
+{
+
+ return (icmap_get_double_r(icmap_global_map, key_name, dbl));
+}
+
+cs_error_t icmap_adjust_int_r(
+ const icmap_map_t map,
const char *key_name,
int32_t step)
{
return (CS_ERR_INVALID_PARAM);
}
- item = qb_map_get(icmap_map, key_name);
+ item = qb_map_get(map->qb_map, key_name);
if (item == NULL) {
return (CS_ERR_NOT_EXIST);
}
return (err);
}
-cs_error_t icmap_fast_adjust_int(
+cs_error_t icmap_adjust_int(
+ const char *key_name,
+ int32_t step)
+{
+
+ return (icmap_adjust_int_r(icmap_global_map, key_name, step));
+}
+
+cs_error_t icmap_fast_adjust_int_r(
+ const icmap_map_t map,
const char *key_name,
int32_t step)
{
return (CS_ERR_INVALID_PARAM);
}
- item = qb_map_get(icmap_map, key_name);
+ item = qb_map_get(map->qb_map, key_name);
if (item == NULL) {
return (CS_ERR_NOT_EXIST);
}
}
if (err == CS_OK) {
- qb_map_put(icmap_map, item->key_name, item);
+ qb_map_put(map->qb_map, item->key_name, item);
}
return (err);
}
+cs_error_t icmap_fast_adjust_int(
+ const char *key_name,
+ int32_t step)
+{
+
+ return (icmap_fast_adjust_int_r(icmap_global_map, key_name, step));
+}
+
+cs_error_t icmap_inc_r(const icmap_map_t map, const char *key_name)
+{
+ return (icmap_adjust_int_r(map, key_name, 1));
+}
+
cs_error_t icmap_inc(const char *key_name)
{
- return (icmap_adjust_int(key_name, 1));
+ return (icmap_inc_r(icmap_global_map, key_name));
+}
+
+cs_error_t icmap_dec_r(const icmap_map_t map, const char *key_name)
+{
+ return (icmap_adjust_int_r(map, key_name, -1));
}
cs_error_t icmap_dec(const char *key_name)
{
- return (icmap_adjust_int(key_name, -1));
+ return (icmap_dec_r(icmap_global_map, key_name));
+}
+
+cs_error_t icmap_fast_inc_r(const icmap_map_t map, const char *key_name)
+{
+ return (icmap_fast_adjust_int_r(map, key_name, 1));
}
cs_error_t icmap_fast_inc(const char *key_name)
{
- return (icmap_fast_adjust_int(key_name, 1));
+ return (icmap_fast_inc_r(icmap_global_map, key_name));
+}
+
+cs_error_t icmap_fast_dec_r(const icmap_map_t map, const char *key_name)
+{
+ return (icmap_fast_adjust_int_r(map, key_name, -1));
}
cs_error_t icmap_fast_dec(const char *key_name)
{
- return (icmap_fast_adjust_int(key_name, -1));
+ return (icmap_fast_dec_r(icmap_global_map, key_name));
+}
+
+icmap_iter_t icmap_iter_init_r(const icmap_map_t map, const char *prefix)
+{
+ return (qb_map_pref_iter_create(map->qb_map, prefix));
}
icmap_iter_t icmap_iter_init(const char *prefix)
{
- return (qb_map_pref_iter_create(icmap_map, prefix));
+ return (icmap_iter_init_r(icmap_global_map, prefix));
}
+
const char *icmap_iter_next(icmap_iter_t iter, size_t *value_len, icmap_value_types_t *type)
{
struct icmap_item *item;
(*icmap_track)->notify_fn = notify_fn;
(*icmap_track)->user_data = user_data;
- if ((err = qb_map_notify_add(icmap_map, (*icmap_track)->key_name, icmap_notify_fn,
+ if ((err = qb_map_notify_add(icmap_global_map->qb_map, (*icmap_track)->key_name, icmap_notify_fn,
icmap_tt_to_qbtt(track_type), *icmap_track)) != 0) {
free((*icmap_track)->key_name);
free(*icmap_track);
return (qb_to_cs_error(err));
}
- list_init(&(*icmap_track)->list);
- list_add (&(*icmap_track)->list, &icmap_track_list_head);
+ qb_list_init(&(*icmap_track)->list);
+ qb_list_add (&(*icmap_track)->list, &icmap_track_list_head);
return (CS_OK);
}
{
int32_t err;
- if ((err = qb_map_notify_del_2(icmap_map, icmap_track->key_name,
+ if ((err = qb_map_notify_del_2(icmap_global_map->qb_map, icmap_track->key_name,
icmap_notify_fn, icmap_tt_to_qbtt(icmap_track->track_type), icmap_track)) != 0) {
return (qb_to_cs_error(err));
}
- list_del(&icmap_track->list);
+ qb_list_del(&icmap_track->list);
free(icmap_track->key_name);
free(icmap_track);
cs_error_t icmap_set_ro_access(const char *key_name, int prefix, int ro_access)
{
- struct list_head *iter;
+ struct qb_list_head *iter, *tmp_iter;
struct icmap_ro_access_item *icmap_ro_ai;
- for (iter = icmap_ro_access_item_list_head.next; iter != &icmap_ro_access_item_list_head; iter = iter->next) {
- icmap_ro_ai = list_entry(iter, struct icmap_ro_access_item, list);
+ qb_list_for_each_safe(iter, tmp_iter, &icmap_ro_access_item_list_head) {
+ icmap_ro_ai = qb_list_entry(iter, struct icmap_ro_access_item, list);
if (icmap_ro_ai->prefix == prefix && strcmp(key_name, icmap_ro_ai->key_name) == 0) {
/*
if (ro_access) {
return (CS_ERR_EXIST);
} else {
- list_del(&icmap_ro_ai->list);
+ qb_list_del(&icmap_ro_ai->list);
free(icmap_ro_ai->key_name);
free(icmap_ro_ai);
}
icmap_ro_ai->prefix = prefix;
- list_init(&icmap_ro_ai->list);
- list_add (&icmap_ro_ai->list, &icmap_ro_access_item_list_head);
+ qb_list_init(&icmap_ro_ai->list);
+ qb_list_add (&icmap_ro_ai->list, &icmap_ro_access_item_list_head);
return (CS_OK);
}
int icmap_is_key_ro(const char *key_name)
{
- struct list_head *iter;
+ struct qb_list_head *iter;
struct icmap_ro_access_item *icmap_ro_ai;
- for (iter = icmap_ro_access_item_list_head.next; iter != &icmap_ro_access_item_list_head; iter = iter->next) {
- icmap_ro_ai = list_entry(iter, struct icmap_ro_access_item, list);
+ qb_list_for_each(iter, &icmap_ro_access_item_list_head) {
+ icmap_ro_ai = qb_list_entry(iter, struct icmap_ro_access_item, list);
if (icmap_ro_ai->prefix) {
if (strlen(icmap_ro_ai->key_name) > strlen(key_name))
return (CS_FALSE);
}
+
+cs_error_t icmap_copy_map(icmap_map_t dst_map, const icmap_map_t src_map)
+{
+ icmap_iter_t iter;
+ size_t value_len;
+ icmap_value_types_t value_type;
+ const char *key_name;
+ cs_error_t err;
+ void *value;
+
+ iter = icmap_iter_init_r(src_map, NULL);
+ if (iter == NULL) {
+ return (CS_ERR_NO_MEMORY);
+ }
+
+ err = CS_OK;
+
+ while ((key_name = icmap_iter_next(iter, &value_len, &value_type)) != NULL) {
+ err = icmap_get_ref_r(src_map, key_name, &value, &value_len, &value_type);
+ if (err != CS_OK) {
+ goto exit_iter_finalize;
+ }
+
+ err = icmap_set_r(dst_map, key_name, value, value_len, value_type);
+ if (err != CS_OK) {
+ goto exit_iter_finalize;
+ }
+ }
+
+exit_iter_finalize:
+ icmap_iter_finalize(iter);
+
+ return (err);
+}
projects / mirror_corosync.git / blobdiff