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

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/libnet/domain.c (modified) (7 diffs)
• source4/torture/libnet/groupinfo.c (modified) (5 diffs)
• source4/torture/libnet/groupman.c (modified) (6 diffs)
• source4/torture/libnet/grouptest.h (modified) (1 diff)
• source4/torture/libnet/libnet.c (modified) (1 diff)
• source4/torture/libnet/libnet_BecomeDC.c (modified) (5 diffs)
• source4/torture/libnet/libnet_domain.c (modified) (23 diffs)
• source4/torture/libnet/libnet_group.c (modified) (11 diffs)
• source4/torture/libnet/libnet_lookup.c (modified) (10 diffs)
• source4/torture/libnet/libnet_rpc.c (modified) (12 diffs)
• source4/torture/libnet/libnet_share.c (modified) (16 diffs)
• source4/torture/libnet/libnet_user.c (modified) (32 diffs)
• source4/torture/libnet/python (copied) (copied from vendor/current/source4/torture/libnet/python )
• source4/torture/libnet/python/samr-test.py (copied) (copied from vendor/current/source4/torture/libnet/python/samr-test.py )
• source4/torture/libnet/userinfo.c (modified) (9 diffs)
• source4/torture/libnet/userman.c (modified) (23 diffs)
• source4/torture/libnet/usertest.h (modified) (1 diff)
• source4/torture/libnet/utils.c (modified) (11 diffs)
• source4/torture/libnet/utils.h (deleted)

trunk/server/source4/torture/libnet/domain.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    Test suite for libnet calls.
 
    Copyright (C) Rafal Szczesniak 2005
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -20 +20 @@
 
 #include "includes.h"
-#include "torture/rpc/rpc.h"
-#include "lib/events/events.h"
+#include "torture/rpc/torture_rpc.h"
 #include "libnet/libnet.h"
 #include "librpc/gen_ndr/ndr_samr_c.h"
 #include "param/param.h"
 
-static bool test_domainopen(struct libnet_context *net_ctx, TALLOC_CTX *mem_ctx,
+static bool test_domainopen(struct torture_context *tctx,
+                            struct libnet_context *net_ctx, TALLOC_CTX *mem_ctx,
                             struct lsa_String *domname,
                             struct policy_handle *domain_handle)
@@ -32 +32 @@
         NTSTATUS status;
         struct libnet_DomainOpen io;
-        
-        printf("opening domain\n");
-        
+
+        torture_comment(tctx, "opening domain\n");
+
         io.in.domain_name  = talloc_strdup(mem_ctx, domname->string);
         io.in.access_mask  = SEC_FLAG_MAXIMUM_ALLOWED;
@@ -40 +40 @@
         status = libnet_DomainOpen(net_ctx, mem_ctx, &io);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("Composite domain open failed - %s\n", nt_errstr(status));
+                torture_comment(tctx, "Composite domain open failed for domain '%s' - %s\n",
+                                domname->string, nt_errstr(status));
                 return false;
         }
@@ -49 +50 @@
 
 
-static bool test_cleanup(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_cleanup(struct torture_context *tctx,
+                         struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
                          struct policy_handle *domain_handle)
 {
-        NTSTATUS status;
         struct samr_Close r;
         struct policy_handle handle;
@@ -58 +59 @@
         r.in.handle   = domain_handle;
         r.out.handle  = &handle;
-        
-        printf("closing domain handle\n");
-        
-        status = dcerpc_samr_Close(p, mem_ctx, &r);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Close failed - %s\n", nt_errstr(status));
-                return false;
-        }
-        
+
+        torture_comment(tctx, "closing domain handle\n");
+
+        torture_assert_ntstatus_ok(tctx,
+                dcerpc_samr_Close_r(b, mem_ctx, &r),
+                "Close failed");
+        torture_assert_ntstatus_ok(tctx, r.out.result,
+                "Close failed");
+
         return true;
 }
@@ -84 +85 @@
         net_ctx = libnet_context_init(torture->ev, torture->lp_ctx);
 
-        status = torture_rpc_connection(torture, 
+        status = torture_rpc_connection(torture,
                                         &net_ctx->samr.pipe,
                                         &ndr_table_samr);
-        
+
         if (!NT_STATUS_IS_OK(status)) {
                 return false;
         }
 
-        name.string = lp_workgroup(torture->lp_ctx);
+        name.string = lpcfg_workgroup(torture->lp_ctx);
 
         /*
          * Testing synchronous version
          */
-        if (!test_domainopen(net_ctx, mem_ctx, &name, &h)) {
+        if (!test_domainopen(torture, net_ctx, mem_ctx, &name, &h)) {
                 ret = false;
                 goto done;
         }
 
-        if (!test_cleanup(net_ctx->samr.pipe, mem_ctx, &h)) {
+        if (!test_cleanup(torture, net_ctx->samr.pipe->binding_handle, mem_ctx, &h)) {
                 ret = false;
                 goto done;

trunk/server/source4/torture/libnet/groupinfo.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    Test suite for libnet calls.
 
    Copyright (C) Rafal Szczesniak 2007
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -20 +20 @@
 
 #include "includes.h"
-#include "torture/rpc/rpc.h"
+#include "torture/rpc/torture_rpc.h"
 #include "libnet/libnet.h"
 #include "libcli/security/security.h"
 #include "librpc/gen_ndr/ndr_samr_c.h"
 #include "param/param.h"
-#include "torture/libnet/utils.h"
+#include "torture/libnet/proto.h"
 
 #define TEST_GROUPNAME  "libnetgroupinfotest"
 
 
-static bool test_groupinfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_groupinfo(struct torture_context *tctx,
+                           struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
                            struct policy_handle *domain_handle,
                            struct dom_sid2 *domain_sid, const char* group_name,
@@ -39 +40 @@
         struct libnet_rpc_groupinfo group;
         struct dom_sid *group_sid;
-        
+
         group_sid = dom_sid_add_rid(mem_ctx, domain_sid, *rid);
-        
+
         group.in.domain_handle = *domain_handle;
         group.in.sid           = dom_sid_string(mem_ctx, group_sid);
         group.in.level         = level;       /* this should be extended */
 
-        printf("Testing sync libnet_rpc_groupinfo (SID argument)\n");
+        torture_comment(tctx, "Testing sync libnet_rpc_groupinfo (SID argument)\n");
         status = libnet_rpc_groupinfo(p, mem_ctx, &group);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("Failed to call sync libnet_rpc_userinfo - %s\n", nt_errstr(status));
+                torture_comment(tctx, "Failed to call sync libnet_rpc_userinfo - %s\n", nt_errstr(status));
                 return false;
         }
@@ -63 +64 @@
         status = libnet_rpc_groupinfo(p, mem_ctx, &group);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("Failed to call sync libnet_rpc_groupinfo - %s\n", nt_errstr(status));
+                torture_comment(tctx, "Failed to call sync libnet_rpc_groupinfo - %s\n", nt_errstr(status));
                 return false;
         }
@@ -81 +82 @@
         struct dom_sid2 sid;
         uint32_t rid;
+        struct dcerpc_binding_handle *b;
 
         mem_ctx = talloc_init("test_userinfo");
 
-        status = torture_rpc_connection(torture, 
+        status = torture_rpc_connection(torture,
                                         &p,
                                         &ndr_table_samr);
-        
+
         if (!NT_STATUS_IS_OK(status)) {
                 return false;
         }
+        b = p->binding_handle;
 
-        name.string = lp_workgroup(torture->lp_ctx);
+        name.string = lpcfg_workgroup(torture->lp_ctx);
 
         /*
          * Testing synchronous version
          */
-        if (!test_opendomain(torture, p, mem_ctx, &h, &name, &sid)) {
+        if (!test_domain_open(torture, b, &name, mem_ctx, &h, &sid)) {
                 ret = false;
                 goto done;
         }
 
-        if (!test_group_create(p, mem_ctx, &h, TEST_GROUPNAME, &rid)) {
+        if (!test_group_create(torture, b, mem_ctx, &h, TEST_GROUPNAME, &rid)) {
                 ret = false;
                 goto done;
         }
 
-        if (!test_groupinfo(p, mem_ctx, &h, &sid, TEST_GROUPNAME, &rid)) {
+        if (!test_groupinfo(torture, p, mem_ctx, &h, &sid, TEST_GROUPNAME, &rid)) {
                 ret = false;
                 goto done;
         }
 
-        if (!test_group_cleanup(p, mem_ctx, &h, TEST_GROUPNAME)) {
+        if (!test_group_cleanup(torture, b, mem_ctx, &h, TEST_GROUPNAME)) {
                 ret = false;
                 goto done;

trunk/server/source4/torture/libnet/groupman.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    Test suite for libnet calls.
 
    Copyright (C) Rafal Szczesniak 2007
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -20 +20 @@
 
 #include "includes.h"
-#include "torture/rpc/rpc.h"
+#include "torture/rpc/torture_rpc.h"
 #include "torture/libnet/grouptest.h"
 #include "libnet/libnet.h"
 #include "librpc/gen_ndr/ndr_samr_c.h"
 #include "param/param.h"
-#include "torture/libnet/utils.h"
+#include "torture/libnet/proto.h"
 
 
@@ -38 +38 @@
         group.in.domain_handle = *domain_handle;
         group.in.groupname     = name;
-        
+
         printf("Testing libnet_rpc_groupadd\n");
 
@@ -46 +46 @@
                 return false;
         }
-        
+
         return ret;
 }
@@ -61 +61 @@
         TALLOC_CTX *mem_ctx;
         bool ret = true;
+        struct dcerpc_binding_handle *b;
 
         mem_ctx = talloc_init("test_groupadd");
 
-        status = torture_rpc_connection(torture, 
+        status = torture_rpc_connection(torture,
                                         &p,
                                         &ndr_table_samr);
-        
+
         torture_assert_ntstatus_ok(torture, status, "RPC connection");
+        b = p->binding_handle;
 
-        domain_name.string = lp_workgroup(torture->lp_ctx);
-        if (!test_opendomain(torture, p, mem_ctx, &h, &domain_name, &sid)) {
+        domain_name.string = lpcfg_workgroup(torture->lp_ctx);
+        if (!test_domain_open(torture, b, &domain_name, mem_ctx, &h, &sid)) {
                 ret = false;
                 goto done;
@@ -81 +83 @@
         }
 
-        if (!test_group_cleanup(p, mem_ctx, &h, name)) {
+        if (!test_group_cleanup(torture, b, mem_ctx, &h, name)) {
                 ret = false;
                 goto done;
         }
-        
+
 done:
         talloc_free(mem_ctx);

trunk/server/source4/torture/libnet/grouptest.h

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
 
    Copyright (C) Rafal Szczesniak 2007
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

trunk/server/source4/torture/libnet/libnet.c

@@ -21 +21 @@
 #include "torture/smbtorture.h"
 #include "librpc/rpc/dcerpc.h"
-#include "librpc/gen_ndr/security.h"
 #include "librpc/gen_ndr/lsa.h"
-#include "libnet/composite.h"
+#include "libnet/libnet.h"
 #include "torture/libnet/proto.h"
 
 NTSTATUS torture_net_init(void)
 {
-        struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "NET");
+        struct torture_suite *suite = torture_suite_create(
+                talloc_autofree_context(), "net");
 
-        torture_suite_add_simple_test(suite, "USERINFO", torture_userinfo);
-        torture_suite_add_simple_test(suite, "USERADD", torture_useradd);
-        torture_suite_add_simple_test(suite, "USERDEL", torture_userdel);
-        torture_suite_add_simple_test(suite, "USERMOD", torture_usermod);
-        torture_suite_add_simple_test(suite, "DOMOPEN", torture_domainopen);
-        torture_suite_add_simple_test(suite, "GROUPINFO", torture_groupinfo);
-        torture_suite_add_simple_test(suite, "GROUPADD", torture_groupadd);
-        torture_suite_add_simple_test(suite, "API-LOOKUP", torture_lookup);
-        torture_suite_add_simple_test(suite, "API-LOOKUPHOST", torture_lookup_host);
-        torture_suite_add_simple_test(suite, "API-LOOKUPPDC", torture_lookup_pdc);
-        torture_suite_add_simple_test(suite, "API-LOOKUPNAME", torture_lookup_sam_name);
-        torture_suite_add_simple_test(suite, "API-CREATEUSER", torture_createuser);
-        torture_suite_add_simple_test(suite, "API-DELETEUSER", torture_deleteuser);
-        torture_suite_add_simple_test(suite, "API-MODIFYUSER", torture_modifyuser);
-        torture_suite_add_simple_test(suite, "API-USERINFO", torture_userinfo_api);
-        torture_suite_add_simple_test(suite, "API-USERLIST", torture_userlist);
-        torture_suite_add_simple_test(suite, "API-GROUPINFO", torture_groupinfo_api);
-        torture_suite_add_simple_test(suite, "API-GROUPLIST", torture_grouplist);
-        torture_suite_add_simple_test(suite, "API-CREATEGROUP", torture_creategroup);
-        torture_suite_add_simple_test(suite, "API-RPCCONN-BIND", torture_rpc_connect_binding);
-        torture_suite_add_simple_test(suite, "API-RPCCONN-SRV", torture_rpc_connect_srv);
-        torture_suite_add_simple_test(suite, "API-RPCCONN-PDC", torture_rpc_connect_pdc);
-        torture_suite_add_simple_test(suite, "API-RPCCONN-DC", torture_rpc_connect_dc);
-        torture_suite_add_simple_test(suite, "API-RPCCONN-DCINFO", torture_rpc_connect_dc_info);
-        torture_suite_add_simple_test(suite, "API-LISTSHARES", torture_listshares);
-        torture_suite_add_simple_test(suite, "API-DELSHARE", torture_delshare);
-        torture_suite_add_simple_test(suite, "API-DOMOPENLSA", torture_domain_open_lsa);
-        torture_suite_add_simple_test(suite, "API-DOMCLOSELSA", torture_domain_close_lsa);
-        torture_suite_add_simple_test(suite, "API-DOMOPENSAMR", torture_domain_open_samr);
-        torture_suite_add_simple_test(suite, "API-DOMCLOSESAMR", torture_domain_close_samr);
-        torture_suite_add_simple_test(suite, "API-BECOME-DC", torture_net_become_dc);
-        torture_suite_add_simple_test(suite, "API-DOMLIST", torture_domain_list);
+        torture_suite_add_simple_test(suite, "userinfo", torture_userinfo);
+        torture_suite_add_simple_test(suite, "useradd", torture_useradd);
+        torture_suite_add_simple_test(suite, "userdel", torture_userdel);
+        torture_suite_add_simple_test(suite, "usermod", torture_usermod);
+        torture_suite_add_simple_test(suite, "domopen", torture_domainopen);
+        torture_suite_add_simple_test(suite, "groupinfo", torture_groupinfo);
+        torture_suite_add_simple_test(suite, "groupadd", torture_groupadd);
+        torture_suite_add_simple_test(suite, "api.lookup", torture_lookup);
+        torture_suite_add_simple_test(suite, "api.lookuphost", torture_lookup_host);
+        torture_suite_add_simple_test(suite, "api.lookuppdc", torture_lookup_pdc);
+        torture_suite_add_simple_test(suite, "api.lookupname", torture_lookup_sam_name);
+        torture_suite_add_simple_test(suite, "api.createuser", torture_createuser);
+        torture_suite_add_simple_test(suite, "api.deleteuser", torture_deleteuser);
+        torture_suite_add_simple_test(suite, "api.modifyuser", torture_modifyuser);
+        torture_suite_add_simple_test(suite, "api.userinfo", torture_userinfo_api);
+        torture_suite_add_simple_test(suite, "api.userlist", torture_userlist);
+        torture_suite_add_simple_test(suite, "api.groupinfo", torture_groupinfo_api);
+        torture_suite_add_simple_test(suite, "api.grouplist", torture_grouplist);
+        torture_suite_add_simple_test(suite, "api.creategroup", torture_creategroup);
+        torture_suite_add_simple_test(suite, "api.rpcconn.bind", torture_rpc_connect_binding);
+        torture_suite_add_simple_test(suite, "api.rpcconn.srv", torture_rpc_connect_srv);
+        torture_suite_add_simple_test(suite, "api.rpcconn.pdc", torture_rpc_connect_pdc);
+        torture_suite_add_simple_test(suite, "api.rpcconn.dc", torture_rpc_connect_dc);
+        torture_suite_add_simple_test(suite, "api.rpcconn.dcinfo", torture_rpc_connect_dc_info);
+        torture_suite_add_simple_test(suite, "api.listshares", torture_listshares);
+        torture_suite_add_simple_test(suite, "api.delshare", torture_delshare);
+        torture_suite_add_simple_test(suite, "api.domopenlsa", torture_domain_open_lsa);
+        torture_suite_add_simple_test(suite, "api.domcloselsa", torture_domain_close_lsa);
+        torture_suite_add_simple_test(suite, "api.domopensamr", torture_domain_open_samr);
+        torture_suite_add_simple_test(suite, "api.domclosesamr", torture_domain_close_samr);
+        torture_suite_add_simple_test(suite, "api.become.dc", torture_net_become_dc);
+        torture_suite_add_simple_test(suite, "api.domlist", torture_domain_list);
 
         suite->description = talloc_strdup(suite, "libnet convenience interface tests");

trunk/server/source4/torture/libnet/libnet_BecomeDC.c

@@ -22 +22 @@
 #include "includes.h"
 #include "lib/cmdline/popt_common.h"
-#include "torture/torture.h"
-#include "torture/rpc/rpc.h"
+#include "torture/rpc/torture_rpc.h"
 #include "libnet/libnet.h"
-#include "lib/events/events.h"
 #include "dsdb/samdb/samdb.h"
 #include "../lib/util/dlinklist.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
-#include "librpc/ndr/libndr.h"
 #include "librpc/gen_ndr/ndr_drsuapi.h"
 #include "librpc/gen_ndr/ndr_drsblobs.h"
-#include "librpc/gen_ndr/ndr_misc.h"
 #include "system/time.h"
-#include "lib/ldb_wrap.h"
+#include "ldb_wrap.h"
 #include "auth/auth.h"
 #include "param/param.h"
-#include "torture/util.h"
 #include "param/provision.h"
-
-struct test_become_dc_state {
-        struct libnet_context *ctx;
-        struct torture_context *tctx;
-        const char *netbios_name;
-        struct test_join *tj;
-        struct cli_credentials *machine_account;
-        struct dsdb_schema *self_made_schema;
-        const struct dsdb_schema *schema;
-
-        struct ldb_context *ldb;
-
-        struct {
-                uint32_t object_count;
-                struct drsuapi_DsReplicaObjectListItemEx *first_object;
-                struct drsuapi_DsReplicaObjectListItemEx *last_object;
-        } schema_part;
-
-        const char *targetdir;
-
-        struct loadparm_context *lp_ctx;
-};
-
-static NTSTATUS test_become_dc_prepare_db(void *private_data,
-                                              const struct libnet_BecomeDC_PrepareDB *p)
-{
-        struct test_become_dc_state *s = talloc_get_type(private_data, struct test_become_dc_state);
-        struct provision_settings settings;
-        struct provision_result result;
-        NTSTATUS status;
-
-        settings.site_name = p->dest_dsa->site_name;
-        settings.root_dn_str = p->forest->root_dn_str;
-        settings.domain_dn_str = p->domain->dn_str;
-        settings.config_dn_str = p->forest->config_dn_str;
-        settings.schema_dn_str = p->forest->schema_dn_str;
-        settings.server_dn_str = torture_join_server_dn_str(s->tj);
-        settings.invocation_id = &p->dest_dsa->invocation_id;
-        settings.netbios_name = p->dest_dsa->netbios_name;
-        settings.host_ip = NULL;
-        settings.realm = torture_join_dom_dns_name(s->tj);
-        settings.domain = torture_join_dom_netbios_name(s->tj);
-        settings.ntds_dn_str = p->dest_dsa->ntds_dn_str;
-        settings.machine_password = cli_credentials_get_password(s->machine_account);
-        settings.targetdir = s->targetdir;
-
-        status = provision_bare(s, s->lp_ctx, &settings, &result);
-        
-        s->ldb = result.samdb;
-        s->lp_ctx = result.lp_ctx;
-        return NT_STATUS_OK;
-
-
-}
-
-static NTSTATUS test_become_dc_check_options(void *private_data,
-                                             const struct libnet_BecomeDC_CheckOptions *o)
-{
-        struct test_become_dc_state *s = talloc_get_type(private_data, struct test_become_dc_state);
-
-        DEBUG(0,("Become DC [%s] of Domain[%s]/[%s]\n",
-                s->netbios_name,
-                o->domain->netbios_name, o->domain->dns_name));
-
-        DEBUG(0,("Promotion Partner is Server[%s] from Site[%s]\n",
-                o->source_dsa->dns_name, o->source_dsa->site_name));
-
-        DEBUG(0,("Options:crossRef behavior_version[%u]\n"
-                       "\tschema object_version[%u]\n"
-                       "\tdomain behavior_version[%u]\n"
-                       "\tdomain w2k3_update_revision[%u]\n", 
-                o->forest->crossref_behavior_version,
-                o->forest->schema_object_version,
-                o->domain->behavior_version,
-                o->domain->w2k3_update_revision));
-
-        return NT_STATUS_OK;
-}
-
-static NTSTATUS test_apply_schema(struct test_become_dc_state *s,
-                                  const struct libnet_BecomeDC_StoreChunk *c)
-{
-        WERROR status;
-        const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr;
-        uint32_t object_count;
-        struct drsuapi_DsReplicaObjectListItemEx *first_object;
-        struct drsuapi_DsReplicaObjectListItemEx *cur;
-        uint32_t linked_attributes_count;
-        struct drsuapi_DsReplicaLinkedAttribute *linked_attributes;
-        const struct drsuapi_DsReplicaCursor2CtrEx *uptodateness_vector;
-        struct dsdb_extended_replicated_objects *objs;
-        struct repsFromTo1 *s_dsa;
-        char *tmp_dns_name;
-        struct ldb_message *msg;
-        struct ldb_val prefixMap_val;
-        struct ldb_message_element *prefixMap_el;
-        struct ldb_val schemaInfo_val;
-        char *sam_ldb_path;
-        uint32_t i;
-        int ret;
-        bool ok;
-        uint64_t seq_num;
-
-        DEBUG(0,("Analyze and apply schema objects\n"));
-
-        s_dsa                   = talloc_zero(s, struct repsFromTo1);
-        NT_STATUS_HAVE_NO_MEMORY(s_dsa);
-        s_dsa->other_info       = talloc(s_dsa, struct repsFromTo1OtherInfo);
-        NT_STATUS_HAVE_NO_MEMORY(s_dsa->other_info);
-
-        switch (c->ctr_level) {
-        case 1:
-                mapping_ctr                     = &c->ctr1->mapping_ctr;
-                object_count                    = s->schema_part.object_count;
-                first_object                    = s->schema_part.first_object;
-                linked_attributes_count         = 0;
-                linked_attributes               = NULL;
-                s_dsa->highwatermark            = c->ctr1->new_highwatermark;
-                s_dsa->source_dsa_obj_guid      = c->ctr1->source_dsa_guid;
-                s_dsa->source_dsa_invocation_id = c->ctr1->source_dsa_invocation_id;
-                uptodateness_vector             = NULL; /* TODO: map it */
-                break;
-        case 6:
-                mapping_ctr                     = &c->ctr6->mapping_ctr;
-                object_count                    = s->schema_part.object_count;
-                first_object                    = s->schema_part.first_object;
-                linked_attributes_count         = 0; /* TODO: ! */
-                linked_attributes               = NULL; /* TODO: ! */;
-                s_dsa->highwatermark            = c->ctr6->new_highwatermark;
-                s_dsa->source_dsa_obj_guid      = c->ctr6->source_dsa_guid;
-                s_dsa->source_dsa_invocation_id = c->ctr6->source_dsa_invocation_id;
-                uptodateness_vector             = c->ctr6->uptodateness_vector;
-                break;
-        default:
-                return NT_STATUS_INVALID_PARAMETER;
-        }
-
-        s_dsa->replica_flags            = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS;
-        memset(s_dsa->schedule, 0x11, sizeof(s_dsa->schedule));
-
-        tmp_dns_name    = GUID_string(s_dsa->other_info, &s_dsa->source_dsa_obj_guid);
-        NT_STATUS_HAVE_NO_MEMORY(tmp_dns_name);
-        tmp_dns_name    = talloc_asprintf_append_buffer(tmp_dns_name, "._msdcs.%s", c->forest->dns_name);
-        NT_STATUS_HAVE_NO_MEMORY(tmp_dns_name);
-        s_dsa->other_info->dns_name = tmp_dns_name;
-
-        for (cur = first_object; cur; cur = cur->next_object) {
-                bool is_attr = false;
-                bool is_class = false;
-
-                for (i=0; i < cur->object.attribute_ctr.num_attributes; i++) {
-                        struct drsuapi_DsReplicaAttribute *a;
-                        uint32_t j;
-                        const char *oid = NULL;
-
-                        a = &cur->object.attribute_ctr.attributes[i];
-                        status = dsdb_map_int2oid(s->self_made_schema, a->attid, s, &oid);
-                        if (!W_ERROR_IS_OK(status)) {
-                                return werror_to_ntstatus(status);
-                        }
-
-                        switch (a->attid) {
-                        case DRSUAPI_ATTRIBUTE_objectClass:
-                                for (j=0; j < a->value_ctr.num_values; j++) {
-                                        uint32_t val = 0xFFFFFFFF;
-
-                                        if (a->value_ctr.values[i].blob
-                                            && a->value_ctr.values[i].blob->length == 4) {
-                                                val = IVAL(a->value_ctr.values[i].blob->data,0);
-                                        }
-
-                                        if (val == DRSUAPI_OBJECTCLASS_attributeSchema) {
-                                                is_attr = true;
-                                        }
-                                        if (val == DRSUAPI_OBJECTCLASS_classSchema) {
-                                                is_class = true;
-                                        }
-                                }
-
-                                break;
-                        default:
-                                break;
-                        }
-                }
-
-                if (is_attr) {
-                        struct dsdb_attribute *sa;
-
-                        sa = talloc_zero(s->self_made_schema, struct dsdb_attribute);
-                        NT_STATUS_HAVE_NO_MEMORY(sa);
-
-                        status = dsdb_attribute_from_drsuapi(s->ldb, s->self_made_schema, &cur->object, s, sa);
-                        if (!W_ERROR_IS_OK(status)) {
-                                return werror_to_ntstatus(status);
-                        }
-
-                        DLIST_ADD_END(s->self_made_schema->attributes, sa, struct dsdb_attribute *);
-                }
-
-                if (is_class) {
-                        struct dsdb_class *sc;
-
-                        sc = talloc_zero(s->self_made_schema, struct dsdb_class);
-                        NT_STATUS_HAVE_NO_MEMORY(sc);
-
-                        status = dsdb_class_from_drsuapi(s->self_made_schema, &cur->object, s, sc);
-                        if (!W_ERROR_IS_OK(status)) {
-                                return werror_to_ntstatus(status);
-                        }
-
-                        DLIST_ADD_END(s->self_made_schema->classes, sc, struct dsdb_class *);
-                }
-        }
-
-        /* attach the schema to the ldb */
-        ret = dsdb_set_schema(s->ldb, s->self_made_schema);
-        if (ret != LDB_SUCCESS) {
-                return NT_STATUS_FOOBAR;
-        }
-        /* we don't want to access the self made schema anymore */
-        s->self_made_schema = NULL;
-        s->schema = dsdb_get_schema(s->ldb);
-
-        status = dsdb_extended_replicated_objects_commit(s->ldb,
-                                                         c->partition->nc.dn,
-                                                         mapping_ctr,
-                                                         object_count,
-                                                         first_object,
-                                                         linked_attributes_count,
-                                                         linked_attributes,
-                                                         s_dsa,
-                                                         uptodateness_vector,
-                                                         c->gensec_skey,
-                                                         s, &objs, &seq_num);
-        if (!W_ERROR_IS_OK(status)) {
-                DEBUG(0,("Failed to commit objects: %s\n", win_errstr(status)));
-                return werror_to_ntstatus(status);
-        }
-
-        if (lp_parm_bool(s->tctx->lp_ctx, NULL, "become dc", "dump objects", false)) {
-                for (i=0; i < objs->num_objects; i++) {
-                        struct ldb_ldif ldif;
-                        fprintf(stdout, "#\n");
-                        ldif.changetype = LDB_CHANGETYPE_NONE;
-                        ldif.msg = objs->objects[i].msg;
-                        ldb_ldif_write_file(s->ldb, stdout, &ldif);
-                        NDR_PRINT_DEBUG(replPropertyMetaDataBlob, objs->objects[i].meta_data);
-                }
-        }
-
-        msg = ldb_msg_new(objs);
-        NT_STATUS_HAVE_NO_MEMORY(msg);
-        msg->dn = objs->partition_dn;
-
-        status = dsdb_get_oid_mappings_ldb(s->schema, msg, &prefixMap_val, &schemaInfo_val);
-        if (!W_ERROR_IS_OK(status)) {
-                DEBUG(0,("Failed dsdb_get_oid_mappings_ldb(%s)\n", win_errstr(status)));
-                return werror_to_ntstatus(status);
-        }
-
-        /* we only add prefixMap here, because schemaInfo is a replicated attribute and already applied */
-        ret = ldb_msg_add_value(msg, "prefixMap", &prefixMap_val, &prefixMap_el);
-        if (ret != LDB_SUCCESS) {
-                return NT_STATUS_FOOBAR;
-        }
-        prefixMap_el->flags = LDB_FLAG_MOD_REPLACE;
-
-        ret = ldb_modify(s->ldb, msg);
-        if (ret != LDB_SUCCESS) {
-                DEBUG(0,("Failed to add prefixMap and schemaInfo %s\n", ldb_strerror(ret)));
-                return NT_STATUS_FOOBAR;
-        }
-
-        talloc_free(s_dsa);
-        talloc_free(objs);
-
-        /* reopen the ldb */
-        talloc_free(s->ldb); /* this also free's the s->schema, because dsdb_set_schema() steals it */
-        s->schema = NULL;
-
-        sam_ldb_path = talloc_asprintf(s, "%s/%s", s->targetdir, "private/sam.ldb");
-        DEBUG(0,("Reopen the SAM LDB with system credentials and a already stored schema: %s\n", sam_ldb_path));
-        s->ldb = ldb_wrap_connect(s, s->tctx->ev, s->tctx->lp_ctx, sam_ldb_path,
-                                  system_session(s, s->tctx->lp_ctx),
-                                  NULL, 0, NULL);
-        if (!s->ldb) {
-                DEBUG(0,("Failed to open '%s'\n",
-                        sam_ldb_path));
-                return NT_STATUS_INTERNAL_DB_ERROR;
-        }
-
-        ok = samdb_set_ntds_invocation_id(s->ldb, &c->dest_dsa->invocation_id);
-        if (!ok) {
-                DEBUG(0,("Failed to set cached ntds invocationId\n"));
-                return NT_STATUS_FOOBAR;
-        }
-        ok = samdb_set_ntds_objectGUID(s->ldb, &c->dest_dsa->ntds_guid);
-        if (!ok) {
-                DEBUG(0,("Failed to set cached ntds objectGUID\n"));
-                return NT_STATUS_FOOBAR;
-        }
-
-        s->schema = dsdb_get_schema(s->ldb);
-        if (!s->schema) {
-                DEBUG(0,("Failed to get loaded dsdb_schema\n"));
-                return NT_STATUS_FOOBAR;
-        }
-
-        return NT_STATUS_OK;
-}
-
-static NTSTATUS test_become_dc_schema_chunk(void *private_data,
-                                            const struct libnet_BecomeDC_StoreChunk *c)
-{
-        struct test_become_dc_state *s = talloc_get_type(private_data, struct test_become_dc_state);
-        WERROR status;
-        const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr;
-        uint32_t nc_object_count;
-        uint32_t object_count;
-        struct drsuapi_DsReplicaObjectListItemEx *first_object;
-        struct drsuapi_DsReplicaObjectListItemEx *cur;
-        uint32_t nc_linked_attributes_count;
-        uint32_t linked_attributes_count;
-
-        switch (c->ctr_level) {
-        case 1:
-                mapping_ctr                     = &c->ctr1->mapping_ctr;
-                nc_object_count                 = c->ctr1->extended_ret; /* maybe w2k send this unexpected? */
-                object_count                    = c->ctr1->object_count;
-                first_object                    = c->ctr1->first_object;
-                nc_linked_attributes_count      = 0;
-                linked_attributes_count         = 0;
-                break;
-        case 6:
-                mapping_ctr                     = &c->ctr6->mapping_ctr;
-                nc_object_count                 = c->ctr6->nc_object_count;
-                object_count                    = c->ctr6->object_count;
-                first_object                    = c->ctr6->first_object;
-                nc_linked_attributes_count      = c->ctr6->nc_linked_attributes_count;
-                linked_attributes_count         = c->ctr6->linked_attributes_count;
-                break;
-        default:
-                return NT_STATUS_INVALID_PARAMETER;
-        }
-
-        if (nc_object_count) {
-                DEBUG(0,("Schema-DN[%s] objects[%u/%u] linked_values[%u/%u]\n",
-                        c->partition->nc.dn, object_count, nc_object_count,
-                        linked_attributes_count, nc_linked_attributes_count));
-        } else {
-                DEBUG(0,("Schema-DN[%s] objects[%u] linked_values[%u\n",
-                c->partition->nc.dn, object_count, linked_attributes_count));
-        }
-
-        if (!s->schema) {
-                s->self_made_schema = dsdb_new_schema(s, lp_iconv_convenience(s->lp_ctx));
-
-                NT_STATUS_HAVE_NO_MEMORY(s->self_made_schema);
-
-                status = dsdb_load_oid_mappings_drsuapi(s->self_made_schema, mapping_ctr);
-                if (!W_ERROR_IS_OK(status)) {
-                        return werror_to_ntstatus(status);
-                }
-
-                s->schema = s->self_made_schema;
-        } else {
-                status = dsdb_verify_oid_mappings_drsuapi(s->schema, mapping_ctr);
-                if (!W_ERROR_IS_OK(status)) {
-                        return werror_to_ntstatus(status);
-                }
-        }
-
-        if (!s->schema_part.first_object) {
-                s->schema_part.object_count = object_count;
-                s->schema_part.first_object = talloc_steal(s, first_object);
-        } else {
-                s->schema_part.object_count             += object_count;
-                s->schema_part.last_object->next_object = talloc_steal(s->schema_part.last_object,
-                                                                       first_object);
-        }
-        for (cur = first_object; cur->next_object; cur = cur->next_object) {}
-        s->schema_part.last_object = cur;
-
-        if (!c->partition->more_data) {
-                return test_apply_schema(s, c);
-        }
-
-        return NT_STATUS_OK;
-}
-
-static NTSTATUS test_become_dc_store_chunk(void *private_data,
-                                           const struct libnet_BecomeDC_StoreChunk *c)
-{
-        struct test_become_dc_state *s = talloc_get_type(private_data, struct test_become_dc_state);
-        WERROR status;
-        const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr;
-        uint32_t nc_object_count;
-        uint32_t object_count;
-        struct drsuapi_DsReplicaObjectListItemEx *first_object;
-        uint32_t nc_linked_attributes_count;
-        uint32_t linked_attributes_count;
-        struct drsuapi_DsReplicaLinkedAttribute *linked_attributes;
-        const struct drsuapi_DsReplicaCursor2CtrEx *uptodateness_vector;
-        struct dsdb_extended_replicated_objects *objs;
-        struct repsFromTo1 *s_dsa;
-        char *tmp_dns_name;
-        uint32_t i;
-        uint64_t seq_num;
-
-        s_dsa                   = talloc_zero(s, struct repsFromTo1);
-        NT_STATUS_HAVE_NO_MEMORY(s_dsa);
-        s_dsa->other_info       = talloc(s_dsa, struct repsFromTo1OtherInfo);
-        NT_STATUS_HAVE_NO_MEMORY(s_dsa->other_info);
-
-        switch (c->ctr_level) {
-        case 1:
-                mapping_ctr                     = &c->ctr1->mapping_ctr;
-                nc_object_count                 = c->ctr1->extended_ret; /* maybe w2k send this unexpected? */
-                object_count                    = c->ctr1->object_count;
-                first_object                    = c->ctr1->first_object;
-                nc_linked_attributes_count      = 0;
-                linked_attributes_count         = 0;
-                linked_attributes               = NULL;
-                s_dsa->highwatermark            = c->ctr1->new_highwatermark;
-                s_dsa->source_dsa_obj_guid      = c->ctr1->source_dsa_guid;
-                s_dsa->source_dsa_invocation_id = c->ctr1->source_dsa_invocation_id;
-                uptodateness_vector             = NULL; /* TODO: map it */
-                break;
-        case 6:
-                mapping_ctr                     = &c->ctr6->mapping_ctr;
-                nc_object_count                 = c->ctr6->nc_object_count;
-                object_count                    = c->ctr6->object_count;
-                first_object                    = c->ctr6->first_object;
-                nc_linked_attributes_count      = c->ctr6->nc_linked_attributes_count;
-                linked_attributes_count         = c->ctr6->linked_attributes_count;
-                linked_attributes               = c->ctr6->linked_attributes;
-                s_dsa->highwatermark            = c->ctr6->new_highwatermark;
-                s_dsa->source_dsa_obj_guid      = c->ctr6->source_dsa_guid;
-                s_dsa->source_dsa_invocation_id = c->ctr6->source_dsa_invocation_id;
-                uptodateness_vector             = c->ctr6->uptodateness_vector;
-                break;
-        default:
-                return NT_STATUS_INVALID_PARAMETER;
-        }
-
-        s_dsa->replica_flags            = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS;
-        memset(s_dsa->schedule, 0x11, sizeof(s_dsa->schedule));
-
-        tmp_dns_name    = GUID_string(s_dsa->other_info, &s_dsa->source_dsa_obj_guid);
-        NT_STATUS_HAVE_NO_MEMORY(tmp_dns_name);
-        tmp_dns_name    = talloc_asprintf_append_buffer(tmp_dns_name, "._msdcs.%s", c->forest->dns_name);
-        NT_STATUS_HAVE_NO_MEMORY(tmp_dns_name);
-        s_dsa->other_info->dns_name = tmp_dns_name;
-
-        if (nc_object_count) {
-                DEBUG(0,("Partition[%s] objects[%u/%u] linked_values[%u/%u]\n",
-                        c->partition->nc.dn, object_count, nc_object_count,
-                        linked_attributes_count, nc_linked_attributes_count));
-        } else {
-                DEBUG(0,("Partition[%s] objects[%u] linked_values[%u\n",
-                c->partition->nc.dn, object_count, linked_attributes_count));
-        }
-
-        status = dsdb_extended_replicated_objects_commit(s->ldb,
-                                                         c->partition->nc.dn,
-                                                         mapping_ctr,
-                                                         object_count,
-                                                         first_object,
-                                                         linked_attributes_count,
-                                                         linked_attributes,
-                                                         s_dsa,
-                                                         uptodateness_vector,
-                                                         c->gensec_skey,
-                                                         s, &objs, &seq_num);
-        if (!W_ERROR_IS_OK(status)) {
-                DEBUG(0,("Failed to commit objects: %s\n", win_errstr(status)));
-                return werror_to_ntstatus(status);
-        }
-
-        if (lp_parm_bool(s->tctx->lp_ctx, NULL, "become dc", "dump objects", false)) {
-                for (i=0; i < objs->num_objects; i++) {
-                        struct ldb_ldif ldif;
-                        fprintf(stdout, "#\n");
-                        ldif.changetype = LDB_CHANGETYPE_NONE;
-                        ldif.msg = objs->objects[i].msg;
-                        ldb_ldif_write_file(s->ldb, stdout, &ldif);
-                        NDR_PRINT_DEBUG(replPropertyMetaDataBlob, objs->objects[i].meta_data);
-                }
-        }
-        talloc_free(s_dsa);
-        talloc_free(objs);
-
-        for (i=0; i < linked_attributes_count; i++) {
-                const struct dsdb_attribute *sa;
-
-                if (!linked_attributes[i].identifier) {
-                        return NT_STATUS_FOOBAR;                
-                }
-
-                if (!linked_attributes[i].value.blob) {
-                        return NT_STATUS_FOOBAR;                
-                }
-
-                sa = dsdb_attribute_by_attributeID_id(s->schema,
-                                                      linked_attributes[i].attid);
-                if (!sa) {
-                        return NT_STATUS_FOOBAR;
-                }
-
-                if (lp_parm_bool(s->tctx->lp_ctx, NULL, "become dc", "dump objects", false)) {
-                        DEBUG(0,("# %s\n", sa->lDAPDisplayName));
-                        NDR_PRINT_DEBUG(drsuapi_DsReplicaLinkedAttribute, &linked_attributes[i]);
-                        dump_data(0,
-                                linked_attributes[i].value.blob->data,
-                                linked_attributes[i].value.blob->length);
-                }
-        }
-
-        return NT_STATUS_OK;
-}
+#include "libcli/resolve/resolve.h"
 
 bool torture_net_become_dc(struct torture_context *torture)
@@ -571 +41 @@
         struct libnet_BecomeDC b;
         struct libnet_UnbecomeDC u;
-        struct test_become_dc_state *s;
+        struct libnet_vampire_cb_state *s;
         struct ldb_message *msg;
         int ldb_ret;
         uint32_t i;
         char *sam_ldb_path;
+        const char *address;
+        struct nbt_name name;
+        const char *netbios_name;
+        struct cli_credentials *machine_account;
+        struct test_join *tj;
+        struct loadparm_context *lp_ctx;
+        struct ldb_context *ldb;
+        struct libnet_context *ctx;
+        struct dsdb_schema *schema;
 
         char *location = NULL;
@@ -581 +60 @@
                                    "torture_temp_dir should return NT_STATUS_OK" );
 
-        s = talloc_zero(torture, struct test_become_dc_state);
-        if (!s) return false;
-
-        s->tctx = torture;
-        s->lp_ctx = torture->lp_ctx;
-
-        s->netbios_name = lp_parm_string(torture->lp_ctx, NULL, "become dc", "smbtorture dc");
-        if (!s->netbios_name || !s->netbios_name[0]) {
-                s->netbios_name = "smbtorturedc";
+        netbios_name = lpcfg_parm_string(torture->lp_ctx, NULL, "become dc", "smbtorture dc");
+        if (!netbios_name || !netbios_name[0]) {
+                netbios_name = "smbtorturedc";
         }
 
-        s->targetdir = location;
+        make_nbt_name_server(&name, torture_setting_string(torture, "host", NULL));
+
+        /* do an initial name resolution to find its IP */
+        status = resolve_name(lpcfg_resolve_context(torture->lp_ctx),
+                              &name, torture, &address, torture->ev);
+        torture_assert_ntstatus_ok(torture, status, talloc_asprintf(torture,
+                                   "Failed to resolve %s - %s\n",
+                                   name.name, nt_errstr(status)));
+
 
         /* Join domain as a member server. */
-        s->tj = torture_join_domain(torture, s->netbios_name,
+        tj = torture_join_domain(torture, netbios_name,
                                  ACB_WSTRUST,
-                                 &s->machine_account);
-        if (!s->tj) {
-                DEBUG(0, ("%s failed to join domain as workstation\n",
-                          s->netbios_name));
-                return false;
-        }
+                                 &machine_account);
+        torture_assert(torture, tj, talloc_asprintf(torture,
+                                                    "%s failed to join domain as workstation\n",
+                                                    netbios_name));
 
-        s->ctx = libnet_context_init(torture->ev, torture->lp_ctx);
-        s->ctx->cred = cmdline_credentials;
+        s = libnet_vampire_cb_state_init(torture, torture->lp_ctx, torture->ev,
+                               netbios_name,
+                               torture_join_dom_netbios_name(tj),
+                               torture_join_dom_dns_name(tj),
+                               location);
+        torture_assert(torture, s, "libnet_vampire_cb_state_init");
 
-        s->ldb = ldb_init(s, torture->ev);
+        ctx = libnet_context_init(torture->ev, torture->lp_ctx);
+        ctx->cred = cmdline_credentials;
 
         ZERO_STRUCT(b);
-        b.in.domain_dns_name            = torture_join_dom_dns_name(s->tj);
-        b.in.domain_netbios_name        = torture_join_dom_netbios_name(s->tj);
-        b.in.domain_sid                 = torture_join_sid(s->tj);
-        b.in.source_dsa_address         = torture_setting_string(torture, "host", NULL);
-        b.in.dest_dsa_netbios_name      = s->netbios_name;
+        b.in.domain_dns_name            = torture_join_dom_dns_name(tj);
+        b.in.domain_netbios_name        = torture_join_dom_netbios_name(tj);
+        b.in.domain_sid                 = torture_join_sid(tj);
+        b.in.source_dsa_address         = address;
+        b.in.dest_dsa_netbios_name      = netbios_name;
 
         b.in.callbacks.private_data     = s;
-        b.in.callbacks.check_options    = test_become_dc_check_options;
-        b.in.callbacks.prepare_db = test_become_dc_prepare_db;
-        b.in.callbacks.schema_chunk     = test_become_dc_schema_chunk;
-        b.in.callbacks.config_chunk     = test_become_dc_store_chunk;
-        b.in.callbacks.domain_chunk     = test_become_dc_store_chunk;
+        b.in.callbacks.check_options    = libnet_vampire_cb_check_options;
+        b.in.callbacks.prepare_db       = libnet_vampire_cb_prepare_db;
+        b.in.callbacks.schema_chunk     = libnet_vampire_cb_schema_chunk;
+        b.in.callbacks.config_chunk     = libnet_vampire_cb_store_chunk;
+        b.in.callbacks.domain_chunk     = libnet_vampire_cb_store_chunk;
 
-        status = libnet_BecomeDC(s->ctx, s, &b);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("libnet_BecomeDC() failed - %s\n", nt_errstr(status));
-                ret = false;
-                goto cleanup;
-        }
+        status = libnet_BecomeDC(ctx, s, &b);
+        torture_assert_ntstatus_ok_goto(torture, status, ret, cleanup, talloc_asprintf(torture,
+                                   "libnet_BecomeDC() failed - %s %s\n",
+                                   nt_errstr(status), b.out.error_string));
+        ldb = libnet_vampire_cb_ldb(s);
 
         msg = ldb_msg_new(s);
-        if (!msg) {
-                printf("ldb_msg_new() failed\n");
-                ret = false;
-                goto cleanup;
-        }
-        msg->dn = ldb_dn_new(msg, s->ldb, "@ROOTDSE");
-        if (!msg->dn) {
-                printf("ldb_msg_new(@ROOTDSE) failed\n");
-                ret = false;
-                goto cleanup;
-        }
+        torture_assert_int_equal_goto(torture, (msg?1:0), 1, ret, cleanup,
+                                      "ldb_msg_new() failed\n");
+        msg->dn = ldb_dn_new(msg, ldb, "@ROOTDSE");
+        torture_assert_int_equal_goto(torture, (msg->dn?1:0), 1, ret, cleanup,
+                                      "ldb_msg_new(@ROOTDSE) failed\n");
 
         ldb_ret = ldb_msg_add_string(msg, "isSynchronized", "TRUE");
-        if (ldb_ret != LDB_SUCCESS) {
-                printf("ldb_msg_add_string(msg, isSynchronized, TRUE) failed: %d\n", ldb_ret);
-                ret = false;
-                goto cleanup;
-        }
+        torture_assert_int_equal_goto(torture, ldb_ret, LDB_SUCCESS, ret, cleanup,
+                                      "ldb_msg_add_string(msg, isSynchronized, TRUE) failed\n");
 
         for (i=0; i < msg->num_elements; i++) {
@@ -654 +128 @@
         }
 
-        printf("mark ROOTDSE with isSynchronized=TRUE\n");
-        ldb_ret = ldb_modify(s->ldb, msg);
-        if (ldb_ret != LDB_SUCCESS) {
-                printf("ldb_modify() failed: %d\n", ldb_ret);
-                ret = false;
-                goto cleanup;
-        }
+        torture_comment(torture, "mark ROOTDSE with isSynchronized=TRUE\n");
+        ldb_ret = ldb_modify(libnet_vampire_cb_ldb(s), msg);
+        torture_assert_int_equal_goto(torture, ldb_ret, LDB_SUCCESS, ret, cleanup,
+                                      "ldb_modify() failed\n");
         
+        /* commit the transaction now we know the secrets were written
+         * out properly
+        */
+        ldb_ret = ldb_transaction_commit(ldb);
+        torture_assert_int_equal_goto(torture, ldb_ret, LDB_SUCCESS, ret, cleanup,
+                                      "ldb_transaction_commit() failed\n");
+
         /* reopen the ldb */
-        talloc_free(s->ldb); /* this also free's the s->schema, because dsdb_set_schema() steals it */
-        s->schema = NULL;
+        talloc_unlink(s, ldb);
 
-        sam_ldb_path = talloc_asprintf(s, "%s/%s", s->targetdir, "private/sam.ldb");
-        DEBUG(0,("Reopen the SAM LDB with system credentials and all replicated data: %s\n", sam_ldb_path));
-        s->ldb = ldb_wrap_connect(s, s->tctx->ev, s->lp_ctx, sam_ldb_path,
-                                  system_session(s, s->lp_ctx),
-                                  NULL, 0, NULL);
-        if (!s->ldb) {
-                DEBUG(0,("Failed to open '%s'\n",
-                        sam_ldb_path));
-                ret = false;
-                goto cleanup;
-        }
+        lp_ctx = libnet_vampire_cb_lp_ctx(s);
+        sam_ldb_path = talloc_asprintf(s, "%s/%s", location, "private/sam.ldb");
+        lpcfg_set_cmdline(lp_ctx, "sam database", sam_ldb_path);
+        torture_comment(torture, "Reopen the SAM LDB with system credentials and all replicated data: %s\n", sam_ldb_path);
+        ldb = samdb_connect(s, torture->ev, lp_ctx, system_session(lp_ctx), 0);
+        torture_assert_goto(torture, ldb != NULL, ret, cleanup,
+                                      talloc_asprintf(torture,
+                                      "Failed to open '%s'\n", sam_ldb_path));
 
-        s->schema = dsdb_get_schema(s->ldb);
-        if (!s->schema) {
-                DEBUG(0,("Failed to get loaded dsdb_schema\n"));
-                ret = false;
-                goto cleanup;
-        }
+        torture_assert_goto(torture, dsdb_uses_global_schema(ldb), ret, cleanup,
+                                                "Uses global schema");
+
+        schema = dsdb_get_schema(ldb, s);
+        torture_assert_goto(torture, schema != NULL, ret, cleanup,
+                                      "Failed to get loaded dsdb_schema\n");
 
         /* Make sure we get this from the command line */
-        if (lp_parm_bool(torture->lp_ctx, NULL, "become dc", "do not unjoin", false)) {
+        if (lpcfg_parm_bool(torture->lp_ctx, NULL, "become dc", "do not unjoin", false)) {
                 talloc_free(s);
                 return ret;
@@ -693 +167 @@
 cleanup:
         ZERO_STRUCT(u);
-        u.in.domain_dns_name            = torture_join_dom_dns_name(s->tj);
-        u.in.domain_netbios_name        = torture_join_dom_netbios_name(s->tj);
-        u.in.source_dsa_address         = torture_setting_string(torture, "host", NULL);
-        u.in.dest_dsa_netbios_name      = s->netbios_name;
+        u.in.domain_dns_name            = torture_join_dom_dns_name(tj);
+        u.in.domain_netbios_name        = torture_join_dom_netbios_name(tj);
+        u.in.source_dsa_address         = address;
+        u.in.dest_dsa_netbios_name      = netbios_name;
 
-        status = libnet_UnbecomeDC(s->ctx, s, &u);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("libnet_UnbecomeDC() failed - %s\n", nt_errstr(status));
-                ret = false;
-        }
+        status = libnet_UnbecomeDC(ctx, s, &u);
+        torture_assert_ntstatus_ok(torture, status, talloc_asprintf(torture,
+                                   "libnet_UnbecomeDC() failed - %s %s\n",
+                                   nt_errstr(status), u.out.error_string));
 
-        /* Leave domain. */                          
-        torture_leave_domain(torture, s->tj);
+        /* Leave domain. */
+        torture_leave_domain(torture, tj);
 
         talloc_free(s);

trunk/server/source4/torture/libnet/libnet_domain.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    Test suite for libnet calls.
 
    Copyright (C) Rafal Szczesniak 2006
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -22 +22 @@
 #include "includes.h"
 #include "lib/cmdline/popt_common.h"
-#include "lib/events/events.h"
-#include "auth/credentials/credentials.h"
 #include "libnet/libnet.h"
 #include "librpc/gen_ndr/ndr_samr_c.h"
 #include "librpc/gen_ndr/ndr_lsa_c.h"
-#include "libcli/security/security.h"
-#include "librpc/rpc/dcerpc.h"
-#include "torture/torture.h"
-#include "torture/rpc/rpc.h"
+#include "torture/rpc/torture_rpc.h"
 #include "param/param.h"
 
 
-static bool test_opendomain_samr(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_opendomain_samr(struct torture_context *tctx,
+                                 struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
                                  struct policy_handle *handle, struct lsa_String *domname,
                                  uint32_t *access_mask, struct dom_sid **sid_p)
 {
-        NTSTATUS status;
         struct policy_handle h, domain_handle;
         struct samr_Connect r1;
@@ -44 +39 @@
         struct dom_sid2 *sid = NULL;
         struct samr_OpenDomain r3;
-        
-        printf("connecting\n");
+
+        torture_comment(tctx, "connecting\n");
 
         *access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
-        
+
         r1.in.system_name = 0;
         r1.in.access_mask = *access_mask;
         r1.out.connect_handle = &h;
-        
-        status = dcerpc_samr_Connect(p, mem_ctx, &r1);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Connect failed - %s\n", nt_errstr(status));
-                return false;
-        }
-        
+
+        torture_assert_ntstatus_ok(tctx,
+                dcerpc_samr_Connect_r(b, mem_ctx, &r1),
+                "Connect failed");
+        torture_assert_ntstatus_ok(tctx, r1.out.result,
+                "Connect failed");
+
         r2.in.connect_handle = &h;
         r2.in.domain_name = domname;
         r2.out.sid = &sid;
 
-        printf("domain lookup on %s\n", domname->string);
-
-        status = dcerpc_samr_LookupDomain(p, mem_ctx, &r2);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("LookupDomain failed - %s\n", nt_errstr(status));
-                return false;
-        }
+        torture_comment(tctx, "domain lookup on %s\n", domname->string);
+
+        torture_assert_ntstatus_ok(tctx,
+                dcerpc_samr_LookupDomain_r(b, mem_ctx, &r2),
+                "LookupDomain failed");
+        torture_assert_ntstatus_ok(tctx, r2.out.result,
+                "LookupDomain failed");
 
         r3.in.connect_handle = &h;
@@ -76 +71 @@
         r3.out.domain_handle = &domain_handle;
 
-        printf("opening domain\n");
-
-        status = dcerpc_samr_OpenDomain(p, mem_ctx, &r3);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("OpenDomain failed - %s\n", nt_errstr(status));
-                return false;
-        } else {
-                *handle = domain_handle;
-        }
+        torture_comment(tctx, "opening domain\n");
+
+        torture_assert_ntstatus_ok(tctx,
+                dcerpc_samr_OpenDomain_r(b, mem_ctx, &r3),
+                "OpenDomain failed");
+        torture_assert_ntstatus_ok(tctx, r3.out.result,
+                "OpenDomain failed");
+
+        *handle = domain_handle;
 
         return true;
@@ -90 +85 @@
 
 
-static bool test_opendomain_lsa(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_opendomain_lsa(struct torture_context *tctx,
+                                struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
                                 struct policy_handle *handle, struct lsa_String *domname,
                                 uint32_t *access_mask)
 {
-        NTSTATUS status;
         struct lsa_OpenPolicy2 open;
         struct lsa_ObjectAttribute attr;
@@ -108 +103 @@
         qos.context_mode        = 1;
         qos.effective_only      = 0;
-        
+
         attr.sec_qos = &qos;
 
@@ -115 +110 @@
         open.in.access_mask = *access_mask;
         open.out.handle     = handle;
-        
-        status = dcerpc_lsa_OpenPolicy2(p, mem_ctx, &open);
-        if (!NT_STATUS_IS_OK(status)) {
-                return false;
-        }
+
+        torture_assert_ntstatus_ok(tctx,
+                dcerpc_lsa_OpenPolicy2_r(b, mem_ctx, &open),
+                "OpenPolicy2 failed");
+        torture_assert_ntstatus_ok(tctx, open.out.result,
+                "OpenPolicy2 failed");
 
         return true;
@@ -137 +133 @@
            passed (it's going to be resolved to dc name and address) instead
            of specific server name. */
-        domain_name = lp_workgroup(torture->lp_ctx);
+        domain_name = lpcfg_workgroup(torture->lp_ctx);
 
         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
         if (ctx == NULL) {
-                d_printf("failed to create libnet context\n");
+                torture_comment(torture, "failed to create libnet context\n");
                 return false;
         }
@@ -154 +150 @@
         status = libnet_DomainOpen(ctx, torture, &r);
         if (!NT_STATUS_IS_OK(status)) {
-                d_printf("failed to open domain on lsa service: %s\n", nt_errstr(status));
+                torture_comment(torture, "failed to open domain on lsa service: %s\n", nt_errstr(status));
                 ret = false;
                 goto done;
@@ -162 +158 @@
         lsa_close.in.handle  = &ctx->lsa.handle;
         lsa_close.out.handle = &h;
-        
-        status = dcerpc_lsa_Close(ctx->lsa.pipe, ctx, &lsa_close);
-        if (!NT_STATUS_IS_OK(status)) {
-                d_printf("failed to close domain on lsa service: %s\n", nt_errstr(status));
-                ret = false;
-        }
+
+        torture_assert_ntstatus_ok(torture,
+                dcerpc_lsa_Close_r(ctx->lsa.pipe->binding_handle, ctx, &lsa_close),
+                "failed to close domain on lsa service");
+        torture_assert_ntstatus_ok(torture, lsa_close.out.result,
+                "failed to close domain on lsa service");
 
 done:
@@ -195 +191 @@
         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
         if (ctx == NULL) {
-                d_printf("failed to create libnet context\n");
+                torture_comment(torture, "failed to create libnet context\n");
                 ret = false;
                 goto done;
@@ -206 +202 @@
                                      cmdline_credentials, torture->ev, torture->lp_ctx);
         if (!NT_STATUS_IS_OK(status)) {
-                d_printf("failed to connect to server: %s\n", nt_errstr(status));
-                ret = false;
-                goto done;
-        }
-
-        domain_name.string = lp_workgroup(torture->lp_ctx);
-        
-        if (!test_opendomain_lsa(p, torture, &h, &domain_name, &access_mask)) {
-                d_printf("failed to open domain on lsa service\n");
-                ret = false;
-                goto done;
-        }
-        
+                torture_comment(torture, "failed to connect to server: %s\n", nt_errstr(status));
+                ret = false;
+                goto done;
+        }
+
+        domain_name.string = lpcfg_workgroup(torture->lp_ctx);
+
+        if (!test_opendomain_lsa(torture, p->binding_handle, torture, &h, &domain_name, &access_mask)) {
+                torture_comment(torture, "failed to open domain on lsa service\n");
+                ret = false;
+                goto done;
+        }
+
         ctx->lsa.pipe        = p;
         ctx->lsa.name        = domain_name.string;
@@ -230 +226 @@
         r.in.type = DOMAIN_LSA;
         r.in.domain_name = domain_name.string;
-        
+
         status = libnet_DomainClose(ctx, mem_ctx, &r);
         if (!NT_STATUS_IS_OK(status)) {
@@ -263 +259 @@
            passed (it's going to be resolved to dc name and address) instead
            of specific server name. */
-        domain_name = lp_workgroup(torture->lp_ctx);
+        domain_name = lpcfg_workgroup(torture->lp_ctx);
 
         /*
          * Testing synchronous version
          */
-        printf("opening domain\n");
-        
+        torture_comment(torture, "opening domain\n");
+
         io.in.type         = DOMAIN_SAMR;
         io.in.domain_name  = domain_name;
@@ -276 +272 @@
         status = libnet_DomainOpen(ctx, mem_ctx, &io);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("Composite domain open failed - %s\n", nt_errstr(status));
+                torture_comment(torture, "Composite domain open failed for domain '%s' - %s\n",
+                                domain_name, nt_errstr(status));
                 ret = false;
                 goto done;
@@ -285 +282 @@
         r.in.handle   = &domain_handle;
         r.out.handle  = &handle;
-        
-        printf("closing domain handle\n");
-        
-        status = dcerpc_samr_Close(ctx->samr.pipe, mem_ctx, &r);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Close failed - %s\n", nt_errstr(status));
-                ret = false;
-                goto done;
-        }
+
+        torture_comment(torture, "closing domain handle\n");
+
+        torture_assert_ntstatus_ok(torture,
+                dcerpc_samr_Close_r(ctx->samr.pipe->binding_handle, mem_ctx, &r),
+                "Close failed");
+        torture_assert_ntstatus_ok(torture, r.out.result,
+                "Close failed");
 
 done:
@@ -324 +320 @@
         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
         if (ctx == NULL) {
-                d_printf("failed to create libnet context\n");
+                torture_comment(torture, "failed to create libnet context\n");
                 ret = false;
                 goto done;
@@ -335 +331 @@
                                      ctx->cred, torture->ev, torture->lp_ctx);
         if (!NT_STATUS_IS_OK(status)) {
-                d_printf("failed to connect to server: %s\n", nt_errstr(status));
-                ret = false;
-                goto done;
-        }
-
-        domain_name.string = talloc_strdup(mem_ctx, lp_workgroup(torture->lp_ctx));
-        
-        if (!test_opendomain_samr(p, torture, &h, &domain_name, &access_mask, &sid)) {
-                d_printf("failed to open domain on samr service\n");
-                ret = false;
-                goto done;
-        }
-        
+                torture_comment(torture, "failed to connect to server: %s\n", nt_errstr(status));
+                ret = false;
+                goto done;
+        }
+
+        domain_name.string = talloc_strdup(mem_ctx, lpcfg_workgroup(torture->lp_ctx));
+
+        if (!test_opendomain_samr(torture, p->binding_handle, torture, &h, &domain_name, &access_mask, &sid)) {
+                torture_comment(torture, "failed to open domain on samr service\n");
+                ret = false;
+                goto done;
+        }
+
         ctx->samr.pipe        = p;
         ctx->samr.name        = talloc_steal(ctx, domain_name.string);
@@ -361 +357 @@
         r.in.type = DOMAIN_SAMR;
         r.in.domain_name = domain_name.string;
-        
+
         status = libnet_DomainClose(ctx, mem_ctx, &r);
         if (!NT_STATUS_IS_OK(status)) {
@@ -392 +388 @@
         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
         if (ctx == NULL) {
-                d_printf("failed to create libnet context\n");
+                torture_comment(torture, "failed to create libnet context\n");
                 ret = false;
                 goto done;
@@ -398 +394 @@
 
         ctx->cred = cmdline_credentials;
-        
+
         mem_ctx = talloc_init("torture_domain_close_samr");
 
@@ -414 +410 @@
         }
 
-        d_printf("Received list or domains (everything in one piece):\n");
-        
+        torture_comment(torture, "Received list or domains (everything in one piece):\n");
+
         for (i = 0; i < r.out.count; i++) {
-                d_printf("Name[%d]: %s\n", i, r.out.domains[i].name);
+                torture_comment(torture, "Name[%d]: %s\n", i, r.out.domains[i].name);
         }
 
@@ -435 +431 @@
         }
 
-        d_printf("Received list or domains (collected in more than one round):\n");
-        
+        torture_comment(torture, "Received list or domains (collected in more than one round):\n");
+
         for (i = 0; i < r.out.count; i++) {
-                d_printf("Name[%d]: %s\n", i, r.out.domains[i].name);
+                torture_comment(torture, "Name[%d]: %s\n", i, r.out.domains[i].name);
         }
 
 done:
-        d_printf("\nStatus: %s\n", nt_errstr(status));
+        torture_comment(torture, "\nStatus: %s\n", nt_errstr(status));
 
         talloc_free(mem_ctx);

trunk/server/source4/torture/libnet/libnet_group.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    Test suite for libnet calls.
 
    Copyright (C) Rafal Szczesniak  2007
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -25 +25 @@
 #include "librpc/gen_ndr/ndr_samr_c.h"
 #include "librpc/gen_ndr/ndr_lsa_c.h"
-#include "torture/torture.h"
-#include "torture/rpc/rpc.h"
+#include "torture/rpc/torture_rpc.h"
+#include "torture/libnet/proto.h"
 #include "param/param.h"
 
 
 #define TEST_GROUPNAME  "libnetgrouptest"
-
-
-static bool test_cleanup(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                         struct policy_handle *domain_handle, const char *groupname)
-{
-        NTSTATUS status;
-        struct samr_LookupNames r1;
-        struct samr_OpenGroup r2;
-        struct samr_DeleteDomainGroup r3;
-        struct lsa_String names[2];
-        uint32_t rid;
-        struct policy_handle group_handle;
-        struct samr_Ids rids, types;
-
-        names[0].string = groupname;
-
-        r1.in.domain_handle  = domain_handle;
-        r1.in.num_names      = 1;
-        r1.in.names          = names;
-        r1.out.rids          = &rids;
-        r1.out.types         = &types;
-        
-        printf("group account lookup '%s'\n", groupname);
-
-        status = dcerpc_samr_LookupNames(p, mem_ctx, &r1);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("LookupNames failed - %s\n", nt_errstr(status));
-                return false;
-        }
-
-        rid = r1.out.rids->ids[0];
-        
-        r2.in.domain_handle  = domain_handle;
-        r2.in.access_mask    = SEC_FLAG_MAXIMUM_ALLOWED;
-        r2.in.rid            = rid;
-        r2.out.group_handle  = &group_handle;
-
-        printf("opening group account\n");
-
-        status = dcerpc_samr_OpenGroup(p, mem_ctx, &r2);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("OpenGroup failed - %s\n", nt_errstr(status));
-                return false;
-        }
-
-        r3.in.group_handle  = &group_handle;
-        r3.out.group_handle = &group_handle;
-
-        printf("deleting group account\n");
-        
-        status = dcerpc_samr_DeleteDomainGroup(p, mem_ctx, &r3);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("DeleteGroup failed - %s\n", nt_errstr(status));
-                return false;
-        }
-
-        return true;
-}
-
-
-static bool test_creategroup(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                             struct policy_handle *handle, const char *name)
-{
-        NTSTATUS status;
-        struct lsa_String groupname;
-        struct samr_CreateDomainGroup r;
-        struct policy_handle group_handle;
-        uint32_t group_rid;
-        
-        groupname.string = name;
-        
-        r.in.domain_handle  = handle;
-        r.in.name           = &groupname;
-        r.in.access_mask    = SEC_FLAG_MAXIMUM_ALLOWED;
-        r.out.group_handle  = &group_handle;
-        r.out.rid           = &group_rid;
-
-        printf("creating group account %s\n", name);
-
-        status = dcerpc_samr_CreateDomainGroup(p, mem_ctx, &r);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("CreateGroup failed - %s\n", nt_errstr(status));
-
-                if (NT_STATUS_EQUAL(status, NT_STATUS_GROUP_EXISTS)) {
-                        printf("Group (%s) already exists - attempting to delete and recreate group again\n", name);
-                        if (!test_cleanup(p, mem_ctx, handle, TEST_GROUPNAME)) {
-                                return false;
-                        }
-
-                        printf("creating group account\n");
-                        
-                        status = dcerpc_samr_CreateDomainGroup(p, mem_ctx, &r);
-                        if (!NT_STATUS_IS_OK(status)) {
-                                printf("CreateGroup failed - %s\n", nt_errstr(status));
-                                return false;
-                        }
-                        return true;
-                }
-                return false;
-        }
-
-        return true;
-}
-
-
-static bool test_opendomain(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                            struct policy_handle *handle, struct lsa_String *domname)
-{
-        NTSTATUS status;
-        struct policy_handle h, domain_handle;
-        struct samr_Connect r1;
-        struct samr_LookupDomain r2;
-        struct dom_sid2 *sid = NULL;
-        struct samr_OpenDomain r3;
-        
-        printf("connecting\n");
-        
-        r1.in.system_name = 0;
-        r1.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
-        r1.out.connect_handle = &h;
-        
-        status = dcerpc_samr_Connect(p, mem_ctx, &r1);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Connect failed - %s\n", nt_errstr(status));
-                return false;
-        }
-        
-        r2.in.connect_handle = &h;
-        r2.in.domain_name = domname;
-        r2.out.sid = &sid;
-
-        printf("domain lookup on %s\n", domname->string);
-
-        status = dcerpc_samr_LookupDomain(p, mem_ctx, &r2);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("LookupDomain failed - %s\n", nt_errstr(status));
-                return false;
-        }
-
-        r3.in.connect_handle = &h;
-        r3.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
-        r3.in.sid = *r2.out.sid;
-        r3.out.domain_handle = &domain_handle;
-
-        printf("opening domain\n");
-
-        status = dcerpc_samr_OpenDomain(p, mem_ctx, &r3);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("OpenDomain failed - %s\n", nt_errstr(status));
-                return false;
-        } else {
-                *handle = domain_handle;
-        }
-
-        return true;
-}
-
-
-static bool test_samr_close(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                            struct policy_handle *domain_handle)
-{
-        NTSTATUS status;
-        struct samr_Close r;
-  
-        r.in.handle = domain_handle;
-        r.out.handle = domain_handle;
-
-        status = dcerpc_samr_Close(p, mem_ctx, &r);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Close samr domain failed - %s\n", nt_errstr(status));
-                return false;
-        }
-        
-        return true;
-}
-
-
-static bool test_lsa_close(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                           struct policy_handle *domain_handle)
-{
-        NTSTATUS status;
-        struct lsa_Close r;
-
-        r.in.handle = domain_handle;
-        r.out.handle = domain_handle;
-        
-        status = dcerpc_lsa_Close(p, mem_ctx, &r);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Close lsa domain failed - %s\n", nt_errstr(status));
-                return false;
-        }
-
-        return true;
-}
 
 
@@ -233 +39 @@
         NTSTATUS status;
         TALLOC_CTX *mem_ctx = NULL, *prep_mem_ctx;
-        struct libnet_context *ctx;
+        struct libnet_context *ctx = NULL;
         struct dcerpc_pipe *p;
         struct policy_handle h;
@@ -240 +46 @@
 
         prep_mem_ctx = talloc_init("prepare torture group info");
-
-        ctx = libnet_context_init(torture->ev, torture->lp_ctx);
-        ctx->cred = cmdline_credentials;
 
         status = torture_rpc_connection(torture,
@@ -251 +54 @@
         }
 
-        domain_name.string = lp_workgroup(torture->lp_ctx);
-        if (!test_opendomain(p, prep_mem_ctx, &h, &domain_name)) {
-                ret = false;
-                goto done;
-        }
-
-        if (!test_creategroup(p, prep_mem_ctx, &h, name)) {
+        domain_name.string = lpcfg_workgroup(torture->lp_ctx);
+        if (!test_domain_open(torture, p->binding_handle, &domain_name, prep_mem_ctx, &h, NULL)) {
+                ret = false;
+                goto done;
+        }
+
+        if (!test_group_create(torture, p->binding_handle, prep_mem_ctx, &h, name, NULL)) {
                 ret = false;
                 goto done;
@@ -263 +66 @@
 
         mem_ctx = talloc_init("torture group info");
+
+        if (!test_libnet_context_init(torture, true, &ctx)) {
+                return false;
+        }
 
         ZERO_STRUCT(req);
@@ -272 +79 @@
         status = libnet_GroupInfo(ctx, mem_ctx, &req);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("libnet_GroupInfo call failed: %s\n", nt_errstr(status));
-                ret = false;
-                goto done;
-        }
-
-        if (!test_cleanup(ctx->samr.pipe, mem_ctx, &ctx->samr.handle, TEST_GROUPNAME)) {
-                printf("cleanup failed\n");
-                ret = false;
-                goto done;
-        }
-
-        if (!test_samr_close(ctx->samr.pipe, mem_ctx, &ctx->samr.handle)) {
-                printf("domain close failed\n");
-                ret = false;
-        }
-
+                torture_comment(torture, "libnet_GroupInfo call failed: %s\n", nt_errstr(status));
+                ret = false;
+                goto done;
+        }
+
+        if (!test_group_cleanup(torture, ctx->samr.pipe->binding_handle,
+                                mem_ctx, &ctx->samr.handle, TEST_GROUPNAME)) {
+                torture_comment(torture, "cleanup failed\n");
+                ret = false;
+                goto done;
+        }
+
+        if (!test_samr_close_handle(torture,
+                                    ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
+                torture_comment(torture, "domain close failed\n");
+                ret = false;
+        }
+
+done:
         talloc_free(ctx);
-
-done:
         talloc_free(mem_ctx);
         return ret;
@@ -309 +117 @@
         ctx->cred = cmdline_credentials;
 
-        domain_name.string = lp_workgroup(torture->lp_ctx);
+        domain_name.string = lpcfg_workgroup(torture->lp_ctx);
         mem_ctx = talloc_init("torture group list");
 
         ZERO_STRUCT(req);
 
-        printf("listing group accounts:\n");
-        
+        torture_comment(torture, "listing group accounts:\n");
+
         do {
                 req.in.domain_name  = domain_name.string;
@@ -326 +134 @@
 
                 for (i = 0; i < req.out.count; i++) {
-                        printf("\tgroup: %s, sid=%s\n",
-                               req.out.groups[i].groupname, req.out.groups[i].sid);
+                        torture_comment(torture, "\tgroup: %s, sid=%s\n",
+                                        req.out.groups[i].groupname, req.out.groups[i].sid);
                 }
 
@@ -334 +142 @@
         if (!(NT_STATUS_IS_OK(status) ||
               NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES))) {
-                printf("libnet_GroupList call failed: %s\n", nt_errstr(status));
-                ret = false;
-                goto done;
-        }
-
-        if (!test_samr_close(ctx->samr.pipe, mem_ctx, &ctx->samr.handle)) {
-                printf("domain close failed\n");
-                ret = false;
-        }
-
-        if (!test_lsa_close(ctx->lsa.pipe, mem_ctx, &ctx->lsa.handle)) {
-                printf("lsa domain close failed\n");
+                torture_comment(torture, "libnet_GroupList call failed: %s\n", nt_errstr(status));
+                ret = false;
+                goto done;
+        }
+
+        if (!test_samr_close_handle(torture,
+                                    ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
+                torture_comment(torture, "domain close failed\n");
+                ret = false;
+        }
+
+        if (!test_lsa_close_handle(torture,
+                                   ctx->lsa.pipe->binding_handle, mem_ctx, &ctx->lsa.handle)) {
+                torture_comment(torture, "lsa domain close failed\n");
                 ret = false;
         }
@@ -371 +181 @@
 
         req.in.group_name = TEST_GROUPNAME;
-        req.in.domain_name = lp_workgroup(torture->lp_ctx);
+        req.in.domain_name = lpcfg_workgroup(torture->lp_ctx);
         req.out.error_string = NULL;
 
         status = libnet_CreateGroup(ctx, mem_ctx, &req);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("libnet_CreateGroup call failed: %s\n", nt_errstr(status));
-                ret = false;
-                goto done;
-        }
-
-        if (!test_cleanup(ctx->samr.pipe, mem_ctx, &ctx->samr.handle, TEST_GROUPNAME)) {
-                printf("cleanup failed\n");
-                ret = false;
-                goto done;
-        }
-
-        if (!test_samr_close(ctx->samr.pipe, mem_ctx, &ctx->samr.handle)) {
-                printf("domain close failed\n");
+                torture_comment(torture, "libnet_CreateGroup call failed: %s\n", nt_errstr(status));
+                ret = false;
+                goto done;
+        }
+
+        if (!test_group_cleanup(torture, ctx->samr.pipe->binding_handle,
+                                mem_ctx, &ctx->samr.handle, TEST_GROUPNAME)) {
+                torture_comment(torture, "cleanup failed\n");
+                ret = false;
+                goto done;
+        }
+
+        if (!test_samr_close_handle(torture,
+                                    ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
+                torture_comment(torture, "domain close failed\n");
                 ret = false;
         }

trunk/server/source4/torture/libnet/libnet_lookup.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    Test suite for libnet calls.
 
    Copyright (C) Rafal Szczesniak 2005
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -22 +22 @@
 #include "lib/cmdline/popt_common.h"
 #include "libnet/libnet.h"
-#include "librpc/gen_ndr/nbt.h"
-#include "librpc/rpc/dcerpc.h"
 #include "libcli/libcli.h"
-#include "torture/rpc/rpc.h"
-#include "torture/torture.h"
+#include "torture/rpc/torture_rpc.h"
 #include "param/param.h"
 
@@ -59 +56 @@
 
         if (!NT_STATUS_IS_OK(status)) {
-                printf("Couldn't lookup name %s: %s\n", lookup.in.hostname, nt_errstr(status));
+                torture_comment(torture, "Couldn't lookup name %s: %s\n", lookup.in.hostname, nt_errstr(status));
                 ret = false;
                 goto done;
@@ -66 +63 @@
         ret = true;
 
-        printf("Name [%s] found at address: %s.\n", lookup.in.hostname, *lookup.out.address);
+        torture_comment(torture, "Name [%s] found at address: %s.\n", lookup.in.hostname, *lookup.out.address);
 
 done:
@@ -102 +99 @@
 
         if (!NT_STATUS_IS_OK(status)) {
-                printf("Couldn't lookup host %s: %s\n", lookup.in.hostname, nt_errstr(status));
+                torture_comment(torture, "Couldn't lookup host %s: %s\n", lookup.in.hostname, nt_errstr(status));
                 ret = false;
                 goto done;
@@ -109 +106 @@
         ret = true;
 
-        printf("Host [%s] found at address: %s.\n", lookup.in.hostname, *lookup.out.address);
+        torture_comment(torture, "Host [%s] found at address: %s.\n", lookup.in.hostname, *lookup.out.address);
 
 done:
@@ -139 +136 @@
         }
 
-        lookup->in.domain_name = lp_workgroup(torture->lp_ctx);
+        lookup->in.domain_name = lpcfg_workgroup(torture->lp_ctx);
         lookup->in.name_type   = NBT_NAME_PDC;
 
@@ -145 +142 @@
 
         if (!NT_STATUS_IS_OK(status)) {
-                printf("Couldn't lookup pdc %s: %s\n", lookup->in.domain_name,
+                torture_comment(torture, "Couldn't lookup pdc %s: %s\n", lookup->in.domain_name,
                        nt_errstr(status));
                 ret = false;
@@ -153 +150 @@
         ret = true;
 
-        printf("DCs of domain [%s] found.\n", lookup->in.domain_name);
+        torture_comment(torture, "DCs of domain [%s] found.\n", lookup->in.domain_name);
         for (i = 0; i < lookup->out.num_dcs; i++) {
-                printf("\tDC[%d]: name=%s, address=%s\n", i, lookup->out.dcs[i].name,
+                torture_comment(torture, "\tDC[%d]: name=%s, address=%s\n", i, lookup->out.dcs[i].name,
                        lookup->out.dcs[i].address);
         }
@@ -179 +176 @@
 
         r.in.name = "Administrator";
-        r.in.domain_name = lp_workgroup(torture->lp_ctx);
+        r.in.domain_name = lpcfg_workgroup(torture->lp_ctx);
 
         status = libnet_LookupName(ctx, mem_ctx, &r);

trunk/server/source4/torture/libnet/libnet_rpc.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    Test suite for libnet calls.
 
    Copyright (C) Rafal Szczesniak 2005
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -21 +21 @@
 #include "includes.h"
 #include "lib/cmdline/popt_common.h"
-#include "auth/credentials/credentials.h"
 #include "libnet/libnet.h"
 #include "libcli/security/security.h"
-#include "librpc/ndr/libndr.h"
 #include "librpc/gen_ndr/ndr_lsa.h"
 #include "librpc/gen_ndr/ndr_samr.h"
 #include "librpc/gen_ndr/ndr_srvsvc.h"
-#include "librpc/rpc/dcerpc.h"
-#include "torture/rpc/rpc.h"
-#include "torture/torture.h"
+#include "torture/rpc/torture_rpc.h"
 #include "param/param.h"
 
 
-static bool test_connect_service(struct libnet_context *ctx,
+static bool test_connect_service(struct torture_context *tctx,
+                                 struct libnet_context *ctx,
                                  const struct ndr_interface_table *iface,
                                  const char *binding_string,
@@ -60 +57 @@
 
         if (!NT_STATUS_EQUAL(status, expected_status)) {
-                d_printf("Connecting to rpc service %s on %s.\n\tFAILED. Expected: %s."
+                torture_comment(tctx, "Connecting to rpc service %s on %s.\n\tFAILED. Expected: %s."
                        "Received: %s\n",
                        connect_r.in.dcerpc_iface->name, connect_r.in.binding, nt_errstr(expected_status),
@@ -68 +65 @@
         }
 
-        d_printf("PASSED. Expected: %s, received: %s\n", nt_errstr(expected_status),
+        torture_comment(tctx, "PASSED. Expected: %s, received: %s\n", nt_errstr(expected_status),
                nt_errstr(status));
 
         if (connect_r.level == LIBNET_RPC_CONNECT_DC_INFO && NT_STATUS_IS_OK(status)) {
-                d_printf("Domain Controller Info:\n");
-                d_printf("\tDomain Name:\t %s\n", connect_r.out.domain_name);
-                d_printf("\tDomain SID:\t %s\n", dom_sid_string(ctx, connect_r.out.domain_sid));
-                d_printf("\tRealm:\t\t %s\n", connect_r.out.realm);
-                d_printf("\tGUID:\t\t %s\n", GUID_string(ctx, connect_r.out.guid));
+                torture_comment(tctx, "Domain Controller Info:\n");
+                torture_comment(tctx, "\tDomain Name:\t %s\n", connect_r.out.domain_name);
+                torture_comment(tctx, "\tDomain SID:\t %s\n", dom_sid_string(ctx, connect_r.out.domain_sid));
+                torture_comment(tctx, "\tRealm:\t\t %s\n", connect_r.out.realm);
+                torture_comment(tctx, "\tGUID:\t\t %s\n", GUID_string(ctx, connect_r.out.guid));
 
         } else if (!NT_STATUS_IS_OK(status)) {
-                d_printf("Error string: %s\n", connect_r.out.error_string);
+                torture_comment(tctx, "Error string: %s\n", connect_r.out.error_string);
         }
 
@@ -94 +91 @@
         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
         ctx->cred = cmdline_credentials;
-        
-        d_printf("Testing connection to LSA interface\n");
-        if (!test_connect_service(ctx, &ndr_table_lsarpc, bindstr,
+
+        torture_comment(torture, "Testing connection to LSA interface\n");
+
+        if (!test_connect_service(torture, ctx, &ndr_table_lsarpc, bindstr,
                                   hostname, level, false, NT_STATUS_OK)) {
-                d_printf("failed to connect LSA interface\n");
-                return false;
-        }
-
-        d_printf("Testing connection to SAMR interface\n");
-        if (!test_connect_service(ctx, &ndr_table_samr, bindstr,
+                torture_comment(torture, "failed to connect LSA interface\n");
+                return false;
+        }
+
+        torture_comment(torture, "Testing connection to SAMR interface\n");
+        if (!test_connect_service(torture, ctx, &ndr_table_samr, bindstr,
                                   hostname, level, false, NT_STATUS_OK)) {
-                d_printf("failed to connect SAMR interface\n");
-                return false;
-        }
-
-        d_printf("Testing connection to SRVSVC interface\n");
-        if (!test_connect_service(ctx, &ndr_table_srvsvc, bindstr,
+                torture_comment(torture, "failed to connect SAMR interface\n");
+                return false;
+        }
+
+        torture_comment(torture, "Testing connection to SRVSVC interface\n");
+        if (!test_connect_service(torture, ctx, &ndr_table_srvsvc, bindstr,
                                   hostname, level, false, NT_STATUS_OK)) {
-                d_printf("failed to connect SRVSVC interface\n");
-                return false;
-        }
-
-        d_printf("Testing connection to LSA interface with wrong credentials\n");
-        if (!test_connect_service(ctx, &ndr_table_lsarpc, bindstr,
+                torture_comment(torture, "failed to connect SRVSVC interface\n");
+                return false;
+        }
+
+        torture_comment(torture, "Testing connection to LSA interface with wrong credentials\n");
+        if (!test_connect_service(torture, ctx, &ndr_table_lsarpc, bindstr,
                                   hostname, level, true, NT_STATUS_LOGON_FAILURE)) {
-                d_printf("failed to test wrong credentials on LSA interface\n");
-                return false;
-        }
-
-        d_printf("Testing connection to SAMR interface with wrong credentials\n");
-        if (!test_connect_service(ctx, &ndr_table_samr, bindstr,
+                torture_comment(torture, "failed to test wrong credentials on LSA interface\n");
+                return false;
+        }
+
+        torture_comment(torture, "Testing connection to SAMR interface with wrong credentials\n");
+        if (!test_connect_service(torture, ctx, &ndr_table_samr, bindstr,
                                   hostname, level, true, NT_STATUS_LOGON_FAILURE)) {
-                d_printf("failed to test wrong credentials on SAMR interface\n");
+                torture_comment(torture, "failed to test wrong credentials on SAMR interface\n");
                 return false;
         }
@@ -157 +155 @@
         struct dcerpc_binding *binding;
         const char *domain_name;
-        
+
         status = torture_rpc_binding(torture, &binding);
         if (!NT_STATUS_IS_OK(status)) {
@@ -166 +164 @@
            passed (it's going to be resolved to dc name and address) instead
            of specific server name. */
-        domain_name = lp_workgroup(torture->lp_ctx);
+        domain_name = lpcfg_workgroup(torture->lp_ctx);
         return torture_rpc_connect(torture, level, NULL, domain_name);
 }
@@ -177 +175 @@
         struct dcerpc_binding *binding;
         const char *domain_name;
-        
+
         status = torture_rpc_binding(torture, &binding);
         if (!NT_STATUS_IS_OK(status)) {
@@ -186 +184 @@
            passed (it's going to be resolved to dc name and address) instead
            of specific server name. */
-        domain_name = lp_workgroup(torture->lp_ctx);
+        domain_name = lpcfg_workgroup(torture->lp_ctx);
         return torture_rpc_connect(torture, level, NULL, domain_name);
 }
@@ -197 +195 @@
         struct dcerpc_binding *binding;
         const char *domain_name;
-        
+
         status = torture_rpc_binding(torture, &binding);
         if (!NT_STATUS_IS_OK(status)) {
@@ -206 +204 @@
            passed (it's going to be resolved to dc name and address) instead
            of specific server name. */
-        domain_name = lp_workgroup(torture->lp_ctx);
+        domain_name = lpcfg_workgroup(torture->lp_ctx);
         return torture_rpc_connect(torture, level, NULL, domain_name);
 }
@@ -217 +215 @@
         struct dcerpc_binding *binding;
         const char *bindstr;
-        
+
         status = torture_rpc_binding(torture, &binding);
         if (!NT_STATUS_IS_OK(status)) {

trunk/server/source4/torture/libnet/libnet_share.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    Test suite for libnet calls.
@@ -5 +5 @@
    Copyright (C) Gregory LEOCADIE <gleocadie@idealx.com> 2005
    Copyright (C) Rafal Szczesniak  2005
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -21 +21 @@
 
 #include "includes.h"
-#include "torture/rpc/rpc.h"
+#include "torture/rpc/torture_rpc.h"
 #include "libnet/libnet.h"
 #include "lib/cmdline/popt_common.h"
@@ -30 +30 @@
 
 
-static void test_displayshares(struct libnet_ListShares s)
+static void test_displayshares(struct torture_context *tctx,
+                               struct libnet_ListShares s)
 {
         int i, j;
@@ -56 +57 @@
                 for (i = 0; i < s.out.ctr.ctr0->count; i++) {
                         struct srvsvc_NetShareInfo0 *info = &s.out.ctr.ctr0->array[i];
-                        d_printf("\t[%d] %s\n", i, info->name);
+                        torture_comment(tctx, "\t[%d] %s\n", i, info->name);
                 }
                 break;
@@ -66 +67 @@
                                 if (share_types[j].type == info->type) break;
                         }
-                        d_printf("\t[%d] %s (%s)\t%s\n", i, info->name,
+                        torture_comment(tctx, "\t[%d] %s (%s)\t%s\n", i, info->name,
                                info->comment, share_types[j].desc);
                 }
@@ -77 +78 @@
                                 if (share_types[j].type == info->type) break;
                         }
-                        d_printf("\t[%d] %s\t%s\n\t    %s\n\t    [perms=0x%08x, max_usr=%d, cur_usr=%d, path=%s, pass=%s]\n",
+                        torture_comment(tctx, "\t[%d] %s\t%s\n\t    %s\n\t    [perms=0x%08x, max_usr=%d, cur_usr=%d, path=%s, pass=%s]\n",
                                  i, info->name, share_types[j].desc, info->comment,
                                  info->permissions, info->max_users,
@@ -91 +92 @@
                                 if (share_types[j].type == info->type) break;
                         }
-                        d_printf("\t[%d] %s\t%s [csc_policy=0x%08x]\n\t    %s\n", i, info->name,
+                        torture_comment(tctx, "\t[%d] %s\t%s [csc_policy=0x%08x]\n\t    %s\n", i, info->name,
                                  share_types[j].desc, info->csc_policy,
                                  info->comment);
@@ -103 +104 @@
                                 if (share_types[j].type == info->type) break;
                         }
-                        d_printf("\t[%d] %s\t%s\n\t    %s\n\t    [perms=0x%08x, max_usr=%d, cur_usr=%d, path=%s, pass=%s]\n",
+                        torture_comment(tctx, "\t[%d] %s\t%s\n\t    %s\n\t    [perms=0x%08x, max_usr=%d, cur_usr=%d, path=%s, pass=%s]\n",
                                  i, info->name, share_types[j].desc, info->comment,
                                  info->permissions, info->max_users,
@@ -134 +135 @@
         libnetctx = libnet_context_init(torture->ev, torture->lp_ctx);
         if (!libnetctx) {
-                printf("Couldn't allocate libnet context\n");
+                torture_comment(torture, "Couldn't allocate libnet context\n");
                 ret = false;
                 goto done;
@@ -140 +141 @@
 
         libnetctx->cred = cmdline_credentials;
-        
-        printf("Testing libnet_ListShare\n");
-        
+
+        torture_comment(torture, "Testing libnet_ListShare\n");
+
         share.in.server_name = talloc_asprintf(mem_ctx, "%s", binding->host);
 
         for (i = 0; i < ARRAY_SIZE(levels); i++) {
                 share.in.level = levels[i];
-                printf("testing libnet_ListShare level %u\n", share.in.level);
+                torture_comment(torture, "Testing libnet_ListShare level %u\n", share.in.level);
 
                 status = libnet_ListShares(libnetctx, mem_ctx, &share);
                 if (!NT_STATUS_IS_OK(status)) {
-                        printf("libnet_ListShare level %u failed - %s\n", share.in.level, share.out.error_string);
+                        torture_comment(torture, "libnet_ListShare level %u failed - %s\n", share.in.level, share.out.error_string);
                         ret = false;
                         goto done;
                 }
 
-                printf("listing shares:\n");
-                test_displayshares(share);
+                torture_comment(torture, "listing shares:\n");
+                test_displayshares(torture, share);
         }
 
@@ -166 +167 @@
 
 
-static bool test_addshare(struct dcerpc_pipe *svc_pipe, TALLOC_CTX *mem_ctx, const char *host,
+static bool test_addshare(struct torture_context *tctx,
+                          struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx, const char *host,
                           const char* share)
 {
@@ -173 +175 @@
         union srvsvc_NetShareInfo info;
         struct srvsvc_NetShareInfo2 i;
-        
+
         i.name         = share;
         i.type         = STYPE_DISKTREE;
@@ -189 +191 @@
         add.in.parm_error = NULL;
 
-        status = dcerpc_srvsvc_NetShareAdd(svc_pipe, mem_ctx, &add);
+        status = dcerpc_srvsvc_NetShareAdd_r(b, mem_ctx, &add);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("Failed to add a new share\n");
+                torture_comment(tctx, "Failed to add a new share\n");
                 return false;
         }
 
-        printf("share added\n");
+        torture_comment(tctx, "share added\n");
         return true;
 }
@@ -209 +211 @@
         bool ret = true;
         struct libnet_DelShare share;
-        
+
         host = torture_setting_string(torture, "host", NULL);
         status = torture_rpc_binding(torture, &binding);
@@ -223 +225 @@
         torture_assert_ntstatus_ok(torture, status, "Failed to get rpc connection");
 
-        if (!test_addshare(p, torture, host, TEST_SHARENAME)) {
+        if (!test_addshare(torture, p->binding_handle, torture, host, TEST_SHARENAME)) {
                 return false;
         }

trunk/server/source4/torture/libnet/libnet_user.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    Test suite for libnet calls.
 
    Copyright (C) Rafal Szczesniak 2005
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -25 +25 @@
 #include "librpc/gen_ndr/ndr_samr_c.h"
 #include "librpc/gen_ndr/ndr_lsa_c.h"
-#include "torture/torture.h"
-#include "torture/rpc/rpc.h"
+#include "torture/rpc/torture_rpc.h"
 #include "torture/libnet/usertest.h"
+#include "torture/libnet/proto.h"
 #include "param/param.h"
 
-
-static bool test_cleanup(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                         struct policy_handle *domain_handle, const char *username)
-{
-        NTSTATUS status;
-        struct samr_LookupNames r1;
-        struct samr_OpenUser r2;
-        struct samr_DeleteUser r3;
-        struct lsa_String names[2];
-        uint32_t rid;
-        struct policy_handle user_handle;
-        struct samr_Ids rids, types;
-
-        names[0].string = username;
-
-        r1.in.domain_handle  = domain_handle;
-        r1.in.num_names      = 1;
-        r1.in.names          = names;
-        r1.out.rids          = &rids;
-        r1.out.types         = &types;
-        
-        printf("user account lookup '%s'\n", username);
-
-        status = dcerpc_samr_LookupNames(p, mem_ctx, &r1);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("LookupNames failed - %s\n", nt_errstr(status));
-                return false;
-        }
-
-        rid = r1.out.rids->ids[0];
-        
-        r2.in.domain_handle  = domain_handle;
-        r2.in.access_mask    = SEC_FLAG_MAXIMUM_ALLOWED;
-        r2.in.rid            = rid;
-        r2.out.user_handle   = &user_handle;
-
-        printf("opening user account\n");
-
-        status = dcerpc_samr_OpenUser(p, mem_ctx, &r2);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("OpenUser failed - %s\n", nt_errstr(status));
-                return false;
-        }
-
-        r3.in.user_handle  = &user_handle;
-        r3.out.user_handle = &user_handle;
-
-        printf("deleting user account\n");
-        
-        status = dcerpc_samr_DeleteUser(p, mem_ctx, &r3);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("DeleteUser failed - %s\n", nt_errstr(status));
-                return false;
-        }
-
-        return true;
-}
-
-
-static bool test_opendomain(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                            struct policy_handle *handle, struct lsa_String *domname)
-{
-        NTSTATUS status;
-        struct policy_handle h, domain_handle;
-        struct samr_Connect r1;
-        struct samr_LookupDomain r2;
-        struct dom_sid2 *sid = NULL;
-        struct samr_OpenDomain r3;
-        
-        printf("connecting\n");
-        
-        r1.in.system_name = 0;
-        r1.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
-        r1.out.connect_handle = &h;
-        
-        status = dcerpc_samr_Connect(p, mem_ctx, &r1);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Connect failed - %s\n", nt_errstr(status));
-                return false;
-        }
-        
-        r2.in.connect_handle = &h;
-        r2.in.domain_name = domname;
-        r2.out.sid = &sid;
-
-        printf("domain lookup on %s\n", domname->string);
-
-        status = dcerpc_samr_LookupDomain(p, mem_ctx, &r2);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("LookupDomain failed - %s\n", nt_errstr(status));
-                return false;
-        }
-
-        r3.in.connect_handle = &h;
-        r3.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
-        r3.in.sid = *r2.out.sid;
-        r3.out.domain_handle = &domain_handle;
-
-        printf("opening domain\n");
-
-        status = dcerpc_samr_OpenDomain(p, mem_ctx, &r3);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("OpenDomain failed - %s\n", nt_errstr(status));
-                return false;
-        } else {
-                *handle = domain_handle;
-        }
-
-        return true;
-}
-
-
-static bool test_samr_close(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                            struct policy_handle *domain_handle)
-{
-        NTSTATUS status;
-        struct samr_Close r;
-  
-        r.in.handle = domain_handle;
-        r.out.handle = domain_handle;
-
-        status = dcerpc_samr_Close(p, mem_ctx, &r);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Close samr domain failed - %s\n", nt_errstr(status));
-                return false;
-        }
-        
-        return true;
-}
-
-
-static bool test_lsa_close(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                           struct policy_handle *domain_handle)
-{
-        NTSTATUS status;
-        struct lsa_Close r;
-
-        r.in.handle = domain_handle;
-        r.out.handle = domain_handle;
-        
-        status = dcerpc_lsa_Close(p, mem_ctx, &r);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Close lsa domain failed - %s\n", nt_errstr(status));
-                return false;
-        }
-
-        return true;
-}
-
-
-static bool test_createuser(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                            struct policy_handle *handle, const char* user)
-{
-        NTSTATUS status;
-        struct policy_handle user_handle;
-        struct lsa_String username;
-        struct samr_CreateUser r1;
-        struct samr_Close r2;
-        uint32_t user_rid;
-
-        username.string = user;
-        
-        r1.in.domain_handle = handle;
-        r1.in.account_name = &username;
-        r1.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
-        r1.out.user_handle = &user_handle;
-        r1.out.rid = &user_rid;
-
-        printf("creating user '%s'\n", username.string);
-        
-        status = dcerpc_samr_CreateUser(p, mem_ctx, &r1);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("CreateUser failed - %s\n", nt_errstr(status));
-
-                if (NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
-                        printf("User (%s) already exists - attempting to delete and recreate account again\n", user);
-                        if (!test_cleanup(p, mem_ctx, handle, TEST_USERNAME)) {
-                                return false;
-                        }
-
-                        printf("creating user account\n");
-                        
-                        status = dcerpc_samr_CreateUser(p, mem_ctx, &r1);
-                        if (!NT_STATUS_IS_OK(status)) {
-                                printf("CreateUser failed - %s\n", nt_errstr(status));
-                                return false;
-                        }
-                        return true;
-                }               
-                return false;
-        }
-
-        r2.in.handle = &user_handle;
-        r2.out.handle = &user_handle;
-        
-        printf("closing user '%s'\n", username.string);
-
-        status = dcerpc_samr_Close(p, mem_ctx, &r2);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Close failed - %s\n", nt_errstr(status));
-                return false;
-        }
-
-        return true;
-}
 
 
@@ -241 +36 @@
         NTSTATUS status;
         TALLOC_CTX *mem_ctx;
-        struct libnet_context *ctx;
+        struct libnet_context *ctx = NULL;
         struct libnet_CreateUser req;
         bool ret = true;
@@ -247 +42 @@
         mem_ctx = talloc_init("test_createuser");
 
-        ctx = libnet_context_init(torture->ev, torture->lp_ctx);
-        ctx->cred = cmdline_credentials;
+        if (!test_libnet_context_init(torture, true, &ctx)) {
+                return false;
+        }
 
         req.in.user_name = TEST_USERNAME;
-        req.in.domain_name = lp_workgroup(torture->lp_ctx);
+        req.in.domain_name = lpcfg_workgroup(torture->lp_ctx);
         req.out.error_string = NULL;
 
         status = libnet_CreateUser(ctx, mem_ctx, &req);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("libnet_CreateUser call failed: %s\n", nt_errstr(status));
-                ret = false;
-                goto done;
-        }
-
-        if (!test_cleanup(ctx->samr.pipe, mem_ctx, &ctx->samr.handle, TEST_USERNAME)) {
-                printf("cleanup failed\n");
-                ret = false;
-                goto done;
-        }
-
-        if (!test_samr_close(ctx->samr.pipe, mem_ctx, &ctx->samr.handle)) {
-                printf("domain close failed\n");
+                torture_comment(torture, "libnet_CreateUser call failed: %s\n", nt_errstr(status));
+                ret = false;
+                goto done;
+        }
+
+        if (!test_user_cleanup(torture, ctx->samr.pipe->binding_handle,
+                               mem_ctx, &ctx->samr.handle, TEST_USERNAME)) {
+                torture_comment(torture, "cleanup failed\n");
+                ret = false;
+                goto done;
+        }
+
+        if (!test_samr_close_handle(torture,
+                                    ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
+                torture_comment(torture, "domain close failed\n");
                 ret = false;
         }
@@ -283 +81 @@
         NTSTATUS status;
         struct dcerpc_pipe *p;
-        TALLOC_CTX *prep_mem_ctx, *mem_ctx;
+        TALLOC_CTX *mem_ctx;
         struct policy_handle h;
         struct lsa_String domain_name;
         const char *name = TEST_USERNAME;
-        struct libnet_context *ctx;
+        struct libnet_context *ctx = NULL;
         struct libnet_DeleteUser req;
-        bool ret = true;
-
-        prep_mem_ctx = talloc_init("prepare test_deleteuser");
-
-        ctx = libnet_context_init(torture->ev, torture->lp_ctx);
-        ctx->cred = cmdline_credentials;
-
-        req.in.user_name = TEST_USERNAME;
-        req.in.domain_name = lp_workgroup(torture->lp_ctx);
+        bool ret = false;
 
         status = torture_rpc_connection(torture,
                                         &p,
                                         &ndr_table_samr);
-        if (!NT_STATUS_IS_OK(status)) {
-                ret = false;
-                goto done;
-        }
-
-        domain_name.string = lp_workgroup(torture->lp_ctx);
-        if (!test_opendomain(p, prep_mem_ctx, &h, &domain_name)) {
-                ret = false;
-                goto done;
-        }
-
-        if (!test_createuser(p, prep_mem_ctx, &h, name)) {
-                ret = false;
-                goto done;
-        }
-
-        mem_ctx = talloc_init("test_deleteuser");
+        torture_assert_ntstatus_ok(torture, status, "torture_rpc_connection() failed");
+
+        mem_ctx = talloc_init("torture_deleteuser");
+
+        /*
+         * Pre-create a user to be deleted later
+         */
+        domain_name.string = lpcfg_workgroup(torture->lp_ctx);
+        ret = test_domain_open(torture, p->binding_handle, &domain_name, mem_ctx, &h, NULL);
+        torture_assert_goto(torture, ret, ret, done, "test_domain_open() failed");
+
+        ret = test_user_create(torture, p->binding_handle, mem_ctx, &h, name, NULL);
+        torture_assert_goto(torture, ret, ret, done, "test_user_create() failed");
+
+        /*
+         * Delete the user using libnet layer
+         */
+        ret = test_libnet_context_init(torture, true, &ctx);
+        torture_assert_goto(torture, ret, ret, done, "test_libnet_context_init() failed");
+
+        req.in.user_name = TEST_USERNAME;
+        req.in.domain_name = lpcfg_workgroup(torture->lp_ctx);
 
         status = libnet_DeleteUser(ctx, mem_ctx, &req);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("libnet_DeleteUser call failed: %s\n", nt_errstr(status));
-                ret = false;
-        }
-
-        talloc_free(mem_ctx);
+        torture_assert_ntstatus_ok_goto(torture, status, ret, done, "libnet_DeleteUser() failed");
+
+        /* mark test as successful */
+        ret = true;
 
 done:
         talloc_free(ctx);
-        talloc_free(prep_mem_ctx);
+        talloc_free(mem_ctx);
         return ret;
 }
@@ -339 +132 @@
 */
 
-static void set_test_changes(TALLOC_CTX *mem_ctx, struct libnet_ModifyUser *r,
+static void set_test_changes(struct torture_context *tctx,
+                             TALLOC_CTX *mem_ctx, struct libnet_ModifyUser *r,
                              int num_changes, char **user_name, enum test_fields req_change)
 {
@@ -352 +146 @@
         int i, testfld;
 
-        printf("Fields to change: [");
-
-        for (i = 0; i < num_changes && i < FIELDS_NUM; i++) {
+        torture_comment(tctx, "Fields to change: [");
+
+        for (i = 0; i < num_changes && i <= USER_FIELD_LAST; i++) {
                 const char *fldname;
 
-                testfld = (req_change == none) ? (random() % FIELDS_NUM) : req_change;
+                testfld = (req_change == none) ? (random() % USER_FIELD_LAST) + 1 : req_change;
 
                 /* get one in case we hit time field this time */
                 gettimeofday(&now, NULL);
-                
+
                 switch (testfld) {
-                case account_name:
+                case acct_name:
                         continue_if_field_set(r->in.account_name);
                         r->in.account_name = talloc_asprintf(mem_ctx, TEST_CHG_ACCOUNTNAME,
                                                              (int)(random() % 100));
                         fldname = "account_name";
-                        
+
                         /* update the test's user name in case it's about to change */
                         *user_name = talloc_strdup(mem_ctx, r->in.account_name);
                         break;
 
-                case full_name:
+                case acct_full_name:
                         continue_if_field_set(r->in.full_name);
                         r->in.full_name = talloc_asprintf(mem_ctx, TEST_CHG_FULLNAME,
@@ -380 +174 @@
                         break;
 
-                case description:
+                case acct_description:
                         continue_if_field_set(r->in.description);
                         r->in.description = talloc_asprintf(mem_ctx, TEST_CHG_DESCRIPTION,
@@ -387 +181 @@
                         break;
 
-                case home_directory:
+                case acct_home_directory:
                         continue_if_field_set(r->in.home_directory);
                         homedir = home_dirs[random() % ARRAY_SIZE(home_dirs)];
@@ -394 +188 @@
                         break;
 
-                case home_drive:
+                case acct_home_drive:
                         continue_if_field_set(r->in.home_drive);
                         homedrive = home_drives[random() % ARRAY_SIZE(home_drives)];
@@ -401 +195 @@
                         break;
 
-                case comment:
+                case acct_comment:
                         continue_if_field_set(r->in.comment);
                         r->in.comment = talloc_asprintf(mem_ctx, TEST_CHG_COMMENT,
@@ -408 +202 @@
                         break;
 
-                case logon_script:
+                case acct_logon_script:
                         continue_if_field_set(r->in.logon_script);
                         logonscript = logon_scripts[random() % ARRAY_SIZE(logon_scripts)];
@@ -414 +208 @@
                         fldname = "logon_script";
                         break;
-                        
-                case profile_path:
+
+                case acct_profile_path:
                         continue_if_field_set(r->in.profile_path);
                         r->in.profile_path = talloc_asprintf(mem_ctx, TEST_CHG_PROFILEPATH,
@@ -438 +232 @@
                         fldname = "unknown_field";
                 }
-                
-                printf(((i < num_changes - 1) ? "%s," : "%s"), fldname);
+
+                torture_comment(tctx, ((i < num_changes - 1) ? "%s," : "%s"), fldname);
 
                 /* disable requested field (it's supposed to be the only one used) */
@@ -445 +239 @@
         }
 
-        printf("]\n");
+        torture_comment(tctx, "]\n");
 }
 
@@ -451 +245 @@
 #define TEST_STR_FLD(fld) \
         if (!strequal(req.in.fld, user_req.out.fld)) { \
-                printf("failed to change '%s'\n", #fld); \
+                torture_comment(torture, "failed to change '%s'\n", #fld); \
                 ret = false; \
                 goto cleanup; \
@@ -458 +252 @@
 #define TEST_TIME_FLD(fld) \
         if (timeval_compare(req.in.fld, user_req.out.fld)) { \
-                printf("failed to change '%s'\n", #fld); \
+                torture_comment(torture, "failed to change '%s'\n", #fld); \
                 ret = false; \
                 goto cleanup; \
@@ -465 +259 @@
 #define TEST_NUM_FLD(fld) \
         if (req.in.fld != user_req.out.fld) { \
-                printf("failed to change '%s'\n", #fld); \
+                torture_comment(torture, "failed to change '%s'\n", #fld); \
                 ret = false; \
                 goto cleanup; \
@@ -474 +268 @@
 {
         NTSTATUS status;
-        struct dcerpc_binding *binding;
         struct dcerpc_pipe *p;
         TALLOC_CTX *prep_mem_ctx;
@@ -480 +273 @@
         struct lsa_String domain_name;
         char *name;
-        struct libnet_context *ctx;
+        struct libnet_context *ctx = NULL;
         struct libnet_ModifyUser req;
         struct libnet_UserInfo user_req;
         int fld;
         bool ret = true;
+        struct dcerpc_binding_handle *b;
 
         prep_mem_ctx = talloc_init("prepare test_deleteuser");
-
-        ctx = libnet_context_init(torture->ev, torture->lp_ctx);
-        ctx->cred = cmdline_credentials;
 
         status = torture_rpc_connection(torture,
@@ -498 +289 @@
                 goto done;
         }
+        b = p->binding_handle;
 
         name = talloc_strdup(prep_mem_ctx, TEST_USERNAME);
 
-        domain_name.string = lp_workgroup(torture->lp_ctx);
-        if (!test_opendomain(p, prep_mem_ctx, &h, &domain_name)) {
-                ret = false;
-                goto done;
-        }
-
-        if (!test_createuser(p, prep_mem_ctx, &h, name)) {
-                ret = false;
-                goto done;
-        }
-
-        status = torture_rpc_binding(torture, &binding);
-        if (!NT_STATUS_IS_OK(status)) {
-                ret = false;
-                goto done;
-        }
-
-        printf("Testing change of all fields - each single one in turn\n");
-
-        for (fld = 1; fld < FIELDS_NUM - 1; fld++) {
+        domain_name.string = lpcfg_workgroup(torture->lp_ctx);
+        if (!test_domain_open(torture, b, &domain_name, prep_mem_ctx, &h, NULL)) {
+                ret = false;
+                goto done;
+        }
+
+        if (!test_user_create(torture, b, prep_mem_ctx, &h, name, NULL)) {
+                ret = false;
+                goto done;
+        }
+
+        torture_comment(torture, "Testing change of all fields - each single one in turn\n");
+
+        if (!test_libnet_context_init(torture, true, &ctx)) {
+                return false;
+        }
+
+        for (fld = USER_FIELD_FIRST; fld <= USER_FIELD_LAST; fld++) {
                 ZERO_STRUCT(req);
-                req.in.domain_name = lp_workgroup(torture->lp_ctx);
+                req.in.domain_name = lpcfg_workgroup(torture->lp_ctx);
                 req.in.user_name = name;
 
-                set_test_changes(torture, &req, 1, &name, fld);
+                set_test_changes(torture, torture, &req, 1, &name, fld);
 
                 status = libnet_ModifyUser(ctx, torture, &req);
                 if (!NT_STATUS_IS_OK(status)) {
-                        printf("libnet_ModifyUser call failed: %s\n", nt_errstr(status));
+                        torture_comment(torture, "libnet_ModifyUser call failed: %s\n", nt_errstr(status));
                         ret = false;
                         continue;
@@ -535 +325 @@
 
                 ZERO_STRUCT(user_req);
-                user_req.in.domain_name = lp_workgroup(torture->lp_ctx);
+                user_req.in.domain_name = lpcfg_workgroup(torture->lp_ctx);
                 user_req.in.data.user_name = name;
                 user_req.in.level = USER_INFO_BY_NAME;
@@ -541 +331 @@
                 status = libnet_UserInfo(ctx, torture, &user_req);
                 if (!NT_STATUS_IS_OK(status)) {
-                        printf("libnet_UserInfo call failed: %s\n", nt_errstr(status));
+                        torture_comment(torture, "libnet_UserInfo call failed: %s\n", nt_errstr(status));
                         ret = false;
                         continue;
@@ -547 +337 @@
 
                 switch (fld) {
-                case account_name: TEST_STR_FLD(account_name);
-                        break;
-                case full_name: TEST_STR_FLD(full_name);
-                        break;
-                case comment: TEST_STR_FLD(comment);
-                        break;
-                case description: TEST_STR_FLD(description);
-                        break;
-                case home_directory: TEST_STR_FLD(home_directory);
-                        break;
-                case home_drive: TEST_STR_FLD(home_drive);
-                        break;
-                case logon_script: TEST_STR_FLD(logon_script);
-                        break;
-                case profile_path: TEST_STR_FLD(profile_path);
+                case acct_name: TEST_STR_FLD(account_name);
+                        break;
+                case acct_full_name: TEST_STR_FLD(full_name);
+                        break;
+                case acct_comment: TEST_STR_FLD(comment);
+                        break;
+                case acct_description: TEST_STR_FLD(description);
+                        break;
+                case acct_home_directory: TEST_STR_FLD(home_directory);
+                        break;
+                case acct_home_drive: TEST_STR_FLD(home_drive);
+                        break;
+                case acct_logon_script: TEST_STR_FLD(logon_script);
+                        break;
+                case acct_profile_path: TEST_STR_FLD(profile_path);
                         break;
                 case acct_expiry: TEST_TIME_FLD(acct_expiry);
@@ -570 +360 @@
                         break;
                 }
-
-                if (fld == account_name) {
-                        /* restore original testing username - it's useful when test fails
-                           because it prevents from problems with recreating account */
-                        ZERO_STRUCT(req);
-                        req.in.domain_name = lp_workgroup(torture->lp_ctx);
-                        req.in.user_name = name;
-                        req.in.account_name = TEST_USERNAME;
-                        
-                        status = libnet_ModifyUser(ctx, torture, &req);
-                        if (!NT_STATUS_IS_OK(status)) {
-                                printf("libnet_ModifyUser call failed: %s\n", nt_errstr(status));
-                                ret = false;
-                                goto done;
-                        }
-                        
-                        name = talloc_strdup(torture, TEST_USERNAME);
-                }
         }
 
 cleanup:
-        if (!test_cleanup(ctx->samr.pipe, torture, &ctx->samr.handle, name)) {
-                printf("cleanup failed\n");
-                ret = false;
-                goto done;
-        }
-
-        if (!test_samr_close(ctx->samr.pipe, torture, &ctx->samr.handle)) {
-                printf("domain close failed\n");
+        if (!test_user_cleanup(torture, ctx->samr.pipe->binding_handle,
+                               torture, &ctx->samr.handle, TEST_USERNAME)) {
+                torture_comment(torture, "cleanup failed\n");
+                ret = false;
+                goto done;
+        }
+
+        if (!test_samr_close_handle(torture,
+                                    ctx->samr.pipe->binding_handle, torture, &ctx->samr.handle)) {
+                torture_comment(torture, "domain close failed\n");
                 ret = false;
         }
@@ -615 +389 @@
         NTSTATUS status;
         TALLOC_CTX *mem_ctx = NULL, *prep_mem_ctx;
-        struct libnet_context *ctx;
+        struct libnet_context *ctx = NULL;
         struct dcerpc_pipe *p;
         struct policy_handle h;
         struct lsa_String domain_name;
         struct libnet_UserInfo req;
+        struct dcerpc_binding_handle *b;
 
         prep_mem_ctx = talloc_init("prepare torture user info");
-
-        ctx = libnet_context_init(torture->ev, torture->lp_ctx);
-        ctx->cred = cmdline_credentials;
 
         status = torture_rpc_connection(torture,
@@ -632 +404 @@
                 return false;
         }
-
-        domain_name.string = lp_workgroup(torture->lp_ctx);
-        if (!test_opendomain(p, prep_mem_ctx, &h, &domain_name)) {
-                ret = false;
-                goto done;
-        }
-
-        if (!test_createuser(p, prep_mem_ctx, &h, name)) {
+        b = p->binding_handle;
+
+        domain_name.string = lpcfg_workgroup(torture->lp_ctx);
+        if (!test_domain_open(torture, b, &domain_name, prep_mem_ctx, &h, NULL)) {
+                ret = false;
+                goto done;
+        }
+
+        if (!test_user_create(torture, b, prep_mem_ctx, &h, name, NULL)) {
                 ret = false;
                 goto done;
@@ -646 +419 @@
         mem_ctx = talloc_init("torture user info");
 
+        if (!test_libnet_context_init(torture, true, &ctx)) {
+                return false;
+        }
+
         ZERO_STRUCT(req);
-        
+
         req.in.domain_name = domain_name.string;
         req.in.data.user_name   = name;
@@ -654 +431 @@
         status = libnet_UserInfo(ctx, mem_ctx, &req);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("libnet_UserInfo call failed: %s\n", nt_errstr(status));
-                ret = false;
-                talloc_free(mem_ctx);
-                goto done;
-        }
-
-        if (!test_cleanup(ctx->samr.pipe, mem_ctx, &ctx->samr.handle, TEST_USERNAME)) {
-                printf("cleanup failed\n");
-                ret = false;
-                goto done;
-        }
-
-        if (!test_samr_close(ctx->samr.pipe, mem_ctx, &ctx->samr.handle)) {
-                printf("domain close failed\n");
-                ret = false;
-        }
-
+                torture_comment(torture, "libnet_UserInfo call failed: %s\n", nt_errstr(status));
+                ret = false;
+                goto done;
+        }
+
+        if (!test_user_cleanup(torture, ctx->samr.pipe->binding_handle,
+                               mem_ctx, &ctx->samr.handle, TEST_USERNAME)) {
+                torture_comment(torture, "cleanup failed\n");
+                ret = false;
+                goto done;
+        }
+
+        if (!test_samr_close_handle(torture,
+                                    ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
+                torture_comment(torture, "domain close failed\n");
+                ret = false;
+        }
+
+done:
         talloc_free(ctx);
-
-done:
         talloc_free(mem_ctx);
         return ret;
@@ -692 +469 @@
         ctx->cred = cmdline_credentials;
 
-        domain_name.string = lp_workgroup(torture->lp_ctx);
+        domain_name.string = lpcfg_workgroup(torture->lp_ctx);
         mem_ctx = talloc_init("torture user list");
 
         ZERO_STRUCT(req);
 
-        printf("listing user accounts:\n");
-        
+        torture_comment(torture, "listing user accounts:\n");
+
         do {
 
@@ -710 +487 @@
 
                 for (i = 0; i < req.out.count; i++) {
-                        printf("\tuser: %s, sid=%s\n",
-                               req.out.users[i].username, req.out.users[i].sid);
+                        torture_comment(torture, "\tuser: %s, sid=%s\n",
+                                        req.out.users[i].username, req.out.users[i].sid);
                 }
 
@@ -718 +495 @@
         if (!(NT_STATUS_IS_OK(status) ||
               NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES))) {
-                printf("libnet_UserList call failed: %s\n", nt_errstr(status));
-                ret = false;
-                goto done;
-        }
-
-        if (!test_samr_close(ctx->samr.pipe, mem_ctx, &ctx->samr.handle)) {
-                printf("samr domain close failed\n");
-                ret = false;
-                goto done;
-        }
-
-        if (!test_lsa_close(ctx->lsa.pipe, mem_ctx, &ctx->lsa.handle)) {
-                printf("lsa domain close failed\n");
+                torture_comment(torture, "libnet_UserList call failed: %s\n", nt_errstr(status));
+                ret = false;
+                goto done;
+        }
+
+        if (!test_samr_close_handle(torture,
+                                    ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
+                torture_comment(torture, "samr domain close failed\n");
+                ret = false;
+                goto done;
+        }
+
+        if (!test_lsa_close_handle(torture,
+                                   ctx->lsa.pipe->binding_handle, mem_ctx, &ctx->lsa.handle)) {
+                torture_comment(torture, "lsa domain close failed\n");
                 ret = false;
         }

trunk/server/source4/torture/libnet/userinfo.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    Test suite for libnet calls.
 
    Copyright (C) Rafal Szczesniak 2005
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -20 +20 @@
 
 #include "includes.h"
-#include "torture/rpc/rpc.h"
+#include "torture/rpc/torture_rpc.h"
 #include "libnet/libnet.h"
 #include "libcli/security/security.h"
 #include "librpc/gen_ndr/ndr_samr_c.h"
 #include "param/param.h"
-#include "torture/libnet/utils.h"
+#include "torture/libnet/proto.h"
 
 
 #define TEST_USERNAME  "libnetuserinfotest"
 
-static bool test_userinfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_userinfo(struct torture_context *tctx,
+                          struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
                           struct policy_handle *domain_handle,
                           struct dom_sid2 *domain_sid, const char* user_name,
@@ -39 +40 @@
         struct libnet_rpc_userinfo user;
         struct dom_sid *user_sid;
-        
+
         user_sid = dom_sid_add_rid(mem_ctx, domain_sid, *rid);
-        
+
         user.in.domain_handle = *domain_handle;
         user.in.sid           = dom_sid_string(mem_ctx, user_sid);
         user.in.level         = level;       /* this should be extended */
 
-        printf("Testing sync libnet_rpc_userinfo (SID argument)\n");
+        torture_comment(tctx, "Testing sync libnet_rpc_userinfo (SID argument)\n");
         status = libnet_rpc_userinfo(p, mem_ctx, &user);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Failed to call sync libnet_rpc_userinfo - %s\n", nt_errstr(status));
-                return false;
-        }
+        torture_assert_ntstatus_ok(tctx, status, "Calling sync libnet_rpc_userinfo() failed");
 
         ZERO_STRUCT(user);
@@ -57 +55 @@
         user.in.domain_handle = *domain_handle;
         user.in.sid           = NULL;
-        user.in.username      = TEST_USERNAME;
+        user.in.username      = user_name;
         user.in.level         = level;
 
-        printf("Testing sync libnet_rpc_userinfo (username argument)\n");
+        torture_comment(tctx, "Testing sync libnet_rpc_userinfo (username argument)\n");
         status = libnet_rpc_userinfo(p, mem_ctx, &user);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Failed to call sync libnet_rpc_userinfo - %s\n", nt_errstr(status));
-                return false;
-        }
+        torture_assert_ntstatus_ok(tctx, status, "Calling sync libnet_rpc_userinfo failed");
 
         return true;
@@ -71 +66 @@
 
 
-static bool test_userinfo_async(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_userinfo_async(struct torture_context *tctx,
+                                struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
                                 struct policy_handle *domain_handle,
                                 struct dom_sid2 *domain_sid, const char* user_name,
@@ -88 +84 @@
         user.in.level         = level;       /* this should be extended */
 
-        printf("Testing async libnet_rpc_userinfo (SID argument)\n");
+        torture_comment(tctx, "Testing async libnet_rpc_userinfo (SID argument)\n");
 
         c = libnet_rpc_userinfo_send(p, &user, msg_handler);
-        if (!c) {
-                printf("Failed to call sync libnet_rpc_userinfo_send\n");
-                return false;
-        }
+        torture_assert(tctx, c != NULL, "Failed to call async libnet_rpc_userinfo_send");
 
         status = libnet_rpc_userinfo_recv(c, mem_ctx, &user);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Calling async libnet_rpc_userinfo failed - %s\n", nt_errstr(status));
-                return false;
-        }
+        torture_assert_ntstatus_ok(tctx, status, "Calling async libnet_rpc_userinfo_recv failed");
 
         ZERO_STRUCT(user);
@@ -106 +96 @@
         user.in.domain_handle = *domain_handle;
         user.in.sid           = NULL;
-        user.in.username      = TEST_USERNAME;
+        user.in.username      = user_name;
         user.in.level         = level;
 
-        printf("Testing async libnet_rpc_userinfo (username argument)\n");
+        torture_comment(tctx, "Testing async libnet_rpc_userinfo (username argument)\n");
 
         c = libnet_rpc_userinfo_send(p, &user, msg_handler);
-        if (!c) {
-                printf("Failed to call sync libnet_rpc_userinfo_send\n");
-                return false;
-        }
+        torture_assert(tctx, c != NULL, "Failed to call async libnet_rpc_userinfo_send");
 
         status = libnet_rpc_userinfo_recv(c, mem_ctx, &user);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Calling async libnet_rpc_userinfo failed - %s\n", nt_errstr(status));
-                return false;
-        }
+        torture_assert_ntstatus_ok(tctx, status, "Calling async libnet_rpc_userinfo_recv failed");
 
         return true;
@@ -137 +121 @@
         struct dom_sid2 sid;
         uint32_t rid;
+        struct dcerpc_binding_handle *b;
 
         mem_ctx = talloc_init("test_userinfo");
 
-        status = torture_rpc_connection(torture, 
+        status = torture_rpc_connection(torture,
                                         &p,
                                         &ndr_table_samr);
-        
+
         if (!NT_STATUS_IS_OK(status)) {
                 return false;
         }
+        b = p->binding_handle;
 
-        name.string = lp_workgroup(torture->lp_ctx);
+        name.string = lpcfg_workgroup(torture->lp_ctx);
 
         /*
          * Testing synchronous version
          */
-        if (!test_opendomain(torture, p, mem_ctx, &h, &name, &sid)) {
+        if (!test_domain_open(torture, b, &name, mem_ctx, &h, &sid)) {
                 ret = false;
                 goto done;
         }
 
-        if (!test_user_create(torture, p, mem_ctx, &h, TEST_USERNAME, &rid)) {
+        if (!test_user_create(torture, b, mem_ctx, &h, TEST_USERNAME, &rid)) {
                 ret = false;
                 goto done;
         }
 
-        if (!test_userinfo(p, mem_ctx, &h, &sid, TEST_USERNAME, &rid)) {
+        if (!test_userinfo(torture, p, mem_ctx, &h, &sid, TEST_USERNAME, &rid)) {
                 ret = false;
                 goto done;
         }
 
-        if (!test_user_cleanup(torture, p, mem_ctx, &h, TEST_USERNAME)) {
+        if (!test_user_cleanup(torture, b, mem_ctx, &h, TEST_USERNAME)) {
                 ret = false;
                 goto done;
@@ -176 +162 @@
          * Testing asynchronous version and monitor messages
          */
-        if (!test_opendomain(torture, p, mem_ctx, &h, &name, &sid)) {
+        if (!test_domain_open(torture, b, &name, mem_ctx, &h, &sid)) {
                 ret = false;
                 goto done;
         }
 
-        if (!test_user_create(torture, p, mem_ctx, &h, TEST_USERNAME, &rid)) {
+        if (!test_user_create(torture, b, mem_ctx, &h, TEST_USERNAME, &rid)) {
                 ret = false;
                 goto done;
         }
 
-        if (!test_userinfo_async(p, mem_ctx, &h, &sid, TEST_USERNAME, &rid)) {
+        if (!test_userinfo_async(torture, p, mem_ctx, &h, &sid, TEST_USERNAME, &rid)) {
                 ret = false;
                 goto done;
         }
 
-        if (!test_user_cleanup(torture, p, mem_ctx, &h, TEST_USERNAME)) {
+        if (!test_user_cleanup(torture, b, mem_ctx, &h, TEST_USERNAME)) {
                 ret = false;
                 goto done;

trunk/server/source4/torture/libnet/userman.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    Test suite for libnet calls.
 
    Copyright (C) Rafal Szczesniak 2005
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -20 +20 @@
 
 #include "includes.h"
-#include "torture/rpc/rpc.h"
+#include "torture/rpc/torture_rpc.h"
 #include "torture/libnet/usertest.h"
 #include "libnet/libnet.h"
@@ -26 +26 @@
 #include "param/param.h"
 
-#include "torture/libnet/utils.h"
-
-
-static bool test_useradd(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+#include "torture/libnet/proto.h"
+
+
+static bool test_useradd(struct torture_context *tctx,
+                         struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
                          struct policy_handle *domain_handle,
                          const char *name)
@@ -36 +37 @@
         bool ret = true;
         struct libnet_rpc_useradd user;
-        
+
         user.in.domain_handle = *domain_handle;
         user.in.username      = name;
 
-        printf("Testing libnet_rpc_useradd\n");
+        torture_comment(tctx, "Testing libnet_rpc_useradd\n");
 
         status = libnet_rpc_useradd(p, mem_ctx, &user);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("Failed to call libnet_rpc_useradd - %s\n", nt_errstr(status));
+                torture_comment(tctx, "Failed to call libnet_rpc_useradd - %s\n", nt_errstr(status));
                 return false;
         }
-        
+
         return ret;
 }
 
 
-static bool test_useradd_async(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_useradd_async(struct torture_context *tctx,
+                               struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
                                struct policy_handle *handle, const char* username)
 {
@@ -61 +63 @@
         user.in.domain_handle = *handle;
         user.in.username      = username;
-        
-        printf("Testing async libnet_rpc_useradd\n");
-        
+
+        torture_comment(tctx, "Testing async libnet_rpc_useradd\n");
+
         c = libnet_rpc_useradd_send(p, &user, msg_handler);
         if (!c) {
-                printf("Failed to call async libnet_rpc_useradd\n");
+                torture_comment(tctx, "Failed to call async libnet_rpc_useradd\n");
                 return false;
         }
@@ -72 +74 @@
         status = libnet_rpc_useradd_recv(c, mem_ctx, &user);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("Calling async libnet_rpc_useradd failed - %s\n", nt_errstr(status));
+                torture_comment(tctx, "Calling async libnet_rpc_useradd failed - %s\n", nt_errstr(status));
                 return false;
         }
@@ -80 +82 @@
 }
 
-static bool test_usermod(struct torture_context *tctx, struct dcerpc_pipe *p, 
+static bool test_usermod(struct torture_context *tctx, struct dcerpc_pipe *p,
                          TALLOC_CTX *mem_ctx,
                          struct policy_handle *handle, int num_changes,
@@ -104 +106 @@
         mod->in.domain_handle = *handle;
 
-        torture_comment(tctx, "modifying user (%d simultaneous change(s))\n", 
+        torture_comment(tctx, "modifying user (%d simultaneous change(s))\n",
                         num_changes);
 
         torture_comment(tctx, "fields to change: [");
 
-        for (i = 0; i < num_changes && i < FIELDS_NUM - 1; i++) {
+        for (i = 0; i < num_changes && i <= USER_FIELD_LAST; i++) {
                 const char *fldname;
 
-                testfld = (random() % (FIELDS_NUM - 1)) + 1;
-
-                gettimeofday(&now, NULL);
+                testfld = (random() % USER_FIELD_LAST) + 1;
+
+                GetTimeOfDay(&now);
 
                 switch (testfld) {
-                case account_name:
+                case acct_name:
                         continue_if_field_set(mod->in.change.account_name);
                         mod->in.change.account_name = talloc_asprintf(mem_ctx, TEST_CHG_ACCOUNTNAME,
@@ -126 +128 @@
                         break;
 
-                case full_name:
+                case acct_full_name:
                         continue_if_field_set(mod->in.change.full_name);
                         mod->in.change.full_name = talloc_asprintf(mem_ctx, TEST_CHG_FULLNAME,
@@ -134 +136 @@
                         break;
 
-                case description:
+                case acct_description:
                         continue_if_field_set(mod->in.change.description);
                         mod->in.change.description = talloc_asprintf(mem_ctx, TEST_CHG_DESCRIPTION,
@@ -141 +143 @@
                         fldname = "description";
                         break;
-                        
-                case home_directory:
+
+                case acct_home_directory:
                         continue_if_field_set(mod->in.change.home_directory);
                         homedir = home_dirs[random() % (sizeof(home_dirs)/sizeof(char*))];
@@ -150 +152 @@
                         break;
 
-                case home_drive:
+                case acct_home_drive:
                         continue_if_field_set(mod->in.change.home_drive);
                         homedrive = home_drives[random() % (sizeof(home_drives)/sizeof(char*))];
@@ -158 +160 @@
                         break;
 
-                case comment:
+                case acct_comment:
                         continue_if_field_set(mod->in.change.comment);
                         mod->in.change.comment = talloc_asprintf(mem_ctx, TEST_CHG_COMMENT,
@@ -166 +168 @@
                         break;
 
-                case logon_script:
+                case acct_logon_script:
                         continue_if_field_set(mod->in.change.logon_script);
                         logonscript = logon_scripts[random() % (sizeof(logon_scripts)/sizeof(char*))];
@@ -174 +176 @@
                         break;
 
-                case profile_path:
+                case acct_profile_path:
                         continue_if_field_set(mod->in.change.profile_path);
                         mod->in.change.profile_path = talloc_asprintf(mem_ctx, TEST_CHG_PROFILEPATH,
@@ -213 +215 @@
 
 
-static bool test_userdel(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_userdel(struct torture_context *tctx,
+                         struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
                          struct policy_handle *handle, const char *username)
 {
         NTSTATUS status;
         struct libnet_rpc_userdel user;
-        
+
         user.in.domain_handle = *handle;
         user.in.username = username;
-        
+
         status = libnet_rpc_userdel(p, mem_ctx, &user);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("Failed to call sync libnet_rpc_userdel - %s\n", nt_errstr(status));
+                torture_comment(tctx, "Failed to call sync libnet_rpc_userdel - %s\n", nt_errstr(status));
                 return false;
         }
@@ -235 +238 @@
         if ((mod->in.change.fields & flags) && \
             !strequal(i->fld.string, mod->in.change.fld)) { \
-                printf("'%s' field does not match\n", #fld); \
-                printf("received: '%s'\n", i->fld.string); \
-                printf("expected: '%s'\n", mod->in.change.fld); \
+                torture_comment(tctx, "'%s' field does not match\n", #fld); \
+                torture_comment(tctx, "received: '%s'\n", i->fld.string); \
+                torture_comment(tctx, "expected: '%s'\n", mod->in.change.fld); \
                 return false; \
         }
@@ -246 +249 @@
                 nttime_to_timeval(&t, i->fld); \
                 if (timeval_compare(&t, mod->in.change.fld)) { \
-                        printf("'%s' field does not match\n", #fld); \
-                        printf("received: '%s (+%ld us)'\n", \
+                        torture_comment(tctx, "'%s' field does not match\n", #fld); \
+                        torture_comment(tctx, "received: '%s (+%ld us)'\n", \
                                timestring(mem_ctx, t.tv_sec), t.tv_usec); \
-                        printf("expected: '%s (+%ld us)'\n", \
+                        torture_comment(tctx, "expected: '%s (+%ld us)'\n", \
                                timestring(mem_ctx, mod->in.change.fld->tv_sec), \
                                mod->in.change.fld->tv_usec); \
@@ -259 +262 @@
         if ((mod->in.change.fields & flags) && \
             (i->fld != mod->in.change.fld)) { \
-                printf("'%s' field does not match\n", #fld); \
-                printf("received: '%04x'\n", i->fld); \
-                printf("expected: '%04x'\n", mod->in.change.fld); \
+                torture_comment(tctx, "'%s' field does not match\n", #fld); \
+                torture_comment(tctx, "received: '%04x'\n", i->fld); \
+                torture_comment(tctx, "expected: '%04x'\n", mod->in.change.fld); \
                 return false; \
         }
 
 
-static bool test_compare(struct torture_context *tctx, 
+static bool test_compare(struct torture_context *tctx,
                          struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
                          struct policy_handle *handle, struct libnet_rpc_usermod *mod,
@@ -312 +315 @@
         TALLOC_CTX *mem_ctx;
         bool ret = true;
+        struct dcerpc_binding_handle *b;
 
         mem_ctx = talloc_init("test_useradd");
 
-        status = torture_rpc_connection(torture, 
+        status = torture_rpc_connection(torture,
                                         &p,
                                         &ndr_table_samr);
-        
+
         torture_assert_ntstatus_ok(torture, status, "RPC connect failed");
-
-        domain_name.string = lp_workgroup(torture->lp_ctx);
-        if (!test_opendomain(torture, p, mem_ctx, &h, &domain_name, &sid)) {
-                ret = false;
-                goto done;
-        }
-
-        if (!test_useradd(p, mem_ctx, &h, name)) {
-                ret = false;
-                goto done;
-        }
-
-        if (!test_user_cleanup(torture, p, mem_ctx, &h, name)) {
-                ret = false;
-                goto done;
-        }
-
-        if (!test_opendomain(torture, p, mem_ctx, &h, &domain_name, &sid)) {
-                ret = false;
-                goto done;
-        }
-
-        if (!test_useradd_async(p, mem_ctx, &h, name)) {
-                ret = false;
-                goto done;
-        }
-
-        if (!test_user_cleanup(torture, p, mem_ctx, &h, name)) {
+        b = p->binding_handle;
+
+        domain_name.string = lpcfg_workgroup(torture->lp_ctx);
+        if (!test_domain_open(torture, b, &domain_name, mem_ctx, &h, &sid)) {
+                ret = false;
+                goto done;
+        }
+
+        if (!test_useradd(torture, p, mem_ctx, &h, name)) {
+                ret = false;
+                goto done;
+        }
+
+        if (!test_user_cleanup(torture, b, mem_ctx, &h, name)) {
+                ret = false;
+                goto done;
+        }
+
+        if (!test_domain_open(torture, b, &domain_name, mem_ctx, &h, &sid)) {
+                ret = false;
+                goto done;
+        }
+
+        if (!test_useradd_async(torture, p, mem_ctx, &h, name)) {
+                ret = false;
+                goto done;
+        }
+
+        if (!test_user_cleanup(torture, b, mem_ctx, &h, name)) {
                 ret = false;
                 goto done;
@@ -369 +374 @@
         TALLOC_CTX *mem_ctx;
         bool ret = true;
+        struct dcerpc_binding_handle *b;
 
         mem_ctx = talloc_init("test_userdel");
 
-        status = torture_rpc_connection(torture, 
+        status = torture_rpc_connection(torture,
                                         &p,
                                         &ndr_table_samr);
-        
+
         if (!NT_STATUS_IS_OK(status)) {
                 return false;
         }
-
-        domain_name.string = lp_workgroup(torture->lp_ctx);
-        if (!test_opendomain(torture, p, mem_ctx, &h, &domain_name, &sid)) {
-                ret = false;
-                goto done;
-        }
-
-        if (!test_user_create(torture, p, mem_ctx, &h, name, &rid)) {
-                ret = false;
-                goto done;
-        }
-        
-        if (!test_userdel(p, mem_ctx, &h, name)) {
-                ret = false;
-                goto done;
-        }
-        
+        b = p->binding_handle;
+
+        domain_name.string = lpcfg_workgroup(torture->lp_ctx);
+        if (!test_domain_open(torture, b, &domain_name, mem_ctx, &h, &sid)) {
+                ret = false;
+                goto done;
+        }
+
+        if (!test_user_create(torture, b, mem_ctx, &h, name, &rid)) {
+                ret = false;
+                goto done;
+        }
+
+        if (!test_userdel(torture, p, mem_ctx, &h, name)) {
+                ret = false;
+                goto done;
+        }
+
 done:
         talloc_free(mem_ctx);
@@ -414 +421 @@
         TALLOC_CTX *mem_ctx;
         bool ret = true;
+        struct dcerpc_binding_handle *b;
 
         mem_ctx = talloc_init("test_userdel");
 
-        status = torture_rpc_connection(torture, 
+        status = torture_rpc_connection(torture,
                                         &p,
                                         &ndr_table_samr);
-        
+
         torture_assert_ntstatus_ok(torture, status, "RPC connect");
-
-        domain_name.string = lp_workgroup(torture->lp_ctx);
+        b = p->binding_handle;
+
+        domain_name.string = lpcfg_workgroup(torture->lp_ctx);
         name = talloc_strdup(mem_ctx, TEST_USERNAME);
 
-        if (!test_opendomain(torture, p, mem_ctx, &h, &domain_name, &sid)) {
-                ret = false;
-                goto done;
-        }
-
-        if (!test_user_create(torture, p, mem_ctx, &h, name, &rid)) {
-                ret = false;
-                goto done;
-        }
-        
-        for (i = 1; i < FIELDS_NUM; i++) {
+        if (!test_domain_open(torture, b, &domain_name, mem_ctx, &h, &sid)) {
+                ret = false;
+                goto done;
+        }
+
+        if (!test_user_create(torture, b, mem_ctx, &h, name, &rid)) {
+                ret = false;
+                goto done;
+        }
+
+        for (i = USER_FIELD_FIRST; i <= USER_FIELD_LAST; i++) {
                 struct libnet_rpc_usermod m;
 
@@ -449 +458 @@
                 }
         }
-        
-cleanup:        
-        if (!test_user_cleanup(torture, p, mem_ctx, &h, name)) {
+
+cleanup:
+        if (!test_user_cleanup(torture, b, mem_ctx, &h, TEST_USERNAME)) {
                 ret = false;
                 goto done;

trunk/server/source4/torture/libnet/usertest.h

@@ -27 +27 @@
 
 
-#define FIELDS_NUM 11
-enum test_fields { none = 0, account_name, full_name, description, home_directory, home_drive,
-                   comment, logon_script, profile_path, acct_expiry, acct_flags };
+#define USER_FIELD_FIRST        acct_name
+#define USER_FIELD_LAST         acct_flags
+
+enum test_fields { none = 0,
+                   acct_name, acct_full_name, acct_description,
+                   acct_home_directory, acct_home_drive, acct_comment,
+                   acct_logon_script, acct_profile_path, acct_expiry, acct_flags };
 
 

trunk/server/source4/torture/libnet/utils.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    Test suite for libnet calls.
 
    Copyright (C) Rafal Szczesniak 2007
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -24 +24 @@
 
 #include "includes.h"
-#include "torture/rpc/rpc.h"
+#include "lib/cmdline/popt_common.h"
+#include "torture/rpc/torture_rpc.h"
 #include "libnet/libnet.h"
 #include "librpc/gen_ndr/ndr_samr_c.h"
-#include "torture/libnet/utils.h"
-
-
-bool test_opendomain(struct torture_context *tctx, 
-                     struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                     struct policy_handle *handle, struct lsa_String *domname,
-                     struct dom_sid2 *sid_p)
-{
-        NTSTATUS status;
-        struct policy_handle h, domain_handle;
+#include "librpc/gen_ndr/ndr_lsa_c.h"
+#include "torture/libnet/proto.h"
+#include "ldb_wrap.h"
+
+/**
+ * Opens handle on Domain using SAMR
+ *
+ * @param _domain_handle [out] Ptr to storage to store Domain handle
+ * @param _dom_sid [out] If NULL, Domain SID won't be returned
+ */
+bool test_domain_open(struct torture_context *tctx,
+                      struct dcerpc_binding_handle *b,
+                      struct lsa_String *domname,
+                      TALLOC_CTX *mem_ctx,
+                      struct policy_handle *_domain_handle,
+                      struct dom_sid2 *_dom_sid)
+{
+        struct policy_handle connect_handle;
+        struct policy_handle domain_handle;
         struct samr_Connect r1;
         struct samr_LookupDomain r2;
         struct dom_sid2 *sid = NULL;
         struct samr_OpenDomain r3;
-        
+
         torture_comment(tctx, "connecting\n");
-        
+
         r1.in.system_name = 0;
         r1.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
-        r1.out.connect_handle = &h;
-        
-        status = dcerpc_samr_Connect(p, mem_ctx, &r1);
-        torture_assert_ntstatus_ok(tctx, status, "Connect failed");
-        
-        r2.in.connect_handle = &h;
+        r1.out.connect_handle = &connect_handle;
+
+        torture_assert_ntstatus_ok(tctx,
+                                   dcerpc_samr_Connect_r(b, mem_ctx, &r1),
+                                   "Connect failed");
+        torture_assert_ntstatus_ok(tctx, r1.out.result,
+                                   "Connect failed");
+
+        r2.in.connect_handle = &connect_handle;
         r2.in.domain_name = domname;
         r2.out.sid = &sid;
@@ -57 +70 @@
         torture_comment(tctx, "domain lookup on %s\n", domname->string);
 
-        status = dcerpc_samr_LookupDomain(p, mem_ctx, &r2);
-        torture_assert_ntstatus_ok(tctx, status, "LookupDomain failed");
-
-        r3.in.connect_handle = &h;
+        torture_assert_ntstatus_ok(tctx,
+                                   dcerpc_samr_LookupDomain_r(b, mem_ctx, &r2),
+                                   "LookupDomain failed");
+        torture_assert_ntstatus_ok(tctx, r2.out.result,
+                                   "LookupDomain failed");
+
+        r3.in.connect_handle = &connect_handle;
         r3.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
         r3.in.sid = *r2.out.sid;
         r3.out.domain_handle = &domain_handle;
 
-        torture_comment(tctx, "opening domain\n");
-
-        status = dcerpc_samr_OpenDomain(p, mem_ctx, &r3);
-        torture_assert_ntstatus_ok(tctx, status, "OpenDomain failed");
-        *handle = domain_handle;
-
-        *sid_p = **r2.out.sid;
-        return true;
-}
-
-
-bool test_user_cleanup(struct torture_context *tctx, struct dcerpc_pipe *p, 
-                       TALLOC_CTX *mem_ctx, struct policy_handle *domain_handle,
-                       const char *name)
-{
-        NTSTATUS status;
+        torture_comment(tctx, "opening domain %s\n", domname->string);
+
+        torture_assert_ntstatus_ok(tctx,
+                                   dcerpc_samr_OpenDomain_r(b, mem_ctx, &r3),
+                                   "OpenDomain failed");
+        torture_assert_ntstatus_ok(tctx, r3.out.result,
+                                   "OpenDomain failed");
+
+        *_domain_handle = domain_handle;
+
+        if (_dom_sid) {
+                *_dom_sid = **r2.out.sid;
+        }
+
+        /* Close connect_handle, we don't need it anymore */
+        test_samr_close_handle(tctx, b, mem_ctx, &connect_handle);
+
+        return true;
+}
+
+
+/**
+ * Find out user's samAccountName for given
+ * user RDN. We need samAccountName value
+ * when deleting users.
+ */
+static bool _get_account_name_for_user_rdn(struct torture_context *tctx,
+                                           const char *user_rdn,
+                                           TALLOC_CTX *mem_ctx,
+                                           const char **_account_name)
+{
+        const char *url;
+        struct ldb_context *ldb;
+        TALLOC_CTX *tmp_ctx;
+        bool test_res = true;
+        const char *hostname = torture_setting_string(tctx, "host", NULL);
+        int ldb_ret;
+        struct ldb_result *ldb_res;
+        const char *account_name = NULL;
+        static const char *attrs[] = {
+                "samAccountName",
+                NULL
+        };
+
+        torture_assert(tctx, hostname != NULL, "Failed to get hostname");
+
+        tmp_ctx = talloc_new(tctx);
+        torture_assert(tctx, tmp_ctx != NULL, "Failed to create temporary mem context");
+
+        url = talloc_asprintf(tmp_ctx, "ldap://%s/", hostname);
+        torture_assert_goto(tctx, url != NULL, test_res, done, "Failed to allocate URL for ldb");
+
+        ldb = ldb_wrap_connect(tmp_ctx,
+                               tctx->ev, tctx->lp_ctx,
+                               url, NULL, cmdline_credentials, 0);
+        torture_assert_goto(tctx, ldb != NULL, test_res, done, "Failed to make LDB connection");
+
+        ldb_ret = ldb_search(ldb, tmp_ctx, &ldb_res,
+                             ldb_get_default_basedn(ldb), LDB_SCOPE_SUBTREE,
+                             attrs,
+                             "(&(objectClass=user)(name=%s))", user_rdn);
+        if (LDB_SUCCESS == ldb_ret && 1 == ldb_res->count) {
+                account_name = ldb_msg_find_attr_as_string(ldb_res->msgs[0], "samAccountName", NULL);
+        }
+
+        /* return user_rdn by default */
+        if (!account_name) {
+                account_name = user_rdn;
+        }
+
+        /* duplicate memory in parent context */
+        *_account_name = talloc_strdup(mem_ctx, account_name);
+
+done:
+        talloc_free(tmp_ctx);
+        return test_res;
+}
+
+/**
+ * Removes user by RDN through SAMR interface.
+ *
+ * @param domain_handle [in] Domain handle
+ * @param user_rdn [in] User's RDN in ldap database
+ */
+bool test_user_cleanup(struct torture_context *tctx,
+                       struct dcerpc_binding_handle *b,
+                       TALLOC_CTX *mem_ctx,
+                       struct policy_handle *domain_handle,
+                       const char *user_rdn)
+{
         struct samr_LookupNames r1;
         struct samr_OpenUser r2;
@@ -88 +178 @@
         struct policy_handle user_handle;
         struct samr_Ids rids, types;
-
-        names[0].string = name;
+        const char *account_name;
+
+        if (!_get_account_name_for_user_rdn(tctx, user_rdn, mem_ctx, &account_name)) {
+                torture_result(tctx, TORTURE_FAIL,
+                               __location__": Failed to find samAccountName for %s", user_rdn);
+                return false;
+        }
+
+        names[0].string = account_name;
 
         r1.in.domain_handle  = domain_handle;
@@ -96 +193 @@
         r1.out.rids          = &rids;
         r1.out.types         = &types;
-        
-        torture_comment(tctx, "user account lookup '%s'\n", name);
-
-        status = dcerpc_samr_LookupNames(p, mem_ctx, &r1);
-        torture_assert_ntstatus_ok(tctx, status, "LookupNames failed");
+
+        torture_comment(tctx, "user account lookup '%s'\n", account_name);
+
+        torture_assert_ntstatus_ok(tctx,
+                                   dcerpc_samr_LookupNames_r(b, mem_ctx, &r1),
+                                   "LookupNames failed");
+        torture_assert_ntstatus_ok(tctx, r1.out.result,
+                                   "LookupNames failed");
 
         rid = r1.out.rids->ids[0];
-        
+
         r2.in.domain_handle  = domain_handle;
         r2.in.access_mask    = SEC_FLAG_MAXIMUM_ALLOWED;
@@ -111 +211 @@
         torture_comment(tctx, "opening user account\n");
 
-        status = dcerpc_samr_OpenUser(p, mem_ctx, &r2);
-        torture_assert_ntstatus_ok(tctx, status, "OpenUser failed");
+        torture_assert_ntstatus_ok(tctx,
+                                   dcerpc_samr_OpenUser_r(b, mem_ctx, &r2),
+                                   "OpenUser failed");
+        torture_assert_ntstatus_ok(tctx, r2.out.result,
+                                   "OpenUser failed");
 
         r3.in.user_handle  = &user_handle;
@@ -118 +221 @@
 
         torture_comment(tctx, "deleting user account\n");
-        
-        status = dcerpc_samr_DeleteUser(p, mem_ctx, &r3);
-        torture_assert_ntstatus_ok(tctx, status, "DeleteUser failed");
-        
-        return true;
-}
-
-
-bool test_user_create(struct torture_context *tctx, 
-                      struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                      struct policy_handle *handle, const char *name,
+
+        torture_assert_ntstatus_ok(tctx,
+                                   dcerpc_samr_DeleteUser_r(b, mem_ctx, &r3),
+                                   "DeleteUser failed");
+        torture_assert_ntstatus_ok(tctx, r3.out.result,
+                                   "DeleteUser failed");
+
+        return true;
+}
+
+
+/**
+ * Creates new user using SAMR
+ *
+ * @param name [in] Username for user to create
+ * @param rid [out] If NULL, User's RID is not returned
+ */
+bool test_user_create(struct torture_context *tctx,
+                      struct dcerpc_binding_handle *b,
+                      TALLOC_CTX *mem_ctx,
+                      struct policy_handle *domain_handle,
+                      const char *name,
                       uint32_t *rid)
 {
-        NTSTATUS status;
+        struct policy_handle user_handle;
         struct lsa_String username;
         struct samr_CreateUser r;
-        struct policy_handle user_handle;
-        
+        uint32_t user_rid;
+
         username.string = name;
-        
-        r.in.domain_handle = handle;
+
+        r.in.domain_handle = domain_handle;
         r.in.account_name  = &username;
         r.in.access_mask   = SEC_FLAG_MAXIMUM_ALLOWED;
         r.out.user_handle  = &user_handle;
-        r.out.rid          = rid;
-
-        torture_comment(tctx, "creating user account %s\n", name);
-
-        status = dcerpc_samr_CreateUser(p, mem_ctx, &r);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("CreateUser failed - %s\n", nt_errstr(status));
-
-                if (NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
-                        torture_comment(tctx, "User (%s) already exists - attempting to delete and recreate account again\n", name);
-                        if (!test_user_cleanup(tctx, p, mem_ctx, handle, name)) {
+        /* return user's RID only if requested */
+        r.out.rid          = rid ? rid : &user_rid;
+
+        torture_comment(tctx, "creating user '%s'\n", username.string);
+
+        torture_assert_ntstatus_ok(tctx,
+                                   dcerpc_samr_CreateUser_r(b, mem_ctx, &r),
+                                   "CreateUser RPC call failed");
+        if (!NT_STATUS_IS_OK(r.out.result)) {
+                torture_comment(tctx, "CreateUser failed - %s\n", nt_errstr(r.out.result));
+
+                if (NT_STATUS_EQUAL(r.out.result, NT_STATUS_USER_EXISTS)) {
+                        torture_comment(tctx,
+                                        "User (%s) already exists - "
+                                        "attempting to delete and recreate account again\n",
+                                        username.string);
+                        if (!test_user_cleanup(tctx, b, mem_ctx, domain_handle, username.string)) {
                                 return false;
                         }
 
                         torture_comment(tctx, "creating user account\n");
-                        
-                        status = dcerpc_samr_CreateUser(p, mem_ctx, &r);
-                        torture_assert_ntstatus_ok(tctx, status, "CreateUser failed");
+
+                        torture_assert_ntstatus_ok(tctx,
+                                                   dcerpc_samr_CreateUser_r(b, mem_ctx, &r),
+                                                   "CreateUser RPC call failed");
+                        torture_assert_ntstatus_ok(tctx, r.out.result,
+                                                   "CreateUser failed");
+
+                        /* be nice and close opened handles */
+                        test_samr_close_handle(tctx, b, mem_ctx, &user_handle);
+
                         return true;
                 }
@@ -165 +292 @@
         }
 
-        return true;
-}
-
-
-bool test_group_cleanup(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+        /* be nice and close opened handles */
+        test_samr_close_handle(tctx, b, mem_ctx, &user_handle);
+
+        return true;
+}
+
+
+/**
+ * Deletes a Group using SAMR interface
+ */
+bool test_group_cleanup(struct torture_context *tctx,
+                        struct dcerpc_binding_handle *b,
+                        TALLOC_CTX *mem_ctx,
                         struct policy_handle *domain_handle,
                         const char *name)
 {
-        NTSTATUS status;
         struct samr_LookupNames r1;
         struct samr_OpenGroup r2;
@@ -189 +323 @@
         r1.out.rids          = &rids;
         r1.out.types         = &types;
-        
-        printf("group account lookup '%s'\n", name);
-
-        status = dcerpc_samr_LookupNames(p, mem_ctx, &r1);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("LookupNames failed - %s\n", nt_errstr(status));
-                return false;
-        }
+
+        torture_comment(tctx, "group account lookup '%s'\n", name);
+
+        torture_assert_ntstatus_ok(tctx,
+                                   dcerpc_samr_LookupNames_r(b, mem_ctx, &r1),
+                                   "LookupNames failed");
+        torture_assert_ntstatus_ok(tctx, r1.out.result,
+                                   "LookupNames failed");
 
         rid = r1.out.rids->ids[0];
-        
+
         r2.in.domain_handle  = domain_handle;
         r2.in.access_mask    = SEC_FLAG_MAXIMUM_ALLOWED;
@@ -205 +339 @@
         r2.out.group_handle  = &group_handle;
 
-        printf("opening group account\n");
-
-        status = dcerpc_samr_OpenGroup(p, mem_ctx, &r2);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("OpenGroup failed - %s\n", nt_errstr(status));
-                return false;
-        }
+        torture_comment(tctx, "opening group account\n");
+
+        torture_assert_ntstatus_ok(tctx,
+                                   dcerpc_samr_OpenGroup_r(b, mem_ctx, &r2),
+                                   "OpenGroup failed");
+        torture_assert_ntstatus_ok(tctx, r2.out.result,
+                                   "OpenGroup failed");
 
         r3.in.group_handle  = &group_handle;
         r3.out.group_handle = &group_handle;
 
-        printf("deleting group account\n");
-        
-        status = dcerpc_samr_DeleteDomainGroup(p, mem_ctx, &r3);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("DeleteGroup failed - %s\n", nt_errstr(status));
-                return false;
-        }
-        
-        return true;
-}
-
-
-bool test_group_create(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                       struct policy_handle *handle, const char *name,
+        torture_comment(tctx, "deleting group account\n");
+
+        torture_assert_ntstatus_ok(tctx,
+                                   dcerpc_samr_DeleteDomainGroup_r(b, mem_ctx, &r3),
+                                   "DeleteGroup failed");
+        torture_assert_ntstatus_ok(tctx, r3.out.result,
+                                   "DeleteGroup failed");
+
+        return true;
+}
+
+
+/**
+ * Creates a Group object using SAMR interface
+ *
+ * @param group_name [in] Name of the group to create
+ * @param rid [out] RID of group created. May be NULL in
+ *                  which case RID is not required by caller
+ */
+bool test_group_create(struct torture_context *tctx,
+                       struct dcerpc_binding_handle *b,
+                       TALLOC_CTX *mem_ctx,
+                       struct policy_handle *handle,
+                       const char *group_name,
                        uint32_t *rid)
 {
-        NTSTATUS status;
+        uint32_t group_rid;
         struct lsa_String groupname;
         struct samr_CreateDomainGroup r;
         struct policy_handle group_handle;
-        
-        groupname.string = name;
-        
+
+        groupname.string = group_name;
+
         r.in.domain_handle  = handle;
         r.in.name           = &groupname;
         r.in.access_mask    = SEC_FLAG_MAXIMUM_ALLOWED;
         r.out.group_handle  = &group_handle;
-        r.out.rid           = rid;
-
-        printf("creating group account %s\n", name);
-
-        status = dcerpc_samr_CreateDomainGroup(p, mem_ctx, &r);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("CreateGroup failed - %s\n", nt_errstr(status));
-
-                if (NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
-                        printf("Group (%s) already exists - attempting to delete and recreate account again\n", name);
-                        if (!test_group_cleanup(p, mem_ctx, handle, name)) {
+        /* use local variable in case caller
+         * don't care about the group RID */
+        r.out.rid           = rid ? rid : &group_rid;
+
+        torture_comment(tctx, "creating group account %s\n", group_name);
+
+        torture_assert_ntstatus_ok(tctx,
+                                   dcerpc_samr_CreateDomainGroup_r(b, mem_ctx, &r),
+                                   "CreateGroup failed");
+        if (!NT_STATUS_IS_OK(r.out.result)) {
+                torture_comment(tctx, "CreateGroup failed - %s\n", nt_errstr(r.out.result));
+
+                if (NT_STATUS_EQUAL(r.out.result, NT_STATUS_GROUP_EXISTS)) {
+                        torture_comment(tctx,
+                                        "Group (%s) already exists - "
+                                        "attempting to delete and recreate group again\n",
+                                        group_name);
+                        if (!test_group_cleanup(tctx, b, mem_ctx, handle, group_name)) {
                                 return false;
                         }
 
-                        printf("creating group account\n");
-                        
-                        status = dcerpc_samr_CreateDomainGroup(p, mem_ctx, &r);
-                        if (!NT_STATUS_IS_OK(status)) {
-                                printf("CreateGroup failed - %s\n", nt_errstr(status));
-                                return false;
-                        }
+                        torture_comment(tctx, "creating group account\n");
+
+                        torture_assert_ntstatus_ok(tctx,
+                                                   dcerpc_samr_CreateDomainGroup_r(b, mem_ctx, &r),
+                                                   "CreateGroup failed");
+                        torture_assert_ntstatus_ok(tctx, r.out.result,
+                                                   "CreateGroup failed");
+
+                        /* be nice and close opened handles */
+                        test_samr_close_handle(tctx, b, mem_ctx, &group_handle);
+
                         return true;
                 }
@@ -269 +424 @@
         }
 
-        return true;
+        /* be nice and close opened handles */
+        test_samr_close_handle(tctx, b, mem_ctx, &group_handle);
+
+        return true;
+}
+
+/**
+ * Closes SAMR handle obtained from Connect, Open User/Domain, etc
+ */
+bool test_samr_close_handle(struct torture_context *tctx,
+                            struct dcerpc_binding_handle *b,
+                            TALLOC_CTX *mem_ctx,
+                            struct policy_handle *samr_handle)
+{
+        struct samr_Close r;
+
+        r.in.handle = samr_handle;
+        r.out.handle = samr_handle;
+
+        torture_assert_ntstatus_ok(tctx,
+                                   dcerpc_samr_Close_r(b, mem_ctx, &r),
+                                   "Close SAMR handle RPC call failed");
+        torture_assert_ntstatus_ok(tctx, r.out.result,
+                                   "Close SAMR handle failed");
+
+        return true;
+}
+
+/**
+ * Closes LSA handle obtained from Connect, Open Group, etc
+ */
+bool test_lsa_close_handle(struct torture_context *tctx,
+                           struct dcerpc_binding_handle *b,
+                           TALLOC_CTX *mem_ctx,
+                           struct policy_handle *lsa_handle)
+{
+        struct lsa_Close r;
+
+        r.in.handle = lsa_handle;
+        r.out.handle = lsa_handle;
+
+        torture_assert_ntstatus_ok(tctx,
+                                   dcerpc_lsa_Close_r(b, mem_ctx, &r),
+                                   "Close LSA handle RPC call failed");
+        torture_assert_ntstatus_ok(tctx, r.out.result,
+                                   "Close LSA handle failed");
+
+        return true;
+}
+
+/**
+ * Create and initialize libnet_context Context.
+ * Use this function in cases where we need to have SAMR and LSA pipes
+ * of libnet_context to be connected before executing any other
+ * libnet call
+ *
+ * @param rpc_connect [in] Connects SAMR and LSA pipes
+ */
+bool test_libnet_context_init(struct torture_context *tctx,
+                              bool rpc_connect,
+                              struct libnet_context **_net_ctx)
+{
+        NTSTATUS status;
+        bool bret = true;
+        struct libnet_context *net_ctx;
+
+        net_ctx = libnet_context_init(tctx->ev, tctx->lp_ctx);
+        torture_assert(tctx, net_ctx != NULL, "Failed to create libnet_context");
+
+        /* Use command line credentials for testing */
+        net_ctx->cred = cmdline_credentials;
+
+        if (rpc_connect) {
+                /* connect SAMR pipe */
+                status = torture_rpc_connection(tctx,
+                                                &net_ctx->samr.pipe,
+                                                &ndr_table_samr);
+                torture_assert_ntstatus_ok_goto(tctx, status, bret, done,
+                                                "Failed to connect SAMR pipe");
+
+                net_ctx->samr.samr_handle = net_ctx->samr.pipe->binding_handle;
+
+                /* connect LSARPC pipe */
+                status = torture_rpc_connection(tctx,
+                                                &net_ctx->lsa.pipe,
+                                                &ndr_table_lsarpc);
+                torture_assert_ntstatus_ok_goto(tctx, status, bret, done,
+                                                "Failed to connect LSA pipe");
+
+                net_ctx->lsa.lsa_handle = net_ctx->lsa.pipe->binding_handle;
+        }
+
+        *_net_ctx = net_ctx;
+
+done:
+        if (!bret) {
+                /* a previous call has failed,
+                 * clean up memory before exit */
+                talloc_free(net_ctx);
+        }
+        return bret;
 }