s4-drsuapi: merge drsuapi_DsCrackNames from s3 drsuapi idl.

Guenther

diff --git a/source4/libnet/libnet_join.c b/source4/libnet/libnet_join.c
index f4de9031ec7fb747e0d9ed4274fc4b8e3f721ad6..0ed5e8ae2623b9d44e8045aa515314f472079829 100644 (file)
--- a/source4/libnet/libnet_join.c
+++ b/source4/libnet/libnet_join.c
@@ -162,13 +162,19 @@ static NTSTATUS libnet_JoinADSDomain(struct libnet_context *ctx, struct libnet_J
        ZERO_STRUCT(r_crack_names);
        r_crack_names.in.bind_handle            = &drsuapi_bind_handle;
        r_crack_names.in.level                  = 1;
-       r_crack_names.in.req.req1.codepage      = 1252; /* western european */
-       r_crack_names.in.req.req1.language      = 0x00000407; /* german */
-       r_crack_names.in.req.req1.count         = 1;
-       r_crack_names.in.req.req1.names         = names;
-       r_crack_names.in.req.req1.format_flags  = DRSUAPI_DS_NAME_FLAG_NO_FLAGS;
-       r_crack_names.in.req.req1.format_offered= DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY;
-       r_crack_names.in.req.req1.format_desired= DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
+       r_crack_names.in.req                    = talloc(r, union drsuapi_DsNameRequest);
+       if (!r_crack_names.in.req) {
+               r->out.error_string = NULL;
+               talloc_free(tmp_ctx);
+               return NT_STATUS_NO_MEMORY;
+       }
+       r_crack_names.in.req->req1.codepage     = 1252; /* western european */
+       r_crack_names.in.req->req1.language     = 0x00000407; /* german */
+       r_crack_names.in.req->req1.count        = 1;
+       r_crack_names.in.req->req1.names        = names;
+       r_crack_names.in.req->req1.format_flags = DRSUAPI_DS_NAME_FLAG_NO_FLAGS;
+       r_crack_names.in.req->req1.format_offered = DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY;
+       r_crack_names.in.req->req1.format_desired = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
        names[0].str = dom_sid_string(tmp_ctx, r->out.account_sid);
        if (!names[0].str) {
                r->out.error_string = NULL;
@@ -176,6 +182,14 @@ static NTSTATUS libnet_JoinADSDomain(struct libnet_context *ctx, struct libnet_J
                return NT_STATUS_NO_MEMORY;
        }
 
+       r_crack_names.out.ctr                   = talloc(r, union drsuapi_DsNameCtr);
+       r_crack_names.out.level_out             = talloc(r, int32_t);
+       if (!r_crack_names.out.ctr || !r_crack_names.out.level_out) {
+               r->out.error_string = NULL;
+               talloc_free(tmp_ctx);
+               return NT_STATUS_NO_MEMORY;
+       }
+
        status = dcerpc_drsuapi_DsCrackNames(drsuapi_pipe, tmp_ctx, &r_crack_names);
        if (!NT_STATUS_IS_OK(status)) {
                if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
@@ -201,24 +215,24 @@ static NTSTATUS libnet_JoinADSDomain(struct libnet_context *ctx, struct libnet_J
                                                  "DsCrackNames failed - %s", win_errstr(r_crack_names.out.result));
                talloc_free(tmp_ctx);
                return NT_STATUS_UNSUCCESSFUL;
-       } else if (r_crack_names.out.level != 1 
-                  || !r_crack_names.out.ctr.ctr1 
-                  || r_crack_names.out.ctr.ctr1->count != 1) {
+       } else if (*r_crack_names.out.level_out != 1
+                  || !r_crack_names.out.ctr->ctr1
+                  || r_crack_names.out.ctr->ctr1->count != 1) {
                r->out.error_string = talloc_asprintf(r, "DsCrackNames failed");
                talloc_free(tmp_ctx);
                return NT_STATUS_INVALID_PARAMETER;
-       } else if (r_crack_names.out.ctr.ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
-               r->out.error_string = talloc_asprintf(r, "DsCrackNames failed: %d", r_crack_names.out.ctr.ctr1->array[0].status);
+       } else if (r_crack_names.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
+               r->out.error_string = talloc_asprintf(r, "DsCrackNames failed: %d", r_crack_names.out.ctr->ctr1->array[0].status);
                talloc_free(tmp_ctx);
                return NT_STATUS_UNSUCCESSFUL;
-       } else if (r_crack_names.out.ctr.ctr1->array[0].result_name == NULL) {
+       } else if (r_crack_names.out.ctr->ctr1->array[0].result_name == NULL) {
                r->out.error_string = talloc_asprintf(r, "DsCrackNames failed: no result name");
                talloc_free(tmp_ctx);
                return NT_STATUS_INVALID_PARAMETER;
        }
 
        /* Store the DN of our machine account. */
-       account_dn_str = r_crack_names.out.ctr.ctr1->array[0].result_name;
+       account_dn_str = r_crack_names.out.ctr->ctr1->array[0].result_name;
 
        /* Now we know the user's DN, open with LDAP, read and modify a few things */
 
@@ -328,8 +342,8 @@ static NTSTATUS libnet_JoinADSDomain(struct libnet_context *ctx, struct libnet_J
        }
                                
        /* DsCrackNames to find out the DN of the domain. */
-       r_crack_names.in.req.req1.format_offered = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
-       r_crack_names.in.req.req1.format_desired = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
+       r_crack_names.in.req->req1.format_offered = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
+       r_crack_names.in.req->req1.format_desired = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
        names[0].str = talloc_asprintf(tmp_ctx, "%s\\", r->out.domain_name);
        if (!names[0].str) {
                r->out.error_string = NULL;
@@ -362,11 +376,11 @@ static NTSTATUS libnet_JoinADSDomain(struct libnet_context *ctx, struct libnet_J
                                          "DsCrackNames failed - %s", win_errstr(r_crack_names.out.result));
                talloc_free(tmp_ctx);
                return NT_STATUS_UNSUCCESSFUL;
-       } else if (r_crack_names.out.level != 1 
-                  || !r_crack_names.out.ctr.ctr1 
-                  || r_crack_names.out.ctr.ctr1->count != 1
-                  || !r_crack_names.out.ctr.ctr1->array[0].result_name           
-                  || r_crack_names.out.ctr.ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
+       } else if (*r_crack_names.out.level_out != 1
+                  || !r_crack_names.out.ctr->ctr1
+                  || r_crack_names.out.ctr->ctr1->count != 1
+                  || !r_crack_names.out.ctr->ctr1->array[0].result_name
+                  || r_crack_names.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
                r->out.error_string = talloc_asprintf(r, "DsCrackNames failed");
                talloc_free(tmp_ctx);
                return NT_STATUS_UNSUCCESSFUL;
@@ -377,8 +391,8 @@ static NTSTATUS libnet_JoinADSDomain(struct libnet_context *ctx, struct libnet_J
        talloc_steal(r, account_dn_str);
 
        /* Store the domain DN. */
-       r->out.domain_dn_str = r_crack_names.out.ctr.ctr1->array[0].result_name;
-       talloc_steal(r, r_crack_names.out.ctr.ctr1->array[0].result_name);
+       r->out.domain_dn_str = r_crack_names.out.ctr->ctr1->array[0].result_name;
+       talloc_steal(r, r_crack_names.out.ctr->ctr1->array[0].result_name);
 
        /* Store the KVNO of the account, critical for some kerberos
         * operations */

diff --git a/source4/librpc/idl/drsuapi.idl b/source4/librpc/idl/drsuapi.idl
index 820ca1c62d572627f4c51808fc47397b2bc87fae..4ded84ebfe14e4bde2c5f57af45b9221c6052d2a 100644 (file)
--- a/source4/librpc/idl/drsuapi.idl
+++ b/source4/librpc/idl/drsuapi.idl
@@ -927,9 +927,10 @@ interface drsuapi
 
        WERROR drsuapi_DsCrackNames(
                [in] policy_handle *bind_handle,
-               [in, out] int32 level,
-               [in,switch_is(level)] drsuapi_DsNameRequest req,
-               [out,switch_is(level)] drsuapi_DsNameCtr ctr
+               [in] int32 level,
+               [in,ref,switch_is(level)] drsuapi_DsNameRequest *req,
+               [out,ref] int32 *level_out,
+               [out,ref,switch_is(*level_out)] drsuapi_DsNameCtr *ctr
                );
 
        /*****************/

diff --git a/source4/rpc_server/drsuapi/dcesrv_drsuapi.c b/source4/rpc_server/drsuapi/dcesrv_drsuapi.c
index 4408b17b8c4ca53302b9b3b513b49d15a6a67090..a84f24a3e8b9074c8a4a5df16df1a23392619925 100644 (file)
--- a/source4/rpc_server/drsuapi/dcesrv_drsuapi.c
+++ b/source4/rpc_server/drsuapi/dcesrv_drsuapi.c
@@ -337,12 +337,14 @@ WERROR dcesrv_drsuapi_DsCrackNames(struct dcesrv_call_state *dce_call, TALLOC_CT
        struct drsuapi_bind_state *b_state;
        struct dcesrv_handle *h;
 
-       r->out.level = r->in.level;
-       ZERO_STRUCT(r->out.ctr);
+       *r->out.level_out = r->in.level;
 
        DCESRV_PULL_HANDLE_WERR(h, r->in.bind_handle, DRSUAPI_BIND_HANDLE);
        b_state = h->data;
 
+       r->out.ctr = talloc_zero(mem_ctx, union drsuapi_DsNameCtr);
+       W_ERROR_HAVE_NO_MEMORY(r->out.ctr);
+
        switch (r->in.level) {
                case 1: {
                        struct drsuapi_DsNameCtr1 *ctr1;
@@ -353,16 +355,16 @@ WERROR dcesrv_drsuapi_DsCrackNames(struct dcesrv_call_state *dce_call, TALLOC_CT
                        ctr1 = talloc(mem_ctx, struct drsuapi_DsNameCtr1);
                        W_ERROR_HAVE_NO_MEMORY(ctr1);
 
-                       count = r->in.req.req1.count;
+                       count = r->in.req->req1.count;
                        names = talloc_array(mem_ctx, struct drsuapi_DsNameInfo1, count);
                        W_ERROR_HAVE_NO_MEMORY(names);
 
                        for (i=0; i < count; i++) {
                                status = DsCrackNameOneName(b_state->sam_ctx, mem_ctx,
-                                                           r->in.req.req1.format_flags,
-                                                           r->in.req.req1.format_offered,
-                                                           r->in.req.req1.format_desired,
-                                                           r->in.req.req1.names[i].str,
+                                                           r->in.req->req1.format_flags,
+                                                           r->in.req->req1.format_offered,
+                                                           r->in.req->req1.format_desired,
+                                                           r->in.req->req1.names[i].str,
                                                            &names[i]);
                                if (!W_ERROR_IS_OK(status)) {
                                        return status;
@@ -371,7 +373,7 @@ WERROR dcesrv_drsuapi_DsCrackNames(struct dcesrv_call_state *dce_call, TALLOC_CT
 
                        ctr1->count = count;
                        ctr1->array = names;
-                       r->out.ctr.ctr1 = ctr1;
+                       r->out.ctr->ctr1 = ctr1;
 
                        return WERR_OK;
                }

diff --git a/source4/torture/rpc/drsuapi_cracknames.c b/source4/torture/rpc/drsuapi_cracknames.c
index a9a614953d674a5b1583e867215b760b24150d50..dabd4125c7356779cca456aca580ec8cd316dee5 100644 (file)
--- a/source4/torture/rpc/drsuapi_cracknames.c
+++ b/source4/torture/rpc/drsuapi_cracknames.c
@@ -38,6 +38,10 @@ static bool test_DsCrackNamesMatrix(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
        NTSTATUS status;
        bool ret = true;
        struct drsuapi_DsCrackNames r;
+       union drsuapi_DsNameRequest req;
+       int32_t level_out;
+       union drsuapi_DsNameCtr ctr;
+
        enum drsuapi_DsNameFormat formats[] = {
                DRSUAPI_DS_NAME_FORMAT_UNKNOWN,
                DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
@@ -60,17 +64,21 @@ static bool test_DsCrackNamesMatrix(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
        ZERO_STRUCT(r);
        r.in.bind_handle                = &priv->bind_handle;
        r.in.level                      = 1;
-       r.in.req.req1.codepage          = 1252; /* german */
-       r.in.req.req1.language          = 0x00000407; /* german */
-       r.in.req.req1.count             = 1;
-       r.in.req.req1.names             = names;
-       r.in.req.req1.format_flags      = DRSUAPI_DS_NAME_FLAG_NO_FLAGS;
+       r.in.req                        = &req;
+       r.in.req->req1.codepage         = 1252; /* german */
+       r.in.req->req1.language         = 0x00000407; /* german */
+       r.in.req->req1.count            = 1;
+       r.in.req->req1.names            = names;
+       r.in.req->req1.format_flags     = DRSUAPI_DS_NAME_FLAG_NO_FLAGS;
+
+       r.out.level_out                 = &level_out;
+       r.out.ctr                       = &ctr;
 
        n_matrix[0][0] = dn;
 
        for (i = 0; i < ARRAY_SIZE(formats); i++) {
-               r.in.req.req1.format_offered    = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
-               r.in.req.req1.format_desired    = formats[i];
+               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);
                if (!NT_STATUS_IS_OK(status)) {
@@ -79,13 +87,13 @@ static bool test_DsCrackNamesMatrix(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
                                errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
                        }
                        printf("testing DsCrackNames (matrix prep) with name '%s' from format: %d desired format:%d ",
-                              names[0].str, r.in.req.req1.format_offered, r.in.req.req1.format_desired);
+                              names[0].str, r.in.req->req1.format_offered, r.in.req->req1.format_desired);
                
                        printf("dcerpc_drsuapi_DsCrackNames failed - %s\n", errstr);
                        ret = false;
                } else if (!W_ERROR_IS_OK(r.out.result)) {
                        printf("testing DsCrackNames (matrix prep) with name '%s' from format: %d desired format:%d ",
-                              names[0].str, r.in.req.req1.format_offered, r.in.req.req1.format_desired);
+                              names[0].str, r.in.req->req1.format_offered, r.in.req->req1.format_desired);
                
                        printf("DsCrackNames failed - %s\n", win_errstr(r.out.result));
                        ret = false;
@@ -96,33 +104,33 @@ static bool test_DsCrackNamesMatrix(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
                }
                switch (formats[i]) {
                case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL:  
-                       if (r.out.ctr.ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE) {
+                       if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE) {
                                printf(__location__ ": Unexpected error (%d): This name lookup should fail\n", 
-                                      r.out.ctr.ctr1->array[0].status);
+                                      r.out.ctr->ctr1->array[0].status);
                                return false;
                        }
                        printf ("(expected) error\n");
                        break;
                case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL:
-                       if (r.out.ctr.ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_NO_MAPPING) {
+                       if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_NO_MAPPING) {
                                printf(__location__ ": Unexpected error (%d): This name lookup should fail\n", 
-                                      r.out.ctr.ctr1->array[0].status);
+                                      r.out.ctr->ctr1->array[0].status);
                                return false;
                        }
                        printf ("(expected) error\n");
                        break;
                case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: 
                case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: 
-                       if (r.out.ctr.ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR) {
+                       if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR) {
                                printf(__location__ ": Unexpected error (%d): This name lookup should fail\n", 
-                                      r.out.ctr.ctr1->array[0].status);
+                                      r.out.ctr->ctr1->array[0].status);
                                return false;
                        }
                        printf ("(expected) error\n");
                        break;
                default:
-                       if (r.out.ctr.ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
-                               printf("Error: %d\n", r.out.ctr.ctr1->array[0].status);
+                       if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
+                               printf("Error: %d\n", r.out.ctr->ctr1->array[0].status);
                                return false;
                        }
                }
@@ -139,15 +147,15 @@ static bool test_DsCrackNamesMatrix(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
                        n_from[i] = NULL;
                        break;
                default:
-                       n_from[i] = r.out.ctr.ctr1->array[0].result_name;
+                       n_from[i] = r.out.ctr->ctr1->array[0].result_name;
                        printf("%s\n", n_from[i]);
                }
        }
 
        for (i = 0; i < ARRAY_SIZE(formats); i++) {
                for (j = 0; j < ARRAY_SIZE(formats); j++) {
-                       r.in.req.req1.format_offered    = formats[i];
-                       r.in.req.req1.format_desired    = formats[j];
+                       r.in.req->req1.format_offered   = formats[i];
+                       r.in.req->req1.format_desired   = formats[j];
                        if (!n_from[i]) {
                                n_matrix[i][j] = NULL;
                                continue;
@@ -160,11 +168,11 @@ static bool test_DsCrackNamesMatrix(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
                                        errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
                                }
                                printf("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);
+                                      names[0].str, r.in.req->req1.format_offered, r.in.req->req1.format_desired, errstr);
                                ret = false;
                        } else if (!W_ERROR_IS_OK(r.out.result)) {
                                printf("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, 
+                                      names[0].str, r.in.req->req1.format_offered, r.in.req->req1.format_desired,
                                       win_errstr(r.out.result));
                                ret = false;
                        }
@@ -172,8 +180,8 @@ static bool test_DsCrackNamesMatrix(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
                        if (!ret) {
                                return ret;
                        }
-                       if (r.out.ctr.ctr1->array[0].status == DRSUAPI_DS_NAME_STATUS_OK) {
-                               n_matrix[i][j] = r.out.ctr.ctr1->array[0].result_name;
+                       if (r.out.ctr->ctr1->array[0].status == DRSUAPI_DS_NAME_STATUS_OK) {
+                               n_matrix[i][j] = r.out.ctr->ctr1->array[0].result_name;
                        } else {
                                n_matrix[i][j] = NULL;
                        }
@@ -211,6 +219,9 @@ bool test_DsCrackNames(struct torture_context *tctx,
 {
        NTSTATUS status;
        struct drsuapi_DsCrackNames r;
+       union drsuapi_DsNameRequest req;
+       int32_t level_out;
+       union drsuapi_DsNameCtr ctr;
        struct drsuapi_DsNameString names[1];
        bool ret = true;
        const char *dns_domain;
@@ -233,21 +244,25 @@ bool test_DsCrackNames(struct torture_context *tctx,
        ZERO_STRUCT(r);
        r.in.bind_handle                = &priv->bind_handle;
        r.in.level                      = 1;
-       r.in.req.req1.codepage          = 1252; /* german */
-       r.in.req.req1.language          = 0x00000407; /* german */
-       r.in.req.req1.count             = 1;
-       r.in.req.req1.names             = names;
-       r.in.req.req1.format_flags      = DRSUAPI_DS_NAME_FLAG_NO_FLAGS;
+       r.in.req                        = &req;
+       r.in.req->req1.codepage         = 1252; /* german */
+       r.in.req->req1.language         = 0x00000407; /* german */
+       r.in.req->req1.count            = 1;
+       r.in.req->req1.names            = names;
+       r.in.req->req1.format_flags     = DRSUAPI_DS_NAME_FLAG_NO_FLAGS;
+
+       r.in.req->req1.format_offered   = DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY;
+       r.in.req->req1.format_desired   = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
 
-       r.in.req.req1.format_offered    = DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY;
-       r.in.req.req1.format_desired    = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
+       r.out.level_out                 = &level_out;
+       r.out.ctr                       = &ctr;
 
        dom_sid = dom_sid_string(mem_ctx, torture_join_sid(priv->join));
        
        names[0].str = dom_sid;
 
        printf("testing DsCrackNames with name '%s' desired format:%d\n",
-                       names[0].str, r.in.req.req1.format_desired);
+                       names[0].str, r.in.req->req1.format_desired);
 
        status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
@@ -260,8 +275,8 @@ bool test_DsCrackNames(struct torture_context *tctx,
        } else if (!W_ERROR_IS_OK(r.out.result)) {
                printf("DsCrackNames failed - %s\n", win_errstr(r.out.result));
                ret = false;
-       } else if (r.out.ctr.ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
-               printf("DsCrackNames failed on name - %d\n", r.out.ctr.ctr1->array[0].status);
+       } else if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
+               printf("DsCrackNames failed on name - %d\n", r.out.ctr->ctr1->array[0].status);
                ret = false;
        }
 
@@ -269,13 +284,13 @@ bool test_DsCrackNames(struct torture_context *tctx,
                return ret;
        }
 
-       dns_domain = r.out.ctr.ctr1->array[0].dns_domain_name;
-       nt4_domain = r.out.ctr.ctr1->array[0].result_name;
+       dns_domain = r.out.ctr->ctr1->array[0].dns_domain_name;
+       nt4_domain = r.out.ctr->ctr1->array[0].result_name;
 
-       r.in.req.req1.format_desired    = DRSUAPI_DS_NAME_FORMAT_GUID;
+       r.in.req->req1.format_desired   = DRSUAPI_DS_NAME_FORMAT_GUID;
 
        printf("testing DsCrackNames with name '%s' desired format:%d\n",
-                       names[0].str, r.in.req.req1.format_desired);
+                       names[0].str, r.in.req->req1.format_desired);
 
        status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
@@ -288,8 +303,8 @@ bool test_DsCrackNames(struct torture_context *tctx,
        } else if (!W_ERROR_IS_OK(r.out.result)) {
                printf("DsCrackNames failed - %s\n", win_errstr(r.out.result));
                ret = false;
-       } else if (r.out.ctr.ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
-               printf("DsCrackNames failed on name - %d\n", r.out.ctr.ctr1->array[0].status);
+       } else if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
+               printf("DsCrackNames failed on name - %d\n", r.out.ctr->ctr1->array[0].status);
                ret = false;
        }
 
@@ -297,14 +312,14 @@ bool test_DsCrackNames(struct torture_context *tctx,
                return ret;
        }
 
-       priv->domain_dns_name = r.out.ctr.ctr1->array[0].dns_domain_name;
-       priv->domain_guid_str = r.out.ctr.ctr1->array[0].result_name;
+       priv->domain_dns_name = r.out.ctr->ctr1->array[0].dns_domain_name;
+       priv->domain_guid_str = r.out.ctr->ctr1->array[0].result_name;
        GUID_from_string(priv->domain_guid_str, &priv->domain_guid);
 
-       r.in.req.req1.format_desired    = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
+       r.in.req->req1.format_desired   = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
 
        printf("testing DsCrackNames with name '%s' desired format:%d\n",
-                       names[0].str, r.in.req.req1.format_desired);
+                       names[0].str, r.in.req->req1.format_desired);
 
        status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
@@ -317,8 +332,8 @@ bool test_DsCrackNames(struct torture_context *tctx,
        } else if (!W_ERROR_IS_OK(r.out.result)) {
                printf("DsCrackNames failed - %s\n", win_errstr(r.out.result));
                ret = false;
-       } else if (r.out.ctr.ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
-               printf("DsCrackNames failed on name - %d\n", r.out.ctr.ctr1->array[0].status);
+       } else if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
+               printf("DsCrackNames failed on name - %d\n", r.out.ctr->ctr1->array[0].status);
                ret = false;
        }
 
@@ -328,7 +343,7 @@ bool test_DsCrackNames(struct torture_context *tctx,
 
        ldb = ldb_init(mem_ctx, tctx->ev);
        
-       realm_dn_str = r.out.ctr.ctr1->array[0].result_name;
+       realm_dn_str = r.out.ctr->ctr1->array[0].result_name;
        realm_dn =  ldb_dn_new(mem_ctx, ldb, realm_dn_str);
        realm_canonical = ldb_dn_canonical_string(mem_ctx, realm_dn);
 
@@ -350,12 +365,12 @@ bool test_DsCrackNames(struct torture_context *tctx,
                    return false;
        };
 
-       r.in.req.req1.format_offered    = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
-       r.in.req.req1.format_desired    = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
+       r.in.req->req1.format_offered   = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
+       r.in.req->req1.format_desired   = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
        names[0].str = nt4_domain;
 
        printf("testing DsCrackNames with name '%s' desired format:%d\n",
-                       names[0].str, r.in.req.req1.format_desired);
+                       names[0].str, r.in.req->req1.format_desired);
 
        status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
@@ -368,8 +383,8 @@ bool test_DsCrackNames(struct torture_context *tctx,
        } else if (!W_ERROR_IS_OK(r.out.result)) {
                printf("DsCrackNames failed - %s\n", win_errstr(r.out.result));
                ret = false;
-       } else if (r.out.ctr.ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
-               printf("DsCrackNames failed on name - %d\n", r.out.ctr.ctr1->array[0].status);
+       } else if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
+               printf("DsCrackNames failed on name - %d\n", r.out.ctr->ctr1->array[0].status);
                ret = false;
        }
 
@@ -377,14 +392,14 @@ bool test_DsCrackNames(struct torture_context *tctx,
                return ret;
        }
 
-       priv->domain_obj_dn = r.out.ctr.ctr1->array[0].result_name;
+       priv->domain_obj_dn = r.out.ctr->ctr1->array[0].result_name;
 
-       r.in.req.req1.format_offered    = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
-       r.in.req.req1.format_desired    = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
+       r.in.req->req1.format_offered   = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
+       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);
 
        printf("testing DsCrackNames with name '%s' desired format:%d\n",
-              names[0].str, r.in.req.req1.format_desired);
+              names[0].str, r.in.req->req1.format_desired);
 
        status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
@@ -397,8 +412,8 @@ bool test_DsCrackNames(struct torture_context *tctx,
        } else if (!W_ERROR_IS_OK(r.out.result)) {
                printf("DsCrackNames failed - %s\n", win_errstr(r.out.result));
                ret = false;
-       } else if (r.out.ctr.ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
-               printf("DsCrackNames failed on name - %d\n", r.out.ctr.ctr1->array[0].status);
+       } else if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
+               printf("DsCrackNames failed on name - %d\n", r.out.ctr->ctr1->array[0].status);
                ret = false;
        }
 
@@ -406,14 +421,14 @@ bool test_DsCrackNames(struct torture_context *tctx,
                return ret;
        }
 
-       FQDN_1779_name = r.out.ctr.ctr1->array[0].result_name;
+       FQDN_1779_name = r.out.ctr->ctr1->array[0].result_name;
 
-       r.in.req.req1.format_offered    = DRSUAPI_DS_NAME_FORMAT_GUID;
-       r.in.req.req1.format_desired    = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
+       r.in.req->req1.format_offered   = DRSUAPI_DS_NAME_FORMAT_GUID;
+       r.in.req->req1.format_desired   = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
        names[0].str = priv->domain_guid_str;
 
        printf("testing DsCrackNames with name '%s' desired format:%d\n",
-              names[0].str, r.in.req.req1.format_desired);
+              names[0].str, r.in.req->req1.format_desired);
 
        status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
@@ -426,8 +441,8 @@ bool test_DsCrackNames(struct torture_context *tctx,
        } else if (!W_ERROR_IS_OK(r.out.result)) {
                printf("DsCrackNames failed - %s\n", win_errstr(r.out.result));
                ret = false;
-       } else if (r.out.ctr.ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
-               printf("DsCrackNames failed on name - %d\n", r.out.ctr.ctr1->array[0].status);
+       } else if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
+               printf("DsCrackNames failed on name - %d\n", r.out.ctr->ctr1->array[0].status);
                ret = false;
        }
 
@@ -435,8 +450,8 @@ bool test_DsCrackNames(struct torture_context *tctx,
                return ret;
        }
 
-       if (strcmp(priv->domain_dns_name, r.out.ctr.ctr1->array[0].dns_domain_name) != 0) {
-               printf("DsCrackNames failed to return same DNS name - expected %s got %s\n", priv->domain_dns_name, r.out.ctr.ctr1->array[0].dns_domain_name);
+       if (strcmp(priv->domain_dns_name, r.out.ctr->ctr1->array[0].dns_domain_name) != 0) {
+               printf("DsCrackNames failed to return same DNS name - expected %s got %s\n", priv->domain_dns_name, r.out.ctr->ctr1->array[0].dns_domain_name);
                return false;
        }
 
@@ -920,17 +935,17 @@ bool test_DsCrackNames(struct torture_context *tctx,
                
                for (i=0; i < ARRAY_SIZE(crack); i++) {
                        const char *comment;
-                       r.in.req.req1.format_flags   = crack[i].flags;
-                       r.in.req.req1.format_offered = crack[i].format_offered; 
-                       r.in.req.req1.format_desired = crack[i].format_desired;
+                       r.in.req->req1.format_flags   = crack[i].flags;
+                       r.in.req->req1.format_offered = crack[i].format_offered;
+                       r.in.req->req1.format_desired = crack[i].format_desired;
                        names[0].str = crack[i].str;
                        
                        if (crack[i].comment) {
                                comment = talloc_asprintf(mem_ctx, "'%s' with name '%s' desired format:%d\n",
-                                                         crack[i].comment, names[0].str, r.in.req.req1.format_desired);
+                                                         crack[i].comment, names[0].str, r.in.req->req1.format_desired);
                        } else {
                                comment = talloc_asprintf(mem_ctx, "'%s' desired format:%d\n",
-                                      names[0].str, r.in.req.req1.format_desired);
+                                      names[0].str, r.in.req->req1.format_desired);
                        }
                        if (crack[i].skip) {
                                printf("skipping: %s", comment);
@@ -947,11 +962,11 @@ bool test_DsCrackNames(struct torture_context *tctx,
                        } else if (!W_ERROR_IS_OK(r.out.result)) {
                                printf("DsCrackNames failed - %s\n", win_errstr(r.out.result));
                                ret = false;
-                       } else if (r.out.ctr.ctr1->array[0].status != crack[i].status) {
+                       } else if (r.out.ctr->ctr1->array[0].status != crack[i].status) {
                                if (crack[i].alternate_status) {
-                                       if (r.out.ctr.ctr1->array[0].status != crack[i].alternate_status) {
+                                       if (r.out.ctr->ctr1->array[0].status != crack[i].alternate_status) {
                                                printf("DsCrackNames unexpected status %d, wanted %d or %d on: %s\n", 
-                                                      r.out.ctr.ctr1->array[0].status,
+                                                      r.out.ctr->ctr1->array[0].status,
                                                       crack[i].status,
                                                       crack[i].alternate_status,
                                                       comment);
@@ -959,30 +974,30 @@ bool test_DsCrackNames(struct torture_context *tctx,
                                        }
                                } else {
                                        printf("DsCrackNames unexpected status %d, wanted %d on: %s\n", 
-                                              r.out.ctr.ctr1->array[0].status,
+                                              r.out.ctr->ctr1->array[0].status,
                                               crack[i].status,
                                               comment);
                                        ret = false;
                                }
                        } else if (crack[i].expected_str
-                                  && (strcmp(r.out.ctr.ctr1->array[0].result_name, 
+                                  && (strcmp(r.out.ctr->ctr1->array[0].result_name,
                                              crack[i].expected_str) != 0)) {
-                               if (strcasecmp(r.out.ctr.ctr1->array[0].result_name, 
+                               if (strcasecmp(r.out.ctr->ctr1->array[0].result_name,
                                               crack[i].expected_str) != 0) {
                                        printf("DsCrackNames failed - got %s, expected %s on %s\n", 
-                                              r.out.ctr.ctr1->array[0].result_name, 
+                                              r.out.ctr->ctr1->array[0].result_name,
                                               crack[i].expected_str, comment);
                                        ret = false;
                                } else {
                                        printf("(warning) DsCrackNames returned different case - got %s, expected %s on %s\n", 
-                                              r.out.ctr.ctr1->array[0].result_name, 
+                                              r.out.ctr->ctr1->array[0].result_name,
                                               crack[i].expected_str, comment);
                                }
                        } else if (crack[i].expected_dns
-                                  && (strcmp(r.out.ctr.ctr1->array[0].dns_domain_name, 
+                                  && (strcmp(r.out.ctr->ctr1->array[0].dns_domain_name,
                                              crack[i].expected_dns) != 0)) {
                                printf("DsCrackNames failed - got DNS name %s, expected %s on %s\n", 
-                                      r.out.ctr.ctr1->array[0].result_name, 
+                                      r.out.ctr->ctr1->array[0].result_name,
                                       crack[i].expected_str, comment);
                                ret = false;
                        }

diff --git a/source4/torture/rpc/dssync.c b/source4/torture/rpc/dssync.c
index 2070485a1918cb2fc2e9d0942ae13eeb75e62882..a832c0f0daef37266809e49d49212681c899b0b4 100644 (file)
--- a/source4/torture/rpc/dssync.c
+++ b/source4/torture/rpc/dssync.c
@@ -265,6 +265,9 @@ static bool test_GetInfo(struct torture_context *tctx, struct DsSyncTest *ctx)
 {
        NTSTATUS status;
        struct drsuapi_DsCrackNames r;
+       union drsuapi_DsNameRequest req;
+       union drsuapi_DsNameCtr ctr;
+       int32_t level_out = 0;
        struct drsuapi_DsNameString names[1];
        bool ret = true;
        struct cldap_socket *cldap;
@@ -274,15 +277,19 @@ static bool test_GetInfo(struct torture_context *tctx, struct DsSyncTest *ctx)
 
        r.in.bind_handle                = &ctx->admin.drsuapi.bind_handle;
        r.in.level                      = 1;
-       r.in.req.req1.codepage          = 1252; /* western european */
-       r.in.req.req1.language          = 0x00000407; /* german */
-       r.in.req.req1.count             = 1;
-       r.in.req.req1.names             = names;
-       r.in.req.req1.format_flags      = DRSUAPI_DS_NAME_FLAG_NO_FLAGS;                
-       r.in.req.req1.format_offered    = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
-       r.in.req.req1.format_desired    = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
+       r.in.req                        = &req;
+       r.in.req->req1.codepage         = 1252; /* western european */
+       r.in.req->req1.language         = 0x00000407; /* german */
+       r.in.req->req1.count            = 1;
+       r.in.req->req1.names            = names;
+       r.in.req->req1.format_flags     = DRSUAPI_DS_NAME_FLAG_NO_FLAGS;
+       r.in.req->req1.format_offered   = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
+       r.in.req->req1.format_desired   = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
        names[0].str = talloc_asprintf(ctx, "%s\\", lp_workgroup(tctx->lp_ctx));
 
+       r.out.level_out                 = &level_out;
+       r.out.ctr                       = &ctr;
+
        status = dcerpc_drsuapi_DsCrackNames(ctx->admin.drsuapi.pipe, ctx, &r);
        if (!NT_STATUS_IS_OK(status)) {
                const char *errstr = nt_errstr(status);
@@ -296,7 +303,7 @@ static bool test_GetInfo(struct torture_context *tctx, struct DsSyncTest *ctx)
                return false;
        }
 
-       ctx->domain_dn = r.out.ctr.ctr1->array[0].result_name;
+       ctx->domain_dn = r.out.ctr->ctr1->array[0].result_name;
        
        ZERO_STRUCT(search);
        search.in.dest_address = ctx->drsuapi_binding->host;