s4-smbtorture: remove trailing whitespace in libnet torture tests.
[gd/samba-autobuild/.git] / source4 / torture / libnet / libnet_domain.c
1 /*
2    Unix SMB/CIFS implementation.
3    Test suite for libnet calls.
4
5    Copyright (C) Rafal Szczesniak 2006
6
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.
11
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.
16
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/>.
19 */
20
21
22 #include "includes.h"
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/rpc.h"
28 #include "param/param.h"
29
30
31 static bool test_opendomain_samr(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
32                                  struct policy_handle *handle, struct lsa_String *domname,
33                                  uint32_t *access_mask, struct dom_sid **sid_p)
34 {
35         NTSTATUS status;
36         struct policy_handle h, domain_handle;
37         struct samr_Connect r1;
38         struct samr_LookupDomain r2;
39         struct dom_sid2 *sid = NULL;
40         struct samr_OpenDomain r3;
41
42         printf("connecting\n");
43
44         *access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
45
46         r1.in.system_name = 0;
47         r1.in.access_mask = *access_mask;
48         r1.out.connect_handle = &h;
49
50         status = dcerpc_samr_Connect_r(b, mem_ctx, &r1);
51         if (!NT_STATUS_IS_OK(status)) {
52                 printf("Connect failed - %s\n", nt_errstr(status));
53                 return false;
54         }
55
56         r2.in.connect_handle = &h;
57         r2.in.domain_name = domname;
58         r2.out.sid = &sid;
59
60         printf("domain lookup on %s\n", domname->string);
61
62         status = dcerpc_samr_LookupDomain_r(b, mem_ctx, &r2);
63         if (!NT_STATUS_IS_OK(status)) {
64                 printf("LookupDomain failed - %s\n", nt_errstr(status));
65                 return false;
66         }
67
68         r3.in.connect_handle = &h;
69         r3.in.access_mask = *access_mask;
70         r3.in.sid = *sid_p = *r2.out.sid;
71         r3.out.domain_handle = &domain_handle;
72
73         printf("opening domain\n");
74
75         status = dcerpc_samr_OpenDomain_r(b, mem_ctx, &r3);
76         if (!NT_STATUS_IS_OK(status)) {
77                 printf("OpenDomain failed - %s\n", nt_errstr(status));
78                 return false;
79         } else {
80                 *handle = domain_handle;
81         }
82
83         return true;
84 }
85
86
87 static bool test_opendomain_lsa(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
88                                 struct policy_handle *handle, struct lsa_String *domname,
89                                 uint32_t *access_mask)
90 {
91         NTSTATUS status;
92         struct lsa_OpenPolicy2 open;
93         struct lsa_ObjectAttribute attr;
94         struct lsa_QosInfo qos;
95
96         *access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
97
98         ZERO_STRUCT(attr);
99         ZERO_STRUCT(qos);
100
101         qos.len                 = 0;
102         qos.impersonation_level = 2;
103         qos.context_mode        = 1;
104         qos.effective_only      = 0;
105
106         attr.sec_qos = &qos;
107
108         open.in.system_name = domname->string;
109         open.in.attr        = &attr;
110         open.in.access_mask = *access_mask;
111         open.out.handle     = handle;
112
113         status = dcerpc_lsa_OpenPolicy2_r(b, mem_ctx, &open);
114         if (!NT_STATUS_IS_OK(status)) {
115                 return false;
116         }
117
118         return true;
119 }
120
121 bool torture_domain_open_lsa(struct torture_context *torture)
122 {
123         NTSTATUS status;
124         bool ret = true;
125         struct libnet_context *ctx;
126         struct libnet_DomainOpen r;
127         struct lsa_Close lsa_close;
128         struct policy_handle h;
129         const char *domain_name;
130
131         /* we're accessing domain controller so the domain name should be
132            passed (it's going to be resolved to dc name and address) instead
133            of specific server name. */
134         domain_name = lp_workgroup(torture->lp_ctx);
135
136         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
137         if (ctx == NULL) {
138                 d_printf("failed to create libnet context\n");
139                 return false;
140         }
141
142         ctx->cred = cmdline_credentials;
143
144         ZERO_STRUCT(r);
145         r.in.type = DOMAIN_LSA;
146         r.in.domain_name = domain_name;
147         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
148
149         status = libnet_DomainOpen(ctx, torture, &r);
150         if (!NT_STATUS_IS_OK(status)) {
151                 d_printf("failed to open domain on lsa service: %s\n", nt_errstr(status));
152                 ret = false;
153                 goto done;
154         }
155
156         ZERO_STRUCT(lsa_close);
157         lsa_close.in.handle  = &ctx->lsa.handle;
158         lsa_close.out.handle = &h;
159
160         status = dcerpc_lsa_Close_r(ctx->lsa.pipe->binding_handle, ctx, &lsa_close);
161         if (!NT_STATUS_IS_OK(status)) {
162                 d_printf("failed to close domain on lsa service: %s\n", nt_errstr(status));
163                 ret = false;
164         }
165
166 done:
167         talloc_free(ctx);
168         return ret;
169 }
170
171
172 bool torture_domain_close_lsa(struct torture_context *torture)
173 {
174         bool ret = true;
175         NTSTATUS status;
176         TALLOC_CTX *mem_ctx=NULL;
177         struct libnet_context *ctx;
178         struct lsa_String domain_name;
179         struct dcerpc_binding *binding;
180         uint32_t access_mask;
181         struct policy_handle h;
182         struct dcerpc_pipe *p;
183         struct libnet_DomainClose r;
184
185         status = torture_rpc_binding(torture, &binding);
186         if (!NT_STATUS_IS_OK(status)) {
187                 return false;
188         }
189
190         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
191         if (ctx == NULL) {
192                 d_printf("failed to create libnet context\n");
193                 ret = false;
194                 goto done;
195         }
196
197         ctx->cred = cmdline_credentials;
198
199         mem_ctx = talloc_init("torture_domain_close_lsa");
200         status = dcerpc_pipe_connect_b(mem_ctx, &p, binding, &ndr_table_lsarpc,
201                                      cmdline_credentials, torture->ev, torture->lp_ctx);
202         if (!NT_STATUS_IS_OK(status)) {
203                 d_printf("failed to connect to server: %s\n", nt_errstr(status));
204                 ret = false;
205                 goto done;
206         }
207
208         domain_name.string = lp_workgroup(torture->lp_ctx);
209
210         if (!test_opendomain_lsa(p->binding_handle, torture, &h, &domain_name, &access_mask)) {
211                 d_printf("failed to open domain on lsa service\n");
212                 ret = false;
213                 goto done;
214         }
215
216         ctx->lsa.pipe        = p;
217         ctx->lsa.name        = domain_name.string;
218         ctx->lsa.access_mask = access_mask;
219         ctx->lsa.handle      = h;
220         /* we have to use pipe's event context, otherwise the call will
221            hang indefinitely */
222         ctx->event_ctx       = p->conn->event_ctx;
223
224         ZERO_STRUCT(r);
225         r.in.type = DOMAIN_LSA;
226         r.in.domain_name = domain_name.string;
227
228         status = libnet_DomainClose(ctx, mem_ctx, &r);
229         if (!NT_STATUS_IS_OK(status)) {
230                 ret = false;
231                 goto done;
232         }
233
234 done:
235         talloc_free(mem_ctx);
236         talloc_free(ctx);
237         return ret;
238 }
239
240
241 bool torture_domain_open_samr(struct torture_context *torture)
242 {
243         NTSTATUS status;
244         struct libnet_context *ctx;
245         TALLOC_CTX *mem_ctx;
246         struct policy_handle domain_handle, handle;
247         struct libnet_DomainOpen io;
248         struct samr_Close r;
249         const char *domain_name;
250         bool ret = true;
251
252         mem_ctx = talloc_init("test_domainopen_lsa");
253
254         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
255         ctx->cred = cmdline_credentials;
256
257         /* we're accessing domain controller so the domain name should be
258            passed (it's going to be resolved to dc name and address) instead
259            of specific server name. */
260         domain_name = lp_workgroup(torture->lp_ctx);
261
262         /*
263          * Testing synchronous version
264          */
265         printf("opening domain\n");
266
267         io.in.type         = DOMAIN_SAMR;
268         io.in.domain_name  = domain_name;
269         io.in.access_mask  = SEC_FLAG_MAXIMUM_ALLOWED;
270
271         status = libnet_DomainOpen(ctx, mem_ctx, &io);
272         if (!NT_STATUS_IS_OK(status)) {
273                 printf("Composite domain open failed - %s\n", nt_errstr(status));
274                 ret = false;
275                 goto done;
276         }
277
278         domain_handle = ctx->samr.handle;
279
280         r.in.handle   = &domain_handle;
281         r.out.handle  = &handle;
282
283         printf("closing domain handle\n");
284
285         status = dcerpc_samr_Close_r(ctx->samr.pipe->binding_handle, mem_ctx, &r);
286         if (!NT_STATUS_IS_OK(status)) {
287                 printf("Close failed - %s\n", nt_errstr(status));
288                 ret = false;
289                 goto done;
290         }
291
292 done:
293         talloc_free(mem_ctx);
294         talloc_free(ctx);
295
296         return ret;
297 }
298
299
300 bool torture_domain_close_samr(struct torture_context *torture)
301 {
302         bool ret = true;
303         NTSTATUS status;
304         TALLOC_CTX *mem_ctx = NULL;
305         struct libnet_context *ctx;
306         struct lsa_String domain_name;
307         struct dcerpc_binding *binding;
308         uint32_t access_mask;
309         struct policy_handle h;
310         struct dcerpc_pipe *p;
311         struct libnet_DomainClose r;
312         struct dom_sid *sid;
313
314         status = torture_rpc_binding(torture, &binding);
315         if (!NT_STATUS_IS_OK(status)) {
316                 return false;
317         }
318
319         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
320         if (ctx == NULL) {
321                 d_printf("failed to create libnet context\n");
322                 ret = false;
323                 goto done;
324         }
325
326         ctx->cred = cmdline_credentials;
327
328         mem_ctx = talloc_init("torture_domain_close_samr");
329         status = dcerpc_pipe_connect_b(mem_ctx, &p, binding, &ndr_table_samr,
330                                      ctx->cred, torture->ev, torture->lp_ctx);
331         if (!NT_STATUS_IS_OK(status)) {
332                 d_printf("failed to connect to server: %s\n", nt_errstr(status));
333                 ret = false;
334                 goto done;
335         }
336
337         domain_name.string = talloc_strdup(mem_ctx, lp_workgroup(torture->lp_ctx));
338
339         if (!test_opendomain_samr(p->binding_handle, torture, &h, &domain_name, &access_mask, &sid)) {
340                 d_printf("failed to open domain on samr service\n");
341                 ret = false;
342                 goto done;
343         }
344
345         ctx->samr.pipe        = p;
346         ctx->samr.name        = talloc_steal(ctx, domain_name.string);
347         ctx->samr.access_mask = access_mask;
348         ctx->samr.handle      = h;
349         ctx->samr.sid         = talloc_steal(ctx, sid);
350         /* we have to use pipe's event context, otherwise the call will
351            hang indefinitely - this wouldn't be the case if pipe was opened
352            by means of libnet call */
353         ctx->event_ctx       = p->conn->event_ctx;
354
355         ZERO_STRUCT(r);
356         r.in.type = DOMAIN_SAMR;
357         r.in.domain_name = domain_name.string;
358
359         status = libnet_DomainClose(ctx, mem_ctx, &r);
360         if (!NT_STATUS_IS_OK(status)) {
361                 ret = false;
362                 goto done;
363         }
364
365 done:
366         talloc_free(mem_ctx);
367         talloc_free(ctx);
368         return ret;
369 }
370
371
372 bool torture_domain_list(struct torture_context *torture)
373 {
374         bool ret = true;
375         NTSTATUS status;
376         TALLOC_CTX *mem_ctx = NULL;
377         struct dcerpc_binding *binding;
378         struct libnet_context *ctx;
379         struct libnet_DomainList r;
380         int i;
381
382         status = torture_rpc_binding(torture, &binding);
383         if (!NT_STATUS_IS_OK(status)) {
384                 return false;
385         }
386
387         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
388         if (ctx == NULL) {
389                 d_printf("failed to create libnet context\n");
390                 ret = false;
391                 goto done;
392         }
393
394         ctx->cred = cmdline_credentials;
395
396         mem_ctx = talloc_init("torture_domain_close_samr");
397
398         /*
399          * querying the domain list using default buffer size
400          */
401
402         ZERO_STRUCT(r);
403         r.in.hostname = binding->host;
404
405         status = libnet_DomainList(ctx, mem_ctx, &r);
406         if (!NT_STATUS_IS_OK(status)) {
407                 ret = false;
408                 goto done;
409         }
410
411         d_printf("Received list or domains (everything in one piece):\n");
412
413         for (i = 0; i < r.out.count; i++) {
414                 d_printf("Name[%d]: %s\n", i, r.out.domains[i].name);
415         }
416
417         /*
418          * querying the domain list using specified (much smaller) buffer size
419          */
420
421         ctx->samr.buf_size = 32;
422
423         ZERO_STRUCT(r);
424         r.in.hostname = binding->host;
425
426         status = libnet_DomainList(ctx, mem_ctx, &r);
427         if (!NT_STATUS_IS_OK(status)) {
428                 ret = false;
429                 goto done;
430         }
431
432         d_printf("Received list or domains (collected in more than one round):\n");
433
434         for (i = 0; i < r.out.count; i++) {
435                 d_printf("Name[%d]: %s\n", i, r.out.domains[i].name);
436         }
437
438 done:
439         d_printf("\nStatus: %s\n", nt_errstr(status));
440
441         talloc_free(mem_ctx);
442         talloc_free(ctx);
443         return ret;
444 }