2 Unix SMB/CIFS implementation.
3 Test suite for libnet calls.
5 Copyright (C) Rafal Szczesniak 2007
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "lib/cmdline/popt_common.h"
24 #include "libnet/libnet.h"
25 #include "librpc/gen_ndr/ndr_samr_c.h"
26 #include "librpc/gen_ndr/ndr_lsa_c.h"
27 #include "torture/rpc/torture_rpc.h"
28 #include "param/param.h"
31 #define TEST_GROUPNAME "libnetgrouptest"
34 static bool test_cleanup(struct torture_context *tctx,
35 struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
36 struct policy_handle *domain_handle, const char *groupname)
38 struct samr_LookupNames r1;
39 struct samr_OpenGroup r2;
40 struct samr_DeleteDomainGroup r3;
41 struct lsa_String names[2];
43 struct policy_handle group_handle;
44 struct samr_Ids rids, types;
46 names[0].string = groupname;
48 r1.in.domain_handle = domain_handle;
52 r1.out.types = &types;
54 torture_comment(tctx, "group account lookup '%s'\n", groupname);
56 torture_assert_ntstatus_ok(tctx,
57 dcerpc_samr_LookupNames_r(b, mem_ctx, &r1),
58 "LookupNames failed");
59 torture_assert_ntstatus_ok(tctx, r1.out.result,
60 "LookupNames failed");
62 rid = r1.out.rids->ids[0];
64 r2.in.domain_handle = domain_handle;
65 r2.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
67 r2.out.group_handle = &group_handle;
69 torture_comment(tctx, "opening group account\n");
71 torture_assert_ntstatus_ok(tctx,
72 dcerpc_samr_OpenGroup_r(b, mem_ctx, &r2),
74 torture_assert_ntstatus_ok(tctx, r2.out.result,
77 r3.in.group_handle = &group_handle;
78 r3.out.group_handle = &group_handle;
80 torture_comment(tctx, "deleting group account\n");
82 torture_assert_ntstatus_ok(tctx,
83 dcerpc_samr_DeleteDomainGroup_r(b, mem_ctx, &r3),
84 "DeleteGroup failed");
85 torture_assert_ntstatus_ok(tctx, r3.out.result,
86 "DeleteGroup failed");
92 static bool test_creategroup(struct torture_context *tctx,
93 struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
94 struct policy_handle *handle, const char *name)
96 struct lsa_String groupname;
97 struct samr_CreateDomainGroup r;
98 struct policy_handle group_handle;
101 groupname.string = name;
103 r.in.domain_handle = handle;
104 r.in.name = &groupname;
105 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
106 r.out.group_handle = &group_handle;
107 r.out.rid = &group_rid;
109 torture_comment(tctx, "creating group account %s\n", name);
111 torture_assert_ntstatus_ok(tctx,
112 dcerpc_samr_CreateDomainGroup_r(b, mem_ctx, &r),
113 "CreateGroup failed");
115 if (!NT_STATUS_IS_OK(r.out.result)) {
116 torture_comment(tctx, "CreateGroup failed - %s\n", nt_errstr(r.out.result));
118 if (NT_STATUS_EQUAL(r.out.result, NT_STATUS_GROUP_EXISTS)) {
119 torture_comment(tctx, "Group (%s) already exists - attempting to delete and recreate group again\n", name);
120 if (!test_cleanup(tctx, b, mem_ctx, handle, TEST_GROUPNAME)) {
124 torture_comment(tctx, "creating group account\n");
126 torture_assert_ntstatus_ok(tctx,
127 dcerpc_samr_CreateDomainGroup_r(b, mem_ctx, &r),
128 "CreateGroup failed");
129 torture_assert_ntstatus_ok(tctx, r.out.result,
130 "CreateGroup failed");
141 static bool test_opendomain(struct torture_context *tctx,
142 struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
143 struct policy_handle *handle, struct lsa_String *domname)
145 struct policy_handle h, domain_handle;
146 struct samr_Connect r1;
147 struct samr_LookupDomain r2;
148 struct dom_sid2 *sid = NULL;
149 struct samr_OpenDomain r3;
151 torture_comment(tctx, "connecting\n");
153 r1.in.system_name = 0;
154 r1.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
155 r1.out.connect_handle = &h;
157 torture_assert_ntstatus_ok(tctx,
158 dcerpc_samr_Connect_r(b, mem_ctx, &r1),
160 torture_assert_ntstatus_ok(tctx, r1.out.result,
163 r2.in.connect_handle = &h;
164 r2.in.domain_name = domname;
167 torture_comment(tctx, "domain lookup on %s\n", domname->string);
169 torture_assert_ntstatus_ok(tctx,
170 dcerpc_samr_LookupDomain_r(b, mem_ctx, &r2),
171 "LookupDomain failed");
172 torture_assert_ntstatus_ok(tctx, r2.out.result,
173 "LookupDomain failed");
175 r3.in.connect_handle = &h;
176 r3.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
177 r3.in.sid = *r2.out.sid;
178 r3.out.domain_handle = &domain_handle;
180 torture_comment(tctx, "opening domain\n");
182 torture_assert_ntstatus_ok(tctx,
183 dcerpc_samr_OpenDomain_r(b, mem_ctx, &r3),
184 "OpenDomain failed");
185 torture_assert_ntstatus_ok(tctx, r3.out.result,
186 "OpenDomain failed");
188 *handle = domain_handle;
194 static bool test_samr_close(struct torture_context *tctx,
195 struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
196 struct policy_handle *domain_handle)
200 r.in.handle = domain_handle;
201 r.out.handle = domain_handle;
203 torture_assert_ntstatus_ok(tctx,
204 dcerpc_samr_Close_r(b, mem_ctx, &r),
205 "Close samr domain failed");
206 torture_assert_ntstatus_ok(tctx, r.out.result,
207 "Close samr domain failed");
213 static bool test_lsa_close(struct torture_context *tctx,
214 struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
215 struct policy_handle *domain_handle)
219 r.in.handle = domain_handle;
220 r.out.handle = domain_handle;
222 torture_assert_ntstatus_ok(tctx,
223 dcerpc_lsa_Close_r(b, mem_ctx, &r),
224 "Close lsa domain failed");
225 torture_assert_ntstatus_ok(tctx, r.out.result,
226 "Close lsa domain failed");
232 bool torture_groupinfo_api(struct torture_context *torture)
234 const char *name = TEST_GROUPNAME;
237 TALLOC_CTX *mem_ctx = NULL, *prep_mem_ctx;
238 struct libnet_context *ctx;
239 struct dcerpc_pipe *p;
240 struct policy_handle h;
241 struct lsa_String domain_name;
242 struct libnet_GroupInfo req;
244 prep_mem_ctx = talloc_init("prepare torture group info");
246 ctx = libnet_context_init(torture->ev, torture->lp_ctx);
247 ctx->cred = cmdline_credentials;
249 status = torture_rpc_connection(torture,
252 if (!NT_STATUS_IS_OK(status)) {
256 domain_name.string = lp_workgroup(torture->lp_ctx);
257 if (!test_opendomain(torture, p->binding_handle, prep_mem_ctx, &h, &domain_name)) {
262 if (!test_creategroup(torture, p->binding_handle, prep_mem_ctx, &h, name)) {
267 mem_ctx = talloc_init("torture group info");
271 req.in.domain_name = domain_name.string;
272 req.in.level = GROUP_INFO_BY_NAME;
273 req.in.data.group_name = name;
275 status = libnet_GroupInfo(ctx, mem_ctx, &req);
276 if (!NT_STATUS_IS_OK(status)) {
277 torture_comment(torture, "libnet_GroupInfo call failed: %s\n", nt_errstr(status));
282 if (!test_cleanup(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle, TEST_GROUPNAME)) {
283 torture_comment(torture, "cleanup failed\n");
288 if (!test_samr_close(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
289 torture_comment(torture, "domain close failed\n");
296 talloc_free(mem_ctx);
301 bool torture_grouplist(struct torture_context *torture)
305 TALLOC_CTX *mem_ctx = NULL;
306 struct libnet_context *ctx;
307 struct lsa_String domain_name;
308 struct libnet_GroupList req;
311 ctx = libnet_context_init(torture->ev, torture->lp_ctx);
312 ctx->cred = cmdline_credentials;
314 domain_name.string = lp_workgroup(torture->lp_ctx);
315 mem_ctx = talloc_init("torture group list");
319 torture_comment(torture, "listing group accounts:\n");
322 req.in.domain_name = domain_name.string;
323 req.in.page_size = 128;
324 req.in.resume_index = req.out.resume_index;
326 status = libnet_GroupList(ctx, mem_ctx, &req);
327 if (!NT_STATUS_IS_OK(status) &&
328 !NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) break;
330 for (i = 0; i < req.out.count; i++) {
331 torture_comment(torture, "\tgroup: %s, sid=%s\n",
332 req.out.groups[i].groupname, req.out.groups[i].sid);
335 } while (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES));
337 if (!(NT_STATUS_IS_OK(status) ||
338 NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES))) {
339 torture_comment(torture, "libnet_GroupList call failed: %s\n", nt_errstr(status));
344 if (!test_samr_close(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
345 torture_comment(torture, "domain close failed\n");
349 if (!test_lsa_close(torture, ctx->lsa.pipe->binding_handle, mem_ctx, &ctx->lsa.handle)) {
350 torture_comment(torture, "lsa domain close failed\n");
357 talloc_free(mem_ctx);
362 bool torture_creategroup(struct torture_context *torture)
366 TALLOC_CTX *mem_ctx = NULL;
367 struct libnet_context *ctx;
368 struct libnet_CreateGroup req;
370 mem_ctx = talloc_init("test_creategroup");
372 ctx = libnet_context_init(torture->ev, torture->lp_ctx);
373 ctx->cred = cmdline_credentials;
375 req.in.group_name = TEST_GROUPNAME;
376 req.in.domain_name = lp_workgroup(torture->lp_ctx);
377 req.out.error_string = NULL;
379 status = libnet_CreateGroup(ctx, mem_ctx, &req);
380 if (!NT_STATUS_IS_OK(status)) {
381 torture_comment(torture, "libnet_CreateGroup call failed: %s\n", nt_errstr(status));
386 if (!test_cleanup(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle, TEST_GROUPNAME)) {
387 torture_comment(torture, "cleanup failed\n");
392 if (!test_samr_close(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
393 torture_comment(torture, "domain close failed\n");
399 talloc_free(mem_ctx);