r15957: - add a test that fetches the schema from an windows LDAP server,

  and stores it into structures.
- this prints out some useful information on the screen about
  attributes (will be extended for objectClasses too)
- the plan is to create hide the relation of structures behind an interface
  we can later use this interface in a lot of places:
  - our schema module for ldb
  - the ndr_print code for DsGetNCChanges, to translate the uint32 attribute
    and objectClass id's into names, display attribute values depending on the
    attribute syntax
  - ...

metze
(This used to be commit 1908f0cd6230c22aabb0e1eab2f9d37d17f12f18)

1 files changed, 517 insertions, 0 deletions

diff --git a/source4/torture/ldap/schema.c b/source4/torture/ldap/schema.c
new file mode 100644
index 0000000000..f6e19a1adb
--- /dev/null
+++ b/source4/torture/ldap/schema.c
@@ -0,0 +1,517 @@
+/* 
+   Unix SMB/CIFS mplementation.
+   LDAP schema tests
+   
+   Copyright (C) Stefan Metzmacher 2006
+    
+   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 2 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, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+   
+*/
+
+#include "includes.h"
+#include "libcli/ldap/ldap_client.h"
+#include "lib/cmdline/popt_common.h"
+#include "db_wrap.h"
+#include "lib/ldb/include/ldb.h"
+#include "lib/ldb/include/ldb_errors.h"
+#include "dsdb/samdb/samdb.h"
+#include "dlinklist.h"
+
+#include "torture/torture.h"
+#include "torture/ldap/proto.h"
+
+struct dsdb_attribute {
+	struct dsdb_attribute *prev, *next;
+
+	const char *lDAPDisplayName;
+	const char *attributeID;
+	uint32_t attID;
+	struct GUID schemaIDGUID;
+
+	uint32_t searchFlags;
+	BOOL systemOnly;
+	uint32_t systemFlags;
+	BOOL isMemberOfPartialAttributeSet;
+
+	const char *attributeSyntax;
+	uint32_t oMSyntax;
+
+	BOOL isSingleValued;
+	uint32_t rangeLower;
+	uint32_t rangeUpper;
+
+	BOOL showInAdvancedViewOnly;
+	const char *adminDisplayName;
+	const char *adminDescription;
+};
+
+struct dsdb_objectClass {
+	struct dsdb_objectClass *prev, *next;
+
+	const char *subClassOf;
+
+	const char *governsID;
+	const char *rDNAttID;
+
+	BOOL showInAdvancedViewOnly;
+	const char *adminDisplayName;
+	const char *adminDescription;
+
+	uint32_t objectClassCategory;
+	const char *lDAPDisplayName;
+
+	struct GUID schemaIDGUID;
+
+	BOOL systemOnly;
+
+	const char **systemPossSuperiors;
+	const char **systemMayContain;
+
+	const char **possSuperiors;
+	const char **mayContain;
+
+	const char *defaultSecurityDescriptor;
+
+	uint32_t systemFlags;
+	BOOL defaultHidingValue;
+
+	const char *defaultObjectCategory;
+};
+
+struct dsdb_schema {
+	struct dsdb_attribute *attributes;
+	struct dsdb_objectClass *objectClasses;
+};
+
+struct test_rootDSE {
+	const char *defaultdn;
+	const char *rootdn;
+	const char *configdn;
+	const char *schemadn;
+};
+
+struct test_schema_async_ctx {
+	struct ldb_paged_control *ctrl;
+	uint32_t count;
+	BOOL pending;
+
+	int (*callback)(void *, struct ldb_context *ldb, struct ldb_message *);
+	void *private_data;
+};
+
+static BOOL test_search_rootDSE(struct ldb_context *ldb, struct test_rootDSE *root)
+{
+	int ret;
+	struct ldb_message *msg;
+	struct ldb_result *r;
+
+	d_printf("Testing RootDSE Search\n");
+
+	ret = ldb_search(ldb, ldb_dn_new(ldb), LDB_SCOPE_BASE, 
+			 NULL, NULL, &r);
+	if (ret != LDB_SUCCESS) {
+		return False;
+	} else if (r->count != 1) {
+		return False;
+	}
+
+	msg = r->msgs[0];
+
+	root->defaultdn	= ldb_msg_find_string(msg, "defaultNamingContext", NULL);
+	talloc_steal(ldb, root->defaultdn);
+	root->rootdn	= ldb_msg_find_string(msg, "rootDomainNamingContext", NULL);
+	talloc_steal(ldb, root->rootdn);
+	root->configdn	= ldb_msg_find_string(msg, "configurationNamingContext", NULL);
+	talloc_steal(ldb, root->configdn);
+	root->schemadn	= ldb_msg_find_string(msg, "schemaNamingContext", NULL);
+	talloc_steal(ldb, root->schemadn);
+
+	talloc_free(r);
+
+	return True;
+}
+
+static int test_schema_search_callback(struct ldb_context *ldb, void *context, struct ldb_async_result *ares)
+{
+	struct test_schema_async_ctx *actx = talloc_get_type(context, struct test_schema_async_ctx);
+	int ret = LDB_SUCCESS;
+
+	switch (ares->type) {
+	case LDB_REPLY_ENTRY:
+		actx->count++;
+		ret = actx->callback(actx->private_data, ldb, ares->message);
+		break;
+
+	case LDB_REPLY_REFERRAL:
+		break;
+
+	case LDB_REPLY_DONE:
+		if (ares->controls) {
+			struct ldb_paged_control *ctrl = NULL;
+			int i;
+
+			for (i=0; ares->controls[i]; i++) {
+				if (strcmp(LDB_CONTROL_PAGED_RESULTS_OID, ares->controls[i]->oid) == 0) {
+					ctrl = talloc_get_type(ares->controls[i]->data, struct ldb_paged_control);
+					break;
+				}
+			}
+
+			if (!ctrl) break;
+
+			talloc_free(actx->ctrl->cookie);
+			actx->ctrl->cookie = talloc_steal(actx->ctrl->cookie, ctrl->cookie);
+			actx->ctrl->cookie_len = ctrl->cookie_len;
+
+			if (actx->ctrl->cookie_len > 0) {
+				actx->pending = True;
+			}
+		}
+		break;
+		
+	default:
+		d_printf("%s: unknown Reply Type %u\n", __location__, ares->type);
+		return LDB_ERR_OTHER;
+	}
+
+	if (talloc_free(ares) == -1) {
+		d_printf("talloc_free failed\n");
+		actx->pending = 0;
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	if (ret) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	return LDB_SUCCESS;
+}
+
+static BOOL test_create_schema_type(struct ldb_context *ldb, struct test_rootDSE *root,
+				    const char *filter,
+				    int (*callback)(void *, struct ldb_context *ldb, struct ldb_message *),
+				    void *private_data)
+{
+	struct ldb_control **ctrl;
+	struct ldb_paged_control *control;
+	struct ldb_request *req;
+	int ret;
+	struct test_schema_async_ctx *actx;
+
+	req = talloc(ldb, struct ldb_request);
+	actx = talloc(req, struct test_schema_async_ctx);
+
+	ctrl = talloc_array(req, struct ldb_control *, 2);
+	ctrl[0] = talloc(ctrl, struct ldb_control);
+	ctrl[0]->oid = LDB_CONTROL_PAGED_RESULTS_OID;
+	ctrl[0]->critical = True;
+	control = talloc(ctrl[0], struct ldb_paged_control);
+	control->size = 1000;
+	control->cookie = NULL;
+	control->cookie_len = 0;
+	ctrl[0]->data = control;
+	ctrl[1] = NULL;
+
+	req->operation = LDB_SEARCH;
+	req->op.search.base = ldb_dn_explode(ldb, root->schemadn);
+	req->op.search.scope = LDB_SCOPE_SUBTREE;
+	req->op.search.tree = ldb_parse_tree(ldb, filter);
+	if (req->op.search.tree == NULL) return -1;
+	req->op.search.attrs = NULL;
+	req->controls = ctrl;
+	req->async.context = actx;
+	req->async.callback = test_schema_search_callback;
+	req->async.timeout = 3600;
+
+	actx->count		= 0;
+	actx->ctrl		= control;
+	actx->callback		= callback;
+	actx->private_data	= private_data;
+again:
+	actx->pending		= False;
+
+	ret = ldb_request(ldb, req);
+	if (ret != LDB_SUCCESS) {
+		d_printf("search failed - %s\n", ldb_errstring(ldb));
+		return False;
+	}
+
+	ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
+       	if (ret != LDB_SUCCESS) {
+		d_printf("search error - %s\n", ldb_errstring(ldb));
+		return False;
+	}
+
+	if (actx->pending)
+		goto again;
+
+	d_printf("filter[%s] count[%u]\n", filter, actx->count);
+	return True;
+}
+
+#define GET_STRING(p, elem, strict) do { \
+	(p)->elem = samdb_result_string(msg, #elem, NULL);\
+	if (strict && (p)->elem == NULL) { \
+		d_printf("%s: %s == NULL\n", __location__, #elem); \
+		goto failed; \
+	} \
+	(void)talloc_steal(p, (p)->elem); \
+} while (0)
+
+#define GET_BOOL(p, elem, strict) do { \
+	const char *str; \
+	str = samdb_result_string(msg, #elem, NULL);\
+	if (str == NULL) { \
+		if (strict) { \
+			d_printf("%s: %s == NULL\n", __location__, #elem); \
+			goto failed; \
+		} else { \
+			(p)->elem = False; \
+		} \
+	} else if (strcasecmp("TRUE", str) == 0) { \
+		(p)->elem = True; \
+	} else if (strcasecmp("FALSE", str) == 0) { \
+		(p)->elem = False; \
+	} else { \
+		d_printf("%s: %s == %s\n", __location__, #elem, str); \
+		goto failed; \
+	} \
+} while (0)
+
+#define GET_UINT32(p, elem) do { \
+	(p)->elem = samdb_result_uint(msg, #elem, 0);\
+} while (0)
+
+#define GET_GUID(p, elem) do { \
+	(p)->elem = samdb_result_guid(msg, #elem);\
+} while (0)
+
+static int test_add_attribute(void *ptr, struct ldb_context *ldb, struct ldb_message *msg)
+{
+	struct dsdb_schema *schema = talloc_get_type(ptr, struct dsdb_schema);
+	struct dsdb_attribute *attr;
+
+	attr = talloc_zero(schema, struct dsdb_attribute);
+
+	GET_STRING(attr, lDAPDisplayName, True);
+	GET_STRING(attr, attributeID, True);
+	attr->attID = UINT32_MAX;
+	GET_GUID(attr, schemaIDGUID);
+
+	GET_UINT32(attr, searchFlags);
+	GET_BOOL(attr, systemOnly, False);
+	GET_UINT32(attr, systemFlags);
+	GET_BOOL(attr, isMemberOfPartialAttributeSet, False);
+
+	GET_STRING(attr, attributeSyntax, True);
+	GET_UINT32(attr, oMSyntax);
+
+	GET_BOOL(attr, isSingleValued, True);
+	GET_UINT32(attr, rangeLower);
+	GET_UINT32(attr, rangeUpper);
+
+	GET_BOOL(attr, showInAdvancedViewOnly, False);
+	GET_STRING(attr, adminDisplayName, True);
+	GET_STRING(attr, adminDescription, True);
+
+	DLIST_ADD_END(schema->attributes, attr, struct dsdb_attribute *);
+	return LDB_SUCCESS;
+failed:
+	return LDB_ERR_OTHER;
+}
+
+static int test_add_class(void *ptr, struct ldb_context *ldb, struct ldb_message *msg)
+{
+	struct dsdb_schema *schema = talloc_get_type(ptr, struct dsdb_schema);
+	struct dsdb_objectClass *obj;
+
+	obj = talloc_zero(schema, struct dsdb_objectClass);
+
+	GET_STRING(obj, subClassOf, True);
+
+	GET_STRING(obj, governsID, True);
+	GET_STRING(obj, rDNAttID, True);
+
+	GET_BOOL(obj, showInAdvancedViewOnly, False);
+	GET_STRING(obj, adminDisplayName, True);
+	GET_STRING(obj, adminDescription, True);
+
+	GET_UINT32(obj, objectClassCategory);
+	GET_STRING(obj, lDAPDisplayName, True);
+
+	GET_GUID(obj, schemaIDGUID);
+
+	GET_BOOL(obj, systemOnly, False);
+
+	obj->systemPossSuperiors= NULL;
+	obj->systemMayContain	= NULL;
+
+	obj->possSuperiors	= NULL;
+	obj->mayContain		= NULL;
+
+	GET_STRING(obj, defaultSecurityDescriptor, False);
+
+	GET_UINT32(obj, systemFlags);
+	GET_BOOL(obj, defaultHidingValue, True);
+
+	GET_STRING(obj, defaultObjectCategory, True);
+
+	DLIST_ADD_END(schema->objectClasses, obj, struct dsdb_objectClass *);
+	return LDB_SUCCESS;
+failed:
+	return LDB_ERR_OTHER;
+}
+
+static BOOL test_create_schema(struct ldb_context *ldb, struct test_rootDSE *root, struct dsdb_schema **_schema)
+{
+	BOOL ret = True;
+	struct dsdb_schema *schema;
+
+	schema = talloc_zero(ldb, struct dsdb_schema);
+
+	d_printf("Fetching attributes...\n");
+	ret &= test_create_schema_type(ldb, root, "(objectClass=attributeSchema)",
+				       test_add_attribute, schema);
+	d_printf("Fetching objectClasses...\n");
+	ret &= test_create_schema_type(ldb, root, "(objectClass=classSchema)",
+				       test_add_class, schema);
+
+	if (ret == True) {
+		*_schema = schema;
+	}
+	return ret;
+}
+
+static BOOL test_dump_not_replicated(struct ldb_context *ldb, struct test_rootDSE *root, struct dsdb_schema *schema)
+{
+	struct dsdb_attribute *a;
+	uint32_t a_i = 1;
+
+	d_printf("Dumping not replicated attributes\n");
+
+	for (a=schema->attributes; a; a = a->next) {
+		if (!(a->systemFlags & 0x00000001)) continue;
+		d_printf("attr[%4u]: '%s'\n", a_i++,
+			 a->lDAPDisplayName);
+	}
+
+	return True;
+}
+
+static BOOL test_dump_partial(struct ldb_context *ldb, struct test_rootDSE *root, struct dsdb_schema *schema)
+{
+	struct dsdb_attribute *a;
+	uint32_t a_i = 1;
+
+	d_printf("Dumping attributes which are provided by the global catalog\n");
+
+	for (a=schema->attributes; a; a = a->next) {
+		if (!(a->systemFlags & 0x00000002) && !a->isMemberOfPartialAttributeSet) continue;
+		d_printf("attr[%4u]:  %u %u '%s'\n", a_i++,
+			 a->systemFlags & 0x00000002, a->isMemberOfPartialAttributeSet,
+			 a->lDAPDisplayName);
+	}
+
+	return True;
+}
+
+static BOOL test_dump_contructed(struct ldb_context *ldb, struct test_rootDSE *root, struct dsdb_schema *schema)
+{
+	struct dsdb_attribute *a;
+	uint32_t a_i = 1;
+
+	d_printf("Dumping constructed attributes\n");
+
+	for (a=schema->attributes; a; a = a->next) {
+		if (!(a->systemFlags & 0x00000004)) continue;
+		d_printf("attr[%4u]: '%s'\n", a_i++,
+			 a->lDAPDisplayName);
+	}
+
+	return True;
+}
+
+static BOOL test_dump_sorted_syntax(struct ldb_context *ldb, struct test_rootDSE *root, struct dsdb_schema *schema)
+{
+	struct dsdb_attribute *a;
+	uint32_t a_i = 1;
+	uint32_t i;
+	const char *syntaxes[] = {
+		"2.5.5.0",
+		"2.5.5.1",
+		"2.5.5.2",
+		"2.5.5.3",
+		"2.5.5.4",
+		"2.5.5.5",
+		"2.5.5.6",
+		"2.5.5.7",
+		"2.5.5.8",
+		"2.5.5.9",
+		"2.5.5.10",
+		"2.5.5.11",
+		"2.5.5.12",
+		"2.5.5.13",
+		"2.5.5.14",
+		"2.5.5.15",
+		"2.5.5.16",
+		"2.5.5.17"
+	};
+
+	for (i=0; i < ARRAY_SIZE(syntaxes); i++) {
+		for (a=schema->attributes; a; a = a->next) {
+			if (strcmp(syntaxes[i], a->attributeSyntax) != 0) continue;
+			d_printf("attr[%4u]: %s %u '%s'\n", a_i++,
+				 a->attributeSyntax, a->oMSyntax,
+				 a->lDAPDisplayName);
+		}
+	}
+
+	return True;
+}
+
+BOOL torture_ldap_schema(struct torture_context *torture)
+{
+	struct ldb_context *ldb;
+	TALLOC_CTX *mem_ctx;
+	BOOL ret = True;
+	const char *host = lp_parm_string(-1, "torture", "host");
+	char *url;
+	struct test_rootDSE rootDSE;
+	struct dsdb_schema *schema = NULL;
+
+	mem_ctx = talloc_init("torture_ldap_basic");
+	ZERO_STRUCT(rootDSE);
+
+	url = talloc_asprintf(mem_ctx, "ldap://%s/", host);
+
+	ldb = ldb_wrap_connect(mem_ctx, url,
+			       NULL,
+			       cmdline_credentials,
+			       0, NULL);
+
+	ret &= test_search_rootDSE(ldb, &rootDSE);
+	if (!ret) goto failed;
+	ret &= test_create_schema(ldb, &rootDSE, &schema);
+	if (!ret) goto failed;
+
+	ret &= test_dump_not_replicated(ldb, &rootDSE, schema);
+	ret &= test_dump_partial(ldb, &rootDSE, schema);
+	ret &= test_dump_contructed(ldb, &rootDSE, schema);
+	ret &= test_dump_sorted_syntax(ldb, &rootDSE, schema);
+
+failed:
+	talloc_free(mem_ctx);
+	return ret;
+}