torture: Fix copy and paste error in debug message.

[kai/samba.git] / source4 / torture / rpc / drsuapi_cracknames.c

diff --git a/source4/torture/rpc/drsuapi_cracknames.c b/source4/torture/rpc/drsuapi_cracknames.c
index b49a006e80a9c3912eb01899516f776405bbd490..8d1ab6fc277d93080f2479e302902de89e7bdab3 100644 (file)
--- a/source4/torture/rpc/drsuapi_cracknames.c
+++ b/source4/torture/rpc/drsuapi_cracknames.c
@@ -22,12 +22,20 @@
 */
 
 #include "includes.h"
-#include "torture/torture.h"
 #include "librpc/gen_ndr/ndr_drsuapi_c.h"
-#include "torture/rpc/rpc.h"
-#include "ldb/include/ldb.h"
+#include "torture/rpc/torture_rpc.h"
+#include <ldb.h>
 #include "libcli/security/security.h"
 
+struct DsCrackNamesPrivate {
+       struct DsPrivate base;
+
+       /* following names are used in Crack Names Matrix test */
+       const char *fqdn_name;
+       const char *user_principal_name;
+       const char *service_principal_name;
+};
+
 static bool test_DsCrackNamesMatrix(struct torture_context *tctx,
                                    struct DsPrivate *priv, const char *dn,
                                    const char *user_principal_name, const char *service_principal_name)
@@ -36,9 +44,9 @@ static bool test_DsCrackNamesMatrix(struct torture_context *tctx,
        const char *err_msg;
        struct drsuapi_DsCrackNames r;
        union drsuapi_DsNameRequest req;
-       int32_t level_out;
+       uint32_t level_out;
        union drsuapi_DsNameCtr ctr;
-       struct dcerpc_pipe *p = priv->pipe;
+       struct dcerpc_pipe *p = priv->drs_pipe;
        TALLOC_CTX *mem_ctx = priv;
 
        enum drsuapi_DsNameFormat formats[] = {
@@ -79,12 +87,9 @@ static bool test_DsCrackNamesMatrix(struct torture_context *tctx,
                r.in.req->req1.format_offered   = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
                r.in.req->req1.format_desired   = formats[i];
                names[0].str = dn;
-               status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
+               status = dcerpc_drsuapi_DsCrackNames_r(p->binding_handle, mem_ctx, &r);
                if (!NT_STATUS_IS_OK(status)) {
                        const char *errstr = nt_errstr(status);
-                       if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
-                               errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
-                       }
                        err_msg = talloc_asprintf(mem_ctx,
                                        "testing DsCrackNames (matrix prep) with name '%s' from format: %d desired format:%d failed - %s",
                                        names[0].str, r.in.req->req1.format_offered, r.in.req->req1.format_desired, errstr);
@@ -164,12 +169,9 @@ static bool test_DsCrackNamesMatrix(struct torture_context *tctx,
                                continue;
                        }
                        names[0].str = n_from[i];
-                       status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
+                       status = dcerpc_drsuapi_DsCrackNames_r(p->binding_handle, mem_ctx, &r);
                        if (!NT_STATUS_IS_OK(status)) {
                                const char *errstr = nt_errstr(status);
-                               if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
-                                       errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
-                               }
                                err_msg = talloc_asprintf(mem_ctx,
                                                "testing DsCrackNames (matrix) with name '%s' from format: %d desired format:%d failed - %s",
                                                names[0].str, r.in.req->req1.format_offered, r.in.req->req1.format_desired, errstr);
@@ -229,7 +231,7 @@ bool test_DsCrackNames(struct torture_context *tctx,
        const char *err_msg;
        struct drsuapi_DsCrackNames r;
        union drsuapi_DsNameRequest req;
-       int32_t level_out;
+       uint32_t level_out;
        union drsuapi_DsNameCtr ctr;
        struct drsuapi_DsNameString names[1];
        const char *dns_domain;
@@ -248,7 +250,7 @@ bool test_DsCrackNames(struct torture_context *tctx,
        const char *canonical_ex_name;
        const char *dom_sid;
        const char *test_dc = torture_join_netbios_name(priv->join);
-       struct dcerpc_pipe *p = priv->pipe;
+       struct dcerpc_pipe *p = priv->drs_pipe;
        TALLOC_CTX *mem_ctx = priv;
 
        ZERO_STRUCT(r);
@@ -271,15 +273,12 @@ bool test_DsCrackNames(struct torture_context *tctx,
        
        names[0].str = dom_sid;
 
-       torture_comment(tctx, "testing DsCrackNames with name '%s' desired format:%d\n",
+       torture_comment(tctx, "Testing DsCrackNames with name '%s' desired format:%d\n",
                        names[0].str, r.in.req->req1.format_desired);
 
-       status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
+       status = dcerpc_drsuapi_DsCrackNames_r(p->binding_handle, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
                const char *errstr = nt_errstr(status);
-               if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
-                       errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
-               }
                err_msg = talloc_asprintf(mem_ctx, "dcerpc_drsuapi_DsCrackNames failed - %s", errstr);
                torture_fail(tctx, err_msg);
        } else if (!W_ERROR_IS_OK(r.out.result)) {
@@ -296,15 +295,12 @@ bool test_DsCrackNames(struct torture_context *tctx,
 
        r.in.req->req1.format_desired   = DRSUAPI_DS_NAME_FORMAT_GUID;
 
-       torture_comment(tctx, "testing DsCrackNames with name '%s' desired format:%d\n",
+       torture_comment(tctx, "Testing DsCrackNames with name '%s' desired format:%d\n",
                        names[0].str, r.in.req->req1.format_desired);
 
-       status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
+       status = dcerpc_drsuapi_DsCrackNames_r(p->binding_handle, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
                const char *errstr = nt_errstr(status);
-               if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
-                       errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
-               }
                err_msg = talloc_asprintf(mem_ctx, "dcerpc_drsuapi_DsCrackNames failed - %s", errstr);
                torture_fail(tctx, err_msg);
        } else if (!W_ERROR_IS_OK(r.out.result)) {
@@ -322,15 +318,12 @@ bool test_DsCrackNames(struct torture_context *tctx,
 
        r.in.req->req1.format_desired   = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
 
-       torture_comment(tctx, "testing DsCrackNames with name '%s' desired format:%d\n",
+       torture_comment(tctx, "Testing DsCrackNames with name '%s' desired format:%d\n",
                        names[0].str, r.in.req->req1.format_desired);
 
-       status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
+       status = dcerpc_drsuapi_DsCrackNames_r(p->binding_handle, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
                const char *errstr = nt_errstr(status);
-               if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
-                       errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
-               }
                err_msg = talloc_asprintf(mem_ctx, "dcerpc_drsuapi_DsCrackNames failed - %s", errstr);
                torture_fail(tctx, err_msg);
        } else if (!W_ERROR_IS_OK(r.out.result)) {
@@ -361,7 +354,7 @@ bool test_DsCrackNames(struct torture_context *tctx,
        if (strcmp(realm_canonical_ex, 
                   talloc_asprintf(mem_ctx, "%s\n", dns_domain))!= 0) {
                err_msg = talloc_asprintf(mem_ctx, "local Round trip on canonical ex name failed: %s != %s!",
-                                         realm_canonical,
+                                         realm_canonical_ex,
                                          talloc_asprintf(mem_ctx, "%s\n", dns_domain));
                torture_fail(tctx, err_msg);
        };
@@ -370,15 +363,12 @@ bool test_DsCrackNames(struct torture_context *tctx,
        r.in.req->req1.format_desired   = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
        names[0].str = nt4_domain;
 
-       torture_comment(tctx, "testing DsCrackNames with name '%s' desired format:%d\n",
+       torture_comment(tctx, "Testing DsCrackNames with name '%s' desired format:%d\n",
                        names[0].str, r.in.req->req1.format_desired);
 
-       status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
+       status = dcerpc_drsuapi_DsCrackNames_r(p->binding_handle, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
                const char *errstr = nt_errstr(status);
-               if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
-                       errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
-               }
                err_msg = talloc_asprintf(mem_ctx, "dcerpc_drsuapi_DsCrackNames failed - %s", errstr);
                torture_fail(tctx, err_msg);
        } else if (!W_ERROR_IS_OK(r.out.result)) {
@@ -396,15 +386,12 @@ bool test_DsCrackNames(struct torture_context *tctx,
        r.in.req->req1.format_desired   = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
        names[0].str = talloc_asprintf(mem_ctx, "%s%s$", nt4_domain, test_dc);
 
-       torture_comment(tctx, "testing DsCrackNames with name '%s' desired format:%d\n",
+       torture_comment(tctx, "Testing DsCrackNames with name '%s' desired format:%d\n",
                        names[0].str, r.in.req->req1.format_desired);
 
-       status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
+       status = dcerpc_drsuapi_DsCrackNames_r(p->binding_handle, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
                const char *errstr = nt_errstr(status);
-               if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
-                       errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
-               }
                err_msg = talloc_asprintf(mem_ctx, "dcerpc_drsuapi_DsCrackNames failed - %s", errstr);
                torture_fail(tctx, err_msg);
        } else if (!W_ERROR_IS_OK(r.out.result)) {
@@ -422,15 +409,12 @@ bool test_DsCrackNames(struct torture_context *tctx,
        r.in.req->req1.format_desired   = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
        names[0].str = priv->domain_guid_str;
 
-       torture_comment(tctx, "testing DsCrackNames with name '%s' desired format:%d\n",
+       torture_comment(tctx, "Testing DsCrackNames with name '%s' desired format:%d\n",
                        names[0].str, r.in.req->req1.format_desired);
 
-       status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
+       status = dcerpc_drsuapi_DsCrackNames_r(p->binding_handle, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
                const char *errstr = nt_errstr(status);
-               if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
-                       errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
-               }
                err_msg = talloc_asprintf(mem_ctx, "dcerpc_drsuapi_DsCrackNames failed - %s", errstr);
                torture_fail(tctx, err_msg);
        } else if (!W_ERROR_IS_OK(r.out.result)) {
@@ -945,12 +929,9 @@ bool test_DsCrackNames(struct torture_context *tctx,
                                torture_comment(tctx, "skipping: %s", comment);
                                continue;
                        }
-                       status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
+                       status = dcerpc_drsuapi_DsCrackNames_r(p->binding_handle, mem_ctx, &r);
                        if (!NT_STATUS_IS_OK(status)) {
                                const char *errstr = nt_errstr(status);
-                               if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
-                                       errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
-                               }
                                err_msg = talloc_asprintf(mem_ctx, "dcerpc_drsuapi_DsCrackNames failed - %s", errstr);
                                torture_fail(tctx, err_msg);
                        } else if (!W_ERROR_IS_OK(r.out.result)) {
@@ -1007,6 +988,28 @@ bool test_DsCrackNames(struct torture_context *tctx,
                                        user_principal_name, service_principal_name);
 }
 
+/**
+ * Test case setup for CrackNames
+ */
+static bool torture_drsuapi_cracknames_setup(struct torture_context *tctx, void **data)
+{
+       struct DsCrackNamesPrivate *priv;
+
+       *data = priv = talloc_zero(tctx, struct DsCrackNamesPrivate);
+
+       return torture_drsuapi_tcase_setup_common(tctx, &priv->base);
+}
+
+/**
+ * Test case tear-down for CrackNames
+ */
+static bool torture_drsuapi_cracknames_teardown(struct torture_context *tctx, void *data)
+{
+       struct DsCrackNamesPrivate *priv = talloc_get_type(data, struct DsCrackNamesPrivate);
+
+       return torture_drsuapi_tcase_teardown_common(tctx, &priv->base);
+}
+
 /**
  * CRACKNAMES test suite implementation
  */
@@ -1015,11 +1018,11 @@ void torture_rpc_drsuapi_cracknames_tcase(struct torture_suite *suite)
        typedef bool (*run_func) (struct torture_context *test, void *tcase_data);
 
        struct torture_test *test;
-       struct torture_tcase *tcase = torture_suite_add_tcase(suite, "CRACKNAMES");
+       struct torture_tcase *tcase = torture_suite_add_tcase(suite, "cracknames");
 
        torture_tcase_set_fixture(tcase,
-                                 torture_rpc_drsuapi_tcase_setup,
-                                 torture_rpc_drsuapi_tcase_teardown);
+                                 torture_drsuapi_cracknames_setup,
+                                 torture_drsuapi_cracknames_teardown);
 
-       test = torture_tcase_add_simple_test(tcase, "CRACKNAMES-TEST", (run_func)test_DsCrackNames);
+       test = torture_tcase_add_simple_test(tcase, "cracknames-test", (run_func)test_DsCrackNames);
 }