From 595a94d8fc3926126a1fd09e7899f0b0a12bc034 Mon Sep 17 00:00:00 2001 From: Jusung Son Date: Tue, 19 Nov 2019 19:36:43 +0900 Subject: Reduce module circular dependency Change-Id: I021334085ffd219e6669b9561425999a4f3ae692 Signed-off-by: Jusung Son --- common/cache.c | 29 +++++++++++----------- common/cache.h | 12 +++++---- common/common.c | 20 +++++++++++++-- common/common.h | 38 ++++++++++++++++++++++++++-- common/direct.c | 72 ++++++++++++++++++++++++++---------------------------- common/direct.h | 2 -- common/serialize.c | 56 ++++++++++++++++++++---------------------- common/serialize.h | 2 -- lib/buxton2.c | 4 +-- 9 files changed, 139 insertions(+), 96 deletions(-) diff --git a/common/cache.c b/common/cache.c index feaf410..160f9e7 100644 --- a/common/cache.c +++ b/common/cache.c @@ -23,7 +23,6 @@ #include -#include "buxton2.h" #include "log.h" #include "cache.h" #include "buxton_error.h" @@ -38,13 +37,13 @@ typedef struct _cache { GHashTable *hash_table; - enum buxton_layer_type layer_type; + enum layer_attribute_type layer_type; int count; int size; } bxt_cache; typedef struct _cache_data { - enum buxton_layer_type layer_type; + enum layer_attribute_type layer_type; int len; /* data size */ void *data; /* raw data */ } cache_data; @@ -52,9 +51,9 @@ typedef struct _cache_data { static bxt_cache *g_base_db_cache; static bxt_cache *g_normal_db_cache; -static bxt_cache *get_cache(enum buxton_layer_type layer_type) +static bxt_cache *get_cache(enum layer_attribute_type layer_type) { - return (layer_type == BUXTON_LAYER_NORMAL) ? + return (layer_type == LAYER_ATTRIBUTE_RW) ? g_normal_db_cache : g_base_db_cache; } @@ -116,7 +115,7 @@ void cache_init(void) g_normal_db_cache->count = 0; } -void cache_remove(enum buxton_layer_type layer_type, const char *key) +void cache_remove(enum layer_attribute_type layer_type, const char *key) { GHashTable *hash_table = NULL; @@ -132,13 +131,13 @@ void cache_remove(enum buxton_layer_type layer_type, const char *key) if (g_hash_table_remove(hash_table, key)) { bxt_dbg("[%s cache] removed (%s)/count(%d)/total size(%d)", - (layer_type == BUXTON_LAYER_NORMAL) ? + (layer_type == LAYER_ATTRIBUTE_RW) ? "NORMAL" : "BASE", key, cache->count, cache->size); } } -void cache_update_data(enum buxton_layer_type layer_type, +void cache_update_data(enum layer_attribute_type layer_type, const char *key, uint8_t *data, int len) { GHashTable *hash_table = NULL; @@ -173,7 +172,7 @@ void cache_update_data(enum buxton_layer_type layer_type, cdata->len = len; } -static void cache_drop(enum buxton_layer_type layer_type, int size) +static void cache_drop(enum layer_attribute_type layer_type, int size) { GHashTableIter iter; gpointer key; @@ -193,7 +192,7 @@ static void cache_drop(enum buxton_layer_type layer_type, int size) while (g_hash_table_iter_next(&iter, &key, &value)) { if (remain > 0) { bxt_dbg("[%s cache][%d] removed (%s)", - (layer_type == BUXTON_LAYER_NORMAL) ? + (layer_type == LAYER_ATTRIBUTE_RW) ? "NORMAL" : "BASE", remain, (char *)key); g_hash_table_iter_remove(&iter); remain--; @@ -201,7 +200,7 @@ static void cache_drop(enum buxton_layer_type layer_type, int size) } } -void cache_insert(enum buxton_layer_type layer_type, const char *key, +void cache_insert(enum layer_attribute_type layer_type, const char *key, uint8_t *data, int len) { GHashTable *hash_table = NULL; @@ -250,12 +249,12 @@ void cache_insert(enum buxton_layer_type layer_type, const char *key, cache->size += len; bxt_dbg("[%s cache] inserted (%s)/size(%d)/count(%d)/total size(%d)", - (layer_type == BUXTON_LAYER_NORMAL) ? + (layer_type == LAYER_ATTRIBUTE_RW) ? "NORMAL" : "BASE", key, len, cache->count, cache->size); } -int cache_get(enum buxton_layer_type layer_type, const char *key, +int cache_get(enum layer_attribute_type layer_type, const char *key, void **data, int *data_len) { GHashTable *hash_table = NULL; @@ -284,13 +283,13 @@ int cache_get(enum buxton_layer_type layer_type, const char *key, *data_len = cdata->len; bxt_dbg("[%s cache] get (%s)/size(%d)", - (layer_type == BUXTON_LAYER_NORMAL) ? + (layer_type == LAYER_ATTRIBUTE_RW) ? "NORMAL" : "BASE", key, cdata->len); return BUXTON_ERROR_NONE; } -void cache_clear(enum buxton_layer_type layer_type) +void cache_clear(enum layer_attribute_type layer_type) { bxt_cache *cache = get_cache(layer_type); diff --git a/common/cache.h b/common/cache.h index 47ffbe6..4e4a800 100644 --- a/common/cache.h +++ b/common/cache.h @@ -18,13 +18,15 @@ #pragma once +#include "common.h" + void cache_init(void); -void cache_insert(enum buxton_layer_type layer_type, const char *key, +void cache_insert(enum layer_attribute_type layer_type, const char *key, uint8_t *data, int len); -void cache_remove(enum buxton_layer_type layer_type, const char *key); -void cache_update_data(enum buxton_layer_type layer_type, const char *key, +void cache_remove(enum layer_attribute_type layer_type, const char *key); +void cache_update_data(enum layer_attribute_type layer_type, const char *key, uint8_t *data, int len); -int cache_get(enum buxton_layer_type layer_type, const char *key, +int cache_get(enum layer_attribute_type layer_type, const char *key, void **data, int *data_len); -void cache_clear(enum buxton_layer_type layer_type); +void cache_clear(enum layer_attribute_type layer_type); diff --git a/common/common.c b/common/common.c index 47e928b..77172da 100644 --- a/common/common.c +++ b/common/common.c @@ -51,7 +51,7 @@ int layer_create(const char *layer_name, struct buxton_layer **layer) tmp_layer->refcnt = 1; tmp_layer->uid = getuid(); - tmp_layer->type = BUXTON_LAYER_NORMAL; + tmp_layer->type = LAYER_ATTRIBUTE_RW; *layer = tmp_layer; @@ -102,7 +102,7 @@ void value_free(struct buxton_value *val) return; switch (val->type) { - case BUXTON_TYPE_STRING: + case VALUE_TYPE_STRING: if (val->value.s) { free(val->value.s); val->value.s = NULL; @@ -113,6 +113,22 @@ void value_free(struct buxton_value *val) } } +void key_list_free(char **keys) +{ + char **key; + + if (!keys) + return; + + key = keys; + while (*key) { + free(*key); + key++; + } + + free(keys); +} + int get_search_key(const struct buxton_layer *layer, const char *key, const char *uid, char **layer_key) { diff --git a/common/common.h b/common/common.h index 01de423..4aca294 100644 --- a/common/common.h +++ b/common/common.h @@ -56,6 +56,16 @@ # define SOCKPATH "/run/buxton-0" #endif + +/* + LAYER_SYSTEM - STORAGE_PERSISTENT - LAYER_ATTRIBUTE_RO + \ - LAYER_ATTRIBUTE_RW + STORAGE_VOLATILE - LAYER_ATTRIBUTE_RO + - LAYER_ATTRIBUTE_RW + +LAYER_USER - ... + +*/ enum layer_type { LAYER_UNKNWON = 0, LAYER_SYSTEM, @@ -70,6 +80,12 @@ enum storage_type { STORAGE_MAX, /* sentinel value */ }; +enum layer_attribute_type { + LAYER_ATTRIBUTE_RW = BUXTON_LAYER_NORMAL, + LAYER_ATTRIBUTE_RO = BUXTON_LAYER_BASE, + LAYER_ATTRIBUTE_MAX = BUXTON_LAYER_MAX, /* sentinel value */ +}; + struct layer { gchar *name; enum layer_type type; @@ -78,6 +94,23 @@ struct layer { gchar *description; }; +enum value_type { + VALUE_TYPE_UNKNOWN = BUXTON_TYPE_UNKNOWN, /**< Unknown type */ + VALUE_TYPE_STRING = BUXTON_TYPE_STRING, /**< String type */ + VALUE_TYPE_INT32 = BUXTON_TYPE_INT32, /**< 32bit integer type */ + VALUE_TYPE_UINT32 = BUXTON_TYPE_UINT32, /**< 32bit unsigned integer type */ + VALUE_TYPE_INT64 = BUXTON_TYPE_INT64, /**< 64bit integer type */ + VALUE_TYPE_UINT64 = BUXTON_TYPE_UINT64, /**< 64bit unsigned integer type */ + VALUE_TYPE_DOUBLE = BUXTON_TYPE_DOUBLE, /**< double-precision float type */ + VALUE_TYPE_BOOLEAN = BUXTON_TYPE_BOOLEAN, /**< boolean type */ + VALUE_TYPE_MAX = BUXTON_TYPE_MAX /* sentinel value */ +}; + +enum priv_type { + PRIV_READ = BUXTON_PRIV_READ, /**< Read privilege type */ + PRIV_WRITE = BUXTON_PRIV_WRITE, /**< Write privilege type */ +}; + enum message_type { MSG_UNKNOWN = 0, /* basic request */ @@ -103,7 +136,7 @@ struct buxton_layer { int refcnt; char *name; uid_t uid; - enum buxton_layer_type type; + enum layer_attribute_type type; }; int layer_create(const char *layer_name, struct buxton_layer **layer); @@ -113,7 +146,7 @@ struct buxton_layer *layer_ref(struct buxton_layer *layer); struct buxton_layer *layer_unref(struct buxton_layer *layer); struct buxton_value { - enum buxton_key_type type; + enum value_type type; union { char *s; int32_t i; @@ -126,6 +159,7 @@ struct buxton_value { }; void value_free(struct buxton_value *val); +void key_list_free(char **keys); int get_search_key(const struct buxton_layer *layer, const char *key, const char *uid, char **layer_key); diff --git a/common/direct.c b/common/direct.c index 80b2aaf..525e7a2 100644 --- a/common/direct.c +++ b/common/direct.c @@ -26,8 +26,6 @@ #include -#include "buxton2.h" - #include "common.h" #include "log.h" #include "direct.h" @@ -36,7 +34,7 @@ #include "serialize.h" #include "cache.h" -static int get_path(uid_t uid, enum buxton_layer_type type, +static int get_path(uid_t uid, enum layer_attribute_type type, const struct layer *ly, char *path, int sz) { const char *prefix; @@ -47,12 +45,12 @@ static int get_path(uid_t uid, enum buxton_layer_type type, return BUXTON_ERROR_INVALID_PARAMETER; } - if (type == BUXTON_LAYER_NORMAL) + if (type == LAYER_ATTRIBUTE_RW) prefix = (ly->storage == STORAGE_VOLATILE) ? TMPFS_DIR : DB_DIR; else prefix = BASE_DB_DIR; - if (type == BUXTON_LAYER_NORMAL && ly->type == LAYER_USER) + if (type == LAYER_ATTRIBUTE_RW && ly->type == LAYER_USER) snprintf(suffix, sizeof(suffix), "-%u", uid); else suffix[0] = '\0'; @@ -63,7 +61,7 @@ static int get_path(uid_t uid, enum buxton_layer_type type, } static int get_raw(const struct layer *ly, uid_t uid, - enum buxton_layer_type type, const char *key, + enum layer_attribute_type type, const char *key, uint8_t **data, int *len) { int r; @@ -92,7 +90,7 @@ static int get_raw(const struct layer *ly, uid_t uid, return r; r = backend->get_value(path, key, (void **)data, len, - (type == BUXTON_LAYER_BASE) ? true : false); + (type == LAYER_ATTRIBUTE_RO) ? true : false); if (r != BUXTON_ERROR_NONE) return r; @@ -102,7 +100,7 @@ static int get_raw(const struct layer *ly, uid_t uid, } static int get_val(const struct layer *ly, uid_t uid, - enum buxton_layer_type type, const char *key, + enum layer_attribute_type type, const char *key, char **rpriv, char **wpriv, struct buxton_value *val) { int r; @@ -142,17 +140,17 @@ int direct_get(const struct buxton_layer *layer, return r; /* First, refer to base db */ - r = get_val(ly, layer->uid, BUXTON_LAYER_BASE, key, NULL, NULL, + r = get_val(ly, layer->uid, LAYER_ATTRIBUTE_RO, key, NULL, NULL, &base_val); if (r != BUXTON_ERROR_NONE) return r; - if (layer->type == BUXTON_LAYER_BASE) { + if (layer->type == LAYER_ATTRIBUTE_RO) { *val = base_val; return BUXTON_ERROR_NONE; } - r = get_val(ly, layer->uid, BUXTON_LAYER_NORMAL, key, NULL, NULL, + r = get_val(ly, layer->uid, LAYER_ATTRIBUTE_RW, key, NULL, NULL, &db_val); if (r != BUXTON_ERROR_NONE) { if (r == BUXTON_ERROR_NOT_EXIST) { @@ -184,7 +182,7 @@ int direct_check(const struct buxton_layer *layer, const char *key) if (r != BUXTON_ERROR_NONE) return r; - r = get_val(ly, layer->uid, BUXTON_LAYER_BASE, key, NULL, NULL, &val); + r = get_val(ly, layer->uid, LAYER_ATTRIBUTE_RO, key, NULL, NULL, &val); if (r != BUXTON_ERROR_NONE) return r; @@ -193,7 +191,7 @@ int direct_check(const struct buxton_layer *layer, const char *key) return BUXTON_ERROR_NONE; } -static bool is_updated_data(enum buxton_layer_type type, const char *key, +static bool is_updated_data(enum layer_attribute_type type, const char *key, uint8_t *data, int len) { uint8_t *cur_data; @@ -221,7 +219,7 @@ static bool is_updated_data(enum buxton_layer_type type, const char *key, } static int set_raw(const struct layer *ly, uid_t uid, - enum buxton_layer_type type, const char *key, + enum layer_attribute_type type, const char *key, uint8_t *data, int len) { int r; @@ -261,7 +259,7 @@ static int set_raw(const struct layer *ly, uid_t uid, } static int set_val(const struct layer *ly, uid_t uid, - enum buxton_layer_type type, const char *key, + enum layer_attribute_type type, const char *key, const char *rpriv, const char *wpriv, const struct buxton_value *val) { @@ -303,7 +301,7 @@ int direct_set(const struct buxton_layer *layer, if (r != BUXTON_ERROR_NONE) return r; - r = get_val(ly, layer->uid, BUXTON_LAYER_BASE, key, &rp, &wp, NULL); + r = get_val(ly, layer->uid, LAYER_ATTRIBUTE_RO, key, &rp, &wp, NULL); if (r != BUXTON_ERROR_NONE) return r; @@ -336,7 +334,7 @@ static int direct_close(const struct buxton_layer *layer, const struct layer *ly return BUXTON_ERROR_INVALID_OPERATION; } - r = get_path(layer->uid, BUXTON_LAYER_BASE, ly, path, sizeof(path)); + r = get_path(layer->uid, LAYER_ATTRIBUTE_RO, ly, path, sizeof(path)); if (r != BUXTON_ERROR_NONE) return r; @@ -371,7 +369,7 @@ int direct_create(const struct buxton_layer *layer, const char *key, if (r != BUXTON_ERROR_NONE) return r; - r = get_val(ly, layer->uid, BUXTON_LAYER_BASE, key, NULL, NULL, NULL); + r = get_val(ly, layer->uid, LAYER_ATTRIBUTE_RO, key, NULL, NULL, NULL); if (r == BUXTON_ERROR_NONE) return BUXTON_ERROR_EXIST; @@ -382,18 +380,18 @@ int direct_create(const struct buxton_layer *layer, const char *key, return r; } - r = set_val(ly, layer->uid, BUXTON_LAYER_BASE, key, rpriv, wpriv, val); + r = set_val(ly, layer->uid, LAYER_ATTRIBUTE_RO, key, rpriv, wpriv, val); if (r != BUXTON_ERROR_NONE) { bxt_err("failed to create (%s: %s) %d", ly->name, key, r); return r; } if (ly->storage == STORAGE_PERSISTENT) { - r = set_val(ly, layer->uid, BUXTON_LAYER_NORMAL, key, rpriv, wpriv, val); + r = set_val(ly, layer->uid, LAYER_ATTRIBUTE_RW, key, rpriv, wpriv, val); if (r != BUXTON_ERROR_NONE) { bxt_err("failed to create (%s: %s) %d", ly->name, key, r); unset_layer = *layer; - unset_layer.type = BUXTON_LAYER_BASE; + unset_layer.type = LAYER_ATTRIBUTE_RO; direct_unset(&unset_layer, key); } } @@ -479,7 +477,7 @@ int direct_list(const struct buxton_layer *layer, } r = get_path(layer->uid, is_base ? - BUXTON_LAYER_BASE : BUXTON_LAYER_NORMAL, + LAYER_ATTRIBUTE_RO : LAYER_ATTRIBUTE_RW, ly, path, sizeof(path)); if (r != BUXTON_ERROR_NONE) return r; @@ -534,7 +532,7 @@ int direct_dump(const struct buxton_layer *layer, return BUXTON_ERROR_INVALID_OPERATION; } - ret = get_path(layer->uid, BUXTON_LAYER_BASE, + ret = get_path(layer->uid, LAYER_ATTRIBUTE_RO, ly, path, sizeof(path)); if (ret != BUXTON_ERROR_NONE) return ret; @@ -546,7 +544,7 @@ int direct_dump(const struct buxton_layer *layer, return ret; } - ret = get_path(layer->uid, BUXTON_LAYER_NORMAL, + ret = get_path(layer->uid, LAYER_ATTRIBUTE_RW, ly, path, sizeof(path)); if (ret != BUXTON_ERROR_NONE) { bxt_err("dump: get_path failed"); @@ -593,14 +591,14 @@ int direct_dump(const struct buxton_layer *layer, *len = base_len; out: - buxton_free_keys((char **)base_values); - buxton_free_keys(normal_keys); - buxton_free_keys((char **)normal_values); + key_list_free((char **)base_values); + key_list_free(normal_keys); + key_list_free((char **)normal_values); free(base_value_len); free(normal_value_len); if (ret != BUXTON_ERROR_NONE) { - buxton_free_keys(base_keys); + key_list_free(base_keys); if (_value_list) free(_value_list); @@ -622,11 +620,11 @@ int direct_get_priv(const struct buxton_layer *layer, } switch (type) { - case BUXTON_PRIV_READ: + case PRIV_READ: rp = priv; wp = NULL; break; - case BUXTON_PRIV_WRITE: + case PRIV_WRITE: rp = NULL; wp = priv; break; @@ -639,7 +637,7 @@ int direct_get_priv(const struct buxton_layer *layer, if (r != BUXTON_ERROR_NONE) return r; - r = get_val(ly, layer->uid, BUXTON_LAYER_BASE, key, rp, wp, NULL); + r = get_val(ly, layer->uid, LAYER_ATTRIBUTE_RO, key, rp, wp, NULL); return r; } @@ -660,8 +658,8 @@ int direct_set_priv(const struct buxton_layer *layer, } switch (type) { - case BUXTON_PRIV_READ: - case BUXTON_PRIV_WRITE: + case PRIV_READ: + case PRIV_WRITE: break; default: bxt_err("Invalid parameter"); @@ -672,16 +670,16 @@ int direct_set_priv(const struct buxton_layer *layer, if (r != BUXTON_ERROR_NONE) return r; - r = get_val(ly, layer->uid, BUXTON_LAYER_BASE, key, &rp, &wp, &val); + r = get_val(ly, layer->uid, LAYER_ATTRIBUTE_RO, key, &rp, &wp, &val); if (r != BUXTON_ERROR_NONE) return r; switch (type) { - case BUXTON_PRIV_READ: + case PRIV_READ: t_rp = priv; t_wp = wp; break; - case BUXTON_PRIV_WRITE: + case PRIV_WRITE: t_rp = rp; t_wp = priv; break; @@ -691,7 +689,7 @@ int direct_set_priv(const struct buxton_layer *layer, break; } - r = set_val(ly, layer->uid, BUXTON_LAYER_BASE, key, t_rp, t_wp, &val); + r = set_val(ly, layer->uid, LAYER_ATTRIBUTE_RO, key, t_rp, t_wp, &val); value_free(&val); free(rp); diff --git a/common/direct.h b/common/direct.h index 62bf869..b8f3385 100644 --- a/common/direct.h +++ b/common/direct.h @@ -18,8 +18,6 @@ #pragma once -#include "buxton2.h" - int direct_init(const char *moddir, const char *confpath, bool *log_on, int *max_line); void direct_exit(void); diff --git a/common/serialize.c b/common/serialize.c index d3152e2..0f42b89 100644 --- a/common/serialize.c +++ b/common/serialize.c @@ -23,8 +23,6 @@ #include -#include "buxton2.h" - #include "serialize.h" #include "log.h" @@ -83,7 +81,7 @@ static int check_values(const char *rpriv, const char *wpriv, return r; } - if (val && val->type == BUXTON_TYPE_STRING) { + if (val && val->type == VALUE_TYPE_STRING) { r = check_val(val->value.s); if (r != BUXTON_ERROR_NONE) { bxt_err("Value string length is too long"); @@ -102,7 +100,7 @@ static GVariant *val_to_gv(const struct buxton_value *val) return g_variant_new_tuple(NULL, 0); switch (val->type) { - case BUXTON_TYPE_STRING: + case VALUE_TYPE_STRING: if (!val->value.s) { bxt_err("Serialize: value has NULL string"); return NULL; @@ -110,22 +108,22 @@ static GVariant *val_to_gv(const struct buxton_value *val) gv = g_variant_new_string(val->value.s); break; - case BUXTON_TYPE_INT32: + case VALUE_TYPE_INT32: gv = g_variant_new_int32(val->value.i); break; - case BUXTON_TYPE_UINT32: + case VALUE_TYPE_UINT32: gv = g_variant_new_uint32(val->value.u); break; - case BUXTON_TYPE_INT64: + case VALUE_TYPE_INT64: gv = g_variant_new_int64(val->value.i64); break; - case BUXTON_TYPE_UINT64: + case VALUE_TYPE_UINT64: gv = g_variant_new_uint64(val->value.u64); break; - case BUXTON_TYPE_DOUBLE: + case VALUE_TYPE_DOUBLE: gv = g_variant_new_double(val->value.d); break; - case BUXTON_TYPE_BOOLEAN: + case VALUE_TYPE_BOOLEAN: gv = g_variant_new_boolean(val->value.b); break; default: @@ -249,13 +247,13 @@ static int gv_to_val(GVariant *v, struct buxton_value *val) if (!strncmp(t, "()", sizeof("()"))) { - val->type = BUXTON_TYPE_UNKNOWN; + val->type = VALUE_TYPE_UNKNOWN; return BUXTON_ERROR_NONE; } switch (*t) { case 's': - val->type = BUXTON_TYPE_STRING; + val->type = VALUE_TYPE_STRING; s = g_variant_get_string(v, NULL); if (!s) { @@ -269,27 +267,27 @@ static int gv_to_val(GVariant *v, struct buxton_value *val) } break; case 'i': - val->type = BUXTON_TYPE_INT32; + val->type = VALUE_TYPE_INT32; val->value.i = g_variant_get_int32(v); break; case 'u': - val->type = BUXTON_TYPE_UINT32; + val->type = VALUE_TYPE_UINT32; val->value.u = g_variant_get_uint32(v); break; case 'x': - val->type = BUXTON_TYPE_INT64; + val->type = VALUE_TYPE_INT64; val->value.i64 = g_variant_get_int64(v); break; case 't': - val->type = BUXTON_TYPE_UINT64; + val->type = VALUE_TYPE_UINT64; val->value.u64 = g_variant_get_uint64(v); break; case 'd': - val->type = BUXTON_TYPE_DOUBLE; + val->type = VALUE_TYPE_DOUBLE; val->value.d = g_variant_get_double(v); break; case 'b': - val->type = BUXTON_TYPE_BOOLEAN; + val->type = VALUE_TYPE_BOOLEAN; val->value.b = g_variant_get_boolean(v); break; default: @@ -447,18 +445,18 @@ static int check_value(const struct buxton_value *val) } switch (val->type) { - case BUXTON_TYPE_STRING: + case VALUE_TYPE_STRING: if (!val->value.s) { bxt_err("Serialize: value has NULL string"); return BUXTON_ERROR_INVALID_PARAMETER; } break; - case BUXTON_TYPE_INT32: - case BUXTON_TYPE_UINT32: - case BUXTON_TYPE_INT64: - case BUXTON_TYPE_UINT64: - case BUXTON_TYPE_DOUBLE: - case BUXTON_TYPE_BOOLEAN: + case VALUE_TYPE_INT32: + case VALUE_TYPE_UINT32: + case VALUE_TYPE_INT64: + case VALUE_TYPE_UINT64: + case VALUE_TYPE_DOUBLE: + case VALUE_TYPE_BOOLEAN: break; default: bxt_err("Serialize: buxton_value has unknown type"); @@ -684,7 +682,7 @@ static int gv_to_req(GVariant *gv, struct request *req) return r; } - if (val->type == BUXTON_TYPE_UNKNOWN) { + if (val->type == VALUE_TYPE_UNKNOWN) { free(val); val = NULL; } @@ -748,7 +746,7 @@ void free_response(struct response *res) value_free(res->val); free(res->val); - buxton_free_keys(res->names); + key_list_free(res->names); } static int check_response(enum message_type type, int32_t res, @@ -942,7 +940,7 @@ static int gv_to_res_list(GVariant *gv, struct response *res) res->names[i] = NULL; if (i < len || ret != BUXTON_ERROR_NONE) { - buxton_free_keys(res->names); + key_list_free(res->names); return ret == BUXTON_ERROR_NONE ? BUXTON_ERROR_INVALID_PARAMETER : ret; } @@ -996,7 +994,7 @@ static int gv_to_res(GVariant *gv, struct response *res) g_variant_unref(v); - if (val->type == BUXTON_TYPE_UNKNOWN) { + if (val->type == VALUE_TYPE_UNKNOWN) { free(val); val = NULL; } diff --git a/common/serialize.h b/common/serialize.h index e5ef8ef..81ac760 100644 --- a/common/serialize.h +++ b/common/serialize.h @@ -20,8 +20,6 @@ #include -#include "buxton2.h" - #include "common.h" int check_key_name(const char *key); diff --git a/lib/buxton2.c b/lib/buxton2.c index c9fc9d7..7bde41c 100644 --- a/lib/buxton2.c +++ b/lib/buxton2.c @@ -271,7 +271,7 @@ static int value_get(const struct buxton_value *val, void *dest, return BUXTON_ERROR_INVALID_PARAMETER; } - if (val->type != type) { + if (val->type != (enum value_type)type) { bxt_err("Invalid parameter : type mismatch %d %d", val->type, type); return BUXTON_ERROR_INVALID_PARAMETER; } @@ -412,7 +412,7 @@ EXPORT struct buxton_value *buxton_value_duplicate( *_val = *val; - if (val->type == BUXTON_TYPE_STRING && val->value.s) { + if (val->type == (enum value_type)BUXTON_TYPE_STRING && val->value.s) { _val->value.s = strdup(val->value.s); if (!_val->value.s) { free(_val); -- cgit v1.2.3