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;
}
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;
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;
}
/* 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;
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;
}
}
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),
/* 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);
}
/* 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;
}
!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;
}
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;
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 {
/* 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
* 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
#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 }
};
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,
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;
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;
}
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,
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;
}
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);
/* 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;
}
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);
/* 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;
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;
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;
/* 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)
{
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
*/
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;
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;
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);
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;
}
}
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)
}
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);
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);
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);
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;
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 */
* 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
* 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;
* 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);
* 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);
}
}
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;
}
/* 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);
}
/*
}
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);
}
/*
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;
/*
* 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,
* 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
*/
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)
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);
}
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);
}
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),
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;
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)