icmap.c
Go to the documentation of this file.
/*
* Copyright (c) 2011 Red Hat, Inc.
*
* All rights reserved.
*
* Author: Jan Friesse (jfriesse@redhat.com)
*
* This software licensed under BSD license, the text of which follows:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* - Neither the name of the Red Hat, Inc. nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <config.h>
#include <string.h>
#include <stdio.h>
#include <corosync/corotypes.h>
#include <qb/qbdefs.h>
#include <qb/qblist.h>
#include <corosync/icmap.h>
#define ICMAP_MAX_VALUE_LEN (16*1024)
struct icmap_item {
char *key_name;
icmap_value_types_t type;
size_t value_len;
char value[];
};
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 qb_list_head list;
};
struct icmap_ro_access_item {
char *key_name;
int prefix;
struct qb_list_head list;
};
QB_LIST_DECLARE (icmap_ro_access_item_list_head);
QB_LIST_DECLARE (icmap_track_list_head);
/*
* Static functions declarations
*/
/*
* Check if key_name is valid icmap key name. Returns 0 on success, and -1 on fail
*/
static int icmap_check_key_name(const char *key_name);
/*
* Check that value with given type has correct length value_len. Returns 0 on success,
* and -1 on fail
*/
static int icmap_check_value_len(const void *value, size_t value_len, icmap_value_types_t type);
/*
* Checks if item has same value as value with value_len and given type. Returns 0 if not, otherwise !0.
*/
static int icmap_item_eq(const struct icmap_item *item, const void *value, size_t value_len, icmap_value_types_t type);
/*
* Checks if given character is valid in key name. Returns 0 if not, otherwise !0.
*/
static int icmap_is_valid_name_char(char c);
/*
* 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_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
*/
int32_t icmap_tt_to_qbtt(int32_t track_type)
{
int32_t res = 0;
if (track_type & ICMAP_TRACK_DELETE) {
res |= QB_MAP_NOTIFY_DELETED;
}
if (track_type & ICMAP_TRACK_MODIFY) {
res |= QB_MAP_NOTIFY_REPLACED;
}
if (track_type & ICMAP_TRACK_ADD) {
res |= QB_MAP_NOTIFY_INSERTED;
}
if (track_type & ICMAP_TRACK_PREFIX) {
res |= QB_MAP_NOTIFY_RECURSIVE;
}
return (res);
}
int32_t icmap_qbtt_to_tt(int32_t track_type)
{
int32_t res = 0;
if (track_type & QB_MAP_NOTIFY_DELETED) {
res |= ICMAP_TRACK_DELETE;
}
if (track_type & QB_MAP_NOTIFY_REPLACED) {
res |= ICMAP_TRACK_MODIFY;
}
if (track_type & QB_MAP_NOTIFY_INSERTED) {
res |= ICMAP_TRACK_ADD;
}
if (track_type & QB_MAP_NOTIFY_RECURSIVE) {
res |= ICMAP_TRACK_PREFIX;
}
return (res);
}
static void icmap_map_free_cb(uint32_t event,
char* key, void* old_value,
void* value, void* user_data)
{
struct icmap_item *item = (struct icmap_item *)old_value;
/*
* value == old_value -> fast_adjust_int was used, don't free data
*/
if (item != NULL && value != old_value) {
free(item->key_name);
free(item);
}
}
cs_error_t icmap_init_r(icmap_map_t *result)
{
int32_t err;
*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((*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 qb_list_head *iter, *tmp_iter;
struct icmap_ro_access_item *icmap_ro_ai;
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);
}
}
static void icmap_del_all_track(void)
{
struct qb_list_head *iter, *tmp_iter;
struct icmap_track *icmap_track;
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);
}
}
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:
* We need to drop this notify but we can't because it calls icmap_map_free_cb
* while destroying the tree to free icmap_item(s).
* -> 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! :)
*/
icmap_fini_r(icmap_global_map);
icmap_set_ro_access_free();
return ;
}
icmap_map_t icmap_get_global_map(void)
{
return (icmap_global_map);
}
static int icmap_is_valid_name_char(char c)
{
return ((c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z') ||
(c >= '0' && c <= '9') ||
c == '.' || c == '_' || c == '-' || c == '/' || c == ':');
}
void icmap_convert_name_to_valid_name(char *key_name)
{
int i;
for (i = 0; i < strlen(key_name); i++) {
if (!icmap_is_valid_name_char(key_name[i])) {
key_name[i] = '_';
}
}
}
static int icmap_check_key_name(const char *key_name)
{
int i;
if ((strlen(key_name) < ICMAP_KEYNAME_MINLEN) || strlen(key_name) > ICMAP_KEYNAME_MAXLEN) {
return (-1);
}
for (i = 0; i < strlen(key_name); i++) {
if (!icmap_is_valid_name_char(key_name[i])) {
return (-1);
}
}
return (0);
}
size_t icmap_get_valuetype_len(icmap_value_types_t type)
{
size_t res = 0;
switch (type) {
case ICMAP_VALUETYPE_INT8: res = sizeof(int8_t); break;
case ICMAP_VALUETYPE_UINT8: res = sizeof(uint8_t); break;
case ICMAP_VALUETYPE_INT16: res = sizeof(int16_t); break;
case ICMAP_VALUETYPE_UINT16: res = sizeof(uint16_t); break;
case ICMAP_VALUETYPE_INT32: res = sizeof(int32_t); break;
case ICMAP_VALUETYPE_UINT32: res = sizeof(uint32_t); break;
case ICMAP_VALUETYPE_INT64: res = sizeof(int64_t); break;
case ICMAP_VALUETYPE_UINT64: res = sizeof(uint64_t); break;
case ICMAP_VALUETYPE_FLOAT: res = sizeof(float); break;
case ICMAP_VALUETYPE_DOUBLE: res = sizeof(double); break;
case ICMAP_VALUETYPE_STRING:
case ICMAP_VALUETYPE_BINARY:
res = 0;
break;
}
return (res);
}
static int icmap_check_value_len(const void *value, size_t value_len, icmap_value_types_t type)
{
if (value_len > ICMAP_MAX_VALUE_LEN) {
return (-1);
}
if (type != ICMAP_VALUETYPE_STRING && type != ICMAP_VALUETYPE_BINARY) {
if (icmap_get_valuetype_len(type) == value_len) {
return (0);
} else {
return (-1);
}
}
if (type == ICMAP_VALUETYPE_STRING) {
/*
* 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);
}
static int icmap_item_eq(const struct icmap_item *item, const void *value, size_t value_len, icmap_value_types_t type)
{
size_t ptr_len;
if (item->type != type) {
return (0);
}
if (item->type == ICMAP_VALUETYPE_STRING) {
ptr_len = strlen((const char *)value);
if (ptr_len > value_len) {
ptr_len = value_len;
}
ptr_len++;
} else {
ptr_len = value_len;
}
if (item->value_len == ptr_len) {
return (memcmp(item->value, value, value_len) == 0);
};
return (0);
}
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,
icmap_value_types_t type)
{
struct icmap_item *item;
struct icmap_item *new_item;
size_t new_value_len;
size_t new_item_size;
if (value == NULL || key_name == NULL) {
return (CS_ERR_INVALID_PARAM);
}
if (icmap_check_value_len(value, value_len, type) != 0) {
return (CS_ERR_INVALID_PARAM);
}
item = qb_map_get(map->qb_map, key_name);
if (item != NULL) {
/*
* Check that key is really changed
*/
if (icmap_item_eq(item, value, value_len, type)) {
return (CS_OK);
}
} else {
if (icmap_check_key_name(key_name) != 0) {
return (CS_ERR_NAME_TOO_LONG);
}
}
if (type == ICMAP_VALUETYPE_BINARY || type == ICMAP_VALUETYPE_STRING) {
if (type == ICMAP_VALUETYPE_STRING) {
new_value_len = strlen((const char *)value);
if (new_value_len > value_len) {
new_value_len = value_len;
}
new_value_len++;
} else {
new_value_len = value_len;
}
} else {
new_value_len = icmap_get_valuetype_len(type);
}
new_item_size = sizeof(struct icmap_item) + new_value_len;
new_item = malloc(new_item_size);
if (new_item == NULL) {
return (CS_ERR_NO_MEMORY);
}
memset(new_item, 0, new_item_size);
if (item == NULL) {
new_item->key_name = strdup(key_name);
if (new_item->key_name == NULL) {
free(new_item);
return (CS_ERR_NO_MEMORY);
}
} else {
new_item->key_name = item->key_name;
item->key_name = NULL;
}
new_item->type = type;
new_item->value_len = new_value_len;
memcpy(new_item->value, value, new_value_len);
if (new_item->type == ICMAP_VALUETYPE_STRING) {
((char *)new_item->value)[new_value_len - 1] = 0;
}
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_int8_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_uint8(const char *key_name, uint8_t value)
{
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_int16_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_uint16(const char *key_name, uint16_t value)
{
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_int32_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_uint32(const char *key_name, uint32_t value)
{
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_int64_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_uint64(const char *key_name, uint64_t value)
{
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_float_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_double(const char *key_name, double value)
{
return (icmap_set_double_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_set_string(const char *key_name, const char *value)
{
return (icmap_set_string_r(icmap_global_map, key_name, value));
}
cs_error_t icmap_delete_r(const icmap_map_t map, const char *key_name)
{
struct icmap_item *item;
if (key_name == NULL) {
return (CS_ERR_INVALID_PARAM);
}
item = qb_map_get(map->qb_map, key_name);
if (item == NULL) {
return (CS_ERR_NOT_EXIST);
}
if (qb_map_rm(map->qb_map, item->key_name) != QB_TRUE) {
return (CS_ERR_NOT_EXIST);
}
return (CS_OK);
}
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,
size_t *value_len,
icmap_value_types_t *type)
{
struct icmap_item *item;
if (key_name == NULL) {
return (CS_ERR_INVALID_PARAM);
}
item = qb_map_get(map->qb_map, key_name);
if (item == NULL) {
return (CS_ERR_NOT_EXIST);
}
if (type != NULL) {
*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 = tmp_value_len;
}
} else {
if (value_len == NULL || *value_len < tmp_value_len) {
return (CS_ERR_INVALID_PARAM);
}
*value_len = tmp_value_len;
memcpy(value, tmp_value, tmp_value_len);
}
return (CS_OK);
}
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)
{
char key_value[16];
size_t key_size;
cs_error_t err;
icmap_value_types_t key_type;
key_size = sizeof(key_value);
memset(key_value, 0, key_size);
err = icmap_get_r(map, key_name, key_value, &key_size, &key_type);
if (err != CS_OK)
return (err);
if (key_type != type) {
return (CS_ERR_INVALID_PARAM);
}
memcpy(value, key_value, icmap_get_valuetype_len(key_type));
return (CS_OK);
}
cs_error_t icmap_get_int8_r(const icmap_map_t map, const char *key_name, int8_t *i8)
{
return (icmap_get_int_r(map, key_name, i8, ICMAP_VALUETYPE_INT8));
}
cs_error_t icmap_get_uint8_r(const icmap_map_t map, const char *key_name, uint8_t *u8)
{
return (icmap_get_int_r(map, key_name, u8, ICMAP_VALUETYPE_UINT8));
}
cs_error_t icmap_get_int16_r(const icmap_map_t map, const char *key_name, int16_t *i16)
{
return (icmap_get_int_r(map, key_name, i16, ICMAP_VALUETYPE_INT16));
}
cs_error_t icmap_get_uint16_r(const icmap_map_t map, const char *key_name, uint16_t *u16)
{
return (icmap_get_int_r(map, key_name, u16, ICMAP_VALUETYPE_UINT16));
}
cs_error_t icmap_get_int32_r(const icmap_map_t map, const char *key_name, int32_t *i32)
{
return (icmap_get_int_r(map, key_name, i32, ICMAP_VALUETYPE_INT32));
}
cs_error_t icmap_get_uint32_r(const icmap_map_t map, const char *key_name, uint32_t *u32)
{
return (icmap_get_int_r(map, key_name, u32, ICMAP_VALUETYPE_UINT32));
}
cs_error_t icmap_get_int64_r(const icmap_map_t map, const char *key_name, int64_t *i64)
{
return(icmap_get_int_r(map, key_name, i64, ICMAP_VALUETYPE_INT64));
}
cs_error_t icmap_get_uint64_r(const icmap_map_t map, const char *key_name, uint64_t *u64)
{
return (icmap_get_int_r(map, key_name, u64, ICMAP_VALUETYPE_UINT64));
}
cs_error_t icmap_get_float_r(const icmap_map_t map, const char *key_name, float *flt)
{
return (icmap_get_int_r(map, key_name, flt, ICMAP_VALUETYPE_FLOAT));
}
cs_error_t icmap_get_double_r(const icmap_map_t map, const char *key_name, double *dbl)
{
return (icmap_get_int_r(map, key_name, dbl, ICMAP_VALUETYPE_DOUBLE));
}
cs_error_t icmap_get_string(const char *key_name, char **str)
{
return (icmap_get_string_r(icmap_global_map, key_name, str));
}
cs_error_t icmap_get_int8(const char *key_name, int8_t *i8)
{
return (icmap_get_int8_r(icmap_global_map, key_name, i8));
}
cs_error_t icmap_get_uint8(const char *key_name, uint8_t *u8)
{
return (icmap_get_uint8_r(icmap_global_map, key_name, u8));
}
cs_error_t icmap_get_int16(const char *key_name, int16_t *i16)
{
return (icmap_get_int16_r(icmap_global_map, key_name, i16));
}
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)
{
struct icmap_item *item;
uint8_t u8;
uint16_t u16;
uint32_t u32;
uint64_t u64;
cs_error_t err = CS_OK;
if (key_name == NULL) {
return (CS_ERR_INVALID_PARAM);
}
item = qb_map_get(map->qb_map, key_name);
if (item == NULL) {
return (CS_ERR_NOT_EXIST);
}
switch (item->type) {
case ICMAP_VALUETYPE_INT8:
case ICMAP_VALUETYPE_UINT8:
memcpy(&u8, item->value, sizeof(u8));
u8 += step;
err = icmap_set(key_name, &u8, sizeof(u8), item->type);
break;
case ICMAP_VALUETYPE_INT16:
case ICMAP_VALUETYPE_UINT16:
memcpy(&u16, item->value, sizeof(u16));
u16 += step;
err = icmap_set(key_name, &u16, sizeof(u16), item->type);
break;
case ICMAP_VALUETYPE_INT32:
case ICMAP_VALUETYPE_UINT32:
memcpy(&u32, item->value, sizeof(u32));
u32 += step;
err = icmap_set(key_name, &u32, sizeof(u32), item->type);
break;
case ICMAP_VALUETYPE_INT64:
case ICMAP_VALUETYPE_UINT64:
memcpy(&u64, item->value, sizeof(u64));
u64 += step;
err = icmap_set(key_name, &u64, sizeof(u64), item->type);
break;
case ICMAP_VALUETYPE_FLOAT:
case ICMAP_VALUETYPE_DOUBLE:
case ICMAP_VALUETYPE_STRING:
case ICMAP_VALUETYPE_BINARY:
err = CS_ERR_INVALID_PARAM;
break;
}
return (err);
}
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)
{
struct icmap_item *item;
cs_error_t err = CS_OK;
if (key_name == NULL) {
return (CS_ERR_INVALID_PARAM);
}
item = qb_map_get(map->qb_map, key_name);
if (item == NULL) {
return (CS_ERR_NOT_EXIST);
}
switch (item->type) {
case ICMAP_VALUETYPE_INT8:
case ICMAP_VALUETYPE_UINT8:
*(uint8_t *)item->value += step;
break;
case ICMAP_VALUETYPE_INT16:
case ICMAP_VALUETYPE_UINT16:
*(uint16_t *)item->value += step;
break;
case ICMAP_VALUETYPE_INT32:
case ICMAP_VALUETYPE_UINT32:
*(uint32_t *)item->value += step;
break;
case ICMAP_VALUETYPE_INT64:
case ICMAP_VALUETYPE_UINT64:
*(uint64_t *)item->value += step;
break;
case ICMAP_VALUETYPE_FLOAT:
case ICMAP_VALUETYPE_DOUBLE:
case ICMAP_VALUETYPE_STRING:
case ICMAP_VALUETYPE_BINARY:
err = CS_ERR_INVALID_PARAM;
break;
}
if (err == CS_OK) {
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_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_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_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_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 (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;
const char *res;
res = qb_map_iter_next(iter, (void **)&item);
if (res == NULL) {
return (res);
}
if (value_len != NULL) {
*value_len = item->value_len;
}
if (type != NULL) {
*type = item->type;
}
return (res);
}
void icmap_iter_finalize(icmap_iter_t iter)
{
qb_map_iter_free(iter);
}
static void icmap_notify_fn(uint32_t event, char *key, void *old_value, void *value, void *user_data)
{
icmap_track_t icmap_track = (icmap_track_t)user_data;
struct icmap_item *new_item = (struct icmap_item *)value;
struct icmap_item *old_item = (struct icmap_item *)old_value;
struct icmap_notify_value new_val;
struct icmap_notify_value old_val;
if (value == NULL && old_value == NULL) {
return ;
}
if (new_item != NULL) {
new_val.type = new_item->type;
new_val.len = new_item->value_len;
new_val.data = new_item->value;
} else {
memset(&new_val, 0, sizeof(new_val));
}
/*
* old_item == new_item if fast functions are used -> don't fill old value
*/
if (old_item != NULL && old_item != new_item) {
old_val.type = old_item->type;
old_val.len = old_item->value_len;
old_val.data = old_item->value;
} else {
memset(&old_val, 0, sizeof(old_val));
}
icmap_track->notify_fn(icmap_qbtt_to_tt(event),
key,
new_val,
old_val,
icmap_track->user_data);
}
cs_error_t icmap_track_add(
const char *key_name,
int32_t track_type,
icmap_notify_fn_t notify_fn,
void *user_data,
icmap_track_t *icmap_track)
{
int32_t err;
if (notify_fn == NULL || icmap_track == NULL) {
return (CS_ERR_INVALID_PARAM);
}
if ((track_type & ~(ICMAP_TRACK_ADD | ICMAP_TRACK_DELETE | ICMAP_TRACK_MODIFY | ICMAP_TRACK_PREFIX)) != 0) {
return (CS_ERR_INVALID_PARAM);
}
*icmap_track = malloc(sizeof(**icmap_track));
if (*icmap_track == NULL) {
return (CS_ERR_NO_MEMORY);
}
memset(*icmap_track, 0, sizeof(**icmap_track));
if (key_name != NULL) {
(*icmap_track)->key_name = strdup(key_name);
};
(*icmap_track)->track_type = track_type;
(*icmap_track)->notify_fn = notify_fn;
(*icmap_track)->user_data = user_data;
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));
}
qb_list_init(&(*icmap_track)->list);
qb_list_add (&(*icmap_track)->list, &icmap_track_list_head);
return (CS_OK);
}
cs_error_t icmap_track_delete(icmap_track_t icmap_track)
{
int32_t err;
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));
}
qb_list_del(&icmap_track->list);
free(icmap_track->key_name);
free(icmap_track);
return (CS_OK);
}
void *icmap_track_get_user_data(icmap_track_t icmap_track)
{
return (icmap_track->user_data);
}
cs_error_t icmap_set_ro_access(const char *key_name, int prefix, int ro_access)
{
struct qb_list_head *iter, *tmp_iter;
struct icmap_ro_access_item *icmap_ro_ai;
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) {
/*
* We found item
*/
if (ro_access) {
return (CS_ERR_EXIST);
} else {
qb_list_del(&icmap_ro_ai->list);
free(icmap_ro_ai->key_name);
free(icmap_ro_ai);
return (CS_OK);
}
}
}
if (!ro_access) {
return (CS_ERR_NOT_EXIST);
}
icmap_ro_ai = malloc(sizeof(*icmap_ro_ai));
if (icmap_ro_ai == NULL) {
return (CS_ERR_NO_MEMORY);
}
memset(icmap_ro_ai, 0, sizeof(*icmap_ro_ai));
icmap_ro_ai->key_name = strdup(key_name);
if (icmap_ro_ai->key_name == NULL) {
free(icmap_ro_ai);
return (CS_ERR_NO_MEMORY);
}
icmap_ro_ai->prefix = prefix;
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 qb_list_head *iter;
struct icmap_ro_access_item *icmap_ro_ai;
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))
continue;
if (strncmp(icmap_ro_ai->key_name, key_name, strlen(icmap_ro_ai->key_name)) == 0) {
return (CS_TRUE);
}
} else {
if (strcmp(icmap_ro_ai->key_name, key_name) == 0) {
return (CS_TRUE);
}
}
}
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);
}
config.h
corotypes.h
CS_FALSE
#define CS_FALSE
Definition: corotypes.h:53
qb_to_cs_error
cs_error_t qb_to_cs_error(int result)
qb_to_cs_error
CS_TRUE
#define CS_TRUE
Definition: corotypes.h:54
cs_error_t
cs_error_t
The cs_error_t enum.
Definition: corotypes.h:98
CS_ERR_NAME_TOO_LONG
@ CS_ERR_NAME_TOO_LONG
Definition: corotypes.h:111
CS_ERR_NO_MEMORY
@ CS_ERR_NO_MEMORY
Definition: corotypes.h:106
CS_OK
@ CS_OK
Definition: corotypes.h:99
CS_ERR_INVALID_PARAM
@ CS_ERR_INVALID_PARAM
Definition: corotypes.h:105
CS_ERR_NOT_EXIST
@ CS_ERR_NOT_EXIST
Definition: corotypes.h:110
CS_ERR_INIT
@ CS_ERR_INIT
Definition: corotypes.h:102
CS_ERR_EXIST
@ CS_ERR_EXIST
Definition: corotypes.h:112
value
uint32_t value
Definition: exec/votequorum.c:2
icmap_tt_to_qbtt
int32_t icmap_tt_to_qbtt(int32_t track_type)
Definition: icmap.c:127
icmap_set_int8_r
cs_error_t icmap_set_int8_r(const icmap_map_t map, const char *key_name, int8_t value)
Definition: icmap.c:497
icmap_iter_init_r
icmap_iter_t icmap_iter_init_r(const icmap_map_t map, const char *prefix)
icmap_iter_init_r
Definition: icmap.c:1084
icmap_get_uint8
cs_error_t icmap_get_uint8(const char *key_name, uint8_t *u8)
Definition: icmap.c:868
icmap_get_string_r
cs_error_t icmap_get_string_r(icmap_map_t map, const char *key_name, char **str)
Definition: icmap.c:735
icmap_fast_adjust_int_r
cs_error_t icmap_fast_adjust_int_r(const icmap_map_t map, const char *key_name, int32_t step)
icmap_fast_adjust_int_r
Definition: icmap.c:987
icmap_get_uint16
cs_error_t icmap_get_uint16(const char *key_name, uint16_t *u16)
Definition: icmap.c:880
icmap_get_float_r
cs_error_t icmap_get_float_r(const icmap_map_t map, const char *key_name, float *flt)
Definition: icmap.c:844
icmap_get_uint32
cs_error_t icmap_get_uint32(const char *key_name, uint32_t *u32)
Definition: icmap.c:892
icmap_set_int16_r
cs_error_t icmap_set_int16_r(const icmap_map_t map, const char *key_name, int16_t value)
Definition: icmap.c:509
icmap_set_uint8
cs_error_t icmap_set_uint8(const char *key_name, uint8_t value)
Definition: icmap.c:573
icmap_set_uint16_r
cs_error_t icmap_set_uint16_r(const icmap_map_t map, const char *key_name, uint16_t value)
Definition: icmap.c:515
icmap_set
cs_error_t icmap_set(const char *key_name, const void *value, size_t value_len, icmap_value_types_t type)
Store value with value_len length and type as key_name name in global icmap.
Definition: icmap.c:487
icmap_adjust_int
cs_error_t icmap_adjust_int(const char *key_name, int32_t step)
icmap_adjust_int
Definition: icmap.c:979
icmap_get_int64
cs_error_t icmap_get_int64(const char *key_name, int64_t *i64)
Definition: icmap.c:898
icmap_set_ro_access
cs_error_t icmap_set_ro_access(const char *key_name, int prefix, int ro_access)
Set read-only access for given key (key_name) or prefix, If prefix is set.
Definition: icmap.c:1225
icmap_set_uint32_r
cs_error_t icmap_set_uint32_r(const icmap_map_t map, const char *key_name, uint32_t value)
Definition: icmap.c:527
icmap_delete
cs_error_t icmap_delete(const char *key_name)
Delete key from map.
Definition: icmap.c:653
icmap_fast_dec_r
cs_error_t icmap_fast_dec_r(const icmap_map_t map, const char *key_name)
icmap_fast_dec_r
Definition: icmap.c:1074
icmap_set_float_r
cs_error_t icmap_set_float_r(const icmap_map_t map, const char *key_name, float value)
Definition: icmap.c:545
ICMAP_MAX_VALUE_LEN
#define ICMAP_MAX_VALUE_LEN
Definition: icmap.c:46
icmap_set_int32
cs_error_t icmap_set_int32(const char *key_name, int32_t value)
Definition: icmap.c:591
icmap_delete_r
cs_error_t icmap_delete_r(const icmap_map_t map, const char *key_name)
icmap_delete_r
Definition: icmap.c:633
icmap_get_uint8_r
cs_error_t icmap_get_uint8_r(const icmap_map_t map, const char *key_name, uint8_t *u8)
Definition: icmap.c:802
icmap_set_uint8_r
cs_error_t icmap_set_uint8_r(const icmap_map_t map, const char *key_name, uint8_t value)
Definition: icmap.c:503
icmap_set_uint16
cs_error_t icmap_set_uint16(const char *key_name, uint16_t value)
Definition: icmap.c:585
icmap_dec_r
cs_error_t icmap_dec_r(const icmap_map_t map, const char *key_name)
icmap_dec_r
Definition: icmap.c:1054
icmap_set_int64
cs_error_t icmap_set_int64(const char *key_name, int64_t value)
Definition: icmap.c:603
icmap_track_add
cs_error_t icmap_track_add(const char *key_name, int32_t track_type, icmap_notify_fn_t notify_fn, void *user_data, icmap_track_t *icmap_track)
Add tracking function for given key_name.
Definition: icmap.c:1159
icmap_set_string
cs_error_t icmap_set_string(const char *key_name, const char *value)
Definition: icmap.c:627
icmap_set_r
cs_error_t icmap_set_r(const icmap_map_t map, const char *key_name, const void *value, size_t value_len, icmap_value_types_t type)
Reentrant version of icmap_set.
Definition: icmap.c:407
icmap_qbtt_to_tt
int32_t icmap_qbtt_to_tt(int32_t track_type)
Definition: icmap.c:150
icmap_inc
cs_error_t icmap_inc(const char *key_name)
Increase stored value by one.
Definition: icmap.c:1049
icmap_set_int64_r
cs_error_t icmap_set_int64_r(const icmap_map_t map, const char *key_name, int64_t value)
Definition: icmap.c:533
icmap_set_double
cs_error_t icmap_set_double(const char *key_name, double value)
Definition: icmap.c:621
icmap_set_int8
cs_error_t icmap_set_int8(const char *key_name, int8_t value)
Definition: icmap.c:567
icmap_get_valuetype_len
size_t icmap_get_valuetype_len(icmap_value_types_t type)
Definition: icmap.c:306
icmap_key_value_eq
int icmap_key_value_eq(const icmap_map_t map1, const char *key_name1, const icmap_map_t map2, const char *key_name2)
Compare value of key with name key_name1 in map1 with key with name key_name2 in map2.
Definition: icmap.c:385
icmap_get_float
cs_error_t icmap_get_float(const char *key_name, float *flt)
Definition: icmap.c:910
icmap_get_double
cs_error_t icmap_get_double(const char *key_name, double *dbl)
Definition: icmap.c:916
icmap_get_int8_r
cs_error_t icmap_get_int8_r(const icmap_map_t map, const char *key_name, int8_t *i8)
Definition: icmap.c:796
icmap_set_uint64_r
cs_error_t icmap_set_uint64_r(const icmap_map_t map, const char *key_name, uint64_t value)
Definition: icmap.c:539
icmap_fast_dec
cs_error_t icmap_fast_dec(const char *key_name)
Decrease stored value by one.
Definition: icmap.c:1079
icmap_iter_init
icmap_iter_t icmap_iter_init(const char *prefix)
Initialize iterator with given prefix.
Definition: icmap.c:1089
icmap_set_double_r
cs_error_t icmap_set_double_r(const icmap_map_t map, const char *key_name, double value)
Definition: icmap.c:551
icmap_get_uint16_r
cs_error_t icmap_get_uint16_r(const icmap_map_t map, const char *key_name, uint16_t *u16)
Definition: icmap.c:814
icmap_copy_map
cs_error_t icmap_copy_map(icmap_map_t dst_map, const icmap_map_t src_map)
Copy content of src_map icmap to dst_map icmap.
Definition: icmap.c:1298
icmap_init_r
cs_error_t icmap_init_r(icmap_map_t *result)
Initialize additional (local, reentrant) icmap_map.
Definition: icmap.c:188
icmap_set_int32_r
cs_error_t icmap_set_int32_r(const icmap_map_t map, const char *key_name, int32_t value)
Definition: icmap.c:521
icmap_get_int64_r
cs_error_t icmap_get_int64_r(const icmap_map_t map, const char *key_name, int64_t *i64)
Definition: icmap.c:832
icmap_iter_next
const char * icmap_iter_next(icmap_iter_t iter, size_t *value_len, icmap_value_types_t *type)
Return next item in iterator iter.
Definition: icmap.c:1095
icmap_convert_name_to_valid_name
void icmap_convert_name_to_valid_name(char *key_name)
Converts given key_name to valid key name (replacing all prohibited characters by _)
Definition: icmap.c:278
icmap_fast_adjust_int
cs_error_t icmap_fast_adjust_int(const char *key_name, int32_t step)
icmap_fast_adjust_int
Definition: icmap.c:1036
icmap_fast_inc
cs_error_t icmap_fast_inc(const char *key_name)
Increase stored value by one.
Definition: icmap.c:1069
icmap_inc_r
cs_error_t icmap_inc_r(const icmap_map_t map, const char *key_name)
icmap_inc_r
Definition: icmap.c:1044
icmap_get_global_map
icmap_map_t icmap_get_global_map(void)
Return global icmap.
Definition: icmap.c:264
icmap_get
cs_error_t icmap_get(const char *key_name, void *value, size_t *value_len, icmap_value_types_t *type)
Retrieve value of key key_name and store it in user preallocated value pointer.
Definition: icmap.c:725
icmap_get_double_r
cs_error_t icmap_get_double_r(const icmap_map_t map, const char *key_name, double *dbl)
Definition: icmap.c:850
icmap_set_string_r
cs_error_t icmap_set_string_r(const icmap_map_t map, const char *key_name, const char *value)
Definition: icmap.c:557
icmap_iter_finalize
void icmap_iter_finalize(icmap_iter_t iter)
Finalize iterator.
Definition: icmap.c:1116
icmap_fini_r
void icmap_fini_r(const icmap_map_t map)
Finalize local, reentrant icmap.
Definition: icmap.c:238
icmap_get_int32_r
cs_error_t icmap_get_int32_r(const icmap_map_t map, const char *key_name, int32_t *i32)
Definition: icmap.c:820
icmap_get_r
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)
Same as icmap_get but it's reentrant and operates on given icmap_map.
Definition: icmap.c:692
icmap_get_int32
cs_error_t icmap_get_int32(const char *key_name, int32_t *i32)
Definition: icmap.c:886
icmap_track_get_user_data
void * icmap_track_get_user_data(icmap_track_t icmap_track)
Return user data associated with given track.
Definition: icmap.c:1220
icmap_init
cs_error_t icmap_init(void)
Initialize global icmap.
Definition: icmap.c:208
icmap_track_delete
cs_error_t icmap_track_delete(icmap_track_t icmap_track)
Remove previously added track.
Definition: icmap.c:1204
icmap_set_uint64
cs_error_t icmap_set_uint64(const char *key_name, uint64_t value)
Definition: icmap.c:609
icmap_dec
cs_error_t icmap_dec(const char *key_name)
Decrease stored value by one.
Definition: icmap.c:1059
icmap_fini
void icmap_fini(void)
Finalize global icmap.
Definition: icmap.c:247
icmap_get_uint32_r
cs_error_t icmap_get_uint32_r(const icmap_map_t map, const char *key_name, uint32_t *u32)
Definition: icmap.c:826
icmap_get_uint64_r
cs_error_t icmap_get_uint64_r(const icmap_map_t map, const char *key_name, uint64_t *u64)
Definition: icmap.c:838
QB_LIST_DECLARE
QB_LIST_DECLARE(icmap_ro_access_item_list_head)
icmap_get_int16_r
cs_error_t icmap_get_int16_r(const icmap_map_t map, const char *key_name, int16_t *i16)
Definition: icmap.c:808
icmap_set_uint32
cs_error_t icmap_set_uint32(const char *key_name, uint32_t value)
Definition: icmap.c:597
icmap_set_int16
cs_error_t icmap_set_int16(const char *key_name, int16_t value)
Definition: icmap.c:579
icmap_get_uint64
cs_error_t icmap_get_uint64(const char *key_name, uint64_t *u64)
Definition: icmap.c:904
icmap_get_string
cs_error_t icmap_get_string(const char *key_name, char **str)
Shortcut for icmap_get for string type.
Definition: icmap.c:856
icmap_get_int16
cs_error_t icmap_get_int16(const char *key_name, int16_t *i16)
Definition: icmap.c:874
icmap_adjust_int_r
cs_error_t icmap_adjust_int_r(const icmap_map_t map, const char *key_name, int32_t step)
icmap_adjust_int_r
Definition: icmap.c:922
icmap_is_key_ro
int icmap_is_key_ro(const char *key_name)
Check in given key is read only.
Definition: icmap.c:1272
icmap_set_float
cs_error_t icmap_set_float(const char *key_name, float value)
Definition: icmap.c:615
icmap_get_int8
cs_error_t icmap_get_int8(const char *key_name, int8_t *i8)
Definition: icmap.c:862
icmap_fast_inc_r
cs_error_t icmap_fast_inc_r(const icmap_map_t map, const char *key_name)
icmap_fast_inc_r
Definition: icmap.c:1064
icmap.h
ICMAP_TRACK_MODIFY
#define ICMAP_TRACK_MODIFY
Definition: icmap.h:78
ICMAP_KEYNAME_MINLEN
#define ICMAP_KEYNAME_MINLEN
Minimum lenght of key in icmap.
Definition: icmap.h:53
icmap_value_types_t
icmap_value_types_t
Possible types of value.
Definition: icmap.h:58
ICMAP_VALUETYPE_UINT64
@ ICMAP_VALUETYPE_UINT64
Definition: icmap.h:66
ICMAP_VALUETYPE_BINARY
@ ICMAP_VALUETYPE_BINARY
Definition: icmap.h:70
ICMAP_VALUETYPE_UINT8
@ ICMAP_VALUETYPE_UINT8
Definition: icmap.h:60
ICMAP_VALUETYPE_INT8
@ ICMAP_VALUETYPE_INT8
Definition: icmap.h:59
ICMAP_VALUETYPE_INT16
@ ICMAP_VALUETYPE_INT16
Definition: icmap.h:61
ICMAP_VALUETYPE_UINT32
@ ICMAP_VALUETYPE_UINT32
Definition: icmap.h:64
ICMAP_VALUETYPE_STRING
@ ICMAP_VALUETYPE_STRING
Definition: icmap.h:69
ICMAP_VALUETYPE_FLOAT
@ ICMAP_VALUETYPE_FLOAT
Definition: icmap.h:67
ICMAP_VALUETYPE_INT64
@ ICMAP_VALUETYPE_INT64
Definition: icmap.h:65
ICMAP_VALUETYPE_DOUBLE
@ ICMAP_VALUETYPE_DOUBLE
Definition: icmap.h:68
ICMAP_VALUETYPE_UINT16
@ ICMAP_VALUETYPE_UINT16
Definition: icmap.h:62
ICMAP_VALUETYPE_INT32
@ ICMAP_VALUETYPE_INT32
Definition: icmap.h:63
ICMAP_TRACK_DELETE
#define ICMAP_TRACK_DELETE
Definition: icmap.h:77
ICMAP_TRACK_PREFIX
#define ICMAP_TRACK_PREFIX
Whole prefix is tracked, instead of key only (so "totem." tracking means that "totem....
Definition: icmap.h:85
icmap_notify_fn_t
void(* icmap_notify_fn_t)(int32_t event, const char *key_name, struct icmap_notify_value new_value, struct icmap_notify_value old_value, void *user_data)
Prototype for notify callback function.
Definition: icmap.h:103
icmap_iter_t
qb_map_iter_t * icmap_iter_t
Itterator type.
Definition: icmap.h:123
icmap_track_t
struct icmap_track * icmap_track_t
Track type.
Definition: icmap.h:128
ICMAP_KEYNAME_MAXLEN
#define ICMAP_KEYNAME_MAXLEN
Maximum length of key in icmap.
Definition: icmap.h:48
ICMAP_TRACK_ADD
#define ICMAP_TRACK_ADD
Definition: icmap.h:76
user_data
void * user_data
Definition: sam.c:127
icmap_item
Definition: icmap.c:48
icmap_item::value
char value[]
Definition: icmap.c:52
icmap_item::type
icmap_value_types_t type
Definition: icmap.c:50
icmap_item::value_len
size_t value_len
Definition: icmap.c:51
icmap_item::key_name
char * key_name
Definition: icmap.c:49
icmap_map
Definition: icmap.c:55
icmap_map::qb_map
qb_map_t * qb_map
Definition: icmap.c:56
icmap_notify_value
Structure passed as new_value and old_value in change callback.
Definition: icmap.h:91
icmap_notify_value::type
icmap_value_types_t type
Definition: icmap.h:92
icmap_ro_access_item
Definition: icmap.c:69
icmap_ro_access_item::key_name
char * key_name
Definition: icmap.c:70
icmap_ro_access_item::prefix
int prefix
Definition: icmap.c:71
icmap_ro_access_item::list
struct qb_list_head list
Definition: icmap.c:72
icmap_track
Definition: icmap.c:61
icmap_track::list
struct qb_list_head list
Definition: icmap.c:66
icmap_track::user_data
void * user_data
Definition: icmap.c:65
icmap_track::notify_fn
icmap_notify_fn_t notify_fn
Definition: icmap.c:64
icmap_track::key_name
char * key_name
Definition: icmap.c:62
icmap_track::track_type
int32_t track_type
Definition: icmap.c:63
type
char type
Definition: totem.h:2