-/*
- Unix SMB/CIFS mplementation.
+/*
+ Unix SMB/CIFS implementation.
DSDB schema header
-
+
Copyright (C) Stefan Metzmacher <metze@samba.org> 2006-2007
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006-2008
+ Copyright (C) Matthieu Patou <mat@matws.net> 2011
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
-
+
*/
#include "includes.h"
#include "lib/util/dlinklist.h"
#include "dsdb/samdb/samdb.h"
-#include "lib/ldb/include/ldb_module.h"
+#include <ldb_module.h>
#include "param/param.h"
#include "librpc/ndr/libndr.h"
#include "librpc/gen_ndr/ndr_misc.h"
#include "lib/util/tsort.h"
+/* change this when we change something in our schema code that
+ * requires a re-index of the database
+ */
+#define SAMDB_INDEXING_VERSION "2"
+
/*
override the name to attribute handler function
*/
-const struct ldb_schema_attribute *dsdb_attribute_handler_override(struct ldb_context *ldb,
+const struct ldb_schema_attribute *dsdb_attribute_handler_override(struct ldb_context *ldb,
void *private_data,
const char *name)
{
mem_ctx = talloc_new(ldb);
if (!mem_ctx) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
msg = ldb_msg_new(mem_ctx);
goto op_error;
}
+
+ ret = ldb_msg_add_string(msg_idx, "@IDXVERSION", SAMDB_INDEXING_VERSION);
+ if (ret != LDB_SUCCESS) {
+ goto op_error;
+ }
+
for (attr = schema->attributes; attr; attr = attr->next) {
const char *syntax = attr->syntax->ldb_syntax;
-
+
if (!syntax) {
syntax = attr->syntax->ldap_oid;
}
- /* Write out a rough approximation of the schema as an @ATTRIBUTES value, for bootstrapping */
+ /*
+ * Write out a rough approximation of the schema
+ * as an @ATTRIBUTES value, for bootstrapping
+ */
if (strcmp(syntax, LDB_SYNTAX_INTEGER) == 0) {
ret = ldb_msg_add_string(msg, attr->lDAPDisplayName, "INTEGER");
} else if (strcmp(syntax, LDB_SYNTAX_DIRECTORY_STRING) == 0) {
ret = ldb_msg_add_string(msg, attr->lDAPDisplayName, "CASE_INSENSITIVE");
- }
+ }
if (ret != LDB_SUCCESS) {
break;
}
return ret;
}
- /* Try to avoid churning the attributes too much - we only want to do this if they have changed */
- ret = ldb_search(ldb, mem_ctx, &res, msg->dn, LDB_SCOPE_BASE, NULL, "dn=%s", ldb_dn_get_linearized(msg->dn));
+ /*
+ * Try to avoid churning the attributes too much,
+ * we only want to do this if they have changed
+ */
+ ret = ldb_search(ldb, mem_ctx, &res, msg->dn, LDB_SCOPE_BASE, NULL,
+ NULL);
if (ret == LDB_ERR_NO_SUCH_OBJECT) {
ret = ldb_add(ldb, msg);
} else if (ret != LDB_SUCCESS) {
ret = LDB_SUCCESS;
/* Annoyingly added to our search results */
ldb_msg_remove_attr(res->msgs[0], "distinguishedName");
-
- mod_msg = ldb_msg_diff(ldb, res->msgs[0], msg);
+
+ ret = ldb_msg_difference(ldb, mem_ctx,
+ res->msgs[0], msg, &mod_msg);
+ if (ret != LDB_SUCCESS) {
+ goto op_error;
+ }
if (mod_msg->num_elements > 0) {
ret = dsdb_replace(ldb, mod_msg, 0);
}
return ret;
}
- /* Now write out the indexs, as found in the schema (if they have changed) */
+ /* Now write out the indexes, as found in the schema (if they have changed) */
- ret = ldb_search(ldb, mem_ctx, &res_idx, msg_idx->dn, LDB_SCOPE_BASE, NULL, "dn=%s", ldb_dn_get_linearized(msg_idx->dn));
+ ret = ldb_search(ldb, mem_ctx, &res_idx, msg_idx->dn, LDB_SCOPE_BASE,
+ NULL, NULL);
if (ret == LDB_ERR_NO_SUCH_OBJECT) {
ret = ldb_add(ldb, msg_idx);
} else if (ret != LDB_SUCCESS) {
/* Annoyingly added to our search results */
ldb_msg_remove_attr(res_idx->msgs[0], "distinguishedName");
- mod_msg = ldb_msg_diff(ldb, res_idx->msgs[0], msg_idx);
+ ret = ldb_msg_difference(ldb, mem_ctx,
+ res_idx->msgs[0], msg_idx, &mod_msg);
+ if (ret != LDB_SUCCESS) {
+ goto op_error;
+ }
if (mod_msg->num_elements > 0) {
ret = dsdb_replace(ldb, mod_msg, 0);
}
op_error:
talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
+}
+
+
+/*
+ create extra attribute shortcuts
+ */
+static void dsdb_setup_attribute_shortcuts(struct ldb_context *ldb, struct dsdb_schema *schema)
+{
+ struct dsdb_attribute *attribute;
+
+ /* setup fast access to one_way_link and DN format */
+ for (attribute=schema->attributes; attribute; attribute=attribute->next) {
+ attribute->dn_format = dsdb_dn_oid_to_format(attribute->syntax->ldap_oid);
+
+ if (attribute->dn_format == DSDB_INVALID_DN) {
+ attribute->one_way_link = false;
+ continue;
+ }
+
+ /* these are not considered to be one way links for
+ the purpose of DN link fixups */
+ if (ldb_attr_cmp("distinguishedName", attribute->lDAPDisplayName) == 0 ||
+ ldb_attr_cmp("objectCategory", attribute->lDAPDisplayName) == 0) {
+ attribute->one_way_link = false;
+ continue;
+ }
+
+ if (attribute->linkID == 0) {
+ attribute->one_way_link = true;
+ continue;
+ }
+ /* handle attributes with a linkID but no backlink */
+ if (dsdb_attribute_by_linkID(schema, attribute->linkID) == NULL) {
+ attribute->one_way_link = true;
+ continue;
+ }
+ attribute->one_way_link = false;
+ }
}
static int uint32_cmp(uint32_t c1, uint32_t c2)
{
return uint32_cmp((*a1)->attributeID_id, (*a2)->attributeID_id);
}
+static int dsdb_compare_attribute_by_msDS_IntId(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
+{
+ return uint32_cmp((*a1)->msDS_IntId, (*a2)->msDS_IntId);
+}
static int dsdb_compare_attribute_by_attributeID_oid(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
{
return strcasecmp((*a1)->attributeID_oid, (*a2)->attributeID_oid);
/*
create the sorted accessor arrays for the schema
*/
-static int dsdb_setup_sorted_accessors(struct ldb_context *ldb,
- struct dsdb_schema *schema)
+int dsdb_setup_sorted_accessors(struct ldb_context *ldb,
+ struct dsdb_schema *schema)
{
struct dsdb_class *cur;
struct dsdb_attribute *a;
/* sort the arrays */
TYPESAFE_QSORT(schema->attributes_by_lDAPDisplayName, schema->num_attributes, dsdb_compare_attribute_by_lDAPDisplayName);
TYPESAFE_QSORT(schema->attributes_by_attributeID_id, schema->num_attributes, dsdb_compare_attribute_by_attributeID_id);
- TYPESAFE_QSORT(schema->attributes_by_msDS_IntId, schema->num_int_id_attr, dsdb_compare_attribute_by_attributeID_id);
+ TYPESAFE_QSORT(schema->attributes_by_msDS_IntId, schema->num_int_id_attr, dsdb_compare_attribute_by_msDS_IntId);
TYPESAFE_QSORT(schema->attributes_by_attributeID_oid, schema->num_attributes, dsdb_compare_attribute_by_attributeID_oid);
TYPESAFE_QSORT(schema->attributes_by_linkID, schema->num_attributes, dsdb_compare_attribute_by_linkID);
+ dsdb_setup_attribute_shortcuts(ldb, schema);
+
return LDB_SUCCESS;
failed:
dsdb_sorted_accessors_free(schema);
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
-}
-
-int dsdb_setup_schema_inversion(struct ldb_context *ldb, struct dsdb_schema *schema)
-{
- /* Walk the list of schema classes */
-
- /* For each subClassOf, add us to subclasses of the parent */
-
- /* collect these subclasses into a recursive list of total subclasses, preserving order */
-
- /* For each subclass under 'top', write the index from it's
- * order as an integer in the dsdb_class (for sorting
- * objectClass lists efficiently) */
-
- /* Walk the list of scheam classes */
-
- /* Create a 'total possible superiors' on each class */
- return LDB_SUCCESS;
+ return ldb_oom(ldb);
}
/**
- * Attach the schema to an opaque pointer on the ldb, so ldb modules
- * can find it
+ * Attach the schema to an opaque pointer on the ldb,
+ * so ldb modules can find it
*/
-
int dsdb_set_schema(struct ldb_context *ldb, struct dsdb_schema *schema)
{
struct dsdb_schema *old_schema;
if (ret != LDB_SUCCESS) {
return ret;
}
- /* Remove the refernece to the schema we just overwrote - if there was none, NULL is harmless here */
+
+ /* Remove the reference to the schema we just overwrote - if there was
+ * none, NULL is harmless here */
if (old_schema != schema) {
talloc_unlink(ldb, old_schema);
talloc_steal(ldb, schema);
return ret;
}
- /* Remove the refernece to the schema we just overwrote - if there was none, NULL is harmless here */
+ /* Remove the reference to the schema we just overwrote - if there was
+ * none, NULL is harmless here */
talloc_unlink(ldb, old_schema);
if (talloc_reference(ldb, schema) == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
+ }
+
+ /* Make this ldb use local schema preferably */
+ ret = ldb_set_opaque(ldb, "dsdb_use_global_schema", NULL);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
ret = dsdb_schema_set_attributes(ldb, schema, write_attributes);
/* Set the new attributes based on the new schema */
ret = dsdb_schema_set_attributes(ldb, global_schema, false /* Don't write attributes, it's expensive */);
if (ret == LDB_SUCCESS) {
- /* Keep a reference to this schema, just incase the original copy is replaced */
+ /* Keep a reference to this schema, just in case the original copy is replaced */
if (talloc_reference(ldb, global_schema) == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
}
return ret;
}
+bool dsdb_uses_global_schema(struct ldb_context *ldb)
+{
+ return (ldb_get_opaque(ldb, "dsdb_use_global_schema") != NULL);
+}
+
/**
* Find the schema object for this ldb
*
}
/* see if we have a cached copy */
- use_global_schema = (ldb_get_opaque(ldb, "dsdb_use_global_schema") != NULL);
+ use_global_schema = dsdb_uses_global_schema(ldb);
if (use_global_schema) {
schema_in = global_schema;
} else {
if (schema_in->refresh_fn && !schema_in->refresh_in_progress) {
if (!talloc_reference(tmp_ctx, schema_in)) {
- /* ensure that the schema_in->refresh_in_progress remains valid for the right amount of time */
+ /*
+ * ensure that the schema_in->refresh_in_progress
+ * remains valid for the right amount of time
+ */
talloc_free(tmp_ctx);
return NULL;
}
dsdb_set_global_schema(ldb);
}
-/* When loading the schema from LDIF files, we don't get the extended DNs.
-
- We need to set these up, so that from the moment we start the provision, the defaultObjectCategory links are set up correctly.
+/**
+ * When loading the schema from LDIF files, we don't get the extended DNs.
+ *
+ * We need to set these up, so that from the moment we start the provision,
+ * the defaultObjectCategory links are set up correctly.
*/
int dsdb_schema_fill_extended_dn(struct ldb_context *ldb, struct dsdb_schema *schema)
{
talloc_free(dn);
return LDB_ERR_CONSTRAINT_VIOLATION;
}
-
+
status = GUID_to_ndr_blob(&target_class->objectGUID, dn, &guid);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(dn);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ldb_dn_set_extended_component(dn, "GUID", &guid);
return LDB_SUCCESS;
}
-/**
+/**
* Add an element to the schema (attribute or class) from an LDB message
*/
-WERROR dsdb_schema_set_el_from_ldb_msg(struct ldb_context *ldb, struct dsdb_schema *schema,
- struct ldb_message *msg)
+WERROR dsdb_schema_set_el_from_ldb_msg(struct ldb_context *ldb, struct dsdb_schema *schema,
+ struct ldb_message *msg)
{
if (samdb_find_attribute(ldb, msg,
"objectclass", "attributeSchema") != NULL) {
}
talloc_steal(mem_ctx, ldif);
- msg = ldb_msg_canonicalize(ldb, ldif->msg);
- if (!msg) {
+ ret = ldb_msg_normalize(ldb, mem_ctx, ldif->msg, &msg);
+ if (ret != LDB_SUCCESS) {
goto nomem;
}
- talloc_steal(mem_ctx, msg);
talloc_free(ldif);
prefix_val = ldb_msg_find_ldb_val(msg, "prefixMap");
goto failed;
}
- /*
- * load the attribute and class definitions outof df
- */
+ /* load the attribute and class definitions out of df */
while ((ldif = ldb_ldif_read_string(ldb, &df))) {
talloc_steal(mem_ctx, ldif);
- msg = ldb_msg_canonicalize(ldb, ldif->msg);
- if (!msg) {
+ ret = ldb_msg_normalize(ldb, ldif, ldif->msg, &msg);
+ if (ret != LDB_SUCCESS) {
goto nomem;
}
git.samba.org / amitay / samba.git / blobdiff