From 679e95db033fd11d17c1f1ac5e44f6cc4df2220e Mon Sep 17 00:00:00 2001 From: Simo Sorce Date: Mon, 15 Nov 2004 11:40:27 +0000 Subject: r3754: merge in ldb modules support from the tmp branch ldbPlugins (This used to be commit 71323f424b4561af1fdddd2358629049be3dad8c) --- source4/ldap_server/ldap_parse.c | 75 ++++++++++++++- source4/ldap_server/ldap_parse.h | 4 + source4/ldap_server/ldap_simple_ldb.c | 9 +- source4/lib/ldb/Makefile.ldb | 8 +- source4/lib/ldb/common/ldb.c | 56 +++++------- source4/lib/ldb/config.mk | 12 ++- source4/lib/ldb/include/ldb.h | 40 +++++--- source4/lib/ldb/ldb_ldap/ldb_ldap.c | 53 +++++++---- source4/lib/ldb/ldb_tdb/ldb_cache.c | 57 ++++++------ source4/lib/ldb/ldb_tdb/ldb_index.c | 121 ++++++++++++------------ source4/lib/ldb/ldb_tdb/ldb_match.c | 27 +++--- source4/lib/ldb/ldb_tdb/ldb_search.c | 81 +++++++++-------- source4/lib/ldb/ldb_tdb/ldb_tdb.c | 167 +++++++++++++++++++--------------- source4/lib/ldb/tools/ldbadd.c | 22 ++++- source4/lib/ldb/tools/ldbdel.c | 22 ++++- source4/lib/ldb/tools/ldbedit.c | 22 ++++- source4/lib/ldb/tools/ldbmodify.c | 22 ++++- source4/lib/ldb/tools/ldbrename.c | 22 ++++- source4/lib/ldb/tools/ldbsearch.c | 23 ++++- source4/lib/ldb/tools/ldbtest.c | 22 ++++- source4/provision.ldif | 5 + source4/rootdse.ldif | 5 + 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,3 +1,12 @@ +################################################ +# 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] @@ -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, <db->cache.baseinfo); - ltdb_search_dn1_free(ldb, <db->cache.indexlist); - ltdb_search_dn1_free(ldb, <db->cache.subclasses); - ltdb_search_dn1_free(ldb, <db->cache.attributes); + ltdb_search_dn1_free(module, <db->cache.baseinfo); + ltdb_search_dn1_free(module, <db->cache.indexlist); + ltdb_search_dn1_free(module, <db->cache.subclasses); + ltdb_search_dn1_free(module, <db->cache.attributes); ldb_free(ldb, ltdb->cache.last_attribute.name); memset(<db->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, <db->cache.baseinfo); + ltdb_search_dn1_free(module, <db->cache.baseinfo); - if (ltdb_search_dn1(ldb, LTDB_BASEINFO, <db->cache.baseinfo) == -1) { + if (ltdb_search_dn1(module, LTDB_BASEINFO, <db->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, <db->cache.baseinfo) != 1) { + if (ltdb_search_dn1(module, LTDB_BASEINFO, <db->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(<db->cache.last_attribute, 0, sizeof(ltdb->cache.last_attribute)); - ltdb_search_dn1_free(ldb, <db->cache.indexlist); - ltdb_search_dn1_free(ldb, <db->cache.subclasses); - ltdb_search_dn1_free(ldb, <db->cache.attributes); + ltdb_search_dn1_free(module, <db->cache.indexlist); + ltdb_search_dn1_free(module, <db->cache.subclasses); + ltdb_search_dn1_free(module, <db->cache.attributes); - if (ltdb_search_dn1(ldb, LTDB_INDEXLIST, <db->cache.indexlist) == -1) { + if (ltdb_search_dn1(module, LTDB_INDEXLIST, <db->cache.indexlist) == -1) { goto failed; } - if (ltdb_search_dn1(ldb, LTDB_SUBCLASSES, <db->cache.subclasses) == -1) { + if (ltdb_search_dn1(module, LTDB_SUBCLASSES, <db->cache.subclasses) == -1) { goto failed; } - if (ltdb_search_dn1(ldb, LTDB_ATTRIBUTES, <db->cache.attributes) == -1) { + if (ltdb_search_dn1(module, LTDB_ATTRIBUTES, <db->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;icache.subclasses.num_elements;i++) { struct ldb_message_element *el = <db->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;iu.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;iu.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;icount;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, <db->cache.indexlist, &dn_list); + ret = ltdb_index_dn(module, tree, <db->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;jelements[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;jelements[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;jnum_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;jelements[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;iu.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;iu.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;inum_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;inum_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;inum_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 (inum_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;jelements[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(<db->cache, 0, sizeof(ltdb->cache)); - ldb->private_data = ltdb; - ldb->ops = <db_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 = <db_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} -- cgit