Changeset 745 for trunk/server/source4/torture/ldap

Timestamp:

Nov 27, 2012, 4:43:17 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.0

Location:

trunk/server

Files:

• . (modified) (1 prop)
• source4/torture/ldap/basic.c (modified) (17 diffs)
• source4/torture/ldap/cldap.c (modified) (22 diffs)
• source4/torture/ldap/cldapbench.c (modified) (7 diffs)
• source4/torture/ldap/common.c (modified) (2 diffs)
• source4/torture/ldap/ldap_sort.c (modified) (6 diffs)
• source4/torture/ldap/nested_search.c (copied) (copied from vendor/current/source4/torture/ldap/nested_search.c )
• source4/torture/ldap/schema.c (modified) (7 diffs)
• source4/torture/ldap/uptodatevector.c (modified) (5 diffs)

trunk/server/source4/torture/ldap/basic.c

@@ -5 +5 @@
    Copyright (C) Stefan Metzmacher 2004
    Copyright (C) Simo Sorce 2004
-   Copyright (C) Matthias Dieter Wallnöfer 2009
+   Copyright (C) Matthias Dieter Wallnöfer 2009-2010
     
    This program is free software; you can redistribute it and/or modify
@@ -23 +23 @@
 
 #include "includes.h"
+#include "ldb_wrap.h"
 #include "libcli/ldap/ldap_client.h"
 #include "lib/cmdline/popt_common.h"
@@ -29 +30 @@
 #include "torture/ldap/proto.h"
 
-#include "param/param.h"
 
 static bool test_bind_simple(struct ldap_connection *conn, const char *userdn, const char *password)
@@ -64 +64 @@
         bool ret = true;
 
-        printf("Testing multiple binds on a single connnection as anonymous and user\n");
+        printf("Testing multiple binds on a single connection as anonymous and user\n");
 
         ret = test_bind_simple(conn, NULL, NULL);
@@ -80 +80 @@
 }
 
-static bool test_search_rootDSE(struct ldap_connection *conn, char **basedn)
+static bool test_search_rootDSE(struct ldap_connection *conn, const char **basedn,
+        const char ***partitions)
 {
         bool ret = true;
@@ -92 +93 @@
 
         *basedn = NULL;
+
+        if (partitions != NULL) {
+                *partitions = const_str_list(str_list_make_empty(conn));
+        }
 
         msg = new_ldap_message(conn);
@@ -139 +144 @@
                                                           (char *)r->attributes[i].values[j].data);
                         }
+                        if ((partitions != NULL) &&
+                            (strcasecmp("namingContexts", r->attributes[i].name) == 0)) {
+                                char *entry = talloc_asprintf(conn, "%.*s",
+                                                              (int)r->attributes[i].values[j].length,
+                                                              (char *)r->attributes[i].values[j].data);
+                                *partitions = str_list_add(*partitions, entry);
+                        }
                 }
         }
-
-        talloc_free(req);
 
         return ret;
@@ -209 +219 @@
 }
 
+/* This has to be done using the LDAP API since the LDB API does only transmit
+ * the error code and not the error message. */
 static bool test_error_codes(struct torture_context *tctx,
         struct ldap_connection *conn, const char *basedn)
@@ -214 +226 @@
         struct ldap_message *msg, *rep;
         struct ldap_request *req;
-        char *err_code_str, *endptr;
+        const char *err_code_str;
+        char *endptr;
         WERROR err;
         NTSTATUS status;
 
-        printf("Testing error codes - to make this test pass against SAMBA 4 you have to specify the target!\n");
+        printf("Testing the most important error code -> error message conversions!\n");
 
         if (!basedn) {
@@ -243 +256 @@
         status = ldap_result_one(req, &rep, LDAP_TAG_AddResponse);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("error in ldap addition request - %s\n", nt_errstr(status));
+                printf("error in ldap add request - %s\n", nt_errstr(status));
                 return false;
         }
@@ -258 +271 @@
         err_code_str = win_errstr(err);
         printf(" - Errorcode: %s; Reason: %s\n", err_code_str, endptr);
-        if (!torture_setting_bool(tctx, "samba4", false)) {
-                if ((!W_ERROR_EQUAL(err, WERR_DS_REFERRAL))
-                        || (rep->r.AddResponse.resultcode != 10)) {
+        if ((!W_ERROR_EQUAL(err, WERR_DS_REFERRAL))
+                        || (rep->r.AddResponse.resultcode != LDAP_REFERRAL)) {
                         return false;
-                }
-        } else {
-                if ((!W_ERROR_EQUAL(err, WERR_DS_GENERIC_ERROR))
-                        || (rep->r.AddResponse.resultcode != 80)) {
+        }
+        if ((rep->r.AddResponse.referral == NULL)
+                        || (strstr(rep->r.AddResponse.referral, basedn) == NULL)) {
                         return false;
-                }
+        }
+
+        printf(" Try another wrong addition\n");
+
+        msg->type = LDAP_TAG_AddRequest;
+        msg->r.AddRequest.dn = "";
+        msg->r.AddRequest.num_attributes = 0;
+        msg->r.AddRequest.attributes = NULL;
+
+        req = ldap_request_send(conn, msg);
+        if (!req) {
+                return false;
+        }
+
+        status = ldap_result_one(req, &rep, LDAP_TAG_AddResponse);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("error in ldap add request - %s\n", nt_errstr(status));
+                return false;
+        }
+
+        if ((rep->r.AddResponse.resultcode == 0)
+                || (rep->r.AddResponse.errormessage == NULL)
+                || (strtol(rep->r.AddResponse.errormessage, &endptr,16) <= 0)
+                || (*endptr != ':')) {
+                printf("Invalid error message!\n");
+                return false;
+        }
+
+        err = ad_error(rep->r.AddResponse.errormessage, &endptr);
+        err_code_str = win_errstr(err);
+        printf(" - Errorcode: %s; Reason: %s\n", err_code_str, endptr);
+        if ((!W_ERROR_EQUAL(err, WERR_DS_ROOT_MUST_BE_NC) &&
+             !W_ERROR_EQUAL(err, WERR_DS_NAMING_VIOLATION))
+                || (rep->r.AddResponse.resultcode != LDAP_NAMING_VIOLATION)) {
+                return false;
         }
 
         printf(" Try a wrong modification\n");
+
+        msg->type = LDAP_TAG_ModifyRequest;
+        msg->r.ModifyRequest.dn = basedn;
+        msg->r.ModifyRequest.num_mods = 0;
+        msg->r.ModifyRequest.mods = NULL;
+
+        req = ldap_request_send(conn, msg);
+        if (!req) {
+                return false;
+        }
+
+        status = ldap_result_one(req, &rep, LDAP_TAG_ModifyResponse);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("error in ldap modifification request - %s\n", nt_errstr(status));
+                return false;
+        }
+
+        if ((rep->r.ModifyResponse.resultcode == 0)
+                || (rep->r.ModifyResponse.errormessage == NULL)
+                || (strtol(rep->r.ModifyResponse.errormessage, &endptr,16) <= 0)
+                || (*endptr != ':')) {
+                printf("Invalid error message!\n");
+                return false;
+        }
+
+        err = ad_error(rep->r.ModifyResponse.errormessage, &endptr);
+        err_code_str = win_errstr(err);
+        printf(" - Errorcode: %s; Reason: %s\n", err_code_str, endptr);
+        if ((!W_ERROR_EQUAL(err, WERR_INVALID_PARAM) &&
+             !W_ERROR_EQUAL(err, WERR_DS_UNWILLING_TO_PERFORM))
+                || (rep->r.ModifyResponse.resultcode != LDAP_UNWILLING_TO_PERFORM)) {
+                return false;
+        }
+
+        printf(" Try another wrong modification\n");
 
         msg->type = LDAP_TAG_ModifyRequest;
@@ -299 +379 @@
         err_code_str = win_errstr(err);
         printf(" - Errorcode: %s; Reason: %s\n", err_code_str, endptr);
-        if (!torture_setting_bool(tctx, "samba4", false)) {
-                if ((!W_ERROR_EQUAL(err, WERR_INVALID_PARAM))
-                        || (rep->r.ModifyResponse.resultcode != 53)) {
-                        return false;
-                }
-        } else {
-                if ((!W_ERROR_EQUAL(err, WERR_DS_GENERIC_ERROR))
-                        || (rep->r.ModifyResponse.resultcode != 80)) {
-                        return false;
-                }
+        if ((!W_ERROR_EQUAL(err, WERR_INVALID_PARAM) &&
+             !W_ERROR_EQUAL(err, WERR_DS_UNWILLING_TO_PERFORM))
+                || (rep->r.ModifyResponse.resultcode != LDAP_UNWILLING_TO_PERFORM)) {
+                return false;
         }
 
@@ -314 +388 @@
 
         msg->type = LDAP_TAG_DelRequest;
-        msg->r.DelRequest.dn = "";
+        msg->r.DelRequest.dn = basedn;
 
         req = ldap_request_send(conn, msg);
@@ -334 +408 @@
                 return false;
         }
+
+        err = ad_error(rep->r.DelResponse.errormessage, &endptr);
+        err_code_str = win_errstr(err);
+        printf(" - Errorcode: %s; Reason: %s\n", err_code_str, endptr);
+        if ((!W_ERROR_EQUAL(err, WERR_DS_CANT_DELETE) &&
+             !W_ERROR_EQUAL(err, WERR_DS_UNWILLING_TO_PERFORM))
+                || (rep->r.DelResponse.resultcode != LDAP_UNWILLING_TO_PERFORM)) {
+                return false;
+        }
+
+        printf(" Try another wrong removal\n");
+
+        msg->type = LDAP_TAG_DelRequest;
+        msg->r.DelRequest.dn = "";
+
+        req = ldap_request_send(conn, msg);
+        if (!req) {
+                return false;
+        }
+
+        status = ldap_result_one(req, &rep, LDAP_TAG_DelResponse);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("error in ldap removal request - %s\n", nt_errstr(status));
+                return false;
+        }
+
+        if ((rep->r.DelResponse.resultcode == 0)
+                || (rep->r.DelResponse.errormessage == NULL)
+                || (strtol(rep->r.DelResponse.errormessage, &endptr,16) <= 0)
+                || (*endptr != ':')) {
+                printf("Invalid error message!\n");
+                return false;
+        }
         
         err = ad_error(rep->r.DelResponse.errormessage, &endptr);
         err_code_str = win_errstr(err);
         printf(" - Errorcode: %s; Reason: %s\n", err_code_str, endptr);
-        if (!torture_setting_bool(tctx, "samba4", false)) {
-                if ((!W_ERROR_EQUAL(err, WERR_DS_OBJ_NOT_FOUND))
-                        || (rep->r.DelResponse.resultcode != 32)) {
+        if ((!W_ERROR_EQUAL(err, WERR_DS_OBJ_NOT_FOUND) &&
+             !W_ERROR_EQUAL(err, WERR_DS_NO_SUCH_OBJECT))
+                || (rep->r.DelResponse.resultcode != LDAP_NO_SUCH_OBJECT)) {
+                return false;
+        }
+
+        printf(" Try a wrong rename\n");
+
+        msg->type = LDAP_TAG_ModifyDNRequest;
+        msg->r.ModifyDNRequest.dn = basedn;
+        msg->r.ModifyDNRequest.newrdn = "dc=test";
+        msg->r.ModifyDNRequest.deleteolddn = true;
+        msg->r.ModifyDNRequest.newsuperior = NULL;
+
+        req = ldap_request_send(conn, msg);
+        if (!req) {
+                return false;
+        }
+
+        status = ldap_result_one(req, &rep, LDAP_TAG_ModifyDNResponse);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("error in ldap rename request - %s\n", nt_errstr(status));
+                return false;
+        }
+
+        if ((rep->r.ModifyDNResponse.resultcode == 0)
+                || (rep->r.ModifyDNResponse.errormessage == NULL)
+                || (strtol(rep->r.ModifyDNResponse.errormessage, &endptr,16) <= 0)
+                || (*endptr != ':')) {
+                printf("Invalid error message!\n");
+                return false;
+        }
+
+        err = ad_error(rep->r.ModifyDNResponse.errormessage, &endptr);
+        err_code_str = win_errstr(err);
+        printf(" - Errorcode: %s; Reason: %s\n", err_code_str, endptr);
+        if ((!W_ERROR_EQUAL(err, WERR_DS_NO_PARENT_OBJECT) &&
+             !W_ERROR_EQUAL(err, WERR_DS_GENERIC_ERROR))
+                || (rep->r.ModifyDNResponse.resultcode != LDAP_OTHER)) {
+                return false;
+        }
+
+        printf(" Try another wrong rename\n");
+
+        msg->type = LDAP_TAG_ModifyDNRequest;
+        msg->r.ModifyDNRequest.dn = basedn;
+        msg->r.ModifyDNRequest.newrdn = basedn;
+        msg->r.ModifyDNRequest.deleteolddn = true;
+        msg->r.ModifyDNRequest.newsuperior = NULL;
+
+        req = ldap_request_send(conn, msg);
+        if (!req) {
+                return false;
+        }
+
+        status = ldap_result_one(req, &rep, LDAP_TAG_ModifyDNResponse);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("error in ldap rename request - %s\n", nt_errstr(status));
+                return false;
+        }
+
+        if ((rep->r.ModifyDNResponse.resultcode == 0)
+                || (rep->r.ModifyDNResponse.errormessage == NULL)
+                || (strtol(rep->r.ModifyDNResponse.errormessage, &endptr,16) <= 0)
+                || (*endptr != ':')) {
+                printf("Invalid error message!\n");
+                return false;
+        }
+
+        err = ad_error(rep->r.ModifyDNResponse.errormessage, &endptr);
+        err_code_str = win_errstr(err);
+        printf(" - Errorcode: %s; Reason: %s\n", err_code_str, endptr);
+        if ((!W_ERROR_EQUAL(err, WERR_INVALID_PARAM) &&
+             !W_ERROR_EQUAL(err, WERR_DS_NAMING_VIOLATION))
+                || (rep->r.ModifyDNResponse.resultcode != LDAP_NAMING_VIOLATION)) {
+                return false;
+        }
+
+        printf(" Try another wrong rename\n");
+
+        msg->type = LDAP_TAG_ModifyDNRequest;
+        msg->r.ModifyDNRequest.dn = basedn;
+        msg->r.ModifyDNRequest.newrdn = "";
+        msg->r.ModifyDNRequest.deleteolddn = true;
+        msg->r.ModifyDNRequest.newsuperior = NULL;
+
+        req = ldap_request_send(conn, msg);
+        if (!req) {
+                return false;
+        }
+
+        status = ldap_result_one(req, &rep, LDAP_TAG_ModifyDNResponse);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("error in ldap rename request - %s\n", nt_errstr(status));
+                return false;
+        }
+
+        if ((rep->r.ModifyDNResponse.resultcode == 0)
+                || (rep->r.ModifyDNResponse.errormessage == NULL)
+                || (strtol(rep->r.ModifyDNResponse.errormessage, &endptr,16) <= 0)
+                || (*endptr != ':')) {
+                printf("Invalid error message!\n");
+                return false;
+        }
+
+        err = ad_error(rep->r.ModifyDNResponse.errormessage, &endptr);
+        err_code_str = win_errstr(err);
+        printf(" - Errorcode: %s; Reason: %s\n", err_code_str, endptr);
+        if ((!W_ERROR_EQUAL(err, WERR_INVALID_PARAM) &&
+             !W_ERROR_EQUAL(err, WERR_DS_PROTOCOL_ERROR))
+                || (rep->r.ModifyDNResponse.resultcode != LDAP_PROTOCOL_ERROR)) {
+                return false;
+        }
+
+        printf(" Try another wrong rename\n");
+
+        msg->type = LDAP_TAG_ModifyDNRequest;
+        msg->r.ModifyDNRequest.dn = "";
+        msg->r.ModifyDNRequest.newrdn = "cn=temp";
+        msg->r.ModifyDNRequest.deleteolddn = true;
+        msg->r.ModifyDNRequest.newsuperior = NULL;
+
+        req = ldap_request_send(conn, msg);
+        if (!req) {
+                return false;
+        }
+
+        status = ldap_result_one(req, &rep, LDAP_TAG_ModifyDNResponse);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("error in ldap rename request - %s\n", nt_errstr(status));
+                return false;
+        }
+
+        if ((rep->r.ModifyDNResponse.resultcode == 0)
+                || (rep->r.ModifyDNResponse.errormessage == NULL)
+                || (strtol(rep->r.ModifyDNResponse.errormessage, &endptr,16) <= 0)
+                || (*endptr != ':')) {
+                printf("Invalid error message!\n");
+                return false;
+        }
+
+        err = ad_error(rep->r.ModifyDNResponse.errormessage, &endptr);
+        err_code_str = win_errstr(err);
+        printf(" - Errorcode: %s; Reason: %s\n", err_code_str, endptr);
+        if ((!W_ERROR_EQUAL(err, WERR_DS_OBJ_NOT_FOUND) &&
+             !W_ERROR_EQUAL(err, WERR_DS_NO_SUCH_OBJECT))
+                || (rep->r.ModifyDNResponse.resultcode != LDAP_NO_SUCH_OBJECT)) {
+                return false;
+        }
+
+        return true;
+}
+
+static bool test_referrals(struct torture_context *tctx, TALLOC_CTX *mem_ctx,
+        const char *url, const char *basedn, const char **partitions)
+{
+        struct ldb_context *ldb;
+        struct ldb_result *res;
+        const char * const *attrs = { NULL };
+        struct ldb_dn *dn1, *dn2;
+        int ret;
+        int i, j, k;
+        char *tempstr;
+        bool found, l_found;
+
+        printf("Testing referrals\n");
+
+        if (partitions[0] == NULL) {
+                printf("Partitions list empty!\n");
+                return false;
+        }
+
+        if (strcmp(partitions[0], basedn) != 0) {
+                printf("The first (root) partition DN should be the base DN!\n");
+                return false;
+        }
+
+        ldb = ldb_wrap_connect(mem_ctx, tctx->ev, tctx->lp_ctx, url,
+                               NULL, cmdline_credentials, 0);
+
+        /* "partitions[i]" are the partitions for which we search the parents */
+        for (i = 1; partitions[i] != NULL; i++) {
+                dn1 = ldb_dn_new(mem_ctx, ldb, partitions[i]);
+                if (dn1 == NULL) {
+                        printf("Out of memory\n");
+                        talloc_free(ldb);
                         return false;
                 }
-        } else {
-                if ((!W_ERROR_EQUAL(err, WERR_DS_INVALID_DN_SYNTAX))
-                        || (rep->r.DelResponse.resultcode != 34)) {
-                        return false;
+
+                /* search using base scope */
+                /* "partitions[j]" are the parent candidates */
+                for (j = str_list_length(partitions) - 1; j >= 0; --j) {
+                        dn2 = ldb_dn_new(mem_ctx, ldb, partitions[j]);
+                        if (dn2 == NULL) {
+                                printf("Out of memory\n");
+                                talloc_free(ldb);
+                                return false;
+                        }
+
+                        ret = ldb_search(ldb, mem_ctx, &res, dn2,
+                                         LDB_SCOPE_BASE, attrs,
+                                         "(foo=bar)");
+                        if (ret != LDB_SUCCESS) {
+                                printf("%s", ldb_errstring(ldb));
+                                talloc_free(ldb);
+                                return false;
+                        }
+
+                        if (res->refs != NULL) {
+                                printf("There shouldn't be generated any referrals in the base scope!\n");
+                                talloc_free(ldb);
+                                return false;
+                        }
+
+                        talloc_free(res);
+                        talloc_free(dn2);
                 }
-        }
+
+                /* search using onelevel scope */
+                found = false;
+                /* "partitions[j]" are the parent candidates */
+                for (j = str_list_length(partitions) - 1; j >= 0; --j) {
+                        dn2 = ldb_dn_new(mem_ctx, ldb, partitions[j]);
+                        if (dn2 == NULL) {
+                                printf("Out of memory\n");
+                                talloc_free(ldb);
+                                return false;
+                        }
+
+                        ret = ldb_search(ldb, mem_ctx, &res, dn2,
+                                         LDB_SCOPE_ONELEVEL, attrs,
+                                         "(foo=bar)");
+                        if (ret != LDB_SUCCESS) {
+                                printf("%s", ldb_errstring(ldb));
+                                talloc_free(ldb);
+                                return false;
+                        }
+
+                        tempstr = talloc_asprintf(mem_ctx, "/%s??base",
+                                                  partitions[i]);
+                        if (tempstr == NULL) {
+                                printf("Out of memory\n");
+                                talloc_free(ldb);
+                                return false;
+                        }
+
+                        /* Try to find or find not a matching referral */
+                        l_found = false;
+                        for (k = 0; (!l_found) && (res->refs != NULL)
+                            && (res->refs[k] != NULL); k++) {
+                                if (strstr(res->refs[k], tempstr) != NULL) {
+                                        l_found = true;
+                                }
+                        }
+
+                        talloc_free(tempstr);
+
+                        if ((!found) && (ldb_dn_compare_base(dn2, dn1) == 0)
+                            && (ldb_dn_compare(dn2, dn1) != 0)) {
+                                /* This is a referral candidate */
+                                if (!l_found) {
+                                        printf("A required referral hasn't been found on onelevel scope (%s -> %s)!\n", partitions[j], partitions[i]);
+                                        talloc_free(ldb);
+                                        return false;
+                                }
+                                found = true;
+                        } else {
+                                /* This isn't a referral candidate */
+                                if (l_found) {
+                                        printf("A unrequired referral has been found on onelevel scope (%s -> %s)!\n", partitions[j], partitions[i]);
+                                        talloc_free(ldb);
+                                        return false;
+                                }
+                        }
+
+                        talloc_free(res);
+                        talloc_free(dn2);
+                }
+
+                /* search using subtree scope */
+                found = false;
+                /* "partitions[j]" are the parent candidates */
+                for (j = str_list_length(partitions) - 1; j >= 0; --j) {
+                        dn2 = ldb_dn_new(mem_ctx, ldb, partitions[j]);
+                        if (dn2 == NULL) {
+                                printf("Out of memory\n");
+                                talloc_free(ldb);
+                                return false;
+                        }
+
+                        ret = ldb_search(ldb, mem_ctx, &res, dn2,
+                                         LDB_SCOPE_SUBTREE, attrs,
+                                         "(foo=bar)");
+                        if (ret != LDB_SUCCESS) {
+                                printf("%s", ldb_errstring(ldb));
+                                talloc_free(ldb);
+                                return false;
+                        }
+
+                        tempstr = talloc_asprintf(mem_ctx, "/%s",
+                                                  partitions[i]);
+                        if (tempstr == NULL) {
+                                printf("Out of memory\n");
+                                talloc_free(ldb);
+                                return false;
+                        }
+
+                        /* Try to find or find not a matching referral */
+                        l_found = false;
+                        for (k = 0; (!l_found) && (res->refs != NULL)
+                            && (res->refs[k] != NULL); k++) {
+                                if (strstr(res->refs[k], tempstr) != NULL) {
+                                        l_found = true;
+                                }
+                        }
+
+                        talloc_free(tempstr);
+
+                        if ((!found) && (ldb_dn_compare_base(dn2, dn1) == 0)
+                            && (ldb_dn_compare(dn2, dn1) != 0)) {
+                                /* This is a referral candidate */
+                                if (!l_found) {
+                                        printf("A required referral hasn't been found on subtree scope (%s -> %s)!\n", partitions[j], partitions[i]);
+                                        talloc_free(ldb);
+                                        return false;
+                                }
+                                found = true;
+                        } else {
+                                /* This isn't a referral candidate */
+                                if (l_found) {
+                                        printf("A unrequired referral has been found on subtree scope (%s -> %s)!\n", partitions[j], partitions[i]);
+                                        talloc_free(ldb);
+                                        return false;
+                                }
+                        }
+
+                        talloc_free(res);
+                        talloc_free(dn2);
+                }
+
+                talloc_free(dn1);
+        }
+
+        talloc_free(ldb);
 
         return true;
 }
+
+static bool test_abandom_request(struct torture_context *tctx,
+        struct ldap_connection *conn, const char *basedn)
+{
+        struct ldap_message *msg;
+        struct ldap_request *req;
+        NTSTATUS status;
+
+        printf("Testing the AbandonRequest with an old message id!\n");
+
+        if (!basedn) {
+                return false;
+        }
+
+        msg = new_ldap_message(conn);
+        if (!msg) {
+                return false;
+        }
+
+        printf(" Try a AbandonRequest for an old message id\n");
+
+        msg->type = LDAP_TAG_AbandonRequest;
+        msg->r.AbandonRequest.messageid = 1;
+
+        req = ldap_request_send(conn, msg);
+        if (!req) {
+                return false;
+        }
+
+        status = ldap_request_wait(req);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("error in ldap abandon request - %s\n", nt_errstr(status));
+                return false;
+        }
+
+        return true;
+}
+
 
 bool torture_ldap_basic(struct torture_context *torture)
@@ -362 +840 @@
         const char *userdn = torture_setting_string(torture, "ldap_userdn", NULL);
         const char *secret = torture_setting_string(torture, "ldap_secret", NULL);
-        char *url;
-        char *basedn;
+        const char *url;
+        const char *basedn;
+        const char **partitions;
 
         mem_ctx = talloc_init("torture_ldap_basic");
@@ -374 +853 @@
         }
 
-        if (!test_search_rootDSE(conn, &basedn)) {
+        if (!test_search_rootDSE(conn, &basedn, &partitions)) {
                 ret = false;
         }
@@ -395 +874 @@
 
         if (!test_error_codes(torture, conn, basedn)) {
+                ret = false;
+        }
+
+        /* referrals test here */
+
+        if (!test_referrals(torture, mem_ctx, url, basedn, partitions)) {
+                ret = false;
+        }
+
+        if (!test_abandom_request(torture, conn, basedn)) {
                 ret = false;
         }

trunk/server/source4/torture/ldap/cldap.c

@@ -5 +5 @@
    
    Copyright (C) Andrew Tridgell 2005
+   Copyright (C) Matthias Dieter Wallnöfer 2009
     
    This program is free software; you can redistribute it and/or modify
@@ -23 +24 @@
 #include "includes.h"
 #include "libcli/cldap/cldap.h"
-#include "libcli/ldap/ldap.h"
-#include "librpc/gen_ndr/ndr_nbt.h"
+#include "libcli/ldap/libcli_ldap.h"
 #include "librpc/gen_ndr/netlogon.h"
 #include "torture/torture.h"
-#include "lib/ldb/include/ldb.h"
 #include "param/param.h"
 #include "../lib/tsocket/tsocket.h"
@@ -47 +46 @@
         struct GUID guid;
         int i;
-        struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(tctx->lp_ctx);
         struct tsocket_address *dest_addr;
         int ret;
@@ -53 +51 @@
         ret = tsocket_address_inet_from_strings(tctx, "ip",
                                                 dest,
-                                                lp_cldap_port(tctx->lp_ctx),
+                                                lpcfg_cldap_port(tctx->lp_ctx),
                                                 &dest_addr);
         CHECK_VAL(ret, 0);
@@ -71 +69 @@
         printf("Trying without any attributes\n");
         search = empty_search;
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+        status = cldap_netlogon(cldap, tctx, &search);
         CHECK_STATUS(status, NT_STATUS_OK);
 
@@ -84 +82 @@
                 search.in.version = i;
                 printf("Trying netlogon level %d\n", i);
-                status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+                status = cldap_netlogon(cldap, tctx, &search);
                 CHECK_STATUS(status, NT_STATUS_OK);
         }
@@ -92 +90 @@
                 search.in.version = (1<<i);
                 printf("Trying netlogon level 0x%x\n", i);
-                status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+                status = cldap_netlogon(cldap, tctx, &search);
                 CHECK_STATUS(status, NT_STATUS_OK);
         }
 
         search.in.version = NETLOGON_NT_VERSION_5|NETLOGON_NT_VERSION_5EX|NETLOGON_NT_VERSION_IP;
-
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+        status = cldap_netlogon(cldap, tctx, &search);
         CHECK_STATUS(status, NT_STATUS_OK);
 
         printf("Trying with User=NULL\n");
-
         search.in.user = NULL;
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
-        CHECK_STATUS(status, NT_STATUS_OK);
-        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
-        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+        status = cldap_netlogon(cldap, tctx, &search);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
 
         printf("Trying with User=Administrator\n");
-
         search.in.user = "Administrator";
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
-        CHECK_STATUS(status, NT_STATUS_OK);
-
+        status = cldap_netlogon(cldap, tctx, &search);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
         CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, search.in.user);
-        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
 
         search.in.version = NETLOGON_NT_VERSION_5;
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+        status = cldap_netlogon(cldap, tctx, &search);
         CHECK_STATUS(status, NT_STATUS_OK);
 
         printf("Trying with User=NULL\n");
-
         search.in.user = NULL;
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
-        CHECK_STATUS(status, NT_STATUS_OK);
-        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
+        status = cldap_netlogon(cldap, tctx, &search);
+        CHECK_STATUS(status, NT_STATUS_OK);
         CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
 
         printf("Trying with User=Administrator\n");
-
         search.in.user = "Administrator";
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
-        CHECK_STATUS(status, NT_STATUS_OK);
-
+        status = cldap_netlogon(cldap, tctx, &search);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN);
         CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, search.in.user);
-        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN);
 
         search.in.version = NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX;
@@ -144 +135 @@
         search.in.realm       = NULL;
         search.in.domain_guid = GUID_string(tctx, &n1.data.nt5_ex.domain_uuid);
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+        status = cldap_netlogon(cldap, tctx, &search);
         CHECK_STATUS(status, NT_STATUS_OK);
         CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
@@ -153 +144 @@
         search.in.user        = NULL;
         search.in.domain_guid = GUID_string(tctx, &guid);
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+        status = cldap_netlogon(cldap, tctx, &search);
         CHECK_STATUS(status, NT_STATUS_NOT_FOUND);
 
@@ -159 +150 @@
         search.in.acct_control = ACB_WSTRUST|ACB_SVRTRUST;
         search.in.realm = n1.data.nt5_ex.dns_domain;
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+        status = cldap_netlogon(cldap, tctx, &search);
         CHECK_STATUS(status, NT_STATUS_OK);
         CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
@@ -167 +158 @@
         search.in.acct_control = 0x0;
         search.in.realm = n1.data.nt5_ex.dns_domain;
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+        status = cldap_netlogon(cldap, tctx, &search);
         CHECK_STATUS(status, NT_STATUS_OK);
         CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
@@ -176 +167 @@
         search.in.user = "Administrator";
         search.in.realm = n1.data.nt5_ex.dns_domain;
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+        status = cldap_netlogon(cldap, tctx, &search);
         CHECK_STATUS(status, NT_STATUS_OK);
         CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
@@ -185 +176 @@
         search.in.acct_control = 0xFF00FF00;
         search.in.realm = n1.data.nt5_ex.dns_domain;
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+        status = cldap_netlogon(cldap, tctx, &search);
         CHECK_STATUS(status, NT_STATUS_OK);
         CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
@@ -193 +184 @@
         search = empty_search;
         search.in.user = "Administrator";
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
-        CHECK_STATUS(status, NT_STATUS_OK);
+        status = cldap_netlogon(cldap, tctx, &search);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
         CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.domain_name, n1.data.nt5_ex.domain_name);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.pdc_name, n1.data.nt5_ex.pdc_name);
         CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, search.in.user);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.server_site, n1.data.nt5_ex.server_site);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.client_site, n1.data.nt5_ex.client_site);
 
         printf("Trying with just a bad username\n");
         search.in.user = "___no_such_user___";
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
-        CHECK_STATUS(status, NT_STATUS_OK);
+        status = cldap_netlogon(cldap, tctx, &search);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.domain_name, n1.data.nt5_ex.domain_name);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.pdc_name, n1.data.nt5_ex.pdc_name);
         CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, search.in.user);
-        CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
-        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.server_site, n1.data.nt5_ex.server_site);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.client_site, n1.data.nt5_ex.client_site);
 
         printf("Trying with just a bad domain\n");
         search = empty_search;
         search.in.realm = "___no_such_domain___";
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+        status = cldap_netlogon(cldap, tctx, &search);
         CHECK_STATUS(status, NT_STATUS_NOT_FOUND);
 
         printf("Trying with a incorrect domain and correct guid\n");
         search.in.domain_guid = GUID_string(tctx, &n1.data.nt5_ex.domain_uuid);
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
-        CHECK_STATUS(status, NT_STATUS_OK);
+        status = cldap_netlogon(cldap, tctx, &search);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
         CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
-        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
-        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.domain_name, n1.data.nt5_ex.domain_name);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.pdc_name, n1.data.nt5_ex.pdc_name);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.server_site, n1.data.nt5_ex.server_site);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.client_site, n1.data.nt5_ex.client_site);
 
         printf("Trying with a incorrect domain and incorrect guid\n");
         search.in.domain_guid = GUID_string(tctx, &guid);
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+        status = cldap_netlogon(cldap, tctx, &search);
         CHECK_STATUS(status, NT_STATUS_NOT_FOUND);
+        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
         CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
-        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
-        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.domain_name, n1.data.nt5_ex.domain_name);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.pdc_name, n1.data.nt5_ex.pdc_name);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.server_site, n1.data.nt5_ex.server_site);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.client_site, n1.data.nt5_ex.client_site);
 
         printf("Trying with a incorrect GUID and correct domain\n");
         search.in.domain_guid = GUID_string(tctx, &guid);
         search.in.realm = n1.data.nt5_ex.dns_domain;
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
-        CHECK_STATUS(status, NT_STATUS_OK);
+        status = cldap_netlogon(cldap, tctx, &search);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
         CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
-        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
-        CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.domain_name, n1.data.nt5_ex.domain_name);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.pdc_name, n1.data.nt5_ex.pdc_name);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.server_site, n1.data.nt5_ex.server_site);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.client_site, n1.data.nt5_ex.client_site);
+
+        printf("Proof other results\n");
+        search.in.user = "Administrator";
+        status = cldap_netlogon(cldap, tctx, &search);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.domain_name, n1.data.nt5_ex.domain_name);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.pdc_name, n1.data.nt5_ex.pdc_name);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, search.in.user);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.server_site, n1.data.nt5_ex.server_site);
+        CHECK_STRING(search.out.netlogon.data.nt5_ex.client_site, n1.data.nt5_ex.client_site);
 
         return true;
@@ -251 +279 @@
         struct netlogon_samlogon_response n1;
         uint32_t server_type;
-        struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(tctx->lp_ctx);
+        struct tsocket_address *dest_addr;
+        int ret;
+
+        ret = tsocket_address_inet_from_strings(tctx, "ip",
+                                                dest,
+                                                lpcfg_cldap_port(tctx->lp_ctx),
+                                                &dest_addr);
+        CHECK_VAL(ret, 0);
 
         /* cldap_socket_init should now know about the dest. address */
-        status = cldap_socket_init(tctx, NULL, NULL, NULL, &cldap);
+        status = cldap_socket_init(tctx, NULL, NULL, dest_addr, &cldap);
         CHECK_STATUS(status, NT_STATUS_OK);
 
@@ -260 +295 @@
 
         ZERO_STRUCT(search);
-        search.in.dest_address = dest;
-        search.in.dest_port = lp_cldap_port(tctx->lp_ctx);
+        search.in.dest_address = NULL;
+        search.in.dest_port = 0;
         search.in.acct_control = -1;
         search.in.version = NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX;
         search.in.map_response = true;
 
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+        status = cldap_netlogon(cldap, tctx, &search);
         CHECK_STATUS(status, NT_STATUS_OK);
 
@@ -304 +339 @@
         if (server_type & DS_DNS_DOMAIN)
                 printf("DS_DNS_DOMAIN ");
-        if (server_type & DS_DNS_FOREST)
-                printf("DS_DNS_FOREST ");
+        if (server_type & DS_DNS_FOREST_ROOT)
+                printf("DS_DNS_FOREST_ROOT ");
 
         printf("\n");
@@ -353 +388 @@
 
 /*
-  test cldap netlogon server type flag "NBT_SERVER_DS_DNS_FOREST"
+  test cldap netlogon server type flag "NBT_SERVER_FOREST_ROOT"
 */
 static bool test_cldap_netlogon_flag_ds_dns_forest(struct torture_context *tctx,
@@ -363 +398 @@
         uint32_t server_type;
         struct netlogon_samlogon_response n1;
-        struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(tctx->lp_ctx);
         bool result = true;
+        struct tsocket_address *dest_addr;
+        int ret;
+
+        ret = tsocket_address_inet_from_strings(tctx, "ip",
+                                                dest,
+                                                lpcfg_cldap_port(tctx->lp_ctx),
+                                                &dest_addr);
+        CHECK_VAL(ret, 0);
 
         /* cldap_socket_init should now know about the dest. address */
-        status = cldap_socket_init(tctx, NULL, NULL, NULL, &cldap);
-        CHECK_STATUS(status, NT_STATUS_OK);
-
-        printf("Testing netlogon server type flag NBT_SERVER_DS_DNS_FOREST: ");
+        status = cldap_socket_init(tctx, NULL, NULL, dest_addr, &cldap);
+        CHECK_STATUS(status, NT_STATUS_OK);
+
+        printf("Testing netlogon server type flag NBT_SERVER_FOREST_ROOT: ");
 
         ZERO_STRUCT(search);
-        search.in.dest_address = dest;
-        search.in.dest_port = lp_cldap_port(tctx->lp_ctx);
+        search.in.dest_address = NULL;
+        search.in.dest_port = 0;
         search.in.acct_control = -1;
         search.in.version = NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX;
         search.in.map_response = true;
 
-        status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+        status = cldap_netlogon(cldap, tctx, &search);
         CHECK_STATUS(status, NT_STATUS_OK);
 
@@ -388 +430 @@
                 server_type = n1.data.nt5_ex.server_type;
 
-        if (server_type & DS_DNS_FOREST) {
+        if (server_type & DS_DNS_FOREST_ROOT) {
                 struct cldap_search search2;
                 const char *attrs[] = { "defaultNamingContext", "rootDomainNamingContext", 
@@ -399 +441 @@
                 ZERO_STRUCT(search2);
                 search2.in.dest_address = dest;
-                search2.in.dest_port = lp_cldap_port(tctx->lp_ctx);
+                search2.in.dest_port = lpcfg_cldap_port(tctx->lp_ctx);
                 search2.in.timeout = 10;
                 search2.in.retries = 3;
@@ -439 +481 @@
         const char *attrs2[] = { "currentTime", "highestCommittedUSN", "netlogon", NULL };
         const char *attrs3[] = { "netlogon", NULL };
+        struct tsocket_address *dest_addr;
+        int ret;
+
+        ret = tsocket_address_inet_from_strings(tctx, "ip",
+                                                dest,
+                                                lpcfg_cldap_port(tctx->lp_ctx),
+                                                &dest_addr);
+        CHECK_VAL(ret, 0);
 
         /* cldap_socket_init should now know about the dest. address */
-        status = cldap_socket_init(tctx, NULL, NULL, NULL, &cldap);
+        status = cldap_socket_init(tctx, NULL, NULL, dest_addr, &cldap);
         CHECK_STATUS(status, NT_STATUS_OK);
 
         ZERO_STRUCT(search);
-        search.in.dest_address = dest;
-        search.in.dest_port = lp_cldap_port(tctx->lp_ctx);
+        search.in.dest_address = NULL;
+        search.in.dest_port = 0;
         search.in.timeout = 10;
         search.in.retries = 3;

trunk/server/source4/torture/ldap/cldapbench.c

@@ -21 +21 @@
 
 #include "includes.h"
-#include <tevent.h>
 #include "libcli/cldap/cldap.h"
 #include "libcli/resolve/resolve.h"
@@ -42 +41 @@
         TALLOC_CTX *tmp_ctx = talloc_new(NULL);
         io.in.version = 6;
-        status = cldap_netlogon_recv(req,
-                                     lp_iconv_convenience(state->tctx->lp_ctx),
-                                     tmp_ctx, &io);
+        status = cldap_netlogon_recv(req, tmp_ctx, &io);
         talloc_free(req);
         if (NT_STATUS_IS_OK(status)) {
@@ -71 +68 @@
         ret = tsocket_address_inet_from_strings(tctx, "ip",
                                                 address,
-                                                lp_cldap_port(tctx->lp_ctx),
+                                                lpcfg_cldap_port(tctx->lp_ctx),
                                                 &dest_addr);
         CHECK_VAL(ret, 0);
@@ -82 +79 @@
 
         ZERO_STRUCT(search);
-        search.in.dest_address = address;
-        search.in.dest_port     = lp_cldap_port(tctx->lp_ctx);
+        search.in.dest_address = NULL;
+        search.in.dest_port = 0;
         search.in.acct_control = -1;
         search.in.version = 6;
@@ -149 +146 @@
         struct bench_state *state;
         NTSTATUS status;
+        struct tsocket_address *dest_addr;
+        int ret;
+
+        ret = tsocket_address_inet_from_strings(tctx, "ip",
+                                                address,
+                                                lpcfg_cldap_port(tctx->lp_ctx),
+                                                &dest_addr);
+        CHECK_VAL(ret, 0);
 
         /* cldap_socket_init should now know about the dest. address */
-        status = cldap_socket_init(tctx, tctx->ev, NULL, NULL, &cldap);
+        status = cldap_socket_init(tctx, tctx->ev, NULL, dest_addr, &cldap);
         torture_assert_ntstatus_ok(tctx, status, "cldap_socket_init");
 
@@ -157 +162 @@
 
         ZERO_STRUCT(search);
-        search.in.dest_address  = address;
-        search.in.dest_port     = lp_cldap_port(tctx->lp_ctx);
+        search.in.dest_address  = NULL;
+        search.in.dest_port     = 0;
         search.in.filter        = "(objectClass=*)";
         search.in.timeout       = 2;
@@ -211 +216 @@
 
         /* do an initial name resolution to find its IP */
-        status = resolve_name(lp_resolve_context(torture->lp_ctx), &name, torture, &address, torture->ev);
+        status = resolve_name(lpcfg_resolve_context(torture->lp_ctx), &name, torture, &address, torture->ev);
         if (!NT_STATUS_IS_OK(status)) {
                 printf("Failed to resolve %s - %s\n",

trunk/server/source4/torture/ldap/common.c

@@ -97 +97 @@
 NTSTATUS torture_ldap_close(struct ldap_connection *conn)
 {
+        struct ldap_message *msg;
+        struct ldap_request *req;
+        NTSTATUS status;
+
+        printf("Testing the most important error code -> error message conversions!\n");
+
+        msg = new_ldap_message(conn);
+        if (!msg) {
+                talloc_free(conn);
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        printf(" Try a AbandonRequest for an old message id\n");
+
+        msg->type = LDAP_TAG_UnbindRequest;
+
+        req = ldap_request_send(conn, msg);
+        if (!req) {
+                talloc_free(conn);
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        status = ldap_request_wait(req);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("error in ldap unbind request - %s\n", nt_errstr(status));
+                talloc_free(conn);
+                return status;
+        }
+
         talloc_free(conn);
         return NT_STATUS_OK;
@@ -103 +132 @@
 NTSTATUS torture_ldap_init(void)
 {
-        struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "LDAP");
-        torture_suite_add_simple_test(suite, "BENCH-CLDAP", torture_bench_cldap);
-        torture_suite_add_simple_test(suite, "BASIC", torture_ldap_basic);
-        torture_suite_add_simple_test(suite, "SORT", torture_ldap_sort);
-        torture_suite_add_simple_test(suite, "CLDAP", torture_cldap);
-        torture_suite_add_simple_test(suite, "SCHEMA", torture_ldap_schema);
-        torture_suite_add_simple_test(suite, "UPTODATEVECTOR", torture_ldap_uptodatevector);
+        struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "ldap");
+        torture_suite_add_simple_test(suite, "bench-cldap", torture_bench_cldap);
+        torture_suite_add_simple_test(suite, "basic", torture_ldap_basic);
+        torture_suite_add_simple_test(suite, "sort", torture_ldap_sort);
+        torture_suite_add_simple_test(suite, "cldap", torture_cldap);
+        torture_suite_add_simple_test(suite, "schema", torture_ldap_schema);
+        torture_suite_add_simple_test(suite, "uptodatevector", torture_ldap_uptodatevector);
+        torture_suite_add_simple_test(suite, "nested-search", test_ldap_nested_search);
 
         suite->description = talloc_strdup(suite, "LDAP and CLDAP tests");

trunk/server/source4/torture/ldap/ldap_sort.c

@@ -23 +23 @@
 #include "includes.h"
 #include "lib/events/events.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
+#include <ldb.h>
+#include <ldb_errors.h>
 #include "ldb_wrap.h"
 #include "param/param.h"
@@ -31 +31 @@
 #include "torture/local/proto.h"
 #include <ctype.h>
+
 bool torture_ldap_sort(struct torture_context *torture)
 {
-
         struct ldb_context *ldb;
 
@@ -47 +47 @@
         struct ldb_request *req;
         struct ldb_result *ctx;
-        struct ldb_val* prev = NULL;
+        struct ldb_val *prev = NULL;
         const char *prev_txt = NULL;
         int prev_len = 0;
-        struct ldb_val* cur = NULL;
+        struct ldb_val *cur = NULL;
         const char *cur_txt = NULL;
         int cur_len = 0;
-        struct ldb_dn* dn;
+        struct ldb_dn *dn;
                  
                  
@@ -63 +63 @@
                                                  NULL,
                                                  cmdline_credentials,
-                                                 0, NULL);
+                                                 0);
         torture_assert(torture, ldb, "Failed to make LDB connection to target");
 
@@ -75 +75 @@
         control[1] = NULL;
 
-        dn = ldb_get_root_basedn(ldb);
+        dn = ldb_get_default_basedn(ldb);
         ldb_dn_add_child_fmt(dn, "cn=users");
         ret = ldb_build_search_req(&req, ldb, ctx,
@@ -104 +104 @@
                         {
                                 /* Do only the ascii case right now ... */
-                                cur_txt=cur->data;
-                                cur_len=cur->length;
-                                prev_txt=prev->data;
-                                prev_len=prev->length;
+                                cur_txt = (const char *) cur->data;
+                                cur_len = cur->length;
+                                prev_txt = (const char *) prev->data;
+                                prev_len = prev->length;
                                 /* Remove leading whitespace as the sort function do so ... */
                                 while ( cur_txt[0] == cur_txt[1] ) { cur_txt++; cur_len--;}

trunk/server/source4/torture/ldap/schema.c

@@ -24 +24 @@
 #include "lib/cmdline/popt_common.h"
 #include "ldb_wrap.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
 #include "dsdb/samdb/samdb.h"
 #include "../lib/util/dlinklist.h"
 
 #include "torture/torture.h"
-#include "torture/ldap/proto.h"
-
-#include "param/param.h"
+
 
 struct test_rootDSE {
@@ -216 +212 @@
 {
         struct dsdb_schema *schema = talloc_get_type(ptr, struct dsdb_schema);
-        struct dsdb_attribute *attr = NULL;
         WERROR status;
 
-        attr = talloc_zero(schema, struct dsdb_attribute);
-        if (!attr) {
-                goto failed;
-        }
-
-        status = dsdb_attribute_from_ldb(ldb, schema, msg, attr, attr);
+        status = dsdb_attribute_from_ldb(ldb, schema, msg);
         if (!W_ERROR_IS_OK(status)) {
                 goto failed;
         }
 
-        DLIST_ADD_END(schema->attributes, attr, struct dsdb_attribute *);
         return LDB_SUCCESS;
 failed:
-        talloc_free(attr);
         return LDB_ERR_OTHER;
 }
@@ -239 +227 @@
 {
         struct dsdb_schema *schema = talloc_get_type(ptr, struct dsdb_schema);
-        struct dsdb_class *obj;
         WERROR status;
 
-        obj = talloc_zero(schema, struct dsdb_class);
-        if (!obj) {
-                goto failed;
-        }
-
-        status = dsdb_class_from_ldb(schema, msg, obj, obj);
+        status = dsdb_class_from_ldb(schema, msg);
         if (!W_ERROR_IS_OK(status)) {
                 goto failed;
         }
 
-        DLIST_ADD_END(schema->classes, obj, struct dsdb_class *);
         return LDB_SUCCESS;
 failed:
@@ -361 +342 @@
                         if (strcmp(syntaxes[i], a->attributeSyntax_oid) != 0) continue;
 
-                        om_hex = data_blob_hex_string(ldb, &a->oMObjectClass);
+                        om_hex = data_blob_hex_string_upper(ldb, &a->oMObjectClass);
                         if (!om_hex) {
                                 return false;
@@ -373 +354 @@
         }
 
+        return true;
+}
+
+static bool test_dump_not_in_filtered_replica(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 not in filtered replica\n");
+
+        for (a=schema->attributes; a; a = a->next) {
+                if (!dsdb_attribute_is_attr_in_filtered_replica(a)) {
+                        d_printf("attr[%4u]: '%s'\n", a_i++,
+                                 a->lDAPDisplayName);
+                }
+        }
         return true;
 }
@@ -392 +389 @@
                                NULL,
                                cmdline_credentials,
-                               0, NULL);
+                               0);
         if (!ldb) goto failed;
 
@@ -404 +401 @@
         ret &= test_dump_contructed(ldb, &rootDSE, schema);
         ret &= test_dump_sorted_syntax(ldb, &rootDSE, schema);
+        ret &= test_dump_not_in_filtered_replica(ldb, &rootDSE, schema);
 
 failed:

trunk/server/source4/torture/ldap/uptodatevector.c

@@ -24 +24 @@
 #include "lib/cmdline/popt_common.h"
 #include "ldb_wrap.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
 #include "dsdb/samdb/samdb.h"
-#include "../lib/util/dlinklist.h"
 
 #include "torture/torture.h"
-#include "torture/ldap/proto.h"
 
-#include "librpc/ndr/libndr.h"
 #include "librpc/gen_ndr/ndr_drsblobs.h"
 
@@ -71 +66 @@
         if (utdv_val1) {
                 ndr_err = ndr_pull_struct_blob_all(utdv_val1, torture, 
-                                                   lp_iconv_convenience(torture->lp_ctx), &utdv1,
+                                                   &utdv1,
                                                    (ndr_pull_flags_fn_t)ndr_pull_replUpToDateVectorBlob);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
@@ -117 +112 @@
                 if (utdv_val) {
                         ndr_err = ndr_pull_struct_blob_all(utdv_val, torture, 
-                                                           lp_iconv_convenience(torture->lp_ctx), &utdv,
+                                                           &utdv,
                                                            (ndr_pull_flags_fn_t)ndr_pull_replUpToDateVectorBlob);
                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
@@ -136 +131 @@
 
                 torture_comment(torture, "[%u]: uSNChanged[%llu] description[%s] replUpToDateVector[%s]\n", i,
-                                (unsigned long long)samdb_result_uint64(r->msgs[0], "uSNChanged", 0),
-                                samdb_result_string(r->msgs[0], "description", NULL),
+                                (unsigned long long)ldb_msg_find_attr_as_uint64(r->msgs[0], "uSNChanged", 0),
+                                ldb_msg_find_attr_as_string(r->msgs[0], "description", NULL),
                                 (no_match ? "changed!: not ok" : "not changed: ok"));
 
@@ -165 +160 @@
                                NULL,
                                cmdline_credentials,
-                               0, NULL);
+                               0);
         if (!ldb) goto failed;
 
-        ret &= test_check_uptodatevector(torture, ldb, samdb_base_dn(ldb));
-        ret &= test_check_uptodatevector(torture, ldb, samdb_config_dn(ldb));
-        ret &= test_check_uptodatevector(torture, ldb, samdb_schema_dn(ldb));
+        ret &= test_check_uptodatevector(torture, ldb, ldb_get_default_basedn(ldb));
+        ret &= test_check_uptodatevector(torture, ldb, ldb_get_config_basedn(ldb));
+        ret &= test_check_uptodatevector(torture, ldb, ldb_get_schema_basedn(ldb));
 
         return ret;