#define LDBLOCK "INT_LDBLOCK"
+
+/*
+ callback function used in call to ldb_dn_fold() for determining whether an
+ attribute type requires case folding.
+*/
+static int ltdb_case_fold_attr_required(void * user_data, char *attr)
+{
+ struct ldb_module *module = talloc_get_type(user_data, struct ldb_module);
+
+ return ltdb_attribute_flags(module, attr) & LTDB_FLAG_CASE_INSENSITIVE;
+}
+
/*
form a TDB_DATA for a record key
caller frees
there are 3 cases dealt with in this code:
- 1) if the dn doesn't start with @INDEX: then uppercase whole dn
+ 1) if the dn doesn't start with @INDEX: then uppercase the attribute
+ names and the attributes values of case insensitive attributes
2) if the dn starts with @INDEX:attr and 'attr' is a case insensitive
attribute then uppercase whole dn
3) if the dn starts with @INDEX:attr and 'attr' is a case sensitive
if (strncmp(dn, prefix, strlen(prefix)) == 0 &&
(s = strchr(dn+strlen(prefix), ':'))) {
char *attr_name, *attr_name_folded;
- attr_name = ldb_strndup(ldb, dn+strlen(prefix), (s-(dn+strlen(prefix))));
+ attr_name = talloc_strndup(ldb, dn+strlen(prefix), (s-(dn+strlen(prefix))));
if (!attr_name) {
goto failed;
}
if (!attr_name_folded) {
goto failed;
}
- ldb_asprintf(ldb, &dn_folded, "%s:%s:%s",
- prefix, attr_name_folded,
- s+1);
- ldb_free(ldb, attr_name_folded);
+ dn_folded = talloc_asprintf(ldb, "%s:%s:%s",
+ prefix, attr_name_folded,
+ s+1);
+ talloc_free(attr_name_folded);
}
- ldb_free(ldb, attr_name);
+ talloc_free(attr_name);
} else {
- dn_folded = ldb_casefold(ldb, dn);
+ dn_folded = ldb_dn_fold(module->ldb, dn,
+ module, ltdb_case_fold_attr_required);
}
if (!dn_folded) {
goto failed;
}
- ldb_asprintf(ldb, &key_str, "DN=%s", dn_folded);
- ldb_free(ldb, dn_folded);
+ key_str = talloc_asprintf(ldb, "DN=%s", dn_folded);
+ talloc_free(dn_folded);
if (!key_str) {
goto failed;
*/
static int ltdb_lock(struct ldb_module *module, const char *lockname)
{
- struct ldb_context *ldb = module->ldb;
struct ltdb_private *ltdb = module->private_data;
TDB_DATA key;
int ret;
ret = tdb_chainlock(ltdb->tdb, key);
- ldb_free(ldb, key.dptr);
+ talloc_free(key.dptr);
return ret;
}
*/
static int ltdb_unlock(struct ldb_module *module, const char *lockname)
{
- struct ldb_context *ldb = module->ldb;
struct ltdb_private *ltdb = module->private_data;
TDB_DATA key;
tdb_chainunlock(ltdb->tdb, key);
- ldb_free(ldb, key.dptr);
+ talloc_free(key.dptr);
+
+ return 0;
+}
+
+
+/*
+ lock the database for read - use by ltdb_search
+*/
+int ltdb_lock_read(struct ldb_module *module)
+{
+ struct ltdb_private *ltdb = module->private_data;
+ TDB_DATA key;
+ int ret;
+ key = ltdb_key(module, LDBLOCK);
+ if (!key.dptr) {
+ return -1;
+ }
+ ret = tdb_chainlock_read(ltdb->tdb, key);
+ talloc_free(key.dptr);
+ return ret;
+}
+
+/*
+ unlock the database after a ltdb_lock_read()
+*/
+int ltdb_unlock_read(struct ldb_module *module)
+{
+ struct ltdb_private *ltdb = module->private_data;
+ TDB_DATA key;
+ key = ltdb_key(module, LDBLOCK);
+ if (!key.dptr) {
+ return -1;
+ }
+ tdb_chainunlock_read(ltdb->tdb, key);
+ talloc_free(key.dptr);
+ return 0;
+}
+
+/*
+ check special dn's have valid attributes
+ currently only @ATTRIBUTES is checked
+*/
+int ltdb_check_special_dn(struct ldb_module *module, const struct ldb_message *msg)
+{
+ struct ltdb_private *ltdb = module->private_data;
+ int i, j;
+
+ if (strcmp(msg->dn, LTDB_ATTRIBUTES) != 0) {
+ return 0;
+ }
+
+ /* we have @ATTRIBUTES, let's check attributes are fine */
+ /* should we check that we deny multivalued attributes ? */
+ for (i = 0; i < msg->num_elements; i++) {
+ for (j = 0; j < msg->elements[i].num_values; j++) {
+ if (ltdb_check_at_attributes_values(&msg->elements[i].values[j]) != 0) {
+ ltdb->last_err_string = "Invalid attribute value in an @ATTRIBUTES entry";
+ return -1;
+ }
+ }
+ }
return 0;
}
*/
int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flgs)
{
- struct ldb_context *ldb = module->ldb;
struct ltdb_private *ltdb = module->private_data;
TDB_DATA tdb_key, tdb_data;
int ret;
ret = ltdb_pack_data(module, msg, &tdb_data);
if (ret == -1) {
- ldb_free(ldb, tdb_key.dptr);
+ talloc_free(tdb_key.dptr);
return -1;
}
}
done:
- ldb_free(ldb, tdb_key.dptr);
- ldb_free(ldb, tdb_data.dptr);
+ talloc_free(tdb_key.dptr);
+ talloc_free(tdb_data.dptr);
return ret;
}
ltdb->last_err_string = NULL;
+ ret = ltdb_check_special_dn(module, msg);
+ if (ret != 0) {
+ return ret;
+ }
+
if (ltdb_lock(module, LDBLOCK) != 0) {
return -1;
}
ltdb_unlock(module, LDBLOCK);
return -1;
}
-
+
ret = ltdb_store(module, msg, TDB_INSERT);
if (ret == 0) {
*/
int ltdb_delete_noindex(struct ldb_module *module, const char *dn)
{
- struct ldb_context *ldb = module->ldb;
struct ltdb_private *ltdb = module->private_data;
TDB_DATA tdb_key;
int ret;
}
ret = tdb_delete(ltdb->tdb, tdb_key);
- ldb_free(ldb, tdb_key.dptr);
+ talloc_free(tdb_key.dptr);
return ret;
}
{
struct ltdb_private *ltdb = module->private_data;
int ret;
- struct ldb_message msg;
+ struct ldb_message *msg = NULL;
ltdb->last_err_string = NULL;
}
if (ltdb_cache_load(module) != 0) {
- ltdb_unlock(module, LDBLOCK);
- return -1;
+ goto failed;
+ }
+
+ msg = talloc(module, struct ldb_message);
+ if (msg == NULL) {
+ goto failed;
}
/* in case any attribute of the message was indexed, we need
to fetch the old record */
- ret = ltdb_search_dn1(module, dn, &msg);
+ ret = ltdb_search_dn1(module, dn, msg);
if (ret != 1) {
/* not finding the old record is an error */
goto failed;
ret = ltdb_delete_noindex(module, dn);
if (ret == -1) {
- ltdb_search_dn1_free(module, &msg);
goto failed;
}
/* remove any indexed attributes */
- ret = ltdb_index_del(module, &msg);
-
- ltdb_search_dn1_free(module, &msg);
+ ret = ltdb_index_del(module, msg);
if (ret == 0) {
ltdb_modified(module, dn);
}
+ talloc_free(msg);
ltdb_unlock(module, LDBLOCK);
return ret;
failed:
+ talloc_free(msg);
ltdb_unlock(module, LDBLOCK);
return -1;
}
struct ldb_message_element *e2;
unsigned int i;
- e2 = ldb_realloc_p(ldb, msg->elements, struct ldb_message_element,
- msg->num_elements+1);
+ e2 = talloc_realloc(msg, msg->elements, struct ldb_message_element,
+ msg->num_elements+1);
if (!e2) {
errno = ENOMEM;
return -1;
e2->flags = el->flags;
e2->values = NULL;
if (el->num_values != 0) {
- e2->values = ldb_malloc_array_p(ldb, struct ldb_val, el->num_values);
+ e2->values = talloc_array(msg->elements, struct ldb_val, el->num_values);
if (!e2->values) {
errno = ENOMEM;
return -1;
/*
delete all elements having a specified attribute name
*/
-static int msg_delete_attribute(struct ldb_context *ldb,
+static int msg_delete_attribute(struct ldb_module *module,
+ struct ldb_context *ldb,
struct ldb_message *msg, const char *name)
{
- unsigned int i, count=0;
- struct ldb_message_element *el2;
-
- el2 = ldb_malloc_array_p(ldb, struct ldb_message_element, msg->num_elements);
- if (!el2) {
- errno = ENOMEM;
- return -1;
- }
+ unsigned int i, j;
for (i=0;i<msg->num_elements;i++) {
- if (ldb_attr_cmp(msg->elements[i].name, name) != 0) {
- el2[count++] = msg->elements[i];
- } else {
- ldb_free(ldb, msg->elements[i].values);
+ if (ldb_attr_cmp(msg->elements[i].name, name) == 0) {
+ for (j=0;j<msg->elements[i].num_values;j++) {
+ ltdb_index_del_value(module, msg->dn, &msg->elements[i], j);
+ }
+ talloc_free(msg->elements[i].values);
+ if (msg->num_elements > (i+1)) {
+ memmove(&msg->elements[i],
+ &msg->elements[i+1],
+ sizeof(struct ldb_message_element)*
+ (msg->num_elements - (i+1)));
+ }
+ msg->num_elements--;
+ i--;
+ msg->elements = talloc_realloc(msg, msg->elements,
+ struct ldb_message_element,
+ msg->num_elements);
}
}
- msg->num_elements = count;
- ldb_free(ldb, msg->elements);
- msg->elements = el2;
-
return 0;
}
}
el->num_values--;
if (el->num_values == 0) {
- return msg_delete_attribute(ldb, msg, name);
+ return msg_delete_attribute(module, ldb, msg, name);
}
return 0;
}
struct ldb_context *ldb = module->ldb;
struct ltdb_private *ltdb = module->private_data;
TDB_DATA tdb_key, tdb_data;
- struct ldb_message msg2;
+ struct ldb_message *msg2;
unsigned i, j;
int ret;
tdb_data = tdb_fetch(ltdb->tdb, tdb_key);
if (!tdb_data.dptr) {
- ldb_free(ldb, tdb_key.dptr);
+ talloc_free(tdb_key.dptr);
return -1;
}
- ret = ltdb_unpack_data(module, &tdb_data, &msg2);
+ msg2 = talloc(tdb_key.dptr, struct ldb_message);
+ if (msg2 == NULL) {
+ talloc_free(tdb_key.dptr);
+ return -1;
+ }
+
+ ret = ltdb_unpack_data(module, &tdb_data, msg2);
if (ret == -1) {
- ldb_free(ldb, tdb_key.dptr);
+ talloc_free(tdb_key.dptr);
free(tdb_data.dptr);
return -1;
}
- if (!msg2.dn) {
- msg2.dn = msg->dn;
+ if (!msg2->dn) {
+ msg2->dn = msg->dn;
}
for (i=0;i<msg->num_elements;i++) {
+ struct ldb_message_element *el = &msg->elements[i];
+ struct ldb_message_element *el2;
+ struct ldb_val *vals;
+
switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
case LDB_FLAG_MOD_ADD:
/* add this element to the message. fail if it
already exists */
- ret = find_element(&msg2, msg->elements[i].name);
- if (ret != -1) {
- for (j=0;j<msg->elements[i].num_values;j++) {
- if (ldb_msg_find_val(&msg2.elements[ret],
- &msg->elements[i].values[j])) {
- ltdb->last_err_string = "Type or value exists";
- goto failed;
- }
+ ret = find_element(msg2, el->name);
+
+ if (ret == -1) {
+ if (msg_add_element(ldb, msg2, el) != 0) {
+ goto failed;
+ }
+ continue;
+ }
+
+ el2 = &msg2->elements[ret];
+
+ /* An attribute with this name already exists, add all
+ * values if they don't already exist. */
+
+ for (j=0;j<el->num_values;j++) {
+ if (ldb_msg_find_val(el2, &el->values[j])) {
+ ltdb->last_err_string =
+ "Type or value exists";
+ goto failed;
}
}
- if (msg_add_element(ldb, &msg2, &msg->elements[i]) != 0) {
+
+ vals = talloc_realloc(msg2->elements, el2->values, struct ldb_val,
+ el2->num_values + el->num_values);
+
+ if (vals == NULL)
goto failed;
+
+ for (j=0;j<el->num_values;j++) {
+ vals[el2->num_values + j] =
+ ldb_val_dup(vals, &el->values[j]);
}
+
+ el2->values = vals;
+ el2->num_values += el->num_values;
+
break;
case LDB_FLAG_MOD_REPLACE:
/* replace all elements of this attribute name with the elements
listed. The attribute not existing is not an error */
- msg_delete_attribute(ldb, &msg2, msg->elements[i].name);
+ msg_delete_attribute(module, ldb, msg2, msg->elements[i].name);
/* add the replacement element, if not empty */
if (msg->elements[i].num_values != 0 &&
- msg_add_element(ldb, &msg2, &msg->elements[i]) != 0) {
+ msg_add_element(ldb, msg2, &msg->elements[i]) != 0) {
goto failed;
}
break;
/* we could be being asked to delete all
values or just some values */
if (msg->elements[i].num_values == 0) {
- if (msg_delete_attribute(ldb, &msg2,
+ if (msg_delete_attribute(module, ldb, msg2,
msg->elements[i].name) != 0) {
ltdb->last_err_string = "No such attribute";
goto failed;
}
for (j=0;j<msg->elements[i].num_values;j++) {
if (msg_delete_element(module,
- &msg2,
+ msg2,
msg->elements[i].name,
&msg->elements[i].values[j]) != 0) {
ltdb->last_err_string = "No such attribute";
goto failed;
}
+ if (ltdb_index_del_value(module, msg->dn, &msg->elements[i], j) != 0) {
+ goto failed;
+ }
}
break;
}
}
/* we've made all the mods - save the modified record back into the database */
- ret = ltdb_store(module, &msg2, TDB_MODIFY);
+ ret = ltdb_store(module, msg2, TDB_MODIFY);
- ldb_free(ldb, tdb_key.dptr);
+ talloc_free(tdb_key.dptr);
free(tdb_data.dptr);
- ltdb_unpack_data_free(module, &msg2);
return ret;
failed:
- ldb_free(ldb, tdb_key.dptr);
+ talloc_free(tdb_key.dptr);
free(tdb_data.dptr);
- ltdb_unpack_data_free(module, &msg2);
return -1;
}
ltdb->last_err_string = NULL;
+ ret = ltdb_check_special_dn(module, msg);
+ if (ret != 0) {
+ return ret;
+ }
+
if (ltdb_lock(module, LDBLOCK) != 0) {
return -1;
}
*/
static int ltdb_rename(struct ldb_module *module, const char *olddn, const char *newdn)
{
- struct ldb_context *ldb = module->ldb;
struct ltdb_private *ltdb = module->private_data;
int ret;
- struct ldb_message msg;
+ struct ldb_message *msg;
const char *error_str;
ltdb->last_err_string = NULL;
return -1;
}
+ if (ltdb_cache_load(module) != 0) {
+ ltdb_unlock(module, LDBLOCK);
+ return -1;
+ }
+
+ msg = talloc(module, struct ldb_message);
+ if (msg == NULL) {
+ goto failed;
+ }
+
/* in case any attribute of the message was indexed, we need
to fetch the old record */
- ret = ltdb_search_dn1(module, olddn, &msg);
+ ret = ltdb_search_dn1(module, olddn, msg);
if (ret != 1) {
/* not finding the old record is an error */
goto failed;
}
- msg.dn = ldb_strdup(ldb,newdn);
- if (!msg.dn) {
- ltdb_search_dn1_free(module, &msg);
+ msg->dn = talloc_strdup(msg, newdn);
+ if (!msg->dn) {
goto failed;
}
- ret = ltdb_add(module, &msg);
+ ret = ltdb_add(module, msg);
if (ret == -1) {
- ldb_free(ldb, msg.dn);
- ltdb_search_dn1_free(module, &msg);
goto failed;
}
- ldb_free(ldb, msg.dn);
- ltdb_search_dn1_free(module, &msg);
ret = ltdb_delete(module, olddn);
error_str = ltdb->last_err_string;
ltdb->last_err_string = error_str;
+ talloc_free(msg);
ltdb_unlock(module, LDBLOCK);
return ret;
+
failed:
+ talloc_free(msg);
ltdb_unlock(module, LDBLOCK);
return -1;
}
-/*
- close database
-*/
-static int ltdb_close(struct ldb_module *module)
-{
- struct ldb_context *ldb = module->ldb;
- struct ltdb_private *ltdb = module->private_data;
- int ret;
-
- ltdb->last_err_string = NULL;
-
- ltdb_cache_free(module);
- ldb_set_alloc(ldb, NULL, NULL);
-
- ret = tdb_close(ltdb->tdb);
- ldb_free(ldb, ltdb);
- free(ldb);
- return ret;
-}
-
/*
return extended error information
static const struct ldb_module_ops ltdb_ops = {
- "tdb",
- ltdb_close,
- ltdb_search,
- ltdb_search_free,
- ltdb_add,
- ltdb_modify,
- ltdb_delete,
- ltdb_rename,
- ltdb_lock,
- ltdb_unlock,
- ltdb_errstring,
- ltdb_cache_free
+ .name = "tdb",
+ .search = ltdb_search,
+ .search_bytree = ltdb_search_bytree,
+ .add_record = ltdb_add,
+ .modify_record = ltdb_modify,
+ .delete_record = ltdb_delete,
+ .rename_record = ltdb_rename,
+ .named_lock = ltdb_lock,
+ .named_unlock = ltdb_unlock,
+ .errstring = ltdb_errstring
};
+/*
+ destroy the ltdb context
+*/
+static int ltdb_destructor(void *p)
+{
+ struct ltdb_private *ltdb = p;
+ tdb_close(ltdb->tdb);
+ return 0;
+}
+
/*
connect to the database
*/
-struct ldb_context *ltdb_connect(const char *url,
- unsigned int flags,
- const char *options[])
+int ltdb_connect(struct ldb_context *ldb, const char *url,
+ unsigned int flags, const char *options[])
{
const char *path;
int tdb_flags, open_flags;
struct ltdb_private *ltdb;
TDB_CONTEXT *tdb;
- struct ldb_context *ldb;
-
- ldb = calloc(1, sizeof(struct ldb_context));
- if (!ldb) {
- errno = ENOMEM;
- return NULL;
- }
/* parse the url */
if (strchr(url, ':')) {
if (strncmp(url, "tdb://", 6) != 0) {
- errno = EINVAL;
- return NULL;
+ ldb_debug(ldb, LDB_DEBUG_ERROR, "Invalid tdb URL '%s'", url);
+ return -1;
}
path = url+6;
} else {
/* note that we use quite a large default hash size */
tdb = tdb_open(path, 10000, tdb_flags, open_flags, 0666);
if (!tdb) {
- free(ldb);
- return NULL;
+ ldb_debug(ldb, LDB_DEBUG_ERROR, "Unable to open tdb '%s'", path);
+ return -1;
}
- ltdb = ldb_malloc_p(ldb, struct ltdb_private);
+ ltdb = talloc_zero(ldb, struct ltdb_private);
if (!ltdb) {
tdb_close(tdb);
- free(ldb);
- errno = ENOMEM;
- return NULL;
+ ldb_oom(ldb);
+ return -1;
}
ltdb->tdb = tdb;
ltdb->sequence_number = 0;
- memset(<db->cache, 0, sizeof(ltdb->cache));
+ talloc_set_destructor(ltdb, ltdb_destructor);
- ldb->modules = ldb_malloc_p(ldb, struct ldb_module);
+ ldb->modules = talloc(ldb, struct ldb_module);
if (!ldb->modules) {
- tdb_close(tdb);
- free(ldb);
- errno = ENOMEM;
- return NULL;
+ ldb_oom(ldb);
+ talloc_free(ltdb);
+ return -1;
}
ldb->modules->ldb = ldb;
ldb->modules->prev = ldb->modules->next = NULL;
ldb->modules->private_data = ltdb;
ldb->modules->ops = <db_ops;
- return ldb;
+ return 0;
}
git.samba.org / abartlet / samba.git / .git / blobdiff