From d494c66ca7b4378957acaa7591214992e9cacbfd Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 30 May 2006 17:57:35 +0000 Subject: 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) --- source4/torture/config.mk | 3 +- source4/torture/ldap/schema.c | 517 ++++++++++++++++++++++++++++++++++++++++++ source4/torture/torture.c | 1 + 3 files changed, 520 insertions(+), 1 deletion(-) create mode 100644 source4/torture/ldap/schema.c (limited to 'source4/torture') diff --git a/source4/torture/config.mk b/source4/torture/config.mk index 818778e479..b48ea86d7c 100644 --- a/source4/torture/config.mk +++ b/source4/torture/config.mk @@ -200,10 +200,11 @@ PRIVATE_PROTO_HEADER = \ OBJ_FILES = \ ldap/common.o \ ldap/basic.o \ + ldap/schema.o \ ldap/cldap.o \ ldap/cldapbench.o PUBLIC_DEPENDENCIES = \ - LIBCLI_LDAP LIBCLI_CLDAP POPT_CREDENTIALS + LIBCLI_LDAP LIBCLI_CLDAP SAMDB POPT_CREDENTIALS # End SUBSYSTEM TORTURE_LDAP ################################# 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; +} diff --git a/source4/torture/torture.c b/source4/torture/torture.c index fb4985fe1e..9962fbb9f8 100644 --- a/source4/torture/torture.c +++ b/source4/torture/torture.c @@ -655,6 +655,7 @@ static struct { /* ldap testers */ {"LDAP-BASIC", torture_ldap_basic, 0}, + {"LDAP-SCHEMA", torture_ldap_schema, 0}, {"LDAP-CLDAP", torture_cldap, 0}, /* nbt tests */ -- cgit