--- /dev/null
+/*
+ ldb database library
+
+ Copyright (C) Simo Sorce 2004
+
+ ** NOTE! The following LGPL license applies to the ldb
+ ** library. This does NOT imply that all of Samba is released
+ ** under the LGPL
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+/*
+ * Name: ldb
+ *
+ * Component: ldb schema module
+ *
+ * Description: add schema check functionality
+ *
+ * Author: Simo Sorce
+ */
+
+#include "includes.h"
+#include "ldb/include/ldb.h"
+#include "ldb/include/ldb_private.h"
+
+struct attribute_syntax {
+ const char *name;
+ const char *syntax_id;
+};
+
+static struct attribute_syntax attrsyn[] = {
+ { "Object(DS-DN)", "2.5.5.1"},
+ { "String(Object-Identifier)", "2.5.5.2"},
+ { "", "2.5.5.3"},
+ { "String(Teletex)", "2.5.5.4"},
+ { "String(IA5)", "2.5.5.5"}, /* Also String(Printable) */
+ { "String(Numeric)", "2.5.5.6"},
+ { "Object(DN-Binary)", "2.5.5.7"}, /* Also Object(OR-Name) */
+ { "Boolean", "2.5.5.8"},
+ { "Integer", "2.5.5.9"}, /* Also Enumeration (3 types ?) ... */
+ { "String(Octet)", "2.5.5.10"}, /* Also Object(Replica-Link) */
+ { "String(UTC-Time)", "2.5.5.11"}, /* Also String(Generalized-Time) */
+ { "String(Unicode)", "2.5.5.12"},
+ { "Object(Presentation-Address)", "2.5.5.13"},
+ { "Object(DN-String)", "2.5.5.14"}, /* Also Object(Access-Point) */
+ { "String(NT-Sec-Desc))", "2.5.5.15"},
+ { "LargeInteger", "2.5.5.16"}, /* Also Interval ... */
+ { "String(Sid)", "2.5.5.17"}
+ };
+
+#define SCHEMA_TALLOC_CHECK(root, mem, ret) do { if (!mem) { talloc_free(root); return ret;} } while(0);
+
+struct private_data {
+ struct ldb_context *schema_db;
+ const char *error_string;
+};
+
+/* close */
+static int schema_close(struct ldb_module *module)
+{
+ return ldb_next_close(module);
+}
+
+/* search */
+static int schema_search(struct ldb_module *module, const char *base,
+ enum ldb_scope scope, const char *expression,
+ const char * const *attrs, struct ldb_message ***res)
+{
+ return ldb_next_search(module, base, scope, expression, attrs, res);
+}
+
+/* search_free */
+static int schema_search_free(struct ldb_module *module, struct ldb_message **res)
+{
+ return ldb_next_search_free(module, res);
+}
+
+struct check_list {
+ int check;
+ char *name;
+};
+
+struct attr_list {
+ int syntax;
+ char *name;
+};
+
+struct objc_list {
+ int aux;
+ char *name;
+};
+
+struct schema_structures {
+ struct check_list *cl;
+ struct objc_list *ol;
+ struct attr_list *must;
+ struct attr_list *may;
+ int num_cl;
+ int num_objc;
+ int num_must;
+ int num_may;
+};
+
+/* add_record */
+static int schema_add_record(struct ldb_module *module, const struct ldb_message *msg)
+{
+ struct private_data *data = (struct private_data *)module->private_data;
+ struct ldb_message **srch;
+ struct schema_structures *ss;
+ int i, j, k, l;
+ int ret;
+
+ /* First implementation:
+ Build up a list of must and mays from each objectclass
+ Check all the musts are there and all the other attributes are mays
+ Throw an error in case a check fail
+ Free all structures and commit the change
+ */
+
+ ss = talloc_p(module, struct schema_structures);
+ if (!ss) {
+ return -1;
+ }
+
+ ss->ol = NULL;
+ ss->num_cl = msg->num_elements;
+ ss->cl = talloc_array_p(ss, struct check_list, ss->num_cl);
+ SCHEMA_TALLOC_CHECK(ss, ss->cl, -1);
+ for (i = 0, j = 0; i < msg->num_elements; i++) {
+ if (strcasecmp(msg->elements[i].name, "objectclass") == 0) {
+ ss->num_objc = msg->elements[i].num_values;
+ ss->ol = talloc_array_p(ss, struct objc_list, ss->num_objc);
+ SCHEMA_TALLOC_CHECK(ss, ss->ol, -1);
+ for (k = 0; k < ss->num_objc; k++) {
+ ss->ol[k].name = talloc_strndup(ss->ol, msg->elements[i].values[k].data, msg->elements[i].values[k].length);
+ SCHEMA_TALLOC_CHECK(ss, ss->ol[k].name, -1);
+ ss->ol[k].aux = 0;
+ }
+ }
+
+ ss->cl[j].check = 0;
+ ss->cl[j].name = talloc_strdup(ss->cl, msg->elements[i].name);
+ SCHEMA_TALLOC_CHECK(ss, ss->cl[j].name, -1);
+ j++;
+ }
+
+ /* find all other objectclasses recursively */
+ ss->must = NULL;
+ ss->may = NULL;
+ ss->num_must = 0;
+ ss->num_may = 0;
+ for (i = 0; i < ss->num_objc; i++) {
+ char *filter;
+
+ filter = talloc_asprintf(ss, "lDAPDisplayName=%s", ss->ol[i].name);
+ SCHEMA_TALLOC_CHECK(ss, filter, -1);
+ ret = ldb_search(data->schema_db, NULL, LDB_SCOPE_SUBTREE, filter, NULL, &srch);
+ if (ret == 0) {
+ int ok;
+
+ ok = 0;
+ /* suppose auxiliary classess are not required */
+ if (ss->ol[i].aux) {
+ int d;
+ ok = 1;
+ ss->num_objc -= 1;
+ for (d = i; d < ss->num_objc; d++) {
+ ss->ol[d] = ss->ol[d + 1];
+ }
+ i -= 1;
+ }
+ if (!ok) {
+ /* Schema Violation: Object Class Description Not Found */
+ data->error_string = "ObjectClass not found";
+ talloc_free(ss);
+ return -1;
+ }
+ continue;
+ } else {
+ if (ret < 0) {
+ /* Schema DB Error: Error occurred retrieving Object Class Description */
+ data->error_string = "Internal error. Error retrieving schema objectclass";
+ talloc_free(ss);
+ return -1;
+ }
+ if (ret > 1) {
+ /* Schema DB Error: Too Many Records */
+ data->error_string = "Internal error. Too many records searching for schema objectclass";
+ talloc_free(ss);
+ return -1;
+ }
+ }
+
+ /* Add inherited classes eliminating duplicates */
+ /* fill in kust and may attribute lists */
+ for (j = 0; j < (*srch)->num_elements; j++) {
+ int o, is_aux, is_class;
+
+ is_aux = 0;
+ is_class = 0;
+ if (strcasecmp((*srch)->elements[j].name, "systemAuxiliaryclass") == 0) {
+ is_aux = 1;
+ is_class = 1;
+ }
+ if (strcasecmp((*srch)->elements[j].name, "subClassOf") == 0) {
+ is_class = 1;
+ }
+
+ if (is_class) {
+ o = (*srch)->elements[j].num_values;
+ ss->ol = talloc_realloc_p(ss, ss->ol, struct objc_list, ss->num_objc + o);
+ SCHEMA_TALLOC_CHECK(ss, ss->ol, -1);
+ for (k = 0, l = 0; k < o; k++) {
+ int c, found, len;
+
+ found = 0;
+ for (c = 0; c < ss->num_objc; c++) {
+ len = strlen(ss->ol[c].name);
+ if (len == (*srch)->elements[j].values[k].length) {
+ if (strncasecmp(ss->ol[c].name, (*srch)->elements[j].values[k].data, len) == 0) {
+ found = 1;
+ break;
+ }
+ }
+ }
+ if (!found) {
+ ss->ol[l + ss->num_objc].name = talloc_strndup(ss->ol, (*srch)->elements[j].values[k].data, (*srch)->elements[j].values[k].length);
+ SCHEMA_TALLOC_CHECK(ss, ss->ol[l + ss->num_objc].name, -1);
+ ss->ol[l + ss->num_objc].aux = is_aux;
+ l++;
+ }
+ }
+ ss->num_objc += l;
+ } else {
+
+ if (strcasecmp((*srch)->elements[j].name, "mustContain") == 0 || strcasecmp((*srch)->elements[j].name, "SystemMustContain") == 0) {
+ int m;
+
+ m = (*srch)->elements[j].num_values;
+
+ ss->must = talloc_realloc_p(ss, ss->must, struct attr_list, ss->num_must + m);
+ SCHEMA_TALLOC_CHECK(ss, ss->must, -1);
+ for (k = 0, l = 0; k < m; k++) {
+ int c, found, len;
+
+ found = 0;
+ for (c = 0; c < ss->num_must; c++) {
+ len = strlen(ss->must[c].name);
+ if (len == (*srch)->elements[j].values[k].length) {
+ if (strncasecmp(ss->must[c].name, (*srch)->elements[j].values[k].data, len) == 0) {
+ found = 1;
+ break;
+ }
+ }
+ }
+ if (!found) {
+ ss->must[l + ss->num_must].name = talloc_strndup(ss->must, (*srch)->elements[j].values[k].data, (*srch)->elements[j].values[k].length);
+ SCHEMA_TALLOC_CHECK(ss, ss->must[l + ss->num_must].name, -1);
+ l++;
+ }
+ }
+ ss->num_must += l;
+ }
+
+ if (strcasecmp((*srch)->elements[j].name, "mayContain") == 0 || strcasecmp((*srch)->elements[j].name, "SystemMayContain") == 0) {
+ int m;
+
+ m = (*srch)->elements[j].num_values;
+
+ ss->may = talloc_realloc_p(ss, ss->may, struct attr_list, ss->num_may + m);
+ SCHEMA_TALLOC_CHECK(ss, ss->may, -1);
+ for (k = 0, l = 0; k < m; k++) {
+ int c, found, len;
+
+ found = 0;
+ for (c = 0; c < ss->num_may; c++) {
+ len = strlen(ss->may[c].name);
+ if (len == (*srch)->elements[j].values[k].length) {
+ if (strncasecmp(ss->may[c].name, (*srch)->elements[j].values[k].data, (*srch)->elements[j].values[k].length) == 0) {
+ found = 1;
+ break;
+ }
+ }
+ }
+ if (!found) {
+ ss->may[l + ss->num_may].name = talloc_strndup(ss->may, (*srch)->elements[j].values[k].data, (*srch)->elements[j].values[k].length);
+ SCHEMA_TALLOC_CHECK(ss, ss->may[l + ss->num_may].name, -1);
+ l++;
+ }
+ }
+ ss->num_may += l;
+ }
+ }
+ }
+
+ ldb_search_free(module->ldb, srch);
+ }
+
+ /* now check all musts are present */
+ for (i = 0; i < ss->num_must; i++) {
+ int found;
+
+ found = 0;
+ for (j = 0; j < ss->num_cl; j++) {
+ if (strcasecmp(ss->must[i].name, ss->cl[j].name) == 0) {
+ ss->cl[j].check = 1;
+ found = 1;
+ break;
+ }
+ }
+
+ if ( ! found ) {
+ /* TODO: set the error string */
+ data->error_string = "Objectclass violation, a required attribute is missing";
+ talloc_free(ss);
+ return -1;
+ }
+ }
+
+ /* now check all others atribs are found in mays */
+ for (i = 0; i < ss->num_cl; i++) {
+
+ if ( ! ss->cl[i].check ) {
+ int found;
+
+ found = 0;
+ for (j = 0; j < ss->num_may; j++) {
+ if (strcasecmp(ss->may[j].name, ss->cl[i].name) == 0) {
+ ss->cl[i].check = 1;
+ found = 1;
+ break;
+ }
+ }
+
+ if ( ! found ) {
+ data->error_string = "Objectclass violation, an invalid attribute name was found";
+ talloc_free(ss);
+ return -1;
+ }
+ }
+ }
+
+ talloc_free(ss);
+
+ return ldb_next_add_record(module, msg);
+}
+
+/* modify_record */
+static int schema_modify_record(struct ldb_module *module, const struct ldb_message *msg)
+{
+ struct private_data *data = (struct private_data *)module->private_data;
+ return ldb_next_modify_record(module, msg);
+}
+
+/* delete_record */
+static int schema_delete_record(struct ldb_module *module, const char *dn)
+{
+ struct private_data *data = (struct private_data *)module->private_data;
+ return ldb_next_delete_record(module, dn);
+}
+
+/* rename_record */
+static int schema_rename_record(struct ldb_module *module, const char *olddn, const char *newdn)
+{
+ return ldb_next_rename_record(module, olddn, newdn);
+}
+
+static int schema_named_lock(struct ldb_module *module, const char *name) {
+ return ldb_next_named_lock(module, name);
+}
+
+static int schema_named_unlock(struct ldb_module *module, const char *name) {
+ return ldb_next_named_unlock(module, name);
+}
+
+/* return extended error information */
+static const char *schema_errstring(struct ldb_module *module)
+{
+ struct private_data *data = (struct private_data *)module->private_data;
+
+ if (data->error_string) {
+ const char *error;
+
+ error = data->error_string;
+ data->error_string = NULL;
+ return error;
+ }
+
+ return ldb_next_errstring(module);
+}
+
+static const struct ldb_module_ops schema_ops = {
+ "schema",
+ schema_close,
+ schema_search,
+ schema_search_free,
+ schema_add_record,
+ schema_modify_record,
+ schema_delete_record,
+ schema_rename_record,
+ schema_named_lock,
+ schema_named_unlock,
+ schema_errstring,
+};
+
+#define SCHEMA_PREFIX "schema:"
+#define SCHEMA_PREFIX_LEN 7
+
+#ifdef HAVE_DLOPEN_DISABLED
+struct ldb_module *init_module(struct ldb_context *ldb, const char *options[])
+#else
+struct ldb_module *schema_module_init(struct ldb_context *ldb, const char *options[])
+#endif
+{
+ struct ldb_module *ctx;
+ struct private_data *data;
+ char *db_url = NULL;
+ int i;
+
+ ctx = talloc_p(ldb, struct ldb_module);
+ if (!ctx) {
+ return NULL;
+ }
+
+ if (options) {
+ for (i = 0; options[i] != NULL; i++) {
+ if (strncmp(options[i], SCHEMA_PREFIX, SCHEMA_PREFIX_LEN) == 0) {
+ db_url = talloc_strdup(ctx, &options[i][SCHEMA_PREFIX_LEN]);
+ SCHEMA_TALLOC_CHECK(ctx, db_url, NULL);
+ }
+ }
+ }
+
+ if (!db_url) { /* search if it is defined in the calling ldb */
+ int ret;
+ const char * attrs[] = { "@SCHEMADB", NULL };
+ struct ldb_message **msgs;
+
+ ret = ldb_search(ldb, "", LDB_SCOPE_BASE, "dn=@MODULES", (const char * const *)attrs, &msgs);
+ if (ret == 0) {
+ ldb_debug(ldb, LDB_DEBUG_TRACE, "Schema DB not found\n");
+ ldb_search_free(ldb, msgs);
+ return NULL;
+ } else {
+ if (ret < 0) {
+ ldb_debug(ldb, LDB_DEBUG_FATAL, "ldb error (%s) occurred searching for schema db, bailing out!\n", ldb_errstring(ldb));
+ ldb_search_free(ldb, msgs);
+ return NULL;
+ }
+ if (ret > 1) {
+ ldb_debug(ldb, LDB_DEBUG_FATAL, "Too many records found, bailing out\n");
+ ldb_search_free(ldb, msgs);
+ return NULL;
+ }
+
+ db_url = talloc_strndup(ctx, msgs[0]->elements[0].values[0].data, msgs[0]->elements[0].values[0].length);
+ SCHEMA_TALLOC_CHECK(ctx, db_url, NULL);
+ }
+
+ ldb_search_free(ldb, msgs);
+ }
+
+ data = talloc_p(ctx, struct private_data);
+ SCHEMA_TALLOC_CHECK(ctx, data, NULL);
+
+ data->schema_db = ldb_connect(db_url, 0, NULL);
+ SCHEMA_TALLOC_CHECK(ctx, data->schema_db, NULL);
+
+ data->error_string = NULL;
+ ctx->private_data = data;
+ ctx->ldb = ldb;
+ ctx->prev = ctx->next = NULL;
+ ctx->ops = &schema_ops;
+
+ return ctx;
+}
git.samba.org / jra / samba / .git / commitdiff