Browse Source

stringpair_t and stringpair_map_t

async_key_management
vb 7 years ago
parent
commit
e728f94dd1
2 changed files with 480 additions and 0 deletions
  1. +354
    -0
      src/transport.c
  2. +126
    -0
      src/transport.h

+ 354
- 0
src/transport.c View File

@ -193,6 +193,360 @@ DYNAMIC_API bloblist_t *bloblist_add(bloblist_t *bloblist, char *blob, size_t si
return bloblist_add(bloblist->next, blob, size, mime_type, file_name);
}
DYNAMIC_API stringpair_t * new_stringpair(const char *key, const char *value)
{
stringpair_t *pair = NULL;
assert(key);
assert(value),
pair = calloc(1, sizeof(stringpair_t));
assert(pair);
if (pair == NULL)
goto enomem;
pair->key = strdup(key);
assert(pair->key);
if (pair->key == NULL)
goto enomem;
pair->value = strdup(value);
assert(pair->value);
if (pair->value == NULL)
goto enomem;
return pair;
enomem:
free_stringpair(pair);
return NULL;
}
DYNAMIC_API void free_stringpair(stringpair_t * pair)
{
if (pair) {
free(pair->key);
free(pair->value);
free(pair);
}
}
DYNAMIC_API stringpair_t * stringpair_dup(const stringpair_t *src)
{
assert(src);
return new_stringpair(src->key, src->value);
}
DYNAMIC_API stringpair_map_t * new_stringpair_map(const stringpair_t *pair)
{
stringpair_map_t *map = NULL;
map = calloc(1, sizeof(stringpair_map_t));
assert(map);
if (map == NULL)
goto enomem;
if (pair) {
map->pair = stringpair_dup(pair);
if (map->pair == NULL)
goto enomem;
}
return map;
enomem:
free_stringpair_map(map);
return NULL;
}
DYNAMIC_API void free_stringpair_map(stringpair_map_t *map)
{
if (map) {
free_stringpair_map(map->left);
free_stringpair_map(map->right);
free_stringpair(map->pair);
free(map);
}
}
static stringpair_map_t * _stringpair_map_dup(
const stringpair_map_t *src,
stringpair_map_t *parent
)
{
stringpair_map_t *map = NULL;
assert(src);
map = new_stringpair_map(src->pair);
if (map == NULL)
goto enomem;
map->color = src->color;
if (src->left) {
map->left = _stringpair_map_dup(src->left, map);
if (map->left == NULL)
goto enomem;
}
if (src->right) {
map->right = _stringpair_map_dup(src->right, map);
if (map->right == NULL)
goto enomem;
}
map->parent_ref = parent;
return map;
enomem:
free_stringpair_map(map);
return NULL;
}
DYNAMIC_API stringpair_map_t * stringpair_map_dup(const stringpair_map_t *src)
{
return _stringpair_map_dup(src, NULL);
}
static bool stringpair_map_is_leave(const stringpair_map_t *node)
{
assert(node);
return node->left == NULL && node->right == NULL;
}
DYNAMIC_API stringpair_map_t * stringpair_map_find(
stringpair_map_t *map,
const char *key
)
{
int c;
assert(key);
if (map == NULL || map->pair == NULL) // empty map
return NULL;
c = strcmp(map->pair->key, key);
if (c == 0)
return map;
else if (c < 0)
return stringpair_map_find(map->left, key);
else
return stringpair_map_find(map->right, key);
}
static stringpair_map_t * stringpair_map_grandparent(stringpair_map_t *node)
{
assert(node);
if (node->parent_ref == NULL)
return NULL;
return node->parent_ref->parent_ref;
}
static stringpair_map_t * stringpair_map_uncle(stringpair_map_t *node)
{
assert(stringpair_map_grandparent(node));
if (node->parent_ref == stringpair_map_grandparent(node)->left)
return stringpair_map_grandparent(node)->right;
else
return stringpair_map_grandparent(node)->left;
}
static stringpair_map_t * _stringpair_map_add(
stringpair_map_t *map,
stringpair_t * pair
)
{
int c;
assert(map);
assert(pair);
if (map->pair == NULL) {
map->pair = stringpair_dup(pair);
if (map->pair == NULL)
return NULL;
return map;
}
assert(map->pair->key);
assert(pair->key);
c = strcmp(map->pair->key, pair->key);
if (c == 0) {
free(map->pair->value);
assert(pair->value);
map->pair->value = strdup(pair->value);
assert(map->pair->value);
if (map->pair->value == NULL)
return NULL;
}
else if (c < 0) {
if (map->left == NULL) {
map->left = new_stringpair_map(pair);
if (map->left)
return NULL;
map = map->left;
}
else {
map = _stringpair_map_add(map->left, pair);
}
}
else {
if (map->right == NULL) {
map->right = new_stringpair_map(pair);
if (map->right)
return NULL;
map = map->right;
}
else {
map = _stringpair_map_add(map->right, pair);
}
}
return map;
}
static void stringpair_map_rotate_left(stringpair_map_t *l)
{
stringpair_map_t * _parent;
stringpair_map_t * _r;
assert(l);
assert(l->parent_ref);
assert(l->right);
_parent = l->parent_ref;
_r = l->right;
l->right = _r->left;
_r->left = l;
if (_parent->left == l)
_parent->left = _r;
else
_parent->right = _r;
}
static void stringpair_map_rotate_right(stringpair_map_t *r)
{
stringpair_map_t * _parent;
stringpair_map_t * _l;
assert(r);
assert(r->parent_ref);
assert(r->left);
_parent = r->parent_ref;
_l = r->left;
r->left = _l->right;
_l->right = r;
if (_parent->left == r)
_parent->left = _l;
else
_parent->right = _l;
}
static void stringpair_map_case5(stringpair_map_t *map)
{
map->parent_ref->color = rbt_black;
stringpair_map_grandparent(map)->color = rbt_red;
if (map == map->parent_ref->left &&
map->parent_ref == stringpair_map_grandparent(map)->left) {
stringpair_map_rotate_right(stringpair_map_grandparent(map));
}
else {
assert(map == map->parent_ref->right &&
map->parent_ref == stringpair_map_grandparent(map)->right);
stringpair_map_rotate_left(stringpair_map_grandparent(map));
}
}
static void stringpair_map_case4(stringpair_map_t *map)
{
if (map == map->parent_ref->right &&
map->parent_ref == stringpair_map_grandparent(map)->left) {
stringpair_map_rotate_left(map->parent_ref);
map = map->left;
}
else if (map == map->parent_ref->left &&
map->parent_ref == stringpair_map_grandparent(map)->right) {
stringpair_map_rotate_right(map->parent_ref);
map = map->right;
}
stringpair_map_case5(map);
}
static void stringpair_map_case1(stringpair_map_t *map);
static void stringpair_map_case3(stringpair_map_t *map)
{
if (stringpair_map_uncle(map) != NULL &&
stringpair_map_uncle(map)->color == rbt_red) {
map->parent_ref->color = rbt_black;
stringpair_map_uncle(map)->color = rbt_black;
stringpair_map_grandparent(map)->color = rbt_red;
stringpair_map_case1(stringpair_map_grandparent(map));
}
else {
stringpair_map_case4(map);
}
}
static void stringpair_map_case2(stringpair_map_t *map)
{
if (map->parent_ref->color == rbt_black)
return;
else
stringpair_map_case3(map);
}
static void stringpair_map_case1(stringpair_map_t *map)
{
assert(map);
if (map->parent_ref == NULL)
map->color = rbt_black;
else
stringpair_map_case2(map);
}
static void stringpair_map_repair(stringpair_map_t *map)
{
stringpair_map_case1(map);
}
DYNAMIC_API stringpair_map_t * stringpair_map_add(
stringpair_map_t *map,
stringpair_t * pair
)
{
stringpair_map_t * _map = NULL;
assert(map);
assert(pair);
_map = _stringpair_map_add(map, pair);
if (_map == NULL)
return NULL;
stringpair_map_repair(_map);
return _map;
}
DYNAMIC_API message *new_message(
PEP_msg_direction dir,
pEp_identity *from,


+ 126
- 0
src/transport.h View File

@ -22,6 +22,7 @@ typedef enum _PEP_transports {
typedef struct _PEP_transport_t PEP_transport_t;
typedef struct _identity_list {
pEp_identity *ident;
struct _identity_list *next;
@ -163,6 +164,131 @@ DYNAMIC_API bloblist_t *bloblist_add(bloblist_t *bloblist, char *blob, size_t si
const char *mime_type, const char *file_name);
typedef struct _stringpair_t {
char * key;
char * value;
} stringpair_t;
// new_stringpair() - allocate new stringpair_t
//
// parameters:
// key (in) utf-8 string used as key
// value (in) utf-8 string containing the value
//
// return value:
// pointer to stringpair_t or NULL on failure
//
// caveat:
// key and value are copied and remain in the ownership of the caller
DYNAMIC_API stringpair_t * new_stringpair(const char *key, const char *value);
// free_stringpair() - free memory allocated by stringpair_t
//
// parameters:
// pair (in) pointer to stringpair_t to free
DYNAMIC_API void free_stringpair(stringpair_t * pair);
// stringpair_dup() - duplicate stringpair_t (deep copy)
//
// parameters:
// src (in) pointer to stringpair_t to duplicate
//
// return value:
// pointer to copy of src or NULL on failure
DYNAMIC_API stringpair_t * stringpair_dup(const stringpair_t *src);
typedef enum _rbt_color_t {
rbt_red = 0,
rbt_black
} rbt_color_t;
// stringpair_map_t is implemented as red-black-tree
typedef struct _stringpair_map_t {
rbt_color_t color;
struct _stringpair_map_t *parent_ref;
struct _stringpair_map_t *left;
struct _stringpair_map_t *right;
stringpair_t *pair;
} stringpair_map_t;
// new_stringpair_map() - allocate root node of new stringpair_map_t
//
// parameters:
// pair (in) optional pointer to pair for root node or NULL
//
// return value:
// pointer to rood node of new stringpair_map_t or NULL on failure
//
// caveat:
// if a pair is given it is being copied; the original remains in the
// ownership of the caller
DYNAMIC_API stringpair_map_t * new_stringpair_map(const stringpair_t *pair);
// free_stringpair_map() - free memory allocated by stringpair_map_t
//
// parameters:
// map (in) pointer to stringpair_map_t to release
DYNAMIC_API void free_stringpair_map(stringpair_map_t *map);
// stringpair_map_dup() - duplicate stringpair_map_t (deep copy)
//
// parameters:
// src (in) pointer to stringpair_map_t to duplicate
//
// return value:
// pointer to copy of src of NULL on failure
DYNAMIC_API stringpair_map_t * stringpair_map_dup(const stringpair_map_t *src);
// stringpair_map_find() - find node with key
//
// parameters:
// map (in) pointer to map to search
// key (in) pointer to key to search for
//
// return value:
// pointer to node with result or NULL if not found
DYNAMIC_API stringpair_map_t * stringpair_map_find(
stringpair_map_t *map,
const char *key
);
// stringpair_map_add() - add stringpair_t to map
//
// parameters:
// map (in) pointer to map to add to
// pair (in) pointer to pair to add
//
// return value:
// pointer to node with added value
//
// caveat:
// a copy of pair is added to the map; the original pair remains in the
// ownership of the caller
DYNAMIC_API stringpair_map_t * stringpair_map_add(
stringpair_map_t *map,
stringpair_t * pair
);
typedef enum _PEP_enc_format {
PEP_enc_none = 0, // message is in pieces and nor
// encoded nor encrypted


Loading…
Cancel
Save