source: branches/samba-3.5.x/source4/torture/rpc/wkssvc.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 16 years ago

Samba 3.5.0: Initial import
File size: 37.2 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 test suite for wkssvc rpc operations
4
5 Copyright (C) Andrew Tridgell 2003
6 Copyright (C) GÃŒnther Deschner 2007
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20*/
21
22#include "includes.h"
23#include "torture/torture.h"
24#include "librpc/gen_ndr/ndr_wkssvc_c.h"
25#include "torture/rpc/rpc.h"
26#include "lib/cmdline/popt_common.h"
27#include "param/param.h"
28#include "../lib/crypto/crypto.h"
29#include "libcli/auth/libcli_auth.h"
30
31#define SMBTORTURE_MACHINE_NAME "smbtrt_name"
32#define SMBTORTURE_ALTERNATE_NAME "smbtrt_altname"
33#define SMBTORTURE_TRANSPORT_NAME "\\Device\\smbtrt_transport_name"
34#define SMBTORTURE_USE_NAME "S:"
35#define SMBTORTURE_MESSAGE "You are currently tortured by Samba"
36
37static bool test_NetWkstaGetInfo(struct torture_context *tctx,
38 struct dcerpc_pipe *p)
39{
40 NTSTATUS status;
41 struct wkssvc_NetWkstaGetInfo r;
42 union wkssvc_NetWkstaInfo info;
43 uint16_t levels[] = {100, 101, 102, 502};
44 int i;
45
46 r.in.server_name = dcerpc_server_name(p);
47 r.out.info = &info;
48
49 for (i=0;i<ARRAY_SIZE(levels);i++) {
50 r.in.level = levels[i];
51 torture_comment(tctx, "testing NetWkstaGetInfo level %u\n",
52 r.in.level);
53 status = dcerpc_wkssvc_NetWkstaGetInfo(p, tctx, &r);
54 torture_assert_ntstatus_ok(tctx, status,
55 talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed",
56 r.in.level));
57 torture_assert_werr_ok(tctx, r.out.result,
58 talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed",
59 r.in.level));
60 }
61
62 return true;
63}
64
65static bool test_NetWkstaTransportEnum(struct torture_context *tctx,
66 struct dcerpc_pipe *p)
67{
68 NTSTATUS status;
69 struct wkssvc_NetWkstaTransportEnum r;
70 uint32_t resume_handle = 0;
71 struct wkssvc_NetWkstaTransportInfo info;
72 union wkssvc_NetWkstaTransportCtr ctr;
73 struct wkssvc_NetWkstaTransportCtr0 ctr0;
74 uint32_t total_entries = 0;
75
76 ZERO_STRUCT(ctr0);
77 ctr.ctr0 = &ctr0;
78
79 info.level = 0;
80 info.ctr = ctr;
81
82 r.in.server_name = dcerpc_server_name(p);
83 r.in.info = &info;
84 r.in.max_buffer = (uint32_t)-1;
85 r.in.resume_handle = &resume_handle;
86 r.out.total_entries = &total_entries;
87 r.out.info = &info;
88 r.out.resume_handle = &resume_handle;
89
90 torture_comment(tctx, "testing NetWkstaTransportEnum level 0\n");
91
92 status = dcerpc_wkssvc_NetWkstaTransportEnum(p, tctx, &r);
93 torture_assert_ntstatus_ok(tctx, status,
94 "NetWkstaTransportEnum failed");
95 torture_assert_werr_ok(tctx, r.out.result, talloc_asprintf(tctx,
96 "NetWkstaTransportEnum level %u failed",
97 info.level));
98
99 return true;
100}
101
102static bool test_NetrWkstaTransportAdd(struct torture_context *tctx,
103 struct dcerpc_pipe *p)
104{
105 NTSTATUS status;
106 struct wkssvc_NetrWkstaTransportAdd r;
107 struct wkssvc_NetWkstaTransportInfo0 info0;
108 uint32_t parm_err = 0;
109
110 ZERO_STRUCT(info0);
111
112 info0.quality_of_service = 0xffff;
113 info0.vc_count = 0;
114 info0.name = SMBTORTURE_TRANSPORT_NAME;
115 info0.address = "000000000000";
116 info0.wan_link = 0x400;
117
118 r.in.server_name = dcerpc_server_name(p);
119 r.in.level = 0;
120 r.in.info0 = &info0;
121 r.in.parm_err = r.out.parm_err = &parm_err;
122
123 torture_comment(tctx, "testing NetrWkstaTransportAdd level 0\n");
124
125 status = dcerpc_wkssvc_NetrWkstaTransportAdd(p, tctx, &r);
126 torture_assert_ntstatus_ok(tctx, status,
127 "NetrWkstaTransportAdd failed");
128 torture_assert_werr_equal(tctx, r.out.result,
129 WERR_INVALID_PARAM,
130 "NetrWkstaTransportAdd level 0 failed");
131
132 return true;
133}
134
135static bool test_NetrWkstaTransportDel(struct torture_context *tctx,
136 struct dcerpc_pipe *p)
137{
138 NTSTATUS status;
139 struct wkssvc_NetrWkstaTransportDel r;
140
141 r.in.server_name = dcerpc_server_name(p);
142 r.in.transport_name = SMBTORTURE_TRANSPORT_NAME;
143 r.in.unknown3 = 0;
144
145 torture_comment(tctx, "testing NetrWkstaTransportDel\n");
146
147 status = dcerpc_wkssvc_NetrWkstaTransportDel(p, tctx, &r);
148 torture_assert_ntstatus_ok(tctx, status,
149 "NetrWkstaTransportDel failed");
150 torture_assert_werr_ok(tctx, r.out.result,
151 "NetrWkstaTransportDel");
152
153 return true;
154}
155
156static bool test_NetWkstaEnumUsers(struct torture_context *tctx,
157 struct dcerpc_pipe *p)
158{
159 NTSTATUS status;
160 struct wkssvc_NetWkstaEnumUsers r;
161 uint32_t handle = 0;
162 uint32_t entries_read = 0;
163 struct wkssvc_NetWkstaEnumUsersInfo info;
164 struct wkssvc_NetWkstaEnumUsersCtr0 *user0;
165 struct wkssvc_NetWkstaEnumUsersCtr1 *user1;
166 uint32_t levels[] = { 0, 1 };
167 int i;
168
169 for (i=0; i<ARRAY_SIZE(levels); i++) {
170
171 ZERO_STRUCT(info);
172
173 info.level = levels[i];
174 switch (info.level) {
175 case 0:
176 user0 = talloc_zero(tctx,
177 struct wkssvc_NetWkstaEnumUsersCtr0);
178 info.ctr.user0 = user0;
179 break;
180 case 1:
181 user1 = talloc_zero(tctx,
182 struct wkssvc_NetWkstaEnumUsersCtr1);
183 info.ctr.user1 = user1;
184 break;
185 default:
186 break;
187 }
188
189 r.in.server_name = dcerpc_server_name(p);
190 r.in.prefmaxlen = (uint32_t)-1;
191 r.in.info = r.out.info = &info;
192 r.in.resume_handle = r.out.resume_handle = &handle;
193
194 r.out.entries_read = &entries_read;
195
196 torture_comment(tctx, "testing NetWkstaEnumUsers level %u\n",
197 levels[i]);
198
199 status = dcerpc_wkssvc_NetWkstaEnumUsers(p, tctx, &r);
200 torture_assert_ntstatus_ok(tctx, status,
201 "NetWkstaEnumUsers failed");
202 torture_assert_werr_ok(tctx, r.out.result,
203 "NetWkstaEnumUsers failed");
204 }
205
206 return true;
207}
208
209static bool test_NetrWkstaUserGetInfo(struct torture_context *tctx,
210 struct dcerpc_pipe *p)
211{
212 NTSTATUS status;
213 struct wkssvc_NetrWkstaUserGetInfo r;
214 union wkssvc_NetrWkstaUserInfo info;
215 const char *dom = lp_workgroup(tctx->lp_ctx);
216 struct cli_credentials *creds = cmdline_credentials;
217 const char *user = cli_credentials_get_username(creds);
218 int i;
219
220 const struct {
221 const char *unknown;
222 uint32_t level;
223 WERROR result;
224 } tests[] = {
225 { NULL, 0, WERR_NO_SUCH_LOGON_SESSION },
226 { NULL, 1, WERR_NO_SUCH_LOGON_SESSION },
227 { NULL, 1101, WERR_OK },
228 { dom, 0, WERR_INVALID_PARAM },
229 { dom, 1, WERR_INVALID_PARAM },
230 { dom, 1101, WERR_INVALID_PARAM },
231 { user, 0, WERR_INVALID_PARAM },
232 { user, 1, WERR_INVALID_PARAM },
233 { user, 1101, WERR_INVALID_PARAM },
234 };
235
236 for (i=0; i<ARRAY_SIZE(tests); i++) {
237 r.in.unknown = tests[i].unknown;
238 r.in.level = tests[i].level;
239 r.out.info = &info;
240
241 torture_comment(tctx, "testing NetrWkstaUserGetInfo level %u\n",
242 r.in.level);
243
244 status = dcerpc_wkssvc_NetrWkstaUserGetInfo(p, tctx, &r);
245 torture_assert_ntstatus_ok(tctx, status,
246 "NetrWkstaUserGetInfo failed");
247 torture_assert_werr_equal(tctx, r.out.result,
248 tests[i].result,
249 "NetrWkstaUserGetInfo failed");
250 }
251
252 return true;
253}
254
255static bool test_NetrUseEnum(struct torture_context *tctx,
256 struct dcerpc_pipe *p)
257{
258 NTSTATUS status;
259 struct wkssvc_NetrUseEnum r;
260 uint32_t handle = 0;
261 uint32_t entries_read = 0;
262 struct wkssvc_NetrUseEnumInfo info;
263 struct wkssvc_NetrUseEnumCtr0 *use0;
264 struct wkssvc_NetrUseEnumCtr1 *use1;
265 struct wkssvc_NetrUseEnumCtr2 *use2;
266 uint32_t levels[] = { 0, 1, 2 };
267 int i;
268
269 for (i=0; i<ARRAY_SIZE(levels); i++) {
270
271 ZERO_STRUCT(info);
272
273 info.level = levels[i];
274 switch (info.level) {
275 case 0:
276 use0 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr0);
277 info.ctr.ctr0 = use0;
278 break;
279 case 1:
280 use1 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr1);
281 info.ctr.ctr1 = use1;
282 break;
283 case 2:
284 use2 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr2);
285 info.ctr.ctr2 = use2;
286 break;
287 default:
288 break;
289 }
290
291 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
292 r.in.prefmaxlen = (uint32_t)-1;
293 r.in.info = r.out.info = &info;
294 r.in.resume_handle = r.out.resume_handle = &handle;
295
296 r.out.entries_read = &entries_read;
297
298 torture_comment(tctx, "testing NetrUseEnum level %u\n",
299 levels[i]);
300
301 status = dcerpc_wkssvc_NetrUseEnum(p, tctx, &r);
302 torture_assert_ntstatus_ok(tctx, status,
303 "NetrUseEnum failed");
304 torture_assert_werr_ok(tctx, r.out.result,
305 "NetrUseEnum failed");
306 }
307
308 return true;
309}
310
311static bool test_NetrUseAdd(struct torture_context *tctx,
312 struct dcerpc_pipe *p)
313{
314 NTSTATUS status;
315 struct wkssvc_NetrUseAdd r;
316 struct wkssvc_NetrUseInfo0 info0;
317 struct wkssvc_NetrUseInfo1 info1;
318 union wkssvc_NetrUseGetInfoCtr *ctr;
319 uint32_t parm_err = 0;
320
321 ctr = talloc(tctx, union wkssvc_NetrUseGetInfoCtr);
322
323 ZERO_STRUCT(info0);
324
325 info0.local = SMBTORTURE_USE_NAME;
326 info0.remote = "\\\\localhost\\c$";
327
328 ctr->info0 = &info0;
329
330 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
331 r.in.level = 0;
332 r.in.ctr = ctr;
333 r.in.parm_err = r.out.parm_err = &parm_err;
334
335 torture_comment(tctx, "testing NetrUseAdd level %u\n",
336 r.in.level);
337
338 status = dcerpc_wkssvc_NetrUseAdd(p, tctx, &r);
339 torture_assert_ntstatus_ok(tctx, status,
340 "NetrUseAdd failed");
341 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
342 "NetrUseAdd failed");
343
344 ZERO_STRUCT(r);
345 ZERO_STRUCT(info1);
346
347 info1.local = SMBTORTURE_USE_NAME;
348 info1.remote = "\\\\localhost\\sysvol";
349 info1.password = NULL;
350
351 ctr->info1 = &info1;
352
353 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
354 r.in.level = 1;
355 r.in.ctr = ctr;
356 r.in.parm_err = r.out.parm_err = &parm_err;
357
358 torture_comment(tctx, "testing NetrUseAdd level %u\n",
359 r.in.level);
360
361 status = dcerpc_wkssvc_NetrUseAdd(p, tctx, &r);
362 torture_assert_ntstatus_ok(tctx, status,
363 "NetrUseAdd failed");
364 torture_assert_werr_ok(tctx, r.out.result,
365 "NetrUseAdd failed");
366
367 return true;
368}
369
370static bool test_NetrUseDel(struct torture_context *tctx,
371 struct dcerpc_pipe *p)
372{
373 NTSTATUS status;
374 struct wkssvc_NetrUseDel r;
375
376 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
377 r.in.use_name = SMBTORTURE_USE_NAME;
378 r.in.force_cond = 0;
379
380 torture_comment(tctx, "testing NetrUseDel\n");
381
382 status = dcerpc_wkssvc_NetrUseDel(p, tctx, &r);
383 torture_assert_ntstatus_ok(tctx, status,
384 "NetrUseDel failed");
385 torture_assert_werr_ok(tctx, r.out.result,
386 "NetrUseDel failed");
387 return true;
388}
389
390static bool test_NetrUseGetInfo_level(struct torture_context *tctx,
391 struct dcerpc_pipe *p,
392 const char *use_name,
393 uint32_t level,
394 WERROR werr)
395{
396 NTSTATUS status;
397 struct wkssvc_NetrUseGetInfo r;
398 union wkssvc_NetrUseGetInfoCtr ctr;
399
400 ZERO_STRUCT(ctr);
401
402 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
403 r.in.use_name = use_name;
404 r.in.level = level;
405 r.out.ctr = &ctr;
406 status = dcerpc_wkssvc_NetrUseGetInfo(p, tctx, &r);
407
408 torture_assert_ntstatus_ok(tctx, status,
409 "NetrUseGetInfo failed");
410 torture_assert_werr_equal(tctx, r.out.result, werr,
411 "NetrUseGetInfo failed");
412 return true;
413}
414
415static bool test_NetrUseGetInfo(struct torture_context *tctx,
416 struct dcerpc_pipe *p)
417{
418 NTSTATUS status;
419 struct wkssvc_NetrUseEnum r;
420 uint32_t handle = 0;
421 uint32_t entries_read = 0;
422 struct wkssvc_NetrUseEnumInfo info;
423 struct wkssvc_NetrUseEnumCtr0 *use0;
424 uint32_t levels[] = { 0, 1, 2 };
425 const char *use_name = NULL;
426 int i, k;
427
428 ZERO_STRUCT(info);
429
430 info.level = 0;
431 use0 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr0);
432 info.ctr.ctr0 = use0;
433
434 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
435 r.in.prefmaxlen = (uint32_t)-1;
436 r.in.info = r.out.info = &info;
437 r.in.resume_handle = r.out.resume_handle = &handle;
438 r.out.entries_read = &entries_read;
439
440 status = dcerpc_wkssvc_NetrUseEnum(p, tctx, &r);
441 torture_assert_ntstatus_ok(tctx, status,
442 "NetrUseEnum failed");
443 torture_assert_werr_ok(tctx, r.out.result,
444 "NetrUseEnum failed");
445
446 for (k=0; k < r.out.info->ctr.ctr0->count; k++) {
447
448 use_name = r.out.info->ctr.ctr0->array[k].local;
449
450 for (i=0; i<ARRAY_SIZE(levels); i++) {
451
452 if (!test_NetrUseGetInfo_level(tctx, p, use_name,
453 levels[i],
454 WERR_OK))
455 {
456 if (levels[i] != 0) {
457 return false;
458 }
459 }
460 }
461
462 use_name = r.out.info->ctr.ctr0->array[k].remote;
463
464 for (i=0; i<ARRAY_SIZE(levels); i++) {
465
466 if (!test_NetrUseGetInfo_level(tctx, p, use_name,
467 levels[i],
468 WERR_NOT_CONNECTED))
469 {
470 if (levels[i] != 0) {
471 return false;
472 }
473 }
474 }
475 }
476
477 return true;
478}
479
480static bool test_NetrLogonDomainNameAdd(struct torture_context *tctx,
481 struct dcerpc_pipe *p)
482{
483 NTSTATUS status;
484 struct wkssvc_NetrLogonDomainNameAdd r;
485
486 r.in.domain_name = lp_workgroup(tctx->lp_ctx);
487
488 torture_comment(tctx, "testing NetrLogonDomainNameAdd\n");
489
490 status = dcerpc_wkssvc_NetrLogonDomainNameAdd(p, tctx, &r);
491 torture_assert_ntstatus_ok(tctx, status,
492 "NetrLogonDomainNameAdd failed");
493 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
494 "NetrLogonDomainNameAdd failed");
495 return true;
496}
497
498static bool test_NetrLogonDomainNameDel(struct torture_context *tctx,
499 struct dcerpc_pipe *p)
500{
501 NTSTATUS status;
502 struct wkssvc_NetrLogonDomainNameDel r;
503
504 r.in.domain_name = lp_workgroup(tctx->lp_ctx);
505
506 torture_comment(tctx, "testing NetrLogonDomainNameDel\n");
507
508 status = dcerpc_wkssvc_NetrLogonDomainNameDel(p, tctx, &r);
509 torture_assert_ntstatus_ok(tctx, status,
510 "NetrLogonDomainNameDel failed");
511 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
512 "NetrLogonDomainNameDel failed");
513 return true;
514}
515
516static bool test_NetrEnumerateComputerNames_level(struct torture_context *tctx,
517 struct dcerpc_pipe *p,
518 uint16_t level,
519 const char ***names,
520 int *num_names)
521{
522 NTSTATUS status;
523 struct wkssvc_NetrEnumerateComputerNames r;
524 struct wkssvc_ComputerNamesCtr *ctr;
525 int i;
526
527 ctr = talloc_zero(tctx, struct wkssvc_ComputerNamesCtr);
528
529 r.in.server_name = dcerpc_server_name(p);
530 r.in.name_type = level;
531 r.in.Reserved = 0;
532 r.out.ctr = &ctr;
533
534 torture_comment(tctx, "testing NetrEnumerateComputerNames level %u\n",
535 r.in.name_type);
536
537 status = dcerpc_wkssvc_NetrEnumerateComputerNames(p, tctx, &r);
538 torture_assert_ntstatus_ok(tctx, status,
539 "NetrEnumerateComputerNames failed");
540 torture_assert_werr_ok(tctx, r.out.result,
541 "NetrEnumerateComputerNames failed");
542
543 if ((level == NetPrimaryComputerName) && ctr->count != 1) {
544 torture_comment(tctx,
545 "NetrEnumerateComputerNames did not return one "
546 "name but %u\n", ctr->count);
547 return false;
548 }
549
550 if (names && num_names) {
551 *num_names = 0;
552 *names = NULL;
553 for (i=0; i<ctr->count; i++) {
554 if (!add_string_to_array(tctx,
555 ctr->computer_name[i].string,
556 names,
557 num_names))
558 {
559 return false;
560 }
561 }
562 }
563
564 return true;
565}
566
567static bool test_NetrEnumerateComputerNames(struct torture_context *tctx,
568 struct dcerpc_pipe *p)
569{
570 uint16_t levels[] = {0,1,2};
571 int i;
572
573 for (i=0; i<ARRAY_SIZE(levels); i++) {
574
575 if (!test_NetrEnumerateComputerNames_level(tctx,
576 p,
577 levels[i],
578 NULL, NULL))
579 {
580 return false;
581 }
582 }
583
584 return true;
585}
586
587static bool test_NetrValidateName(struct torture_context *tctx,
588 struct dcerpc_pipe *p)
589{
590 NTSTATUS status;
591 struct wkssvc_NetrValidateName r;
592 uint16_t levels[] = {0,1,2,3,4,5};
593 int i;
594
595 for (i=0; i<ARRAY_SIZE(levels); i++) {
596
597 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
598 r.in.name = lp_workgroup(tctx->lp_ctx);
599 r.in.Account = NULL;
600 r.in.Password = NULL;
601 r.in.name_type = levels[i];
602
603 torture_comment(tctx, "testing NetrValidateName level %u\n",
604 r.in.name_type);
605
606 status = dcerpc_wkssvc_NetrValidateName(p, tctx, &r);
607 torture_assert_ntstatus_ok(tctx, status,
608 "NetrValidateName failed");
609 torture_assert_werr_equal(tctx, r.out.result,
610 WERR_NOT_SUPPORTED,
611 "NetrValidateName failed");
612 }
613
614 return true;
615}
616
617static bool test_NetrValidateName2(struct torture_context *tctx,
618 struct dcerpc_pipe *p)
619{
620 NTSTATUS status;
621 struct wkssvc_NetrValidateName2 r;
622 uint16_t levels[] = {0,1,2,3,4,5};
623 int i;
624
625 for (i=0; i<ARRAY_SIZE(levels); i++) {
626
627 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
628 r.in.name = lp_workgroup(tctx->lp_ctx);
629 r.in.Account = NULL;
630 r.in.EncryptedPassword = NULL;
631 r.in.name_type = levels[i];
632
633 torture_comment(tctx, "testing NetrValidateName2 level %u\n",
634 r.in.name_type);
635
636 status = dcerpc_wkssvc_NetrValidateName2(p, tctx, &r);
637 torture_assert_ntstatus_ok(tctx, status,
638 "NetrValidateName2 failed");
639 torture_assert_werr_equal(tctx, r.out.result,
640 WERR_RPC_E_REMOTE_DISABLED,
641 "NetrValidateName2 failed");
642 }
643
644 return true;
645}
646
647static bool test_NetrAddAlternateComputerName(struct torture_context *tctx,
648 struct dcerpc_pipe *p)
649{
650 NTSTATUS status;
651 struct wkssvc_NetrAddAlternateComputerName r;
652 const char **names = NULL;
653 int num_names = 0;
654 int i;
655
656 r.in.server_name = dcerpc_server_name(p);
657 r.in.NewAlternateMachineName = SMBTORTURE_ALTERNATE_NAME;
658 r.in.Account = NULL;
659 r.in.EncryptedPassword = NULL;
660 r.in.Reserved = 0;
661
662 torture_comment(tctx, "testing NetrAddAlternateComputerName\n");
663
664 status = dcerpc_wkssvc_NetrAddAlternateComputerName(p, tctx, &r);
665 torture_assert_ntstatus_ok(tctx, status,
666 "NetrAddAlternateComputerName failed");
667 torture_assert_werr_ok(tctx, r.out.result,
668 "NetrAddAlternateComputerName failed");
669
670 if (!test_NetrEnumerateComputerNames_level(tctx, p,
671 NetAlternateComputerNames,
672 &names, &num_names))
673 {
674 return false;
675 }
676
677 for (i=0; i<num_names; i++) {
678 if (strequal(names[i], SMBTORTURE_ALTERNATE_NAME)) {
679 return true;
680 }
681 }
682
683 torture_comment(tctx, "new alternate name not set\n");
684
685 return false;
686}
687
688static bool test_NetrRemoveAlternateComputerName(struct torture_context *tctx,
689 struct dcerpc_pipe *p)
690{
691 NTSTATUS status;
692 struct wkssvc_NetrRemoveAlternateComputerName r;
693 const char **names = NULL;
694 int num_names = 0;
695 int i;
696
697 r.in.server_name = dcerpc_server_name(p);
698 r.in.AlternateMachineNameToRemove = SMBTORTURE_ALTERNATE_NAME;
699 r.in.Account = NULL;
700 r.in.EncryptedPassword = NULL;
701 r.in.Reserved = 0;
702
703 torture_comment(tctx, "testing NetrRemoveAlternateComputerName\n");
704
705 status = dcerpc_wkssvc_NetrRemoveAlternateComputerName(p, tctx, &r);
706 torture_assert_ntstatus_ok(tctx, status,
707 "NetrRemoveAlternateComputerName failed");
708 torture_assert_werr_ok(tctx, r.out.result,
709 "NetrRemoveAlternateComputerName failed");
710
711 if (!test_NetrEnumerateComputerNames_level(tctx, p,
712 NetAlternateComputerNames,
713 &names, &num_names))
714 {
715 return false;
716 }
717
718 for (i=0; i<num_names; i++) {
719 if (strequal(names[i], SMBTORTURE_ALTERNATE_NAME)) {
720 return false;
721 }
722 }
723
724 return true;
725}
726
727static bool test_NetrSetPrimaryComputername_name(struct torture_context *tctx,
728 struct dcerpc_pipe *p,
729 const char *name)
730{
731 NTSTATUS status;
732 struct wkssvc_NetrSetPrimaryComputername r;
733
734 r.in.server_name = dcerpc_server_name(p);
735 r.in.primary_name = name;
736 r.in.Account = NULL;
737 r.in.EncryptedPassword = NULL;
738 r.in.Reserved = 0;
739
740 status = dcerpc_wkssvc_NetrSetPrimaryComputername(p, tctx, &r);
741 torture_assert_ntstatus_ok(tctx, status,
742 "NetrSetPrimaryComputername failed");
743 torture_assert_werr_ok(tctx, r.out.result,
744 "NetrSetPrimaryComputername failed");
745 return true;
746}
747
748
749static bool test_NetrSetPrimaryComputername(struct torture_context *tctx,
750 struct dcerpc_pipe *p)
751{
752 /*
753 add alternate,
754 check if there
755 store old primary
756 set new primary (alternate)
757 check if there
758 later: check if del is possible
759 set primary back to origin
760 check if there
761 del alternate
762 */
763
764 const char **names_o = NULL, **names = NULL;
765 int num_names_o = 0, num_names = 0;
766
767 torture_comment(tctx, "testing NetrSetPrimaryComputername\n");
768
769 if (!test_NetrAddAlternateComputerName(tctx, p)) {
770 return false;
771 }
772
773 if (!test_NetrEnumerateComputerNames_level(tctx, p,
774 NetPrimaryComputerName,
775 &names_o, &num_names_o))
776 {
777 return false;
778 }
779
780 if (num_names_o != 1) {
781 return false;
782 }
783
784 if (!test_NetrSetPrimaryComputername_name(tctx, p,
785 SMBTORTURE_ALTERNATE_NAME))
786 {
787 return false;
788 }
789
790 if (!test_NetrEnumerateComputerNames_level(tctx, p,
791 NetPrimaryComputerName,
792 &names, &num_names))
793 {
794 return false;
795 }
796
797 if (num_names != 1) {
798 return false;
799 }
800
801 if (!strequal(names[0], SMBTORTURE_ALTERNATE_NAME)) {
802 torture_comment(tctx,
803 "name mismatch (%s != %s) after NetrSetPrimaryComputername!\n",
804 names[0], SMBTORTURE_ALTERNATE_NAME);
805 /*return false */;
806 }
807
808 if (!test_NetrSetPrimaryComputername_name(tctx, p,
809 names_o[0]))
810 {
811 return false;
812 }
813
814 if (!test_NetrRemoveAlternateComputerName(tctx, p)) {
815 return false;
816 }
817
818
819 return true;
820}
821
822static bool test_NetrRenameMachineInDomain(struct torture_context *tctx,
823 struct dcerpc_pipe *p)
824{
825 NTSTATUS status;
826 struct wkssvc_NetrRenameMachineInDomain r;
827
828 r.in.server_name = dcerpc_server_name(p);
829 r.in.NewMachineName = SMBTORTURE_MACHINE_NAME;
830 r.in.Account = NULL;
831 r.in.password = NULL;
832 r.in.RenameOptions = 0;
833
834 torture_comment(tctx, "testing NetrRenameMachineInDomain\n");
835
836 status = dcerpc_wkssvc_NetrRenameMachineInDomain(p, tctx, &r);
837 torture_assert_ntstatus_ok(tctx, status,
838 "NetrRenameMachineInDomain failed");
839 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
840 "NetrRenameMachineInDomain failed");
841 return true;
842}
843
844static bool test_NetrRenameMachineInDomain2_name(struct torture_context *tctx,
845 struct dcerpc_pipe *p,
846 const char *new_name)
847{
848 NTSTATUS status;
849 struct wkssvc_NetrRenameMachineInDomain2 r;
850
851 r.in.server_name = dcerpc_server_name(p);
852 r.in.NewMachineName = new_name;
853 r.in.Account = NULL;
854 r.in.EncryptedPassword = NULL;
855 r.in.RenameOptions = 0;
856
857 status = dcerpc_wkssvc_NetrRenameMachineInDomain2(p, tctx, &r);
858 torture_assert_ntstatus_ok(tctx, status,
859 "NetrRenameMachineInDomain2 failed");
860 torture_assert_werr_ok(tctx, r.out.result,
861 "NetrRenameMachineInDomain2 failed");
862 return true;
863}
864
865static bool test_NetrRenameMachineInDomain2(struct torture_context *tctx,
866 struct dcerpc_pipe *p)
867{
868 const char **names_o = NULL, **names = NULL;
869 int num_names_o = 0, num_names = 0;
870
871 torture_comment(tctx, "testing NetrRenameMachineInDomain2\n");
872
873 if (!test_NetrEnumerateComputerNames_level(tctx, p,
874 NetPrimaryComputerName,
875 &names_o, &num_names_o))
876 {
877 return false;
878 }
879
880 if (num_names_o != 1) {
881 return false;
882 }
883
884 if (!test_NetrRenameMachineInDomain2_name(tctx, p,
885 SMBTORTURE_MACHINE_NAME))
886 {
887 return false;
888 }
889
890 if (!test_NetrEnumerateComputerNames_level(tctx, p,
891 NetPrimaryComputerName,
892 &names, &num_names))
893 {
894 return false;
895 }
896
897 if (num_names != 1) {
898 return false;
899 }
900
901 if (strequal(names[0], names_o[0])) {
902 test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]);
903 return false;
904 }
905
906 if (!strequal(names[0], SMBTORTURE_MACHINE_NAME)) {
907 test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]);
908 return false;
909 }
910
911 if (!test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]))
912 {
913 return false;
914 }
915
916 if (!test_NetrEnumerateComputerNames_level(tctx, p,
917 NetPrimaryComputerName,
918 &names, &num_names))
919 {
920 return false;
921 }
922
923 if (num_names != 1) {
924 return false;
925 }
926
927 if (!strequal(names[0], names_o[0])) {
928 return false;
929 }
930
931 return true;
932}
933
934static bool test_NetrWorkstationStatisticsGet(struct torture_context *tctx,
935 struct dcerpc_pipe *p)
936{
937 NTSTATUS status;
938 struct wkssvc_NetrWorkstationStatisticsGet r;
939 struct wkssvc_NetrWorkstationStatistics *info;
940
941 ZERO_STRUCT(r);
942
943 info = talloc_zero(tctx, struct wkssvc_NetrWorkstationStatistics);
944
945 r.in.server_name = dcerpc_server_name(p);
946 r.out.info = &info;
947
948 torture_comment(tctx, "testing NetrWorkstationStatisticsGet\n");
949
950 status = dcerpc_wkssvc_NetrWorkstationStatisticsGet(p, tctx, &r);
951 torture_assert_ntstatus_ok(tctx, status,
952 "NetrWorkstationStatisticsGet failed");
953 torture_assert_werr_ok(tctx, r.out.result,
954 "NetrWorkstationStatisticsGet failed");
955 return true;
956}
957
958/* only succeeds as long as the local messenger service is running - Guenther */
959
960static bool test_NetrMessageBufferSend(struct torture_context *tctx,
961 struct dcerpc_pipe *p)
962{
963 NTSTATUS status;
964 struct wkssvc_NetrMessageBufferSend r;
965 const char *message = SMBTORTURE_MESSAGE;
966 size_t size;
967 uint16_t *msg;
968
969 if (!push_ucs2_talloc(tctx, &msg, message, &size)) {
970 return false;
971 }
972
973 r.in.server_name = dcerpc_server_name(p);
974 r.in.message_name = dcerpc_server_name(p);
975 r.in.message_sender_name = dcerpc_server_name(p);
976 r.in.message_buffer = (uint8_t *)msg;
977 r.in.message_size = size;
978
979 torture_comment(tctx, "testing NetrMessageBufferSend\n");
980
981 status = dcerpc_wkssvc_NetrMessageBufferSend(p, tctx, &r);
982 torture_assert_ntstatus_ok(tctx, status,
983 "NetrMessageBufferSend failed");
984 torture_assert_werr_ok(tctx, r.out.result,
985 "NetrMessageBufferSend failed");
986 return true;
987}
988
989static bool test_NetrGetJoinInformation(struct torture_context *tctx,
990 struct dcerpc_pipe *p)
991{
992 NTSTATUS status;
993 struct wkssvc_NetrGetJoinInformation r;
994 enum wkssvc_NetJoinStatus join_status;
995 const char *name_buffer = "";
996
997 r.in.server_name = dcerpc_server_name(p);
998 r.in.name_buffer = r.out.name_buffer = &name_buffer;
999 r.out.name_type = &join_status;
1000
1001 torture_comment(tctx, "testing NetrGetJoinInformation\n");
1002
1003 status = dcerpc_wkssvc_NetrGetJoinInformation(p, tctx, &r);
1004 torture_assert_ntstatus_ok(tctx, status,
1005 "NetrGetJoinInformation failed");
1006 torture_assert_werr_ok(tctx, r.out.result,
1007 "NetrGetJoinInformation failed");
1008 return true;
1009}
1010
1011static bool test_GetJoinInformation(struct torture_context *tctx,
1012 struct dcerpc_pipe *p,
1013 enum wkssvc_NetJoinStatus *join_status_p,
1014 const char **name)
1015{
1016 NTSTATUS status;
1017 struct wkssvc_NetrGetJoinInformation r;
1018 enum wkssvc_NetJoinStatus join_status;
1019 const char *name_buffer = "";
1020
1021 r.in.server_name = dcerpc_server_name(p);
1022 r.in.name_buffer = r.out.name_buffer = &name_buffer;
1023 r.out.name_type = &join_status;
1024
1025 status = dcerpc_wkssvc_NetrGetJoinInformation(p, tctx, &r);
1026 torture_assert_ntstatus_ok(tctx, status,
1027 "NetrGetJoinInformation failed");
1028 torture_assert_werr_ok(tctx, r.out.result,
1029 "NetrGetJoinInformation failed");
1030
1031 if (join_status_p) {
1032 *join_status_p = join_status;
1033 }
1034
1035 if (*name) {
1036 *name = talloc_strdup(tctx, name_buffer);
1037 }
1038
1039 return true;
1040
1041}
1042
1043static bool test_NetrGetJoinableOus(struct torture_context *tctx,
1044 struct dcerpc_pipe *p)
1045{
1046 NTSTATUS status;
1047 struct wkssvc_NetrGetJoinableOus r;
1048 uint32_t num_ous = 0;
1049 const char **ous = NULL;
1050
1051 r.in.server_name = dcerpc_server_name(p);
1052 r.in.domain_name = lp_workgroup(tctx->lp_ctx);
1053 r.in.Account = NULL;
1054 r.in.unknown = NULL;
1055 r.in.num_ous = r.out.num_ous = &num_ous;
1056 r.out.ous = &ous;
1057
1058 torture_comment(tctx, "testing NetrGetJoinableOus\n");
1059
1060 status = dcerpc_wkssvc_NetrGetJoinableOus(p, tctx, &r);
1061 torture_assert_ntstatus_ok(tctx, status, "NetrGetJoinableOus failed");
1062 torture_assert_werr_equal(tctx, r.out.result,
1063 WERR_NOT_SUPPORTED,
1064 "NetrGetJoinableOus failed");
1065
1066 return true;
1067}
1068
1069static bool test_NetrGetJoinableOus2(struct torture_context *tctx,
1070 struct dcerpc_pipe *p)
1071{
1072 NTSTATUS status;
1073 struct wkssvc_NetrGetJoinableOus2 r;
1074 uint32_t num_ous = 0;
1075 const char **ous = NULL;
1076
1077 r.in.server_name = dcerpc_server_name(p);
1078 r.in.domain_name = lp_workgroup(tctx->lp_ctx);
1079 r.in.Account = NULL;
1080 r.in.EncryptedPassword = NULL;
1081 r.in.num_ous = r.out.num_ous = &num_ous;
1082 r.out.ous = &ous;
1083
1084 torture_comment(tctx, "testing NetrGetJoinableOus2\n");
1085
1086 status = dcerpc_wkssvc_NetrGetJoinableOus2(p, tctx, &r);
1087 torture_assert_ntstatus_ok(tctx, status, "NetrGetJoinableOus2 failed");
1088 torture_assert_werr_equal(tctx, r.out.result,
1089 WERR_RPC_E_REMOTE_DISABLED,
1090 "NetrGetJoinableOus2 failed");
1091
1092 return true;
1093}
1094
1095static bool test_NetrUnjoinDomain(struct torture_context *tctx,
1096 struct dcerpc_pipe *p)
1097{
1098 NTSTATUS status;
1099 struct wkssvc_NetrUnjoinDomain r;
1100 struct cli_credentials *creds = cmdline_credentials;
1101 const char *user = cli_credentials_get_username(creds);
1102 const char *admin_account = NULL;
1103
1104 admin_account = talloc_asprintf(tctx, "%s\\%s",
1105 lp_workgroup(tctx->lp_ctx),
1106 user);
1107
1108 r.in.server_name = dcerpc_server_name(p);
1109 r.in.Account = admin_account;
1110 r.in.password = NULL;
1111 r.in.unjoin_flags = 0;
1112
1113 torture_comment(tctx, "testing NetrUnjoinDomain\n");
1114
1115 status = dcerpc_wkssvc_NetrUnjoinDomain(p, tctx, &r);
1116 torture_assert_ntstatus_ok(tctx, status,
1117 "NetrUnjoinDomain failed");
1118 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1119 "NetrUnjoinDomain failed");
1120 return true;
1121}
1122
1123static bool test_NetrJoinDomain(struct torture_context *tctx,
1124 struct dcerpc_pipe *p)
1125{
1126 NTSTATUS status;
1127 struct wkssvc_NetrJoinDomain r;
1128 struct cli_credentials *creds = cmdline_credentials;
1129 const char *user = cli_credentials_get_username(creds);
1130 const char *admin_account = NULL;
1131
1132 admin_account = talloc_asprintf(tctx, "%s\\%s",
1133 lp_workgroup(tctx->lp_ctx),
1134 user);
1135
1136 r.in.server_name = dcerpc_server_name(p);
1137 r.in.domain_name = lp_realm(tctx->lp_ctx);
1138 r.in.account_ou = NULL;
1139 r.in.Account = admin_account;
1140 r.in.password = NULL;
1141 r.in.join_flags = 0;
1142
1143 torture_comment(tctx, "testing NetrJoinDomain\n");
1144
1145 status = dcerpc_wkssvc_NetrJoinDomain(p, tctx, &r);
1146 torture_assert_ntstatus_ok(tctx, status,
1147 "NetrJoinDomain failed");
1148 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1149 "NetrJoinDomain failed");
1150 return true;
1151}
1152
1153/*
1154 * prerequisites for remotely joining an unjoined XP SP2 workstation:
1155 * - firewall needs to be disabled (or open for ncacn_np access)
1156 * - HKLM\System\CurrentControlSet\Control\Lsa\forceguest needs to 0
1157 * see also:
1158 * http://support.microsoft.com/kb/294355/EN-US/ and
1159 * http://support.microsoft.com/kb/290403/EN-US/
1160 */
1161
1162static bool test_NetrJoinDomain2(struct torture_context *tctx,
1163 struct dcerpc_pipe *p)
1164{
1165 NTSTATUS status;
1166 struct wkssvc_NetrJoinDomain2 r;
1167 const char *domain_admin_account = NULL;
1168 const char *domain_admin_password = NULL;
1169 const char *domain_name = NULL;
1170 struct wkssvc_PasswordBuffer *pwd_buf;
1171 enum wkssvc_NetJoinStatus join_status;
1172 const char *join_name = NULL;
1173 WERROR expected_err;
1174 DATA_BLOB session_key;
1175
1176 /* FIXME: this test assumes to join workstations / servers and does not
1177 * handle DCs (WERR_SETUP_DOMAIN_CONTROLLER) */
1178
1179 if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1180 {
1181 return false;
1182 }
1183
1184 switch (join_status) {
1185 case NET_SETUP_DOMAIN_NAME:
1186 expected_err = WERR_SETUP_ALREADY_JOINED;
1187 break;
1188 case NET_SETUP_UNKNOWN_STATUS:
1189 case NET_SETUP_UNJOINED:
1190 case NET_SETUP_WORKGROUP_NAME:
1191 default:
1192 expected_err = WERR_OK;
1193 break;
1194 }
1195
1196 domain_admin_account = torture_setting_string(tctx, "domain_admin_account", NULL);
1197
1198 domain_admin_password = torture_setting_string(tctx, "domain_admin_password", NULL);
1199
1200 domain_name = torture_setting_string(tctx, "domain_name", NULL);
1201
1202 if ((domain_admin_account == NULL) ||
1203 (domain_admin_password == NULL) ||
1204 (domain_name == NULL)) {
1205 torture_comment(tctx, "not enough input parameter\n");
1206 return false;
1207 }
1208
1209 status = dcerpc_fetch_session_key(p, &session_key);
1210 if (!NT_STATUS_IS_OK(status)) {
1211 return false;
1212 }
1213
1214 encode_wkssvc_join_password_buffer(tctx, domain_admin_password,
1215 &session_key, &pwd_buf);
1216
1217 r.in.server_name = dcerpc_server_name(p);
1218 r.in.domain_name = domain_name;
1219 r.in.account_ou = NULL;
1220 r.in.admin_account = domain_admin_account;
1221 r.in.encrypted_password = pwd_buf;
1222 r.in.join_flags = WKSSVC_JOIN_FLAGS_JOIN_TYPE |
1223 WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE;
1224
1225 torture_comment(tctx, "testing NetrJoinDomain2 (assuming non-DC)\n");
1226
1227 status = dcerpc_wkssvc_NetrJoinDomain2(p, tctx, &r);
1228 torture_assert_ntstatus_ok(tctx, status,
1229 "NetrJoinDomain2 failed");
1230 torture_assert_werr_equal(tctx, r.out.result, expected_err,
1231 "NetrJoinDomain2 failed");
1232
1233 if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1234 {
1235 return false;
1236 }
1237
1238 if (join_status != NET_SETUP_DOMAIN_NAME) {
1239 torture_comment(tctx,
1240 "Join verify failed: got %d\n", join_status);
1241 return false;
1242 }
1243
1244 return true;
1245}
1246
1247static bool test_NetrUnjoinDomain2(struct torture_context *tctx,
1248 struct dcerpc_pipe *p)
1249{
1250 NTSTATUS status;
1251 struct wkssvc_NetrUnjoinDomain2 r;
1252 const char *domain_admin_account = NULL;
1253 const char *domain_admin_password = NULL;
1254 struct wkssvc_PasswordBuffer *pwd_buf;
1255 enum wkssvc_NetJoinStatus join_status;
1256 const char *join_name = NULL;
1257 WERROR expected_err;
1258 DATA_BLOB session_key;
1259
1260 /* FIXME: this test assumes to join workstations / servers and does not
1261 * handle DCs (WERR_SETUP_DOMAIN_CONTROLLER) */
1262
1263 if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1264 {
1265 return false;
1266 }
1267
1268 switch (join_status) {
1269 case NET_SETUP_UNJOINED:
1270 expected_err = WERR_SETUP_NOT_JOINED;
1271 break;
1272 case NET_SETUP_DOMAIN_NAME:
1273 case NET_SETUP_UNKNOWN_STATUS:
1274 case NET_SETUP_WORKGROUP_NAME:
1275 default:
1276 expected_err = WERR_OK;
1277 break;
1278 }
1279
1280 domain_admin_account = torture_setting_string(tctx, "domain_admin_account", NULL);
1281
1282 domain_admin_password = torture_setting_string(tctx, "domain_admin_password", NULL);
1283
1284 if ((domain_admin_account == NULL) ||
1285 (domain_admin_password == NULL)) {
1286 torture_comment(tctx, "not enough input parameter\n");
1287 return false;
1288 }
1289
1290 status = dcerpc_fetch_session_key(p, &session_key);
1291 if (!NT_STATUS_IS_OK(status)) {
1292 return false;
1293 }
1294
1295 encode_wkssvc_join_password_buffer(tctx, domain_admin_password,
1296 &session_key, &pwd_buf);
1297
1298 r.in.server_name = dcerpc_server_name(p);
1299 r.in.account = domain_admin_account;
1300 r.in.encrypted_password = pwd_buf;
1301 r.in.unjoin_flags = 0;
1302
1303 torture_comment(tctx, "testing NetrUnjoinDomain2 (assuming non-DC)\n");
1304
1305 status = dcerpc_wkssvc_NetrUnjoinDomain2(p, tctx, &r);
1306 torture_assert_ntstatus_ok(tctx, status,
1307 "NetrUnjoinDomain2 failed");
1308 torture_assert_werr_equal(tctx, r.out.result, expected_err,
1309 "NetrUnjoinDomain2 failed");
1310
1311 if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1312 {
1313 return false;
1314 }
1315
1316 switch (join_status) {
1317 case NET_SETUP_UNJOINED:
1318 case NET_SETUP_WORKGROUP_NAME:
1319 break;
1320 case NET_SETUP_UNKNOWN_STATUS:
1321 case NET_SETUP_DOMAIN_NAME:
1322 default:
1323 torture_comment(tctx,
1324 "Unjoin verify failed: got %d\n", join_status);
1325 return false;
1326 }
1327
1328 return true;
1329}
1330
1331
1332struct torture_suite *torture_rpc_wkssvc(TALLOC_CTX *mem_ctx)
1333{
1334 struct torture_suite *suite;
1335 struct torture_rpc_tcase *tcase;
1336 struct torture_test *test;
1337
1338 suite = torture_suite_create(mem_ctx, "WKSSVC");
1339 tcase = torture_suite_add_rpc_iface_tcase(suite, "wkssvc",
1340 &ndr_table_wkssvc);
1341
1342 torture_rpc_tcase_add_test(tcase, "NetWkstaGetInfo",
1343 test_NetWkstaGetInfo);
1344
1345 torture_rpc_tcase_add_test(tcase, "NetWkstaTransportEnum",
1346 test_NetWkstaTransportEnum);
1347 torture_rpc_tcase_add_test(tcase, "NetrWkstaTransportDel",
1348 test_NetrWkstaTransportDel);
1349 torture_rpc_tcase_add_test(tcase, "NetrWkstaTransportAdd",
1350 test_NetrWkstaTransportAdd);
1351
1352 torture_rpc_tcase_add_test(tcase, "NetWkstaEnumUsers",
1353 test_NetWkstaEnumUsers);
1354 torture_rpc_tcase_add_test(tcase, "NetrWkstaUserGetInfo",
1355 test_NetrWkstaUserGetInfo);
1356
1357 torture_rpc_tcase_add_test(tcase, "NetrUseDel",
1358 test_NetrUseDel);
1359 torture_rpc_tcase_add_test(tcase, "NetrUseGetInfo",
1360 test_NetrUseGetInfo);
1361 torture_rpc_tcase_add_test(tcase, "NetrUseEnum",
1362 test_NetrUseEnum);
1363 torture_rpc_tcase_add_test(tcase, "NetrUseAdd",
1364 test_NetrUseAdd);
1365
1366 torture_rpc_tcase_add_test(tcase, "NetrValidateName",
1367 test_NetrValidateName);
1368 torture_rpc_tcase_add_test(tcase, "NetrValidateName2",
1369 test_NetrValidateName2);
1370 torture_rpc_tcase_add_test(tcase, "NetrLogonDomainNameDel",
1371 test_NetrLogonDomainNameDel);
1372 torture_rpc_tcase_add_test(tcase, "NetrLogonDomainNameAdd",
1373 test_NetrLogonDomainNameAdd);
1374 torture_rpc_tcase_add_test(tcase, "NetrRemoveAlternateComputerName",
1375 test_NetrRemoveAlternateComputerName);
1376 torture_rpc_tcase_add_test(tcase, "NetrAddAlternateComputerName",
1377 test_NetrAddAlternateComputerName);
1378 test = torture_rpc_tcase_add_test(tcase, "NetrSetPrimaryComputername",
1379 test_NetrSetPrimaryComputername);
1380 test->dangerous = true;
1381 test = torture_rpc_tcase_add_test(tcase, "NetrRenameMachineInDomain",
1382 test_NetrRenameMachineInDomain);
1383 test->dangerous = true;
1384 test = torture_rpc_tcase_add_test(tcase, "NetrRenameMachineInDomain2",
1385 test_NetrRenameMachineInDomain2);
1386 test->dangerous = true;
1387 torture_rpc_tcase_add_test(tcase, "NetrEnumerateComputerNames",
1388 test_NetrEnumerateComputerNames);
1389
1390 test = torture_rpc_tcase_add_test(tcase, "NetrJoinDomain2",
1391 test_NetrJoinDomain2);
1392 test->dangerous = true;
1393 test = torture_rpc_tcase_add_test(tcase, "NetrUnjoinDomain2",
1394 test_NetrUnjoinDomain2);
1395 test->dangerous = true;
1396
1397 torture_rpc_tcase_add_test(tcase, "NetrJoinDomain",
1398 test_NetrJoinDomain);
1399 test->dangerous = true;
1400 torture_rpc_tcase_add_test(tcase, "NetrUnjoinDomain",
1401 test_NetrUnjoinDomain);
1402 test->dangerous = true;
1403 torture_rpc_tcase_add_test(tcase, "NetrGetJoinInformation",
1404 test_NetrGetJoinInformation);
1405 torture_rpc_tcase_add_test(tcase, "NetrGetJoinableOus",
1406 test_NetrGetJoinableOus);
1407 torture_rpc_tcase_add_test(tcase, "NetrGetJoinableOus2",
1408 test_NetrGetJoinableOus2);
1409
1410 torture_rpc_tcase_add_test(tcase, "NetrWorkstationStatisticsGet",
1411 test_NetrWorkstationStatisticsGet);
1412 torture_rpc_tcase_add_test(tcase, "NetrMessageBufferSend",
1413 test_NetrMessageBufferSend);
1414
1415 return suite;
1416}
Note: See TracBrowser for help on using the repository browser.