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 <gary@catalyst.net.nz>
Reviewed-by: Andrew Bartlett <abartlet@samba.org>

diff --git a/lib/ldb/ldb_key_value/ldb_kv.c b/lib/ldb/ldb_key_value/ldb_kv.c
index 2449ec276b467ba21f73b940ec47dbd73daba329..2d6abf641ba67c7ad39cc6987a4ad1f48c807010 100644 (file)
--- 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 13fe1256766b52359cae3e35197f2d95e25dc7bf..2ea36ca66c330dcb6ce34beb0b7a40804d050e81 100644 (file)
--- 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 f0bc31b60a55d261454b95e1dc739e5a04386782..c39273fb09730c3b77c8b43d6453d78482860dee 100644 (file)
--- 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 = &el;
-       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 4cefe0a69b3dda61a77b550ff8d1fef6a5c42513..96ebd6b86ccec069a099baee0f6f3c8b34a8bae3 100644 (file)
--- 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 5bb780a2788c5d393f3310903b3860c13fd5e293..ee9b4bce29a386ea9983bda713d9d2354bc3d1b6 100644 (file)
--- 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)