summaryrefslogtreecommitdiff
path: root/source4
diff options
context:
space:
mode:
Diffstat (limited to 'source4')
-rw-r--r--source4/ldap_server/ldap_parse.c75
-rw-r--r--source4/ldap_server/ldap_parse.h4
-rw-r--r--source4/ldap_server/ldap_simple_ldb.c9
-rw-r--r--source4/lib/ldb/Makefile.ldb8
-rw-r--r--source4/lib/ldb/common/ldb.c56
-rw-r--r--source4/lib/ldb/config.mk12
-rw-r--r--source4/lib/ldb/include/ldb.h40
-rw-r--r--source4/lib/ldb/ldb_ldap/ldb_ldap.c53
-rw-r--r--source4/lib/ldb/ldb_tdb/ldb_cache.c57
-rw-r--r--source4/lib/ldb/ldb_tdb/ldb_index.c121
-rw-r--r--source4/lib/ldb/ldb_tdb/ldb_match.c27
-rw-r--r--source4/lib/ldb/ldb_tdb/ldb_search.c81
-rw-r--r--source4/lib/ldb/ldb_tdb/ldb_tdb.c167
-rw-r--r--source4/lib/ldb/tools/ldbadd.c22
-rw-r--r--source4/lib/ldb/tools/ldbdel.c22
-rw-r--r--source4/lib/ldb/tools/ldbedit.c22
-rw-r--r--source4/lib/ldb/tools/ldbmodify.c22
-rw-r--r--source4/lib/ldb/tools/ldbrename.c22
-rw-r--r--source4/lib/ldb/tools/ldbsearch.c23
-rw-r--r--source4/lib/ldb/tools/ldbtest.c22
-rw-r--r--source4/provision.ldif5
-rw-r--r--source4/rootdse.ldif5
22 files changed, 577 insertions, 298 deletions
diff --git a/source4/ldap_server/ldap_parse.c b/source4/ldap_server/ldap_parse.c
index b4e0eaadf9..269f51704c 100644
--- a/source4/ldap_server/ldap_parse.c
+++ b/source4/ldap_server/ldap_parse.c
@@ -75,7 +75,80 @@ static char *parse_slash(char *p, char *end) {
} \
} while(0)
-struct ldap_dn *ldap_parse_dn(TALLOC_CTX *mem_ctx, const char *orig_dn)
+#if 0
+static void ldap_parse_attributetypedescription(struct ldap_schema *schema, DATA_BLOB *data)
+{
+ char *desc;
+
+ desc = (char *)talloc(schema, data->lenght + 1);
+ memcpy(desc, data->data, data->lenght);
+ desc[data->lenght] = '\0';
+
+}
+
+static void ldap_parse_objectclassdescription(struct ldap_schema *schema, DATA_BLOB *data)
+{
+ char *desc;
+
+ desc = (char *)talloc(schema, data->lenght + 1);
+ memcpy(desc, data->data, data->lenght);
+ desc[data->lenght] = '\0';
+
+}
+
+static struct ldap_schema *ldap_get_schema(void *mem_ctx, struct ldap_schema *schema, struct ldb_context *ldb)
+{
+ NTSTATUS status;
+ struct ldap_schema *local_schema;
+ struct ldb_message **res;
+ const char *errstr;
+ const char *schema_dn = "cn=schema";
+ const char *attr_filter = "attributeTypeDescription=*";
+ const char *class_filter = "objectClassDescription=*";
+ const char *attrs = "attributeTypeDescription";
+ const char *classes = "objectClassDescription";
+ enum ldb_scope scope = LDAP_SCOPE_SUBTREE;
+ int count, i, j, k;
+
+ local_schema = schema;
+ if (local_schema == NULL) {
+ local_schema = talloc_p(mem_ctx, struct ldap_schema);
+ ALLOC_CHECK(local_schema);
+ }
+
+ count = ldb_search(ldb, schema_dn, scope, attr_filter, attrs, &res);
+
+ for (i = 0; i < count; i++) {
+ if (res[i]->num_elements == 0) {
+ goto attr_done;
+ }
+ for (j = 0; j < res[i]->num_elements; j++) {
+ for (k = 0; res[i]->elements[j].num_values; k++) {
+ ldap_parse_attributetypedescription(local_schema, &(res[i]->elements[j].values[k]));
+ }
+ }
+attr_done:
+ }
+
+ count = ldb_search(ldb, schema_dn, scope, class_filter, classes, &res);
+
+ for (i = 0; i < count; i++) {
+ if (res[i]->num_elements == 0) {
+ goto class_done;
+ }
+ for (j = 0; j < res[i]->num_elements; j++) {
+ for (k = 0; res[i]->elements[j].num_values; k++) {
+ ldap_parse_objectclassdescription(local_schema, &(res[i]->elements[j].values[k]));
+ }
+ }
+class_done:
+ }
+
+ return local_schema;
+}
+#endif
+
+struct ldap_dn *ldap_parse_dn(void *mem_ctx, const char *orig_dn)
{
struct ldap_dn *dn;
struct dn_component *component;
diff --git a/source4/ldap_server/ldap_parse.h b/source4/ldap_server/ldap_parse.h
index 91df7c5e49..5b870896c4 100644
--- a/source4/ldap_server/ldap_parse.h
+++ b/source4/ldap_server/ldap_parse.h
@@ -35,3 +35,7 @@ struct ldap_dn {
int comp_num;
struct dn_component **components;
};
+
+struct ldap_schema {
+ int dummy;
+};
diff --git a/source4/ldap_server/ldap_simple_ldb.c b/source4/ldap_server/ldap_simple_ldb.c
index 8f40636a5c..4edd456c6e 100644
--- a/source4/ldap_server/ldap_simple_ldb.c
+++ b/source4/ldap_server/ldap_simple_ldb.c
@@ -385,8 +385,8 @@ static NTSTATUS sldb_Modify(struct ldapsrv_partition *partition, struct ldapsrv_
break;
}
- if (r->mods[i].attrib.num_values > 0) {
- msg->elements[i].num_values = r->mods[i].attrib.num_values;
+ msg->elements[i].num_values = r->mods[i].attrib.num_values;
+ if (msg->elements[i].num_values > 0) {
msg->elements[i].values = talloc_array_p(msg, struct ldb_val, msg->elements[i].num_values);
ALLOC_CHECK(msg->elements[i].values);
@@ -399,11 +399,6 @@ static NTSTATUS sldb_Modify(struct ldapsrv_partition *partition, struct ldapsrv_
msg->elements[i].values[j].length = r->mods[i].attrib.values[j].length;
msg->elements[i].values[j].data = r->mods[i].attrib.values[j].data;
}
- } else {
- /* TODO: test what we should do here
- *
- * LDAP_MODIFY_DELETE is ok to pass here
- */
}
}
} else {
diff --git a/source4/lib/ldb/Makefile.ldb b/source4/lib/ldb/Makefile.ldb
index 38456a75e4..7666f5bd31 100644
--- a/source4/lib/ldb/Makefile.ldb
+++ b/source4/lib/ldb/Makefile.ldb
@@ -23,9 +23,11 @@ LDB_TDB_OBJ=ldb_tdb/ldb_match.o ldb_tdb/ldb_tdb.o \
COMMON_OBJ=common/ldb.o common/ldb_ldif.o common/util.o \
common/ldb_parse.o common/ldb_msg.o common/ldb_utf8.o \
- common/ldb_alloc.o common/ldb_debug.o
+ common/ldb_alloc.o common/ldb_debug.o common/ldb_modules.o
-OBJS = $(COMMON_OBJ) $(LDB_TDB_OBJ) $(TDB_OBJ) $(LDB_LDAP_OBJ)
+MODULES_OBJ=modules/timestamps.o
+
+OBJS = $(MODULES_OBJ) $(COMMON_OBJ) $(LDB_TDB_OBJ) $(TDB_OBJ) $(LDB_LDAP_OBJ)
LDB_LIB = lib/libldb.a
@@ -67,7 +69,7 @@ bin/ldbtest: tools/ldbtest.o $(LIBS)
$(CC) -o bin/ldbtest tools/ldbtest.o $(LIB_FLAGS)
manpages:
- man/build_manpages.sh
+ -man/build_manpages.sh
clean:
rm -f */*.o *~ */*~ $(BINS) $(LDB_LIB) man/man?/*.[13]
diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index fa4a64c19d..4fe2088daf 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -47,20 +47,32 @@
struct ldb_context *ldb_connect(const char *url, unsigned int flags,
const char *options[])
{
+ struct ldb_context *ldb_ctx = NULL;
if (strncmp(url, "tdb:", 4) == 0 ||
strchr(url, ':') == NULL) {
- return ltdb_connect(url, flags, options);
+ ldb_ctx = ltdb_connect(url, flags, options);
}
#if HAVE_LDAP
if (strncmp(url, "ldap", 4) == 0) {
- return lldb_connect(url, flags, options);
+ ldb_ctx = lldb_connect(url, flags, options);
}
#endif
- errno = EINVAL;
- return NULL;
+
+ if (!ldb_ctx) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ if (ldb_load_modules(ldb_ctx, options) != 0) {
+ ldb_close(ldb_ctx);
+ errno = EINVAL;
+ return NULL;
+ }
+
+ return ldb_ctx;
}
/*
@@ -68,8 +80,7 @@ struct ldb_context *ldb_connect(const char *url, unsigned int flags,
*/
int ldb_close(struct ldb_context *ldb)
{
- ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_close");
- return ldb->ops->close(ldb);
+ return ldb->modules->ops->close(ldb->modules);
}
@@ -84,12 +95,7 @@ int ldb_search(struct ldb_context *ldb,
const char *expression,
const char * const *attrs, struct ldb_message ***res)
{
- int ret;
- ret = ldb->ops->search(ldb, base, scope, expression, attrs, res);
-
- ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_search(%s) -> %d records\n",
- expression, ret);
- return ret;
+ return ldb->modules->ops->search(ldb->modules, base, scope, expression, attrs, res);
}
/*
@@ -97,7 +103,7 @@ int ldb_search(struct ldb_context *ldb,
*/
int ldb_search_free(struct ldb_context *ldb, struct ldb_message **msgs)
{
- return ldb->ops->search_free(ldb, msgs);
+ return ldb->modules->ops->search_free(ldb->modules, msgs);
}
@@ -108,10 +114,7 @@ int ldb_search_free(struct ldb_context *ldb, struct ldb_message **msgs)
int ldb_add(struct ldb_context *ldb,
const struct ldb_message *message)
{
- int ret;
- ret = ldb->ops->add_record(ldb, message);
- ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_add(%s) -> %d\n", message->dn, ret);
- return ret;
+ return ldb->modules->ops->add_record(ldb->modules, message);
}
/*
@@ -120,11 +123,7 @@ int ldb_add(struct ldb_context *ldb,
int ldb_modify(struct ldb_context *ldb,
const struct ldb_message *message)
{
- int ret;
- ret = ldb->ops->modify_record(ldb, message);
- ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_modify(%s) -> %d\n",
- message->dn, ret);
- return ret;
+ return ldb->modules->ops->modify_record(ldb->modules, message);
}
@@ -133,10 +132,7 @@ int ldb_modify(struct ldb_context *ldb,
*/
int ldb_delete(struct ldb_context *ldb, const char *dn)
{
- int ret;
- ret = ldb->ops->delete_record(ldb, dn);
- ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_delete(%s) -> %d\n", dn, ret);
- return ret;
+ return ldb->modules->ops->delete_record(ldb->modules, dn);
}
/*
@@ -144,10 +140,7 @@ int ldb_delete(struct ldb_context *ldb, const char *dn)
*/
int ldb_rename(struct ldb_context *ldb, const char *olddn, const char *newdn)
{
- int ret;
- ret = ldb->ops->rename_record(ldb, olddn, newdn);
- ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_rename(%s,%s) -> %d\n", olddn, newdn);
- return ret;
+ return ldb->modules->ops->rename_record(ldb->modules, olddn, newdn);
}
/*
@@ -155,5 +148,6 @@ int ldb_rename(struct ldb_context *ldb, const char *olddn, const char *newdn)
*/
const char *ldb_errstring(struct ldb_context *ldb)
{
- return ldb->ops->errstring(ldb);
+ return ldb->modules->ops->errstring(ldb->modules);
}
+
diff --git a/source4/lib/ldb/config.mk b/source4/lib/ldb/config.mk
index 81c6382292..46fd4e12ae 100644
--- a/source4/lib/ldb/config.mk
+++ b/source4/lib/ldb/config.mk
@@ -1,4 +1,13 @@
################################################
+# Start MODULE libldb_timestamps
+[MODULE::libldb_timestamps]
+SUBSYSTEM = LIBLDB
+INIT_OBJ_FILES = \
+ lib/ldb/modules/timestamps.o
+# End MODULE libldb_timestamps
+################################################
+
+################################################
# Start MODULE libldb_ldap
[MODULE::libldb_ldap]
SUBSYSTEM = LIBLDB
@@ -38,7 +47,8 @@ ADD_OBJ_FILES = \
lib/ldb/common/util.o \
lib/ldb/common/ldb_utf8.o \
lib/ldb/common/ldb_alloc.o \
- lib/ldb/common/ldb_debug.o
+ lib/ldb/common/ldb_debug.o \
+ lib/ldb/common/ldb_modules.o
REQUIRED_SUBSYSTEMS = \
LIBREPLACE
#
diff --git a/source4/lib/ldb/include/ldb.h b/source4/lib/ldb/include/ldb.h
index 3c78f12fb5..6a06678e0e 100644
--- a/source4/lib/ldb/include/ldb.h
+++ b/source4/lib/ldb/include/ldb.h
@@ -121,26 +121,39 @@ struct ldb_context;
typedef int (*ldb_traverse_fn)(struct ldb_context *, const struct ldb_message *);
+struct ldb_module_ops;
+
+/* basic module structure */
+struct ldb_module {
+ struct ldb_module *prev, *next;
+ struct ldb_context *ldb;
+ void *private_data;
+ const struct ldb_module_ops *ops;
+};
+
/*
- these function pointers define the operations that a ldb backend must perform
+ these function pointers define the operations that a ldb module must perform
they correspond exactly to the ldb_*() interface
*/
-struct ldb_backend_ops {
- int (*close)(struct ldb_context *);
- int (*search)(struct ldb_context *, const char *, enum ldb_scope,
+struct ldb_module_ops {
+ const char *name;
+ int (*close)(struct ldb_module *);
+ int (*search)(struct ldb_module *, const char *, enum ldb_scope,
const char *, const char * const [], struct ldb_message ***);
- int (*search_free)(struct ldb_context *, struct ldb_message **);
- int (*add_record)(struct ldb_context *, const struct ldb_message *);
- int (*modify_record)(struct ldb_context *, const struct ldb_message *);
- int (*delete_record)(struct ldb_context *, const char *);
- int (*rename_record)(struct ldb_context *, const char *olddn, const char *newdn);
- const char * (*errstring)(struct ldb_context *);
+ int (*search_free)(struct ldb_module *, struct ldb_message **);
+ int (*add_record)(struct ldb_module *, const struct ldb_message *);
+ int (*modify_record)(struct ldb_module *, const struct ldb_message *);
+ int (*delete_record)(struct ldb_module *, const char *);
+ int (*rename_record)(struct ldb_module *, const char *, const char *);
+ const char * (*errstring)(struct ldb_module *);
/* this is called when the alloc ops changes to ensure we
don't have any old allocated data in the context */
- void (*cache_free)(struct ldb_context *);
+ void (*cache_free)(struct ldb_module *);
};
+/* the modules init function */
+typedef struct ldb_module *(*init_ldb_module_function)(void);
/*
the user can optionally supply a allocator function. It is presumed
@@ -172,11 +185,8 @@ struct ldb_debug_ops {
every ldb connection is started by establishing a ldb_context
*/
struct ldb_context {
- /* a private pointer for the backend to use */
- void *private_data;
-
/* the operations provided by the backend */
- const struct ldb_backend_ops *ops;
+ struct ldb_module *modules;
/* memory allocation info */
struct ldb_alloc_ops alloc_ops;
diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 9ac51b26fe..96aee088a7 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -68,10 +68,11 @@ static const char *lldb_option_find(const struct lldb_private *lldb, const char
/*
close/free the connection
*/
-static int lldb_close(struct ldb_context *ldb)
+static int lldb_close(struct ldb_module *module)
{
int i, ret = 0;
- struct lldb_private *lldb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct lldb_private *lldb = module->private_data;
if (ldap_unbind(lldb->ldap) != LDAP_SUCCESS) {
ret = -1;
@@ -94,9 +95,10 @@ static int lldb_close(struct ldb_context *ldb)
/*
rename a record
*/
-static int lldb_rename(struct ldb_context *ldb, const char *olddn, const char *newdn)
+static int lldb_rename(struct ldb_module *module, const char *olddn, const char *newdn)
{
- struct lldb_private *lldb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct lldb_private *lldb = module->private_data;
int ret = 0;
char *newrdn, *p;
const char *parentdn = "";
@@ -129,9 +131,9 @@ static int lldb_rename(struct ldb_context *ldb, const char *olddn, const char *n
/*
delete a record
*/
-static int lldb_delete(struct ldb_context *ldb, const char *dn)
+static int lldb_delete(struct ldb_module *module, const char *dn)
{
- struct lldb_private *lldb = ldb->private_data;
+ struct lldb_private *lldb = module->private_data;
int ret = 0;
/* ignore ltdb specials */
@@ -171,8 +173,9 @@ static int lldb_msg_free(struct ldb_context *ldb, struct ldb_message *msg)
/*
free a search result
*/
-static int lldb_search_free(struct ldb_context *ldb, struct ldb_message **res)
+static int lldb_search_free(struct ldb_module *module, struct ldb_message **res)
{
+ struct ldb_context *ldb = module->ldb;
int i;
for (i=0;res[i];i++) {
if (lldb_msg_free(ldb, res[i]) != 0) {
@@ -243,11 +246,12 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
/*
search for matching records
*/
-static int lldb_search(struct ldb_context *ldb, const char *base,
+static int lldb_search(struct ldb_module *module, const char *base,
enum ldb_scope scope, const char *expression,
const char * const *attrs, struct ldb_message ***res)
{
- struct lldb_private *lldb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct lldb_private *lldb = module->private_data;
int count, msg_count;
LDAPMessage *ldapres, *msg;
@@ -335,7 +339,7 @@ static int lldb_search(struct ldb_context *ldb, const char *base,
return msg_count;
failed:
- if (*res) lldb_search_free(ldb, *res);
+ if (*res) lldb_search_free(module, *res);
return -1;
}
@@ -434,9 +438,10 @@ failed:
/*
add a record
*/
-static int lldb_add(struct ldb_context *ldb, const struct ldb_message *msg)
+static int lldb_add(struct ldb_module *module, const struct ldb_message *msg)
{
- struct lldb_private *lldb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct lldb_private *lldb = module->private_data;
LDAPMod **mods;
int ret = 0;
@@ -461,9 +466,10 @@ static int lldb_add(struct ldb_context *ldb, const struct ldb_message *msg)
/*
modify a record
*/
-static int lldb_modify(struct ldb_context *ldb, const struct ldb_message *msg)
+static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
{
- struct lldb_private *lldb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct lldb_private *lldb = module->private_data;
LDAPMod **mods;
int ret = 0;
@@ -488,14 +494,15 @@ static int lldb_modify(struct ldb_context *ldb, const struct ldb_message *msg)
/*
return extended error information
*/
-static const char *lldb_errstring(struct ldb_context *ldb)
+static const char *lldb_errstring(struct ldb_module *module)
{
- struct lldb_private *lldb = ldb->private_data;
+ struct lldb_private *lldb = module->private_data;
return ldap_err2string(lldb->last_rc);
}
-static const struct ldb_backend_ops lldb_ops = {
+static const struct ldb_module_ops lldb_ops = {
+ "ldap",
lldb_close,
lldb_search,
lldb_search_free,
@@ -544,8 +551,16 @@ struct ldb_context *lldb_connect(const char *url,
goto failed;
}
- ldb->ops = &lldb_ops;
- ldb->private_data = lldb;
+ ldb->modules = ldb_malloc_p(ldb, struct ldb_module);
+ if (!ldb->modules) {
+ ldb_free(ldb, ldb);
+ errno = ENOMEM;
+ goto failed;
+ }
+ ldb->modules->ldb = ldb;
+ ldb->modules->prev = ldb->modules->next = NULL;
+ ldb->modules->private_data = lldb;
+ ldb->modules->ops = &lldb_ops;
if (options) {
/* take a copy of the options array, so we don't have to rely
diff --git a/source4/lib/ldb/ldb_tdb/ldb_cache.c b/source4/lib/ldb/ldb_tdb/ldb_cache.c
index 55dea406b5..cf175090e6 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_cache.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_cache.c
@@ -38,9 +38,10 @@
/*
initialise the baseinfo record
*/
-static int ltdb_baseinfo_init(struct ldb_context *ldb)
+static int ltdb_baseinfo_init(struct ldb_module *module)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
struct ldb_message msg;
struct ldb_message_element el;
struct ldb_val val;
@@ -77,7 +78,7 @@ static int ltdb_baseinfo_init(struct ldb_context *ldb)
}
val.length = 1;
- ret = ltdb_store(ldb, &msg, TDB_INSERT);
+ ret = ltdb_store(module, &msg, TDB_INSERT);
ldb_free(ldb, msg.dn);
ldb_free(ldb, el.name);
@@ -89,17 +90,18 @@ static int ltdb_baseinfo_init(struct ldb_context *ldb)
/*
free any cache records
*/
-void ltdb_cache_free(struct ldb_context *ldb)
+void ltdb_cache_free(struct ldb_module *module)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
struct ldb_alloc_ops alloc = ldb->alloc_ops;
ldb->alloc_ops.alloc = NULL;
ltdb->sequence_number = 0;
- ltdb_search_dn1_free(ldb, &ltdb->cache.baseinfo);
- ltdb_search_dn1_free(ldb, &ltdb->cache.indexlist);
- ltdb_search_dn1_free(ldb, &ltdb->cache.subclasses);
- ltdb_search_dn1_free(ldb, &ltdb->cache.attributes);
+ ltdb_search_dn1_free(module, &ltdb->cache.baseinfo);
+ ltdb_search_dn1_free(module, &ltdb->cache.indexlist);
+ ltdb_search_dn1_free(module, &ltdb->cache.subclasses);
+ ltdb_search_dn1_free(module, &ltdb->cache.attributes);
ldb_free(ldb, ltdb->cache.last_attribute.name);
memset(&ltdb->cache, 0, sizeof(ltdb->cache));
@@ -110,26 +112,27 @@ void ltdb_cache_free(struct ldb_context *ldb)
/*
load the cache records
*/
-int ltdb_cache_load(struct ldb_context *ldb)
+int ltdb_cache_load(struct ldb_module *module)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
double seq;
struct ldb_alloc_ops alloc = ldb->alloc_ops;
ldb->alloc_ops.alloc = NULL;
- ltdb_search_dn1_free(ldb, &ltdb->cache.baseinfo);
+ ltdb_search_dn1_free(module, &ltdb->cache.baseinfo);
- if (ltdb_search_dn1(ldb, LTDB_BASEINFO, &ltdb->cache.baseinfo) == -1) {
+ if (ltdb_search_dn1(module, LTDB_BASEINFO, &ltdb->cache.baseinfo) == -1) {
goto failed;
}
/* possibly initialise the baseinfo */
if (!ltdb->cache.baseinfo.dn) {
- if (ltdb_baseinfo_init(ldb) != 0) {
+ if (ltdb_baseinfo_init(module) != 0) {
goto failed;
}
- if (ltdb_search_dn1(ldb, LTDB_BASEINFO, &ltdb->cache.baseinfo) != 1) {
+ if (ltdb_search_dn1(module, LTDB_BASEINFO, &ltdb->cache.baseinfo) != 1) {
goto failed;
}
}
@@ -145,17 +148,17 @@ int ltdb_cache_load(struct ldb_context *ldb)
ldb_free(ldb, ltdb->cache.last_attribute.name);
memset(&ltdb->cache.last_attribute, 0, sizeof(ltdb->cache.last_attribute));
- ltdb_search_dn1_free(ldb, &ltdb->cache.indexlist);
- ltdb_search_dn1_free(ldb, &ltdb->cache.subclasses);
- ltdb_search_dn1_free(ldb, &ltdb->cache.attributes);
+ ltdb_search_dn1_free(module, &ltdb->cache.indexlist);
+ ltdb_search_dn1_free(module, &ltdb->cache.subclasses);
+ ltdb_search_dn1_free(module, &ltdb->cache.attributes);
- if (ltdb_search_dn1(ldb, LTDB_INDEXLIST, &ltdb->cache.indexlist) == -1) {
+ if (ltdb_search_dn1(module, LTDB_INDEXLIST, &ltdb->cache.indexlist) == -1) {
goto failed;
}
- if (ltdb_search_dn1(ldb, LTDB_SUBCLASSES, &ltdb->cache.subclasses) == -1) {
+ if (ltdb_search_dn1(module, LTDB_SUBCLASSES, &ltdb->cache.subclasses) == -1) {
goto failed;
}
- if (ltdb_search_dn1(ldb, LTDB_ATTRIBUTES, &ltdb->cache.attributes) == -1) {
+ if (ltdb_search_dn1(module, LTDB_ATTRIBUTES, &ltdb->cache.attributes) == -1) {
goto failed;
}
@@ -172,9 +175,10 @@ failed:
/*
increase the sequence number to indicate a database change
*/
-int ltdb_increase_sequence_number(struct ldb_context *ldb)
+int ltdb_increase_sequence_number(struct ldb_module *module)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
struct ldb_message msg;
struct ldb_message_element el;
struct ldb_val val;
@@ -197,7 +201,7 @@ int ltdb_increase_sequence_number(struct ldb_context *ldb)
val.data = s;
val.length = strlen(s);
- ret = ltdb_modify_internal(ldb, &msg);
+ ret = ltdb_modify_internal(module, &msg);
ldb_free(ldb, s);
ldb_free(ldb, msg.dn);
@@ -215,9 +219,10 @@ int ltdb_increase_sequence_number(struct ldb_context *ldb)
return the attribute flags from the @ATTRIBUTES record
for the given attribute
*/
-int ltdb_attribute_flags(struct ldb_context *ldb, const char *attr_name)
+int ltdb_attribute_flags(struct ldb_module *module, const char *attr_name)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
const char *attrs;
const struct {
const char *name;
diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index cfd097e361..d54208777d 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -107,11 +107,12 @@ static int list_cmp(const char **s1, const char **s2)
/*
return a list of dn's that might match a simple indexed search or
*/
-static int ltdb_index_dn_simple(struct ldb_context *ldb,
+static int ltdb_index_dn_simple(struct ldb_module *module,
struct ldb_parse_tree *tree,
const struct ldb_message *index_list,
struct dn_list *list)
{
+ struct ldb_context *ldb = module->ldb;
char *dn = NULL;
int ret;
unsigned int i, j;
@@ -123,7 +124,7 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
/*
if the value is a wildcard then we can't do a match via indexing
*/
- if (ltdb_has_wildcard(ldb, tree->u.simple.attr, &tree->u.simple.value)) {
+ if (ltdb_has_wildcard(module, tree->u.simple.attr, &tree->u.simple.value)) {
return -1;
}
@@ -138,7 +139,7 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
dn = ldb_dn_key(ldb, tree->u.simple.attr, &tree->u.simple.value);
if (!dn) return -1;
- ret = ltdb_search_dn1(ldb, dn, &msg);
+ ret = ltdb_search_dn1(module, dn, &msg);
ldb_free(ldb, dn);
if (ret == 0 || ret == -1) {
return ret;
@@ -163,14 +164,14 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
ldb_strdup(ldb, (char *)el->values[j].data);
if (!list->dn[list->count]) {
dn_list_free(ldb, list);
- ltdb_search_dn1_free(ldb, &msg);
+ ltdb_search_dn1_free(module, &msg);
return -1;
}
list->count++;
}
}
- ltdb_search_dn1_free(ldb, &msg);
+ ltdb_search_dn1_free(module, &msg);
qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t) list_cmp);
@@ -184,12 +185,13 @@ static int list_union(struct ldb_context *, struct dn_list *, const struct dn_li
return a list of dn's that might match a simple indexed search on
the special objectclass attribute
*/
-static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
+static int ltdb_index_dn_objectclass(struct ldb_module *module,
struct ldb_parse_tree *tree,
const struct ldb_message *index_list,
struct dn_list *list)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
unsigned int i;
int ret;
const char *target = tree->u.simple.value.data;
@@ -197,7 +199,7 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
list->count = 0;
list->dn = NULL;
- ret = ltdb_index_dn_simple(ldb, tree, index_list, list);
+ ret = ltdb_index_dn_simple(module, tree, index_list, list);
for (i=0;i<ltdb->cache.subclasses.num_elements;i++) {
struct ldb_message_element *el = &ltdb->cache.subclasses.elements[i];
@@ -212,7 +214,7 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
return -1;
}
tree2.u.simple.value = el->values[j];
- if (ltdb_index_dn_objectclass(ldb, &tree2,
+ if (ltdb_index_dn_objectclass(module, &tree2,
index_list, &list2) == 1) {
if (list->count == 0) {
*list = list2;
@@ -233,15 +235,15 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
/*
return a list of dn's that might match a leaf indexed search
*/
-static int ltdb_index_dn_leaf(struct ldb_context *ldb,
+static int ltdb_index_dn_leaf(struct ldb_module *module,
struct ldb_parse_tree *tree,
const struct ldb_message *index_list,
struct dn_list *list)
{
if (ldb_attr_cmp(tree->u.simple.attr, LTDB_OBJECTCLASS) == 0) {
- return ltdb_index_dn_objectclass(ldb, tree, index_list, list);
+ return ltdb_index_dn_objectclass(module, tree, index_list, list);
}
- return ltdb_index_dn_simple(ldb, tree, index_list, list);
+ return ltdb_index_dn_simple(module, tree, index_list, list);
}
@@ -331,7 +333,7 @@ static int list_union(struct ldb_context *ldb,
return 0;
}
-static int ltdb_index_dn(struct ldb_context *ldb,
+static int ltdb_index_dn(struct ldb_module *module,
struct ldb_parse_tree *tree,
const struct ldb_message *index_list,
struct dn_list *list);
@@ -340,11 +342,12 @@ static int ltdb_index_dn(struct ldb_context *ldb,
/*
OR two index results
*/
-static int ltdb_index_dn_or(struct ldb_context *ldb,
+static int ltdb_index_dn_or(struct ldb_module *module,
struct ldb_parse_tree *tree,
const struct ldb_message *index_list,
struct dn_list *list)
{
+ struct ldb_context *ldb = module->ldb;
unsigned int i;
int ret;
@@ -355,7 +358,7 @@ static int ltdb_index_dn_or(struct ldb_context *ldb,
for (i=0;i<tree->u.list.num_elements;i++) {
struct dn_list list2;
int v;
- v = ltdb_index_dn(ldb, tree->u.list.elements[i], index_list, &list2);
+ v = ltdb_index_dn(module, tree->u.list.elements[i], index_list, &list2);
if (v == 0) {
/* 0 || X == X */
@@ -395,7 +398,7 @@ static int ltdb_index_dn_or(struct ldb_context *ldb,
/*
NOT an index results
*/
-static int ltdb_index_dn_not(struct ldb_context *ldb,
+static int ltdb_index_dn_not(struct ldb_module *module,
struct ldb_parse_tree *tree,
const struct ldb_message *index_list,
struct dn_list *list)
@@ -414,11 +417,12 @@ static int ltdb_index_dn_not(struct ldb_context *ldb,
/*
AND two index results
*/
-static int ltdb_index_dn_and(struct ldb_context *ldb,
+static int ltdb_index_dn_and(struct ldb_module *module,
struct ldb_parse_tree *tree,
const struct ldb_message *index_list,
struct dn_list *list)
{
+ struct ldb_context *ldb = module->ldb;
unsigned int i;
int ret;
@@ -429,7 +433,7 @@ static int ltdb_index_dn_and(struct ldb_context *ldb,
for (i=0;i<tree->u.list.num_elements;i++) {
struct dn_list list2;
int v;
- v = ltdb_index_dn(ldb, tree->u.list.elements[i], index_list, &list2);
+ v = ltdb_index_dn(module, tree->u.list.elements[i], index_list, &list2);
if (v == 0) {
/* 0 && X == 0 */
@@ -465,7 +469,7 @@ static int ltdb_index_dn_and(struct ldb_context *ldb,
return a list of dn's that might match a indexed search or
-1 if an error. return 0 for no matches, or 1 for matches
*/
-static int ltdb_index_dn(struct ldb_context *ldb,
+static int ltdb_index_dn(struct ldb_module *module,
struct ldb_parse_tree *tree,
const struct ldb_message *index_list,
struct dn_list *list)
@@ -474,19 +478,19 @@ static int ltdb_index_dn(struct ldb_context *ldb,
switch (tree->operation) {
case LDB_OP_SIMPLE:
- ret = ltdb_index_dn_leaf(ldb, tree, index_list, list);
+ ret = ltdb_index_dn_leaf(module, tree, index_list, list);
break;
case LDB_OP_AND:
- ret = ltdb_index_dn_and(ldb, tree, index_list, list);
+ ret = ltdb_index_dn_and(module, tree, index_list, list);
break;
case LDB_OP_OR:
- ret = ltdb_index_dn_or(ldb, tree, index_list, list);
+ ret = ltdb_index_dn_or(module, tree, index_list, list);
break;
case LDB_OP_NOT:
- ret = ltdb_index_dn_not(ldb, tree, index_list, list);
+ ret = ltdb_index_dn_not(module, tree, index_list, list);
break;
}
@@ -497,7 +501,7 @@ static int ltdb_index_dn(struct ldb_context *ldb,
filter a candidate dn_list from an indexed search into a set of results
extracting just the given attributes
*/
-static int ldb_index_filter(struct ldb_context *ldb, struct ldb_parse_tree *tree,
+static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tree,
const char *base,
enum ldb_scope scope,
const struct dn_list *dn_list,
@@ -508,7 +512,7 @@ static int ldb_index_filter(struct ldb_context *ldb, struct ldb_parse_tree *tree
for (i=0;i<dn_list->count;i++) {
struct ldb_message msg;
int ret;
- ret = ltdb_search_dn1(ldb, dn_list->dn[i], &msg);
+ ret = ltdb_search_dn1(module, dn_list->dn[i], &msg);
if (ret == 0) {
/* the record has disappeared? yes, this can happen */
continue;
@@ -519,10 +523,10 @@ static int ldb_index_filter(struct ldb_context *ldb, struct ldb_parse_tree *tree
return -1;
}
- if (ldb_message_match(ldb, &msg, tree, base, scope) == 1) {
- ret = ltdb_add_attr_results(ldb, &msg, attrs, &count, res);
+ if (ldb_message_match(module, &msg, tree, base, scope) == 1) {
+ ret = ltdb_add_attr_results(module, &msg, attrs, &count, res);
}
- ltdb_search_dn1_free(ldb, &msg);
+ ltdb_search_dn1_free(module, &msg);
if (ret != 0) {
return -1;
}
@@ -536,13 +540,14 @@ static int ldb_index_filter(struct ldb_context *ldb, struct ldb_parse_tree *tree
returns -1 if an indexed search is not possible, in which
case the caller should call ltdb_search_full()
*/
-int ltdb_search_indexed(struct ldb_context *ldb,
+int ltdb_search_indexed(struct ldb_module *module,
const char *base,
enum ldb_scope scope,
struct ldb_parse_tree *tree,
const char * const attrs[], struct ldb_message ***res)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
struct dn_list dn_list;
int ret;
@@ -551,12 +556,12 @@ int ltdb_search_indexed(struct ldb_context *ldb,
return -1;
}
- ret = ltdb_index_dn(ldb, tree, &ltdb->cache.indexlist, &dn_list);
+ ret = ltdb_index_dn(module, tree, &ltdb->cache.indexlist, &dn_list);
if (ret == 1) {
/* we've got a candidate list - now filter by the full tree
and extract the needed attributes */
- ret = ldb_index_filter(ldb, tree, base, scope, &dn_list,
+ ret = ldb_index_filter(module, tree, base, scope, &dn_list,
attrs, res);
dn_list_free(ldb, &dn_list);
}
@@ -638,9 +643,10 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
/*
add an index entry for one message element
*/
-static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
+static int ltdb_index_add1(struct ldb_module *module, char *dn,
struct ldb_message_element *el, int v_idx)
{
+ struct ldb_context *ldb = module->ldb;
struct ldb_message msg;
char *dn_key;
int ret, added=0, added_dn=0;
@@ -651,7 +657,7 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
return -1;
}
- ret = ltdb_search_dn1(ldb, dn_key, &msg);
+ ret = ltdb_search_dn1(module, dn_key, &msg);
if (ret == -1) {
ldb_free(ldb, dn_key);
return -1;
@@ -686,7 +692,7 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
}
if (ret == 0) {
- ret = ltdb_store(ldb, &msg, TDB_REPLACE);
+ ret = ltdb_store(module, &msg, TDB_REPLACE);
}
if (added) {
@@ -696,7 +702,7 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
ldb_free(ldb, msg.dn);
}
- ltdb_search_dn1_free(ldb, &msg);
+ ltdb_search_dn1_free(module, &msg);
return ret;
}
@@ -705,9 +711,9 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
add the index entries for a new record
return -1 on failure
*/
-int ltdb_index_add(struct ldb_context *ldb, const struct ldb_message *msg)
+int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ltdb_private *ltdb = module->private_data;
int ret;
unsigned int i, j;
@@ -723,7 +729,7 @@ int ltdb_index_add(struct ldb_context *ldb, const struct ldb_message *msg)
continue;
}
for (j=0;j<msg->elements[i].num_values;j++) {
- ret = ltdb_index_add1(ldb, msg->dn, &msg->elements[i], j);
+ ret = ltdb_index_add1(module, msg->dn, &msg->elements[i], j);
if (ret == -1) {
return -1;
}
@@ -737,9 +743,10 @@ int ltdb_index_add(struct ldb_context *ldb, const struct ldb_message *msg)
/*
delete an index entry for one message element
*/
-static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
+static int ltdb_index_del1(struct ldb_module *module, const char *dn,
struct ldb_message_element *el, int v_idx)
{
+ struct ldb_context *ldb = module->ldb;
struct ldb_message msg;
char *dn_key;
int ret, i;
@@ -750,7 +757,7 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
return -1;
}
- ret = ltdb_search_dn1(ldb, dn_key, &msg);
+ ret = ltdb_search_dn1(module, dn_key, &msg);
if (ret == -1) {
ldb_free(ldb, dn_key);
return -1;
@@ -768,7 +775,7 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
if (i == -1) {
ldb_debug(ldb, LDB_DEBUG_ERROR, "ERROR: dn %s not found in %s\n", dn, dn_key);
/* it ain't there. hmmm */
- ltdb_search_dn1_free(ldb, &msg);
+ ltdb_search_dn1_free(module, &msg);
ldb_free(ldb, dn_key);
return 0;
}
@@ -782,12 +789,12 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
msg.elements[i].num_values--;
if (msg.elements[i].num_values == 0) {
- ret = ltdb_delete_noindex(ldb, dn_key);
+ ret = ltdb_delete_noindex(module, dn_key);
} else {
- ret = ltdb_store(ldb, &msg, TDB_REPLACE);
+ ret = ltdb_store(module, &msg, TDB_REPLACE);
}
- ltdb_search_dn1_free(ldb, &msg);
+ ltdb_search_dn1_free(module, &msg);
ldb_free(ldb, dn_key);
return ret;
@@ -797,9 +804,9 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
delete the index entries for a record
return -1 on failure
*/
-int ltdb_index_del(struct ldb_context *ldb, const struct ldb_message *msg)
+int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ltdb_private *ltdb = module->private_data;
int ret;
unsigned int i, j;
@@ -816,7 +823,7 @@ int ltdb_index_del(struct ldb_context *ldb, const struct ldb_message *msg)
continue;
}
for (j=0;j<msg->elements[i].num_values;j++) {
- ret = ltdb_index_del1(ldb, msg->dn, &msg->elements[i], j);
+ ret = ltdb_index_del1(module, msg->dn, &msg->elements[i], j);
if (ret == -1) {
return -1;
}
@@ -844,7 +851,7 @@ static int delete_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, vo
*/
static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
{
- struct ldb_context *ldb = state;
+ struct ldb_module *module = state;
struct ldb_message msg;
int ret;
@@ -853,7 +860,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
return 0;
}
- ret = ltdb_unpack_data(ldb, &data, &msg);
+ ret = ltdb_unpack_data(module->ldb, &data, &msg);
if (ret != 0) {
return -1;
}
@@ -862,9 +869,9 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
msg.dn = key.dptr+3;
}
- ret = ltdb_index_add(ldb, &msg);
+ ret = ltdb_index_add(module, &msg);
- ltdb_unpack_data_free(ldb, &msg);
+ ltdb_unpack_data_free(module->ldb, &msg);
return ret;
}
@@ -872,14 +879,14 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
/*
force a complete reindex of the database
*/
-int ltdb_reindex(struct ldb_context *ldb)
+int ltdb_reindex(struct ldb_module *module)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ltdb_private *ltdb = module->private_data;
int ret;
- ltdb_cache_free(ldb);
+ ltdb_cache_free(module);
- if (ltdb_cache_load(ldb) != 0) {
+ if (ltdb_cache_load(module) != 0) {
return -1;
}
@@ -891,7 +898,7 @@ int ltdb_reindex(struct ldb_context *ldb)
}
/* now traverse adding any indexes for normal LDB records */
- ret = tdb_traverse(ltdb->tdb, re_index, ldb);
+ ret = tdb_traverse(ltdb->tdb, re_index, module);
if (ret == -1) {
errno = EIO;
return -1;
diff --git a/source4/lib/ldb/ldb_tdb/ldb_match.c b/source4/lib/ldb/ldb_tdb/ldb_match.c
index 6f55496042..52e9f5afc7 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_match.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_match.c
@@ -137,10 +137,10 @@ static int ldb_val_equal_wildcard(struct ldb_context *ldb,
return 1 for a match, 0 for a mis-match
*/
-static int ldb_val_equal_objectclass(struct ldb_context *ldb,
+static int ldb_val_equal_objectclass(struct ldb_module *module,
const struct ldb_val *v1, const struct ldb_val *v2)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ltdb_private *ltdb = module->private_data;
unsigned int i;
if (ldb_val_equal_case_insensitive(v1, v2) == 1) {
@@ -152,7 +152,7 @@ static int ldb_val_equal_objectclass(struct ldb_context *ldb,
if (ldb_attr_cmp(el->name, v2->data) == 0) {
unsigned int j;
for (j=0;j<el->num_values;j++) {
- if (ldb_val_equal_objectclass(ldb, v1, &el->values[j])) {
+ if (ldb_val_equal_objectclass(module, v1, &el->values[j])) {
return 1;
}
}
@@ -171,14 +171,15 @@ static int ldb_val_equal_objectclass(struct ldb_context *ldb,
return 1 for a match, 0 for a mis-match
*/
-int ldb_val_equal(struct ldb_context *ldb,
+int ldb_val_equal(struct ldb_module *module,
const char *attr_name,
const struct ldb_val *v1, const struct ldb_val *v2)
{
- int flags = ltdb_attribute_flags(ldb, attr_name);
+ struct ldb_context *ldb = module->ldb;
+ int flags = ltdb_attribute_flags(module, attr_name);
if (flags & LTDB_FLAG_OBJECTCLASS) {
- return ldb_val_equal_objectclass(ldb, v1, v2);
+ return ldb_val_equal_objectclass(module, v1, v2);
}
if (flags & LTDB_FLAG_INTEGER) {
@@ -254,7 +255,7 @@ static int scope_match(const char *dn, const char *base, enum ldb_scope scope)
/*
match a leaf node
*/
-static int match_leaf(struct ldb_context *ldb,
+static int match_leaf(struct ldb_module *module,
struct ldb_message *msg,
struct ldb_parse_tree *tree,
const char *base,
@@ -279,7 +280,7 @@ static int match_leaf(struct ldb_context *ldb,
return 1;
}
for (j=0;j<msg->elements[i].num_values;j++) {
- if (ldb_val_equal(ldb, msg->elements[i].name,
+ if (ldb_val_equal(module, msg->elements[i].name,
&msg->elements[i].values[j],
&tree->u.simple.value)) {
return 1;
@@ -299,7 +300,7 @@ static int match_leaf(struct ldb_context *ldb,
this is a recursive function, and does short-circuit evaluation
*/
-int ldb_message_match(struct ldb_context *ldb,
+int ldb_message_match(struct ldb_module *module,
struct ldb_message *msg,
struct ldb_parse_tree *tree,
const char *base,
@@ -313,11 +314,11 @@ int ldb_message_match(struct ldb_context *ldb,
break;
case LDB_OP_NOT:
- return ! ldb_message_match(ldb, msg, tree->u.not.child, base, scope);
+ return ! ldb_message_match(module, msg, tree->u.not.child, base, scope);
case LDB_OP_AND:
for (i=0;i<tree->u.list.num_elements;i++) {
- v = ldb_message_match(ldb, msg, tree->u.list.elements[i],
+ v = ldb_message_match(module, msg, tree->u.list.elements[i],
base, scope);
if (!v) return 0;
}
@@ -325,12 +326,12 @@ int ldb_message_match(struct ldb_context *ldb,
case LDB_OP_OR:
for (i=0;i<tree->u.list.num_elements;i++) {
- v = ldb_message_match(ldb, msg, tree->u.list.elements[i],
+ v = ldb_message_match(module, msg, tree->u.list.elements[i],
base, scope);
if (v) return 1;
}
return 0;
}
- return match_leaf(ldb, msg, tree, base, scope);
+ return match_leaf(module, msg, tree, base, scope);
}
diff --git a/source4/lib/ldb/ldb_tdb/ldb_search.c b/source4/lib/ldb/ldb_tdb/ldb_search.c
index 18d51d1aa4..cb93483881 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_search.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_search.c
@@ -131,12 +131,14 @@ static int msg_add_element(struct ldb_context *ldb,
/*
add all elements from one message into another
*/
-static int msg_add_all_elements(struct ldb_context *ldb, struct ldb_message *ret,
+static int msg_add_all_elements(struct ldb_module *module, struct ldb_message *ret,
const struct ldb_message *msg)
{
+ struct ldb_context *ldb = module->ldb;
unsigned int i;
+
for (i=0;i<msg->num_elements;i++) {
- int flags = ltdb_attribute_flags(ldb, msg->elements[i].name);
+ int flags = ltdb_attribute_flags(module, msg->elements[i].name);
if ((msg->dn[0] != '@') && (flags & LTDB_FLAG_HIDDEN)) {
continue;
}
@@ -152,10 +154,11 @@ static int msg_add_all_elements(struct ldb_context *ldb, struct ldb_message *ret
/*
pull the specified list of attributes from a message
*/
-static struct ldb_message *ltdb_pull_attrs(struct ldb_context *ldb,
+static struct ldb_message *ltdb_pull_attrs(struct ldb_module *module,
const struct ldb_message *msg,
const char * const *attrs)
{
+ struct ldb_context *ldb = module->ldb;
struct ldb_message *ret;
int i;
@@ -175,7 +178,7 @@ static struct ldb_message *ltdb_pull_attrs(struct ldb_context *ldb,
ret->private_data = NULL;
if (!attrs) {
- if (msg_add_all_elements(ldb, ret, msg) != 0) {
+ if (msg_add_all_elements(module, ret, msg) != 0) {
msg_free_all_parts(ldb, ret);
return NULL;
}
@@ -186,7 +189,7 @@ static struct ldb_message *ltdb_pull_attrs(struct ldb_context *ldb,
struct ldb_message_element *el;
if (strcmp(attrs[i], "*") == 0) {
- if (msg_add_all_elements(ldb, ret, msg) != 0) {
+ if (msg_add_all_elements(module, ret, msg) != 0) {
msg_free_all_parts(ldb, ret);
return NULL;
}
@@ -237,7 +240,7 @@ static struct ldb_message *ltdb_pull_attrs(struct ldb_context *ldb,
see if a ldb_val is a wildcard
return 1 if yes, 0 if no
*/
-int ltdb_has_wildcard(struct ldb_context *ldb, const char *attr_name,
+int ltdb_has_wildcard(struct ldb_module *module, const char *attr_name,
const struct ldb_val *val)
{
int flags;
@@ -251,7 +254,7 @@ int ltdb_has_wildcard(struct ldb_context *ldb, const char *attr_name,
return 0;
}
- flags = ltdb_attribute_flags(ldb, attr_name);
+ flags = ltdb_attribute_flags(module, attr_name);
if (flags & LTDB_FLAG_WILDCARD) {
return 1;
}
@@ -263,8 +266,9 @@ int ltdb_has_wildcard(struct ldb_context *ldb, const char *attr_name,
/*
free the results of a ltdb_search_dn1 search
*/
-void ltdb_search_dn1_free(struct ldb_context *ldb, struct ldb_message *msg)
+void ltdb_search_dn1_free(struct ldb_module *module, struct ldb_message *msg)
{
+ struct ldb_context *ldb = module->ldb;
unsigned int i;
ldb_free(ldb, msg->private_data);
for (i=0;i<msg->num_elements;i++) {
@@ -281,16 +285,17 @@ void ltdb_search_dn1_free(struct ldb_context *ldb, struct ldb_message *msg)
return 1 on success, 0 on record-not-found and -1 on error
*/
-int ltdb_search_dn1(struct ldb_context *ldb, const char *dn, struct ldb_message *msg)
+int ltdb_search_dn1(struct ldb_module *module, const char *dn, struct ldb_message *msg)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
int ret;
TDB_DATA tdb_key, tdb_data, tdb_data2;
memset(msg, 0, sizeof(*msg));
/* form the key */
- tdb_key = ltdb_key(ldb, dn);
+ tdb_key = ltdb_key(module, dn);
if (!tdb_key.dptr) {
return -1;
}
@@ -335,20 +340,21 @@ int ltdb_search_dn1(struct ldb_context *ldb, const char *dn, struct ldb_message
/*
search the database for a single simple dn
*/
-int ltdb_search_dn(struct ldb_context *ldb, char *dn,
+int ltdb_search_dn(struct ldb_module *module, char *dn,
const char * const attrs[], struct ldb_message ***res)
{
+ struct ldb_context *ldb = module->ldb;
int ret;
struct ldb_message msg, *msg2;
- ret = ltdb_search_dn1(ldb, dn, &msg);
+ ret = ltdb_search_dn1(module, dn, &msg);
if (ret != 1) {
return ret;
}
- msg2 = ltdb_pull_attrs(ldb, &msg, attrs);
+ msg2 = ltdb_pull_attrs(module, &msg, attrs);
- ltdb_search_dn1_free(ldb, &msg);
+ ltdb_search_dn1_free(module, &msg);
if (!msg2) {
return -1;
@@ -371,16 +377,17 @@ int ltdb_search_dn(struct ldb_context *ldb, char *dn,
add a set of attributes from a record to a set of results
return 0 on success, -1 on failure
*/
-int ltdb_add_attr_results(struct ldb_context *ldb, struct ldb_message *msg,
+int ltdb_add_attr_results(struct ldb_module *module, struct ldb_message *msg,
const char * const attrs[],
unsigned int *count,
struct ldb_message ***res)
{
+ struct ldb_context *ldb = module->ldb;
struct ldb_message *msg2;
struct ldb_message **res2;
/* pull the attributes that the user wants */
- msg2 = ltdb_pull_attrs(ldb, msg, attrs);
+ msg2 = ltdb_pull_attrs(module, msg, attrs);
if (!msg2) {
return -1;
}
@@ -406,7 +413,7 @@ int ltdb_add_attr_results(struct ldb_context *ldb, struct ldb_message *msg,
internal search state during a full db search
*/
struct ltdb_search_info {
- struct ldb_context *ldb;
+ struct ldb_module *module;
struct ldb_parse_tree *tree;
const char *base;
enum ldb_scope scope;
@@ -432,7 +439,7 @@ static int search_func(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, voi
}
/* unpack the record */
- ret = ltdb_unpack_data(sinfo->ldb, &data, &msg);
+ ret = ltdb_unpack_data(sinfo->module->ldb, &data, &msg);
if (ret == -1) {
sinfo->failures++;
return 0;
@@ -443,19 +450,19 @@ static int search_func(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, voi
}
/* see if it matches the given expression */
- if (!ldb_message_match(sinfo->ldb, &msg, sinfo->tree,
+ if (!ldb_message_match(sinfo->module, &msg, sinfo->tree,
sinfo->base, sinfo->scope)) {
- ltdb_unpack_data_free(sinfo->ldb, &msg);
+ ltdb_unpack_data_free(sinfo->module->ldb, &msg);
return 0;
}
- ret = ltdb_add_attr_results(sinfo->ldb, &msg, sinfo->attrs, &sinfo->count, &sinfo->msgs);
+ ret = ltdb_add_attr_results(sinfo->module, &msg, sinfo->attrs, &sinfo->count, &sinfo->msgs);
if (ret == -1) {
sinfo->failures++;
}
- ltdb_unpack_data_free(sinfo->ldb, &msg);
+ ltdb_unpack_data_free(sinfo->module->ldb, &msg);
return ret;
}
@@ -464,9 +471,10 @@ static int search_func(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, voi
/*
free a set of search results
*/
-int ltdb_search_free(struct ldb_context *ldb, struct ldb_message **msgs)
+int ltdb_search_free(struct ldb_module *module, struct ldb_message **msgs)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
int i;
ltdb->last_err_string = NULL;
@@ -486,18 +494,18 @@ int ltdb_search_free(struct ldb_context *ldb, struct ldb_message **msgs)
search the database with a LDAP-like expression.
this is the "full search" non-indexed variant
*/
-static int ltdb_search_full(struct ldb_context *ldb,
+static int ltdb_search_full(struct ldb_module *module,
const char *base,
enum ldb_scope scope,
struct ldb_parse_tree *tree,
const char * const attrs[], struct ldb_message ***res)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ltdb_private *ltdb = module->private_data;
int ret;
struct ltdb_search_info sinfo;
sinfo.tree = tree;
- sinfo.ldb = ldb;
+ sinfo.module = module;
sinfo.scope = scope;
sinfo.base = base;
sinfo.attrs = attrs;
@@ -508,7 +516,7 @@ static int ltdb_search_full(struct ldb_context *ldb,
ret = tdb_traverse(ltdb->tdb, search_func, &sinfo);
if (ret == -1) {
- ltdb_search_free(ldb, sinfo.msgs);
+ ltdb_search_free(module, sinfo.msgs);
return -1;
}
@@ -521,17 +529,18 @@ static int ltdb_search_full(struct ldb_context *ldb,
search the database with a LDAP-like expression.
choses a search method
*/
-int ltdb_search(struct ldb_context *ldb, const char *base,
+int ltdb_search(struct ldb_module *module, const char *base,
enum ldb_scope scope, const char *expression,
const char * const attrs[], struct ldb_message ***res)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
struct ldb_parse_tree *tree;
int ret;
ltdb->last_err_string = NULL;
- if (ltdb_cache_load(ldb) != 0) {
+ if (ltdb_cache_load(module) != 0) {
return -1;
}
@@ -546,13 +555,13 @@ int ltdb_search(struct ldb_context *ldb, const char *base,
if (tree->operation == LDB_OP_SIMPLE &&
ldb_attr_cmp(tree->u.simple.attr, "dn") == 0 &&
- !ltdb_has_wildcard(ldb, tree->u.simple.attr, &tree->u.simple.value)) {
+ !ltdb_has_wildcard(module, tree->u.simple.attr, &tree->u.simple.value)) {
/* yay! its a nice simple one */
- ret = ltdb_search_dn(ldb, tree->u.simple.value.data, attrs, res);
+ ret = ltdb_search_dn(module, tree->u.simple.value.data, attrs, res);
} else {
- ret = ltdb_search_indexed(ldb, base, scope, tree, attrs, res);
+ ret = ltdb_search_indexed(module, base, scope, tree, attrs, res);
if (ret == -1) {
- ret = ltdb_search_full(ldb, base, scope, tree, attrs, res);
+ ret = ltdb_search_full(module, base, scope, tree, attrs, res);
}
}
diff --git a/source4/lib/ldb/ldb_tdb/ldb_tdb.c b/source4/lib/ldb/ldb_tdb/ldb_tdb.c
index 3d136ea014..a2aa5a7aca 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_tdb.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_tdb.c
@@ -45,8 +45,9 @@
note that the key for a record can depend on whether the
dn refers to a case sensitive index record or not
*/
-struct TDB_DATA ltdb_key(struct ldb_context *ldb, const char *dn)
+struct TDB_DATA ltdb_key(struct ldb_module *module, const char *dn)
{
+ struct ldb_context *ldb = module->ldb;
TDB_DATA key;
char *key_str = NULL;
char *dn_folded = NULL;
@@ -74,7 +75,7 @@ struct TDB_DATA ltdb_key(struct ldb_context *ldb, const char *dn)
if (!attr_name) {
goto failed;
}
- flags = ltdb_attribute_flags(ldb, attr_name);
+ flags = ltdb_attribute_flags(module, attr_name);
if (flags & LTDB_FLAG_CASE_INSENSITIVE) {
dn_folded = ldb_casefold(ldb, dn);
@@ -119,13 +120,14 @@ failed:
/*
lock the database for write - currently a single lock is used
*/
-static int ltdb_lock(struct ldb_context *ldb)
+static int ltdb_lock(struct ldb_module *module)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
TDB_DATA key;
int ret;
- key = ltdb_key(ldb, "LDBLOCK");
+ key = ltdb_key(module, "LDBLOCK");
if (!key.dptr) {
return -1;
}
@@ -140,12 +142,13 @@ static int ltdb_lock(struct ldb_context *ldb)
/*
unlock the database after a ltdb_lock()
*/
-static void ltdb_unlock(struct ldb_context *ldb)
+static void ltdb_unlock(struct ldb_module *module)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
TDB_DATA key;
- key = ltdb_key(ldb, "LDBLOCK");
+ key = ltdb_key(module, "LDBLOCK");
if (!key.dptr) {
return;
}
@@ -160,18 +163,18 @@ static void ltdb_unlock(struct ldb_context *ldb)
we've made a modification to a dn - possibly reindex and
update sequence number
*/
-static int ltdb_modified(struct ldb_context *ldb, const char *dn)
+static int ltdb_modified(struct ldb_module *module, const char *dn)
{
int ret = 0;
if (strcmp(dn, LTDB_INDEXLIST) == 0 ||
strcmp(dn, LTDB_ATTRIBUTES) == 0) {
- ret = ltdb_reindex(ldb);
+ ret = ltdb_reindex(module);
}
if (ret == 0 &&
strcmp(dn, LTDB_BASEINFO) != 0) {
- ret = ltdb_increase_sequence_number(ldb);
+ ret = ltdb_increase_sequence_number(module);
}
return ret;
@@ -180,13 +183,14 @@ static int ltdb_modified(struct ldb_context *ldb, const char *dn)
/*
store a record into the db
*/
-int ltdb_store(struct ldb_context *ldb, const struct ldb_message *msg, int flgs)
+int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flgs)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
TDB_DATA tdb_key, tdb_data;
int ret;
- tdb_key = ltdb_key(ldb, msg->dn);
+ tdb_key = ltdb_key(module, msg->dn);
if (!tdb_key.dptr) {
return -1;
}
@@ -202,7 +206,7 @@ int ltdb_store(struct ldb_context *ldb, const struct ldb_message *msg, int flgs)
goto done;
}
- ret = ltdb_index_add(ldb, msg);
+ ret = ltdb_index_add(module, msg);
if (ret == -1) {
tdb_delete(ltdb->tdb, tdb_key);
}
@@ -218,29 +222,29 @@ done:
/*
add a record to the database
*/
-static int ltdb_add(struct ldb_context *ldb, const struct ldb_message *msg)
+static int ltdb_add(struct ldb_module *module, const struct ldb_message *msg)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ltdb_private *ltdb = module->private_data;
int ret;
ltdb->last_err_string = NULL;
- if (ltdb_lock(ldb) != 0) {
+ if (ltdb_lock(module) != 0) {
return -1;
}
- if (ltdb_cache_load(ldb) != 0) {
- ltdb_unlock(ldb);
+ if (ltdb_cache_load(module) != 0) {
+ ltdb_unlock(module);
return -1;
}
- ret = ltdb_store(ldb, msg, TDB_INSERT);
+ ret = ltdb_store(module, msg, TDB_INSERT);
if (ret == 0) {
- ltdb_modified(ldb, msg->dn);
+ ltdb_modified(module, msg->dn);
}
- ltdb_unlock(ldb);
+ ltdb_unlock(module);
return ret;
}
@@ -249,13 +253,14 @@ static int ltdb_add(struct ldb_context *ldb, const struct ldb_message *msg)
delete a record from the database, not updating indexes (used for deleting
index records)
*/
-int ltdb_delete_noindex(struct ldb_context *ldb, const char *dn)
+int ltdb_delete_noindex(struct ldb_module *module, const char *dn)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
TDB_DATA tdb_key;
int ret;
- tdb_key = ltdb_key(ldb, dn);
+ tdb_key = ltdb_key(module, dn);
if (!tdb_key.dptr) {
return -1;
}
@@ -269,51 +274,51 @@ int ltdb_delete_noindex(struct ldb_context *ldb, const char *dn)
/*
delete a record from the database
*/
-static int ltdb_delete(struct ldb_context *ldb, const char *dn)
+static int ltdb_delete(struct ldb_module *module, const char *dn)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ltdb_private *ltdb = module->private_data;
int ret;
struct ldb_message msg;
ltdb->last_err_string = NULL;
- if (ltdb_lock(ldb) != 0) {
+ if (ltdb_lock(module) != 0) {
return -1;
}
- if (ltdb_cache_load(ldb) != 0) {
- ltdb_unlock(ldb);
+ if (ltdb_cache_load(module) != 0) {
+ ltdb_unlock(module);
return -1;
}
/* in case any attribute of the message was indexed, we need
to fetch the old record */
- ret = ltdb_search_dn1(ldb, 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(ldb, dn);
+ ret = ltdb_delete_noindex(module, dn);
if (ret == -1) {
- ltdb_search_dn1_free(ldb, &msg);
+ ltdb_search_dn1_free(module, &msg);
goto failed;
}
/* remove any indexed attributes */
- ret = ltdb_index_del(ldb, &msg);
+ ret = ltdb_index_del(module, &msg);
- ltdb_search_dn1_free(ldb, &msg);
+ ltdb_search_dn1_free(module, &msg);
if (ret == 0) {
- ltdb_modified(ldb, dn);
+ ltdb_modified(module, dn);
}
- ltdb_unlock(ldb);
+ ltdb_unlock(module);
return ret;
failed:
- ltdb_unlock(ldb);
+ ltdb_unlock(module);
return -1;
}
@@ -416,11 +421,12 @@ static int msg_delete_attribute(struct ldb_context *ldb,
return 0 on success, -1 on failure
*/
-static int msg_delete_element(struct ldb_context *ldb,
+static int msg_delete_element(struct ldb_module *module,
struct ldb_message *msg,
const char *name,
const struct ldb_val *val)
{
+ struct ldb_context *ldb = module->ldb;
unsigned int i;
int found;
struct ldb_message_element *el;
@@ -433,7 +439,7 @@ static int msg_delete_element(struct ldb_context *ldb,
el = &msg->elements[found];
for (i=0;i<el->num_values;i++) {
- if (ldb_val_equal(ldb, msg->elements[i].name, &el->values[i], val)) {
+ if (ldb_val_equal(module, msg->elements[i].name, &el->values[i], val)) {
if (i<el->num_values-1) {
memmove(&el->values[i], &el->values[i+1],
sizeof(el->values[i])*(el->num_values-(i+1)));
@@ -457,15 +463,16 @@ static int msg_delete_element(struct ldb_context *ldb,
get away with it, but if we ever have really large attribute lists
then we'll need to look at this again
*/
-int ltdb_modify_internal(struct ldb_context *ldb, const struct ldb_message *msg)
+int ltdb_modify_internal(struct ldb_module *module, const struct ldb_message *msg)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
TDB_DATA tdb_key, tdb_data;
struct ldb_message msg2;
unsigned i, j;
int ret;
- tdb_key = ltdb_key(ldb, msg->dn);
+ tdb_key = ltdb_key(module, msg->dn);
if (!tdb_key.dptr) {
return -1;
}
@@ -527,7 +534,7 @@ int ltdb_modify_internal(struct ldb_context *ldb, const struct ldb_message *msg)
break;
}
for (j=0;j<msg->elements[i].num_values;j++) {
- if (msg_delete_element(ldb,
+ if (msg_delete_element(module,
&msg2,
msg->elements[i].name,
&msg->elements[i].values[j]) != 0) {
@@ -540,7 +547,7 @@ int ltdb_modify_internal(struct ldb_context *ldb, const struct ldb_message *msg)
}
/* we've made all the mods - save the modified record back into the database */
- ret = ltdb_store(ldb, &msg2, TDB_MODIFY);
+ ret = ltdb_store(module, &msg2, TDB_MODIFY);
ldb_free(ldb, tdb_key.dptr);
free(tdb_data.dptr);
@@ -557,29 +564,29 @@ failed:
/*
modify a record
*/
-static int ltdb_modify(struct ldb_context *ldb, const struct ldb_message *msg)
+static int ltdb_modify(struct ldb_module *module, const struct ldb_message *msg)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ltdb_private *ltdb = module->private_data;
int ret;
ltdb->last_err_string = NULL;
- if (ltdb_lock(ldb) != 0) {
+ if (ltdb_lock(module) != 0) {
return -1;
}
- if (ltdb_cache_load(ldb) != 0) {
- ltdb_unlock(ldb);
+ if (ltdb_cache_load(module) != 0) {
+ ltdb_unlock(module);
return -1;
}
- ret = ltdb_modify_internal(ldb, msg);
+ ret = ltdb_modify_internal(module, msg);
if (ret == 0) {
- ltdb_modified(ldb, msg->dn);
+ ltdb_modified(module, msg->dn);
}
- ltdb_unlock(ldb);
+ ltdb_unlock(module);
return ret;
}
@@ -587,22 +594,23 @@ static int ltdb_modify(struct ldb_context *ldb, const struct ldb_message *msg)
/*
rename a record
*/
-static int ltdb_rename(struct ldb_context *ldb, const char *olddn, const char *newdn)
+static int ltdb_rename(struct ldb_module *module, const char *olddn, const char *newdn)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
int ret;
struct ldb_message msg;
const char *error_str;
ltdb->last_err_string = NULL;
- if (ltdb_lock(ldb) != 0) {
+ if (ltdb_lock(module) != 0) {
return -1;
}
/* in case any attribute of the message was indexed, we need
to fetch the old record */
- ret = ltdb_search_dn1(ldb, olddn, &msg);
+ ret = ltdb_search_dn1(module, olddn, &msg);
if (ret != 1) {
/* not finding the old record is an error */
goto failed;
@@ -610,46 +618,47 @@ static int ltdb_rename(struct ldb_context *ldb, const char *olddn, const char *n
msg.dn = ldb_strdup(ldb,newdn);
if (!msg.dn) {
- ltdb_search_dn1_free(ldb, &msg);
+ ltdb_search_dn1_free(module, &msg);
goto failed;
}
- ret = ltdb_add(ldb, &msg);
+ ret = ltdb_add(module, &msg);
if (ret == -1) {
ldb_free(ldb, msg.dn);
- ltdb_search_dn1_free(ldb, &msg);
+ ltdb_search_dn1_free(module, &msg);
goto failed;
}
ldb_free(ldb, msg.dn);
- ltdb_search_dn1_free(ldb, &msg);
+ ltdb_search_dn1_free(module, &msg);
- ret = ltdb_delete(ldb, olddn);
+ ret = ltdb_delete(module, olddn);
error_str = ltdb->last_err_string;
if (ret == -1) {
- ltdb_delete(ldb, newdn);
+ ltdb_delete(module, newdn);
}
ltdb->last_err_string = error_str;
- ltdb_unlock(ldb);
+ ltdb_unlock(module);
return ret;
failed:
- ltdb_unlock(ldb);
+ ltdb_unlock(module);
return -1;
}
/*
close database
*/
-static int ltdb_close(struct ldb_context *ldb)
+static int ltdb_close(struct ldb_module *module)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ldb_context *ldb = module->ldb;
+ struct ltdb_private *ltdb = module->private_data;
int ret;
ltdb->last_err_string = NULL;
- ltdb_cache_free(ldb);
+ ltdb_cache_free(module);
ldb_set_alloc(ldb, NULL, NULL);
ret = tdb_close(ltdb->tdb);
@@ -662,9 +671,9 @@ static int ltdb_close(struct ldb_context *ldb)
/*
return extended error information
*/
-static const char *ltdb_errstring(struct ldb_context *ldb)
+static const char *ltdb_errstring(struct ldb_module *module)
{
- struct ltdb_private *ltdb = ldb->private_data;
+ struct ltdb_private *ltdb = module->private_data;
if (ltdb->last_err_string) {
return ltdb->last_err_string;
}
@@ -672,7 +681,8 @@ static const char *ltdb_errstring(struct ldb_context *ldb)
}
-static const struct ldb_backend_ops ltdb_ops = {
+static const struct ldb_module_ops ltdb_ops = {
+ "tdb",
ltdb_close,
ltdb_search,
ltdb_search_free,
@@ -743,8 +753,17 @@ struct ldb_context *ltdb_connect(const char *url,
memset(&ltdb->cache, 0, sizeof(ltdb->cache));
- ldb->private_data = ltdb;
- ldb->ops = &ltdb_ops;
+ ldb->modules = ldb_malloc_p(ldb, struct ldb_module);
+ if (!ldb->modules) {
+ tdb_close(tdb);
+ free(ldb);
+ errno = ENOMEM;
+ return NULL;
+ }
+ ldb->modules->ldb = ldb;
+ ldb->modules->prev = ldb->modules->next = NULL;
+ ldb->modules->private_data = ltdb;
+ ldb->modules->ops = &ltdb_ops;
return ldb;
}
diff --git a/source4/lib/ldb/tools/ldbadd.c b/source4/lib/ldb/tools/ldbadd.c
index 9383197ed0..6d04800502 100644
--- a/source4/lib/ldb/tools/ldbadd.c
+++ b/source4/lib/ldb/tools/ldbadd.c
@@ -83,16 +83,34 @@ static int process_file(struct ldb_context *ldb, FILE *f)
struct ldb_context *ldb;
int count=0;
const char *ldb_url;
+ const char **options = NULL;
+ int ldbopts;
int opt, i;
ldb_url = getenv("LDB_URL");
- while ((opt = getopt(argc, argv, "hH:")) != EOF) {
+ ldbopts = 0;
+ while ((opt = getopt(argc, argv, "hH:o:")) != EOF) {
switch (opt) {
case 'H':
ldb_url = optarg;
break;
+ case 'o':
+ ldbopts++;
+ if (options == NULL) {
+ options = (const char **)malloc(sizeof(char *) * (ldbopts + 1));
+ } else {
+ options = (const char **)realloc(options, sizeof(char *) * (ldbopts + 1));
+ if (options == NULL) {
+ fprintf(stderr, "Out of memory!\n");
+ exit(-1);
+ }
+ }
+ options[ldbopts - 1] = optarg;
+ options[ldbopts] = NULL;
+ break;
+
case 'h':
default:
usage();
@@ -108,7 +126,7 @@ static int process_file(struct ldb_context *ldb, FILE *f)
argc -= optind;
argv += optind;
- ldb = ldb_connect(ldb_url, 0, NULL);
+ ldb = ldb_connect(ldb_url, 0, options);
if (!ldb) {
perror("ldb_connect");
diff --git a/source4/lib/ldb/tools/ldbdel.c b/source4/lib/ldb/tools/ldbdel.c
index d36db5429a..42dc9c19d8 100644
--- a/source4/lib/ldb/tools/ldbdel.c
+++ b/source4/lib/ldb/tools/ldbdel.c
@@ -72,13 +72,16 @@ static void usage(void)
int main(int argc, char * const argv[])
{
struct ldb_context *ldb;
+ const char **options = NULL;
+ int ldbopts;
int ret, i;
const char *ldb_url;
int opt, recursive=0;
ldb_url = getenv("LDB_URL");
- while ((opt = getopt(argc, argv, "hH:r")) != EOF) {
+ ldbopts = 0;
+ while ((opt = getopt(argc, argv, "hH:ro:")) != EOF) {
switch (opt) {
case 'H':
ldb_url = optarg;
@@ -88,6 +91,21 @@ static void usage(void)
recursive=1;
break;
+ case 'o':
+ ldbopts++;
+ if (options == NULL) {
+ options = (const char **)malloc(sizeof(char *) * (ldbopts + 1));
+ } else {
+ options = (const char **)realloc(options, sizeof(char *) * (ldbopts + 1));
+ if (options == NULL) {
+ fprintf(stderr, "Out of memory!\n");
+ exit(-1);
+ }
+ }
+ options[ldbopts - 1] = optarg;
+ options[ldbopts] = NULL;
+ break;
+
case 'h':
default:
usage();
@@ -108,7 +126,7 @@ static void usage(void)
exit(1);
}
- ldb = ldb_connect(ldb_url, 0, NULL);
+ ldb = ldb_connect(ldb_url, 0, options);
if (!ldb) {
perror("ldb_connect");
exit(1);
diff --git a/source4/lib/ldb/tools/ldbedit.c b/source4/lib/ldb/tools/ldbedit.c
index b97c40ff1a..fc3b28872e 100644
--- a/source4/lib/ldb/tools/ldbedit.c
+++ b/source4/lib/ldb/tools/ldbedit.c
@@ -304,6 +304,8 @@ static void usage(void)
const char *expression = NULL;
const char *ldb_url;
const char *basedn = NULL;
+ const char **options = NULL;
+ int ldbopts;
int opt;
enum ldb_scope scope = LDB_SCOPE_SUBTREE;
const char *editor;
@@ -321,7 +323,8 @@ static void usage(void)
editor = "vi";
}
- while ((opt = getopt(argc, argv, "hab:e:H:s:v")) != EOF) {
+ ldbopts = 0;
+ while ((opt = getopt(argc, argv, "hab:e:H:s:vo:")) != EOF) {
switch (opt) {
case 'b':
basedn = optarg;
@@ -353,6 +356,21 @@ static void usage(void)
verbose++;
break;
+ case 'o':
+ ldbopts++;
+ if (options == NULL) {
+ options = (const char **)malloc(sizeof(char *) * (ldbopts + 1));
+ } else {
+ options = (const char **)realloc(options, sizeof(char *) * (ldbopts + 1));
+ if (options == NULL) {
+ fprintf(stderr, "Out of memory!\n");
+ exit(-1);
+ }
+ }
+ options[ldbopts - 1] = optarg;
+ options[ldbopts] = NULL;
+ break;
+
case 'h':
default:
usage();
@@ -381,7 +399,7 @@ static void usage(void)
attrs = (const char * const *)argv;
}
- ldb = ldb_connect(ldb_url, 0, NULL);
+ ldb = ldb_connect(ldb_url, 0, options);
if (!ldb) {
perror("ldb_connect");
diff --git a/source4/lib/ldb/tools/ldbmodify.c b/source4/lib/ldb/tools/ldbmodify.c
index b6ca2993ce..823855ff1e 100644
--- a/source4/lib/ldb/tools/ldbmodify.c
+++ b/source4/lib/ldb/tools/ldbmodify.c
@@ -85,16 +85,34 @@ static int process_file(struct ldb_context *ldb, FILE *f)
struct ldb_context *ldb;
int count=0;
const char *ldb_url;
+ const char **options = NULL;
+ int ldbopts;
int opt, i;
ldb_url = getenv("LDB_URL");
- while ((opt = getopt(argc, argv, "hH:")) != EOF) {
+ ldbopts = 0;
+ while ((opt = getopt(argc, argv, "hH:o:")) != EOF) {
switch (opt) {
case 'H':
ldb_url = optarg;
break;
+ case 'o':
+ ldbopts++;
+ if (options == NULL) {
+ options = (const char **)malloc(sizeof(char *) * (ldbopts + 1));
+ } else {
+ options = (const char **)realloc(options, sizeof(char *) * (ldbopts + 1));
+ if (options == NULL) {
+ fprintf(stderr, "Out of memory!\n");
+ exit(-1);
+ }
+ }
+ options[ldbopts - 1] = optarg;
+ options[ldbopts] = NULL;
+ break;
+
case 'h':
default:
usage();
@@ -110,7 +128,7 @@ static int process_file(struct ldb_context *ldb, FILE *f)
argc -= optind;
argv += optind;
- ldb = ldb_connect(ldb_url, 0, NULL);
+ ldb = ldb_connect(ldb_url, 0, options);
if (!ldb) {
perror("ldb_connect");
diff --git a/source4/lib/ldb/tools/ldbrename.c b/source4/lib/ldb/tools/ldbrename.c
index 3bc3c95208..3e47e17b17 100644
--- a/source4/lib/ldb/tools/ldbrename.c
+++ b/source4/lib/ldb/tools/ldbrename.c
@@ -51,16 +51,34 @@ static void usage(void)
{
struct ldb_context *ldb;
const char *ldb_url;
+ const char **options = NULL;
+ int ldbopts;
int opt, ret;
ldb_url = getenv("LDB_URL");
- while ((opt = getopt(argc, argv, "hH:")) != EOF) {
+ ldbopts = 0;
+ while ((opt = getopt(argc, argv, "hH:o:")) != EOF) {
switch (opt) {
case 'H':
ldb_url = optarg;
break;
+ case 'o':
+ ldbopts++;
+ if (options == NULL) {
+ options = (const char **)malloc(sizeof(char *) * (ldbopts + 1));
+ } else {
+ options = (const char **)realloc(options, sizeof(char *) * (ldbopts + 1));
+ if (options == NULL) {
+ fprintf(stderr, "Out of memory!\n");
+ exit(-1);
+ }
+ }
+ options[ldbopts - 1] = optarg;
+ options[ldbopts] = NULL;
+ break;
+
case 'h':
default:
usage();
@@ -76,7 +94,7 @@ static void usage(void)
argc -= optind;
argv += optind;
- ldb = ldb_connect(ldb_url, 0, NULL);
+ ldb = ldb_connect(ldb_url, 0, options);
if (!ldb) {
perror("ldb_connect");
diff --git a/source4/lib/ldb/tools/ldbsearch.c b/source4/lib/ldb/tools/ldbsearch.c
index 137299d89b..1e7bb1ce4c 100644
--- a/source4/lib/ldb/tools/ldbsearch.c
+++ b/source4/lib/ldb/tools/ldbsearch.c
@@ -89,13 +89,15 @@ static int do_search(struct ldb_context *ldb,
const char * const * attrs = NULL;
const char *ldb_url;
const char *basedn = NULL;
- int opt;
+ const char **options = NULL;
+ int opt, ldbopts;
enum ldb_scope scope = LDB_SCOPE_SUBTREE;
int interactive = 0, ret=0;
ldb_url = getenv("LDB_URL");
- while ((opt = getopt(argc, argv, "b:H:s:hi")) != EOF) {
+ ldbopts = 0;
+ while ((opt = getopt(argc, argv, "b:H:s:o:hi")) != EOF) {
switch (opt) {
case 'b':
basedn = optarg;
@@ -119,6 +121,21 @@ static int do_search(struct ldb_context *ldb,
interactive = 1;
break;
+ case 'o':
+ ldbopts++;
+ if (options == NULL) {
+ options = (const char **)malloc(sizeof(char *) * (ldbopts + 1));
+ } else {
+ options = (const char **)realloc(options, sizeof(char *) * (ldbopts + 1));
+ if (options == NULL) {
+ fprintf(stderr, "Out of memory!\n");
+ exit(-1);
+ }
+ }
+ options[ldbopts - 1] = optarg;
+ options[ldbopts] = NULL;
+ break;
+
case 'h':
default:
usage();
@@ -143,7 +160,7 @@ static int do_search(struct ldb_context *ldb,
attrs = (const char * const *)(argv+1);
}
- ldb = ldb_connect(ldb_url, 0, NULL);
+ ldb = ldb_connect(ldb_url, 0, options);
if (!ldb) {
perror("ldb_connect");
exit(1);
diff --git a/source4/lib/ldb/tools/ldbtest.c b/source4/lib/ldb/tools/ldbtest.c
index e25a7cbcd6..5d90dc797d 100644
--- a/source4/lib/ldb/tools/ldbtest.c
+++ b/source4/lib/ldb/tools/ldbtest.c
@@ -358,13 +358,16 @@ static void usage(void)
int main(int argc, char * const argv[])
{
struct ldb_context *ldb;
+ const char **options = NULL;
+ int ldbopts;
int opt;
int nrecords = 5000;
int nsearches = 2000;
ldb_url = getenv("LDB_URL");
- while ((opt = getopt(argc, argv, "hH:r:s:b:")) != EOF) {
+ ldbopts = 0;
+ while ((opt = getopt(argc, argv, "hH:r:s:b:o:")) != EOF) {
switch (opt) {
case 'H':
ldb_url = optarg;
@@ -382,6 +385,21 @@ static void usage(void)
nsearches = atoi(optarg);
break;
+ case 'o':
+ ldbopts++;
+ if (options == NULL) {
+ options = (const char **)malloc(sizeof(char *) * (ldbopts + 1));
+ } else {
+ options = (const char **)realloc(options, sizeof(char *) * (ldbopts + 1));
+ if (options == NULL) {
+ fprintf(stderr, "Out of memory!\n");
+ exit(-1);
+ }
+ }
+ options[ldbopts - 1] = optarg;
+ options[ldbopts] = NULL;
+ break;
+
case 'h':
default:
usage();
@@ -397,7 +415,7 @@ static void usage(void)
argc -= optind;
argv += optind;
- ldb = ldb_connect(ldb_url, 0, NULL);
+ ldb = ldb_connect(ldb_url, 0, options);
if (!ldb) {
perror("ldb_connect");
diff --git a/source4/provision.ldif b/source4/provision.ldif
index 38189b8898..7b75ea7c18 100644
--- a/source4/provision.ldif
+++ b/source4/provision.ldif
@@ -18,6 +18,8 @@ ntPwdHash: HIDDEN
ntPwdHistory: HIDDEN
lmPwdHash: HIDDEN
lmPwdHistory: HIDDEN
+createTimestamp: HIDDEN
+modifyTimestamp: HIDDEN
dn: @SUBCLASSES
top: domain
@@ -31,6 +33,9 @@ user: computer
template: userTemplate
template: groupTemplate
+dn: @MODULES
+@MODULE: timestamps
+
dn: ${BASEDN}
objectClass: top
objectClass: domain
diff --git a/source4/rootdse.ldif b/source4/rootdse.ldif
index 86ba2fd676..534249859a 100644
--- a/source4/rootdse.ldif
+++ b/source4/rootdse.ldif
@@ -1,9 +1,14 @@
dn: @INDEXLIST
dn: @ATTRIBUTES
+createTimestamp: HIDDEN
+modifyTimestamp: HIDDEN
dn: @SUBCLASSES
+dn: @MODULES
+@MODULE: timestamps
+
dn: cn=rootDSE
currentTime: _DYNAMIC_
subschemaSubentry: CN=Aggregate,CN=Schema,CN=Configuration,${BASEDN}
generated by cgit (git 2.34.1) at 2024-12-16 08:47:17 +0000