From f2d5c2c5cc52788a60fb2c390f681ea4cc767e58 Mon Sep 17 00:00:00 2001 From: Gary Lockyer Date: Mon, 23 Jul 2018 10:08:26 +1200 Subject: [PATCH] lib ldb: rename LTDB_* constants to LDB_KV_* Rename all the LTDB_* constants to LDB_KV_* as they are key value level constants and not tdb specific. Signed-off-by: Gary Lockyer Reviewed-by: Andrew Bartlett --- lib/ldb/ldb_key_value/ldb_kv.c | 36 +++++++-------- lib/ldb/ldb_key_value/ldb_kv.h | 42 +++++++++--------- lib/ldb/ldb_key_value/ldb_kv_cache.c | 54 +++++++++++------------ lib/ldb/ldb_key_value/ldb_kv_index.c | 82 +++++++++++++++++------------------ lib/ldb/ldb_key_value/ldb_kv_search.c | 2 +- 5 files changed, 108 insertions(+), 108 deletions(-) diff --git a/lib/ldb/ldb_key_value/ldb_kv.c b/lib/ldb/ldb_key_value/ldb_kv.c index 2449ec276b4..2d6abf641ba 100644 --- a/lib/ldb/ldb_key_value/ldb_kv.c +++ b/lib/ldb/ldb_key_value/ldb_kv.c @@ -77,12 +77,12 @@ bool ldb_kv_key_is_record(TDB_DATA key) return true; } - if (key.dsize < sizeof(LTDB_GUID_KEY_PREFIX)) { + if (key.dsize < sizeof(LDB_KV_GUID_KEY_PREFIX)) { return false; } - if (memcmp(key.dptr, LTDB_GUID_KEY_PREFIX, - sizeof(LTDB_GUID_KEY_PREFIX) - 1) == 0) { + if (memcmp(key.dptr, LDB_KV_GUID_KEY_PREFIX, + sizeof(LDB_KV_GUID_KEY_PREFIX) - 1) == 0) { return true; } @@ -149,8 +149,8 @@ int ldb_kv_guid_to_key(struct ldb_module *module, const struct ldb_val *GUID_val, TDB_DATA *key) { - const char *GUID_prefix = LTDB_GUID_KEY_PREFIX; - const int GUID_prefix_len = sizeof(LTDB_GUID_KEY_PREFIX) - 1; + const char *GUID_prefix = LDB_KV_GUID_KEY_PREFIX; + const int GUID_prefix_len = sizeof(LDB_KV_GUID_KEY_PREFIX) - 1; if (key->dsize != (GUID_val->length+GUID_prefix_len)) { return LDB_ERR_OPERATIONS_ERROR; @@ -229,7 +229,7 @@ TDB_DATA ldb_kv_key_msg(struct ldb_module *module, ldb_asprintf_errstring(ldb_module_get_ctx(module), "Did not find GUID attribute %s " "in %s, required for TDB record " - "key in " LTDB_IDXGUID " mode.", + "key in " LDB_KV_IDXGUID " mode.", ldb_kv->cache->GUID_index_attribute, ldb_dn_get_linearized(msg->dn)); errno = EINVAL; @@ -239,7 +239,7 @@ TDB_DATA ldb_kv_key_msg(struct ldb_module *module, } /* In this case, allocate with talloc */ - key.dptr = talloc_size(mem_ctx, LTDB_GUID_KEY_SIZE); + key.dptr = talloc_size(mem_ctx, LDB_KV_GUID_KEY_SIZE); if (key.dptr == NULL) { errno = ENOMEM; key.dptr = NULL; @@ -270,7 +270,7 @@ static int ldb_kv_check_special_dn(struct ldb_module *module, unsigned int i, j; if (! ldb_dn_is_special(msg->dn) || - ! ldb_dn_check_special(msg->dn, LTDB_ATTRIBUTES)) { + ! ldb_dn_check_special(msg->dn, LDB_KV_ATTRIBUTES)) { return LDB_SUCCESS; } @@ -310,8 +310,8 @@ static int ldb_kv_modified(struct ldb_module *module, struct ldb_dn *dn) } if (ldb_dn_is_special(dn) && - (ldb_dn_check_special(dn, LTDB_INDEXLIST) || - ldb_dn_check_special(dn, LTDB_ATTRIBUTES)) ) + (ldb_dn_check_special(dn, LDB_KV_INDEXLIST) || + ldb_dn_check_special(dn, LDB_KV_ATTRIBUTES)) ) { if (ldb_kv->warn_reindex) { ldb_debug(ldb_module_get_ctx(module), @@ -326,14 +326,14 @@ static int ldb_kv_modified(struct ldb_module *module, struct ldb_dn *dn) /* If the modify was to a normal record, or any special except @BASEINFO, update the seq number */ if (ret == LDB_SUCCESS && !(ldb_dn_is_special(dn) && - ldb_dn_check_special(dn, LTDB_BASEINFO)) ) { + ldb_dn_check_special(dn, LDB_KV_BASEINFO)) ) { ret = ldb_kv_increase_sequence_number(module); } /* If the modify was to @OPTIONS, reload the cache */ if (ret == LDB_SUCCESS && ldb_dn_is_special(dn) && - (ldb_dn_check_special(dn, LTDB_OPTIONS)) ) { + (ldb_dn_check_special(dn, LDB_KV_OPTIONS)) ) { ret = ldb_kv_cache_reload(module); } @@ -463,7 +463,7 @@ static int ldb_kv_add_internal(struct ldb_module *module, /* Do not check "@ATTRIBUTES" for duplicated values */ if (ldb_dn_is_special(msg->dn) && - ldb_dn_check_special(msg->dn, LTDB_ATTRIBUTES)) { + ldb_dn_check_special(msg->dn, LDB_KV_ATTRIBUTES)) { continue; } @@ -557,7 +557,7 @@ static int ldb_kv_add(struct ldb_kv_context *ctx) !ldb_dn_is_special(req->op.add.message->dn)) { ldb_set_errstring(ldb_module_get_ctx(module), "Must operate ldb_mdb in GUID " - "index mode, but " LTDB_IDXGUID " not set."); + "index mode, but " LDB_KV_IDXGUID " not set."); return LDB_ERR_UNWILLING_TO_PERFORM; } @@ -1533,7 +1533,7 @@ static int ldb_kv_sequence_number(struct ldb_kv_context *ctx, goto done; } - dn = ldb_dn_new(tmp_ctx, ldb, LTDB_BASEINFO); + dn = ldb_dn_new(tmp_ctx, ldb, LDB_KV_BASEINFO); if (dn == NULL) { ret = LDB_ERR_OPERATIONS_ERROR; goto done; @@ -1552,14 +1552,14 @@ static int ldb_kv_sequence_number(struct ldb_kv_context *ctx, switch (seq->type) { case LDB_SEQ_HIGHEST_SEQ: - res->seq_num = ldb_msg_find_attr_as_uint64(msg, LTDB_SEQUENCE_NUMBER, 0); + res->seq_num = ldb_msg_find_attr_as_uint64(msg, LDB_KV_SEQUENCE_NUMBER, 0); break; case LDB_SEQ_NEXT: - res->seq_num = ldb_msg_find_attr_as_uint64(msg, LTDB_SEQUENCE_NUMBER, 0); + res->seq_num = ldb_msg_find_attr_as_uint64(msg, LDB_KV_SEQUENCE_NUMBER, 0); res->seq_num++; break; case LDB_SEQ_HIGHEST_TIMESTAMP: - date = ldb_msg_find_attr_as_string(msg, LTDB_MOD_TIMESTAMP, NULL); + date = ldb_msg_find_attr_as_string(msg, LDB_KV_MOD_TIMESTAMP, NULL); if (date) { res->seq_num = ldb_string_to_time(date); } else { diff --git a/lib/ldb/ldb_key_value/ldb_kv.h b/lib/ldb/ldb_key_value/ldb_kv.h index 13fe1256766..2ea36ca66c3 100644 --- a/lib/ldb/ldb_key_value/ldb_kv.h +++ b/lib/ldb/ldb_key_value/ldb_kv.h @@ -128,15 +128,15 @@ struct ldb_kv_reindex_context { /* special record types */ -#define LTDB_INDEX "@INDEX" -#define LTDB_INDEXLIST "@INDEXLIST" -#define LTDB_IDX "@IDX" -#define LTDB_IDXVERSION "@IDXVERSION" -#define LTDB_IDXATTR "@IDXATTR" -#define LTDB_IDXONE "@IDXONE" -#define LTDB_IDXDN "@IDXDN" -#define LTDB_IDXGUID "@IDXGUID" -#define LTDB_IDX_DN_GUID "@IDX_DN_GUID" +#define LDB_KV_INDEX "@INDEX" +#define LDB_KV_INDEXLIST "@INDEXLIST" +#define LDB_KV_IDX "@IDX" +#define LDB_KV_IDXVERSION "@IDXVERSION" +#define LDB_KV_IDXATTR "@IDXATTR" +#define LDB_KV_IDXONE "@IDXONE" +#define LDB_KV_IDXDN "@IDXDN" +#define LDB_KV_IDXGUID "@IDXGUID" +#define LDB_KV_IDX_DN_GUID "@IDX_DN_GUID" /* * This will be used to indicate when a new, yet to be developed @@ -144,23 +144,23 @@ struct ldb_kv_reindex_context { * not load future databases unintentionally. */ -#define LTDB_IDX_LMDB_SUBDB "@IDX_LMDB_SUBDB" +#define LDB_KV_IDX_LMDB_SUBDB "@IDX_LMDB_SUBDB" -#define LTDB_BASEINFO "@BASEINFO" -#define LTDB_OPTIONS "@OPTIONS" -#define LTDB_ATTRIBUTES "@ATTRIBUTES" +#define LDB_KV_BASEINFO "@BASEINFO" +#define LDB_KV_OPTIONS "@OPTIONS" +#define LDB_KV_ATTRIBUTES "@ATTRIBUTES" /* special attribute types */ -#define LTDB_SEQUENCE_NUMBER "sequenceNumber" -#define LTDB_CHECK_BASE "checkBaseOnSearch" -#define LTDB_DISALLOW_DN_FILTER "disallowDNFilter" -#define LTDB_MOD_TIMESTAMP "whenChanged" -#define LTDB_OBJECTCLASS "objectClass" +#define LDB_KV_SEQUENCE_NUMBER "sequenceNumber" +#define LDB_KV_CHECK_BASE "checkBaseOnSearch" +#define LDB_KV_DISALLOW_DN_FILTER "disallowDNFilter" +#define LDB_KV_MOD_TIMESTAMP "whenChanged" +#define LDB_KV_OBJECTCLASS "objectClass" /* DB keys */ -#define LTDB_GUID_KEY_PREFIX "GUID=" -#define LTDB_GUID_SIZE 16 -#define LTDB_GUID_KEY_SIZE (LTDB_GUID_SIZE + sizeof(LTDB_GUID_KEY_PREFIX) - 1) +#define LDB_KV_GUID_KEY_PREFIX "GUID=" +#define LDB_KV_GUID_SIZE 16 +#define LDB_KV_GUID_KEY_SIZE (LDB_KV_GUID_SIZE + sizeof(LDB_KV_GUID_KEY_PREFIX) - 1) /* * The following definitions come from lib/ldb/ldb_key_value/ldb_kv_cache.c diff --git a/lib/ldb/ldb_key_value/ldb_kv_cache.c b/lib/ldb/ldb_key_value/ldb_kv_cache.c index f0bc31b60a5..c39273fb097 100644 --- a/lib/ldb/ldb_key_value/ldb_kv_cache.c +++ b/lib/ldb/ldb_key_value/ldb_kv_cache.c @@ -34,19 +34,19 @@ #include "ldb_kv.h" #include "ldb_private.h" -#define LTDB_FLAG_CASE_INSENSITIVE (1<<0) -#define LTDB_FLAG_INTEGER (1<<1) -#define LTDB_FLAG_UNIQUE_INDEX (1<<2) +#define LDB_KV_FLAG_CASE_INSENSITIVE (1<<0) +#define LDB_KV_FLAG_INTEGER (1<<1) +#define LDB_KV_FLAG_UNIQUE_INDEX (1<<2) /* valid attribute flags */ static const struct { const char *name; int value; } ldb_kv_valid_attr_flags[] = { - { "CASE_INSENSITIVE", LTDB_FLAG_CASE_INSENSITIVE }, - { "INTEGER", LTDB_FLAG_INTEGER }, + { "CASE_INSENSITIVE", LDB_KV_FLAG_CASE_INSENSITIVE }, + { "INTEGER", LDB_KV_FLAG_INTEGER }, { "HIDDEN", 0 }, - { "UNIQUE_INDEX", LTDB_FLAG_UNIQUE_INDEX}, + { "UNIQUE_INDEX", LDB_KV_FLAG_UNIQUE_INDEX}, { "NONE", 0 }, { NULL, 0 } }; @@ -119,7 +119,7 @@ static int ldb_kv_attributes_load(struct ldb_module *module) goto failed; } - dn = ldb_dn_new(module, ldb, LTDB_ATTRIBUTES); + dn = ldb_dn_new(module, ldb, LDB_KV_ATTRIBUTES); if (dn == NULL) goto failed; r = ldb_kv_search_dn1(module, @@ -171,15 +171,15 @@ static int ldb_kv_attributes_load(struct ldb_module *module) goto failed; } - if (flags & LTDB_FLAG_UNIQUE_INDEX) { + if (flags & LDB_KV_FLAG_UNIQUE_INDEX) { attr_flags = LDB_ATTR_FLAG_UNIQUE_INDEX; } - flags &= ~LTDB_FLAG_UNIQUE_INDEX; + flags &= ~LDB_KV_FLAG_UNIQUE_INDEX; /* These are not currently flags, each is exclusive */ - if (flags == LTDB_FLAG_CASE_INSENSITIVE) { + if (flags == LDB_KV_FLAG_CASE_INSENSITIVE) { syntax = LDB_SYNTAX_DIRECTORY_STRING; - } else if (flags == LTDB_FLAG_INTEGER) { + } else if (flags == LDB_KV_FLAG_INTEGER) { syntax = LDB_SYNTAX_INTEGER; } else if (flags == 0) { syntax = LDB_SYNTAX_OCTET_STRING; @@ -266,7 +266,7 @@ static int ldb_kv_index_load(struct ldb_module *module, ldb_kv->cache->one_level_indexes = false; ldb_kv->cache->attribute_indexes = false; - indexlist_dn = ldb_dn_new(ldb_kv, ldb, LTDB_INDEXLIST); + indexlist_dn = ldb_dn_new(ldb_kv, ldb, LDB_KV_INDEXLIST); if (indexlist_dn == NULL) { return -1; } @@ -283,21 +283,21 @@ static int ldb_kv_index_load(struct ldb_module *module, return -1; } - if (ldb_msg_find_element(ldb_kv->cache->indexlist, LTDB_IDXONE) != + if (ldb_msg_find_element(ldb_kv->cache->indexlist, LDB_KV_IDXONE) != NULL) { ldb_kv->cache->one_level_indexes = true; } - if (ldb_msg_find_element(ldb_kv->cache->indexlist, LTDB_IDXATTR) != + if (ldb_msg_find_element(ldb_kv->cache->indexlist, LDB_KV_IDXATTR) != NULL) { ldb_kv->cache->attribute_indexes = true; } ldb_kv->cache->GUID_index_attribute = ldb_msg_find_attr_as_string( - ldb_kv->cache->indexlist, LTDB_IDXGUID, NULL); + ldb_kv->cache->indexlist, LDB_KV_IDXGUID, NULL); ldb_kv->cache->GUID_index_dn_component = ldb_msg_find_attr_as_string( - ldb_kv->cache->indexlist, LTDB_IDX_DN_GUID, NULL); + ldb_kv->cache->indexlist, LDB_KV_IDX_DN_GUID, NULL); lmdb_subdb_version = ldb_msg_find_attr_as_int( - ldb_kv->cache->indexlist, LTDB_IDX_LMDB_SUBDB, 0); + ldb_kv->cache->indexlist, LDB_KV_IDX_LMDB_SUBDB, 0); if (lmdb_subdb_version != 0) { ldb_set_errstring(ldb, @@ -341,11 +341,11 @@ static int ldb_kv_baseinfo_init(struct ldb_module *module) msg->num_elements = 1; msg->elements = ⪙ - msg->dn = ldb_dn_new(msg, ldb, LTDB_BASEINFO); + msg->dn = ldb_dn_new(msg, ldb, LDB_KV_BASEINFO); if (!msg->dn) { goto failed; } - el.name = talloc_strdup(msg, LTDB_SEQUENCE_NUMBER); + el.name = talloc_strdup(msg, LDB_KV_SEQUENCE_NUMBER); if (!el.name) { goto failed; } @@ -426,7 +426,7 @@ int ldb_kv_cache_load(struct ldb_module *module) baseinfo = ldb_msg_new(ldb_kv->cache); if (baseinfo == NULL) goto failed; - baseinfo_dn = ldb_dn_new(baseinfo, ldb, LTDB_BASEINFO); + baseinfo_dn = ldb_dn_new(baseinfo, ldb, LDB_KV_BASEINFO); if (baseinfo_dn == NULL) goto failed; r = ldb_kv->kv_ops->lock_read(module); @@ -469,7 +469,7 @@ int ldb_kv_cache_load(struct ldb_module *module) /* if the current internal sequence number is the same as the one in the database then assume the rest of the cache is OK */ - seq = ldb_msg_find_attr_as_uint64(baseinfo, LTDB_SEQUENCE_NUMBER, 0); + seq = ldb_msg_find_attr_as_uint64(baseinfo, LDB_KV_SEQUENCE_NUMBER, 0); if (seq == ldb_kv->sequence_number) { goto done; } @@ -480,7 +480,7 @@ int ldb_kv_cache_load(struct ldb_module *module) options = ldb_msg_new(ldb_kv->cache); if (options == NULL) goto failed_and_unlock; - options_dn = ldb_dn_new(options, ldb, LTDB_OPTIONS); + options_dn = ldb_dn_new(options, ldb, LDB_KV_OPTIONS); if (options_dn == NULL) goto failed_and_unlock; r = ldb_kv_search_dn1(module, options_dn, options, 0); @@ -492,9 +492,9 @@ int ldb_kv_cache_load(struct ldb_module *module) /* set flags if they do exist */ if (r == LDB_SUCCESS) { ldb_kv->check_base = - ldb_msg_find_attr_as_bool(options, LTDB_CHECK_BASE, false); + ldb_msg_find_attr_as_bool(options, LDB_KV_CHECK_BASE, false); ldb_kv->disallow_dn_filter = ldb_msg_find_attr_as_bool( - options, LTDB_DISALLOW_DN_FILTER, false); + options, LDB_KV_DISALLOW_DN_FILTER, false); } else { ldb_kv->check_base = false; ldb_kv->disallow_dn_filter = false; @@ -595,13 +595,13 @@ int ldb_kv_increase_sequence_number(struct ldb_module *module) msg->num_elements = ARRAY_SIZE(el); msg->elements = el; - msg->dn = ldb_dn_new(msg, ldb, LTDB_BASEINFO); + msg->dn = ldb_dn_new(msg, ldb, LDB_KV_BASEINFO); if (msg->dn == NULL) { talloc_free(msg); errno = ENOMEM; return LDB_ERR_OPERATIONS_ERROR; } - el[0].name = talloc_strdup(msg, LTDB_SEQUENCE_NUMBER); + el[0].name = talloc_strdup(msg, LDB_KV_SEQUENCE_NUMBER); if (el[0].name == NULL) { talloc_free(msg); errno = ENOMEM; @@ -613,7 +613,7 @@ int ldb_kv_increase_sequence_number(struct ldb_module *module) val.data = (uint8_t *)s; val.length = strlen(s); - el[1].name = talloc_strdup(msg, LTDB_MOD_TIMESTAMP); + el[1].name = talloc_strdup(msg, LDB_KV_MOD_TIMESTAMP); if (el[1].name == NULL) { talloc_free(msg); errno = ENOMEM; diff --git a/lib/ldb/ldb_key_value/ldb_kv_index.c b/lib/ldb/ldb_key_value/ldb_kv_index.c index 4cefe0a69b3..96ebd6b86cc 100644 --- a/lib/ldb/ldb_key_value/ldb_kv_index.c +++ b/lib/ldb/ldb_key_value/ldb_kv_index.c @@ -186,9 +186,9 @@ static void ldb_kv_dn_list_sort(struct ldb_kv_private *ldb_kv, /* we put a @IDXVERSION attribute on index entries. This allows us to tell if it was written by an older version */ -#define LTDB_INDEXING_VERSION 2 +#define LDB_KV_INDEXING_VERSION 2 -#define LTDB_GUID_INDEXING_VERSION 3 +#define LDB_KV_GUID_INDEXING_VERSION 3 static unsigned ldb_kv_max_key_length(struct ldb_kv_private *ldb_kv) { @@ -400,13 +400,13 @@ normal_index: return ret; } - el = ldb_msg_find_element(msg, LTDB_IDX); + el = ldb_msg_find_element(msg, LDB_KV_IDX); if (!el) { talloc_free(msg); return LDB_SUCCESS; } - version = ldb_msg_find_attr_as_int(msg, LTDB_IDXVERSION, 0); + version = ldb_msg_find_attr_as_int(msg, LDB_KV_IDXVERSION, 0); /* * we avoid copying the strings by stealing the list. We have @@ -416,12 +416,12 @@ normal_index: */ if (ldb_kv->cache->GUID_index_attribute == NULL) { /* check indexing version number */ - if (version != LTDB_INDEXING_VERSION) { + if (version != LDB_KV_INDEXING_VERSION) { ldb_debug_set(ldb_module_get_ctx(module), LDB_DEBUG_ERROR, "Wrong DN index version %d " "expected %d for %s", - version, LTDB_INDEXING_VERSION, + version, LDB_KV_INDEXING_VERSION, ldb_dn_get_linearized(dn)); talloc_free(msg); return LDB_ERR_OPERATIONS_ERROR; @@ -432,14 +432,14 @@ normal_index: list->count = el->num_values; } else { unsigned int i; - if (version != LTDB_GUID_INDEXING_VERSION) { + if (version != LDB_KV_GUID_INDEXING_VERSION) { /* This is quite likely during the DB startup on first upgrade to using a GUID index */ ldb_debug_set(ldb_module_get_ctx(module), LDB_DEBUG_ERROR, "Wrong GUID index version %d " "expected %d for %s", - version, LTDB_GUID_INDEXING_VERSION, + version, LDB_KV_GUID_INDEXING_VERSION, ldb_dn_get_linearized(dn)); talloc_free(msg); return LDB_ERR_OPERATIONS_ERROR; @@ -450,12 +450,12 @@ normal_index: return LDB_ERR_OPERATIONS_ERROR; } - if ((el->values[0].length % LTDB_GUID_SIZE) != 0) { + if ((el->values[0].length % LDB_KV_GUID_SIZE) != 0) { talloc_free(msg); return LDB_ERR_OPERATIONS_ERROR; } - list->count = el->values[0].length / LTDB_GUID_SIZE; + list->count = el->values[0].length / LDB_KV_GUID_SIZE; list->dn = talloc_array(list, struct ldb_val, list->count); if (list->dn == NULL) { talloc_free(msg); @@ -469,8 +469,8 @@ normal_index: talloc_steal(list->dn, msg); for (i = 0; i < list->count; i++) { list->dn[i].data - = &el->values[0].data[i * LTDB_GUID_SIZE]; - list->dn[i].length = LTDB_GUID_SIZE; + = &el->values[0].data[i * LDB_KV_GUID_SIZE]; + list->dn[i].length = LDB_KV_GUID_SIZE; } } @@ -528,7 +528,7 @@ int ldb_kv_key_dn_from_idx(struct ldb_module *module, int i; index = -1; for (i=0; i < list->count; i++) { - uint8_t guid_key[LTDB_GUID_KEY_SIZE]; + uint8_t guid_key[LDB_KV_GUID_KEY_SIZE]; TDB_DATA key = { .dptr = guid_key, .dsize = sizeof(guid_key) @@ -633,15 +633,15 @@ static int ldb_kv_dn_list_store_full(struct ldb_module *module, } if (ldb_kv->cache->GUID_index_attribute == NULL) { - ret = ldb_msg_add_fmt(msg, LTDB_IDXVERSION, "%u", - LTDB_INDEXING_VERSION); + ret = ldb_msg_add_fmt(msg, LDB_KV_IDXVERSION, "%u", + LDB_KV_INDEXING_VERSION); if (ret != LDB_SUCCESS) { talloc_free(msg); return ldb_module_oom(module); } } else { - ret = ldb_msg_add_fmt(msg, LTDB_IDXVERSION, "%u", - LTDB_GUID_INDEXING_VERSION); + ret = ldb_msg_add_fmt(msg, LDB_KV_IDXVERSION, "%u", + LDB_KV_GUID_INDEXING_VERSION); if (ret != LDB_SUCCESS) { talloc_free(msg); return ldb_module_oom(module); @@ -651,7 +651,7 @@ static int ldb_kv_dn_list_store_full(struct ldb_module *module, if (list->count > 0) { struct ldb_message_element *el; - ret = ldb_msg_add_empty(msg, LTDB_IDX, LDB_FLAG_MOD_ADD, &el); + ret = ldb_msg_add_empty(msg, LDB_KV_IDX, LDB_FLAG_MOD_ADD, &el); if (ret != LDB_SUCCESS) { talloc_free(msg); return ldb_module_oom(module); @@ -672,7 +672,7 @@ static int ldb_kv_dn_list_store_full(struct ldb_module *module, v.data = talloc_array_size(el->values, list->count, - LTDB_GUID_SIZE); + LDB_KV_GUID_SIZE); if (v.data == NULL) { talloc_free(msg); return ldb_module_oom(module); @@ -682,13 +682,13 @@ static int ldb_kv_dn_list_store_full(struct ldb_module *module, for (i = 0; i < list->count; i++) { if (list->dn[i].length != - LTDB_GUID_SIZE) { + LDB_KV_GUID_SIZE) { talloc_free(msg); return ldb_module_operr(module); } - memcpy(&v.data[LTDB_GUID_SIZE*i], + memcpy(&v.data[LDB_KV_GUID_SIZE*i], list->dn[i].data, - LTDB_GUID_SIZE); + LDB_KV_GUID_SIZE); } el->values[0] = v; el->num_values = 1; @@ -873,7 +873,7 @@ static struct ldb_dn *ldb_kv_index_key(struct ldb_context *ldb, unsigned int max_key_length = ldb_kv_max_key_length(ldb_kv); size_t key_len = 0; size_t attr_len = 0; - const size_t indx_len = sizeof(LTDB_INDEX) - 1; + const size_t indx_len = sizeof(LDB_KV_INDEX) - 1; unsigned frmt_len = 0; const size_t additional_key_length = 4; unsigned int num_separators = 3; /* Estimate for overflow check */ @@ -947,9 +947,9 @@ static struct ldb_dn *ldb_kv_index_key(struct ldb_context *ldb, * avoids embedded NUL etc. */ if (ldb_kv->cache->GUID_index_attribute != NULL) { - if (strcmp(attr, LTDB_IDXDN) == 0) { + if (strcmp(attr, LDB_KV_IDXDN) == 0) { should_b64_encode = false; - } else if (strcmp(attr, LTDB_IDXONE) == 0) { + } else if (strcmp(attr, LDB_KV_IDXONE) == 0) { /* * We can only change the behaviour for IDXONE * when the GUID index is enabled @@ -987,7 +987,7 @@ static struct ldb_dn *ldb_kv_index_key(struct ldb_context *ldb, * indicates that the following value is base64 encoded */ ret = ldb_dn_new_fmt(ldb, ldb, "%s#%s##%.*s", - LTDB_INDEX, attr_for_dn, + LDB_KV_INDEX, attr_for_dn, frmt_len, vstr); } else { frmt_len = vstr_len; @@ -997,7 +997,7 @@ static struct ldb_dn *ldb_kv_index_key(struct ldb_context *ldb, * indicates that the following value is base64 encoded */ ret = ldb_dn_new_fmt(ldb, ldb, "%s:%s::%.*s", - LTDB_INDEX, attr_for_dn, + LDB_KV_INDEX, attr_for_dn, frmt_len, vstr); } talloc_free(vstr); @@ -1019,13 +1019,13 @@ static struct ldb_dn *ldb_kv_index_key(struct ldb_context *ldb, * from the non truncated keys */ ret = ldb_dn_new_fmt(ldb, ldb, "%s#%s#%.*s", - LTDB_INDEX, attr_for_dn, + LDB_KV_INDEX, attr_for_dn, frmt_len, (char *)v.data); } else { frmt_len = v.length; *truncation = KEY_NOT_TRUNCATED; ret = ldb_dn_new_fmt(ldb, ldb, "%s:%s:%.*s", - LTDB_INDEX, attr_for_dn, + LDB_KV_INDEX, attr_for_dn, frmt_len, (char *)v.data); } } @@ -1073,7 +1073,7 @@ static bool ldb_kv_is_indexed(struct ldb_module *module, return false; } - el = ldb_msg_find_element(ldb_kv->cache->indexlist, LTDB_IDXATTR); + el = ldb_msg_find_element(ldb_kv->cache->indexlist, LDB_KV_IDXATTR); if (el == NULL) { return false; } @@ -1645,7 +1645,7 @@ static int ldb_kv_index_dn_one(struct ldb_module *module, /* Ensure we do not shortcut on intersection for this list */ list->strict = true; return ldb_kv_index_dn_attr( - module, ldb_kv, LTDB_IDXONE, parent_dn, list, truncation); + module, ldb_kv, LDB_KV_IDXONE, parent_dn, list, truncation); } /* @@ -1692,7 +1692,7 @@ static int ldb_kv_index_dn_base_dn(struct ldb_module *module, } return ldb_kv_index_dn_attr( - module, ldb_kv, LTDB_IDXDN, base_dn, dn_list, truncation); + module, ldb_kv, LDB_KV_IDXDN, base_dn, dn_list, truncation); } /* @@ -1752,7 +1752,7 @@ static int ldb_kv_index_filter(struct ldb_kv_private *ldb_kv, struct ldb_message *filtered_msg; unsigned int i; unsigned int num_keys = 0; - uint8_t previous_guid_key[LTDB_GUID_KEY_SIZE] = {}; + uint8_t previous_guid_key[LDB_KV_GUID_KEY_SIZE] = {}; TDB_DATA *keys = NULL; /* @@ -1773,7 +1773,7 @@ static int ldb_kv_index_filter(struct ldb_kv_private *ldb_kv, * small allocations) */ struct guid_tdb_key { - uint8_t guid_key[LTDB_GUID_KEY_SIZE]; + uint8_t guid_key[LDB_KV_GUID_KEY_SIZE]; } *key_values = NULL; key_values = talloc_array(keys, @@ -2169,14 +2169,14 @@ static int ldb_kv_index_add1(struct ldb_module *module, * messages. */ if (list->count > 0 && - ldb_attr_cmp(el->name, LTDB_IDXDN) == 0 && + ldb_attr_cmp(el->name, LDB_KV_IDXDN) == 0 && truncation == KEY_NOT_TRUNCATED) { talloc_free(list); return LDB_ERR_CONSTRAINT_VIOLATION; } else if (list->count > 0 - && ldb_attr_cmp(el->name, LTDB_IDXDN) == 0) { + && ldb_attr_cmp(el->name, LDB_KV_IDXDN) == 0) { /* * At least one existing entry in the DN->GUID index, which @@ -2186,7 +2186,7 @@ static int ldb_kv_index_add1(struct ldb_module *module, */ int i; for (i=0; i < list->count; i++) { - uint8_t guid_key[LTDB_GUID_KEY_SIZE]; + uint8_t guid_key[LDB_KV_GUID_KEY_SIZE]; TDB_DATA key = { .dptr = guid_key, .dsize = sizeof(guid_key) @@ -2324,7 +2324,7 @@ static int ldb_kv_index_add1(struct ldb_module *module, return ldb_module_operr(module); } - if (key_val->length != LTDB_GUID_SIZE) { + if (key_val->length != LDB_KV_GUID_SIZE) { talloc_free(list); return ldb_module_operr(module); } @@ -2529,7 +2529,7 @@ static int ldb_kv_index_onelevel(struct ldb_module *module, return LDB_ERR_OPERATIONS_ERROR; } ret = - ldb_kv_modify_index_dn(module, ldb_kv, msg, pdn, LTDB_IDXONE, add); + ldb_kv_modify_index_dn(module, ldb_kv, msg, pdn, LDB_KV_IDXONE, add); talloc_free(pdn); @@ -2553,7 +2553,7 @@ static int ldb_kv_write_index_dn_guid(struct ldb_module *module, } ret = ldb_kv_modify_index_dn( - module, ldb_kv, msg, msg->dn, LTDB_IDXDN, add); + module, ldb_kv, msg, msg->dn, LDB_KV_IDXDN, add); if (ret == LDB_ERR_CONSTRAINT_VIOLATION) { ldb_asprintf_errstring(ldb_module_get_ctx(module), @@ -2809,7 +2809,7 @@ static int delete_index(struct ldb_kv_private *ldb_kv, void *state) { struct ldb_module *module = state; - const char *dnstr = "DN=" LTDB_INDEX ":"; + const char *dnstr = "DN=" LDB_KV_INDEX ":"; struct dn_list list; struct ldb_dn *dn; struct ldb_val v; diff --git a/lib/ldb/ldb_key_value/ldb_kv_search.c b/lib/ldb/ldb_key_value/ldb_kv_search.c index 5bb780a2788..ee9b4bce29a 100644 --- a/lib/ldb/ldb_key_value/ldb_kv_search.c +++ b/lib/ldb/ldb_key_value/ldb_kv_search.c @@ -291,7 +291,7 @@ int ldb_kv_search_dn1(struct ldb_module *module, struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private); int ret; - uint8_t guid_key[LTDB_GUID_KEY_SIZE]; + uint8_t guid_key[LDB_KV_GUID_KEY_SIZE]; TDB_DATA tdb_key = { .dptr = guid_key, .dsize = sizeof(guid_key) -- 2.11.4.GIT