2 Unix SMB/CIFS implementation.
3 test suite for wkssvc rpc operations
5 Copyright (C) Andrew Tridgell 2003
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/>.
22 #include "torture/torture.h"
23 #include "librpc/gen_ndr/ndr_wkssvc_c.h"
24 #include "torture/rpc/rpc.h"
25 #include "lib/cmdline/popt_common.h"
26 #include "param/param.h"
28 #define SMBTORTURE_TRANSPORT_NAME "\\Device\\smbtrt_transport_name"
29 #define SMBTORTURE_USE_NAME "S:"
31 static bool test_NetWkstaGetInfo(struct torture_context *tctx,
32 struct dcerpc_pipe *p)
35 struct wkssvc_NetWkstaGetInfo r;
36 union wkssvc_NetWkstaInfo info;
37 uint16_t levels[] = {100, 101, 102, 502};
40 r.in.server_name = dcerpc_server_name(p);
43 for (i=0;i<ARRAY_SIZE(levels);i++) {
44 r.in.level = levels[i];
45 torture_comment(tctx, "testing NetWkstaGetInfo level %u\n", r.in.level);
46 status = dcerpc_wkssvc_NetWkstaGetInfo(p, tctx, &r);
47 torture_assert_ntstatus_ok(tctx, status,
48 talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed", r.in.level));
49 torture_assert_werr_ok(tctx, r.out.result,
50 talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed", r.in.level));
56 static bool test_NetWkstaTransportEnum(struct torture_context *tctx,
57 struct dcerpc_pipe *p)
60 struct wkssvc_NetWkstaTransportEnum r;
61 uint32_t resume_handle = 0;
62 struct wkssvc_NetWkstaTransportInfo info;
63 union wkssvc_NetWkstaTransportCtr ctr;
64 struct wkssvc_NetWkstaTransportCtr0 ctr0;
65 uint32_t total_entries = 0;
73 r.in.server_name = dcerpc_server_name(p);
75 r.in.max_buffer = (uint32_t)-1;
76 r.in.resume_handle = &resume_handle;
77 r.out.total_entries = &total_entries;
79 r.out.resume_handle = &resume_handle;
81 torture_comment(tctx, "testing NetWkstaTransportEnum level 0\n");
83 status = dcerpc_wkssvc_NetWkstaTransportEnum(p, tctx, &r);
84 torture_assert_ntstatus_ok(tctx, status,
85 "NetWkstaTransportEnum failed");
86 torture_assert_werr_ok(tctx, r.out.result, talloc_asprintf(tctx,
87 "NetWkstaTransportEnum level %u failed",
93 static bool test_NetrWkstaTransportAdd(struct torture_context *tctx,
94 struct dcerpc_pipe *p)
97 struct wkssvc_NetrWkstaTransportAdd r;
98 struct wkssvc_NetWkstaTransportInfo0 info0;
99 uint32_t parm_err = 0;
103 info0.quality_of_service = 0xffff;
105 info0.name = SMBTORTURE_TRANSPORT_NAME;
106 info0.address = "000000000000";
107 info0.wan_link = 0x400;
109 r.in.server_name = dcerpc_server_name(p);
112 r.in.parm_err = r.out.parm_err = &parm_err;
114 torture_comment(tctx, "testing NetrWkstaTransportAdd level 0\n");
116 status = dcerpc_wkssvc_NetrWkstaTransportAdd(p, tctx, &r);
117 torture_assert_ntstatus_ok(tctx, status,
118 "NetrWkstaTransportAdd failed");
119 torture_assert_werr_equal(tctx, r.out.result,
121 "NetrWkstaTransportAdd level 0 failed");
126 static bool test_NetrWkstaTransportDel(struct torture_context *tctx,
127 struct dcerpc_pipe *p)
130 struct wkssvc_NetrWkstaTransportDel r;
132 r.in.server_name = dcerpc_server_name(p);
133 r.in.transport_name = SMBTORTURE_TRANSPORT_NAME;
136 torture_comment(tctx, "testing NetrWkstaTransportDel\n");
138 status = dcerpc_wkssvc_NetrWkstaTransportDel(p, tctx, &r);
139 torture_assert_ntstatus_ok(tctx, status,
140 "NetrWkstaTransportDel failed");
141 torture_assert_werr_ok(tctx, r.out.result,
142 "NetrWkstaTransportDel");
147 static bool test_NetWkstaEnumUsers(struct torture_context *tctx,
148 struct dcerpc_pipe *p)
151 struct wkssvc_NetWkstaEnumUsers r;
153 uint32_t entries_read = 0;
154 struct wkssvc_NetWkstaEnumUsersInfo info;
155 struct wkssvc_NetWkstaEnumUsersCtr0 *user0;
156 struct wkssvc_NetWkstaEnumUsersCtr1 *user1;
157 uint32_t levels[] = { 0, 1 };
160 for (i=0; i<ARRAY_SIZE(levels); i++) {
164 info.level = levels[i];
165 switch (info.level) {
167 user0 = talloc_zero(tctx,
168 struct wkssvc_NetWkstaEnumUsersCtr0);
169 info.ctr.user0 = user0;
172 user1 = talloc_zero(tctx,
173 struct wkssvc_NetWkstaEnumUsersCtr1);
174 info.ctr.user1 = user1;
180 r.in.server_name = dcerpc_server_name(p);
181 r.in.prefmaxlen = (uint32_t)-1;
182 r.in.info = r.out.info = &info;
183 r.in.resume_handle = r.out.resume_handle = &handle;
185 r.out.entries_read = &entries_read;
187 torture_comment(tctx, "testing NetWkstaEnumUsers level %u\n",
190 status = dcerpc_wkssvc_NetWkstaEnumUsers(p, tctx, &r);
191 torture_assert_ntstatus_ok(tctx, status,
192 "NetWkstaEnumUsers failed");
193 torture_assert_werr_ok(tctx, r.out.result,
194 "NetWkstaEnumUsers failed");
200 static bool test_NetrWkstaUserGetInfo(struct torture_context *tctx,
201 struct dcerpc_pipe *p)
204 struct wkssvc_NetrWkstaUserGetInfo r;
205 union wkssvc_NetrWkstaUserInfo info;
206 const char *dom = lp_workgroup(global_loadparm);
207 struct cli_credentials *creds = cmdline_credentials;
208 const char *user = cli_credentials_get_username(creds);
216 { NULL, 0, WERR_NO_SUCH_LOGON_SESSION },
217 { NULL, 1, WERR_NO_SUCH_LOGON_SESSION },
218 { NULL, 1101, WERR_OK },
219 { dom, 0, WERR_INVALID_PARAM },
220 { dom, 1, WERR_INVALID_PARAM },
221 { dom, 1101, WERR_INVALID_PARAM },
222 { user, 0, WERR_INVALID_PARAM },
223 { user, 1, WERR_INVALID_PARAM },
224 { user, 1101, WERR_INVALID_PARAM },
227 for (i=0; i<ARRAY_SIZE(tests); i++) {
228 r.in.unknown = tests[i].unknown;
229 r.in.level = tests[i].level;
232 torture_comment(tctx, "testing NetrWkstaUserGetInfo level %u\n",
235 status = dcerpc_wkssvc_NetrWkstaUserGetInfo(p, tctx, &r);
236 torture_assert_ntstatus_ok(tctx, status,
237 "NetrWkstaUserGetInfo failed");
238 torture_assert_werr_equal(tctx, r.out.result,
240 "NetrWkstaUserGetInfo failed");
246 static bool test_NetrUseEnum(struct torture_context *tctx,
247 struct dcerpc_pipe *p)
250 struct wkssvc_NetrUseEnum r;
252 uint32_t entries_read = 0;
253 struct wkssvc_NetrUseEnumInfo info;
254 struct wkssvc_NetrUseEnumCtr0 *use0;
255 struct wkssvc_NetrUseEnumCtr1 *use1;
256 struct wkssvc_NetrUseEnumCtr2 *use2;
257 uint32_t levels[] = { 0, 1, 2 };
260 for (i=0; i<ARRAY_SIZE(levels); i++) {
264 info.level = levels[i];
265 switch (info.level) {
267 use0 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr0);
268 info.ctr.ctr0 = use0;
271 use1 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr1);
272 info.ctr.ctr1 = use1;
275 use2 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr2);
276 info.ctr.ctr2 = use2;
282 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
283 r.in.prefmaxlen = (uint32_t)-1;
284 r.in.info = r.out.info = &info;
285 r.in.resume_handle = r.out.resume_handle = &handle;
287 r.out.entries_read = &entries_read;
289 torture_comment(tctx, "testing NetrUseEnum level %u\n",
292 status = dcerpc_wkssvc_NetrUseEnum(p, tctx, &r);
293 torture_assert_ntstatus_ok(tctx, status,
294 "NetrUseEnum failed");
295 torture_assert_werr_ok(tctx, r.out.result,
296 "NetrUseEnum failed");
302 static bool test_NetrUseAdd(struct torture_context *tctx,
303 struct dcerpc_pipe *p)
306 struct wkssvc_NetrUseAdd r;
307 struct wkssvc_NetrUseInfo0 info0;
308 struct wkssvc_NetrUseInfo1 info1;
309 union wkssvc_NetrUseGetInfoCtr *ctr;
310 uint32_t parm_err = 0;
312 ctr = talloc(tctx, union wkssvc_NetrUseGetInfoCtr);
316 info0.local = SMBTORTURE_USE_NAME;
317 info0.remote = "\\\\localhost\\c$";
321 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
324 r.in.parm_err = r.out.parm_err = &parm_err;
326 torture_comment(tctx, "testing NetrUseAdd level %u\n",
329 status = dcerpc_wkssvc_NetrUseAdd(p, tctx, &r);
330 torture_assert_ntstatus_ok(tctx, status,
331 "NetrUseAdd failed");
332 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
333 "NetrUseAdd failed");
338 info1.local = SMBTORTURE_USE_NAME;
339 info1.remote = "\\\\localhost\\sysvol";
340 info1.password = NULL;
344 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
347 r.in.parm_err = r.out.parm_err = &parm_err;
349 torture_comment(tctx, "testing NetrUseAdd level %u\n",
352 status = dcerpc_wkssvc_NetrUseAdd(p, tctx, &r);
353 torture_assert_ntstatus_ok(tctx, status,
354 "NetrUseAdd failed");
355 torture_assert_werr_ok(tctx, r.out.result,
356 "NetrUseAdd failed");
361 static bool test_NetrUseDel(struct torture_context *tctx,
362 struct dcerpc_pipe *p)
365 struct wkssvc_NetrUseDel r;
367 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
368 r.in.use_name = SMBTORTURE_USE_NAME;
371 torture_comment(tctx, "testing NetrUseDel\n");
373 status = dcerpc_wkssvc_NetrUseDel(p, tctx, &r);
374 torture_assert_ntstatus_ok(tctx, status,
375 "NetrUseDel failed");
376 torture_assert_werr_ok(tctx, r.out.result,
377 "NetrUseDel failed");
381 static bool test_NetrUseGetInfo_level(struct torture_context *tctx,
382 struct dcerpc_pipe *p,
383 const char *use_name,
388 struct wkssvc_NetrUseGetInfo r;
389 union wkssvc_NetrUseGetInfoCtr ctr;
393 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
394 r.in.use_name = use_name;
397 status = dcerpc_wkssvc_NetrUseGetInfo(p, tctx, &r);
399 torture_assert_ntstatus_ok(tctx, status,
400 "NetrUseGetInfo failed");
401 torture_assert_werr_equal(tctx, r.out.result, werr,
402 "NetrUseGetInfo failed");
406 static bool test_NetrUseGetInfo(struct torture_context *tctx,
407 struct dcerpc_pipe *p)
410 struct wkssvc_NetrUseEnum r;
412 uint32_t entries_read = 0;
413 struct wkssvc_NetrUseEnumInfo info;
414 struct wkssvc_NetrUseEnumCtr0 *use0;
415 uint32_t levels[] = { 0, 1, 2 };
416 const char *use_name = NULL;
422 use0 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr0);
423 info.ctr.ctr0 = use0;
425 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
426 r.in.prefmaxlen = (uint32_t)-1;
427 r.in.info = r.out.info = &info;
428 r.in.resume_handle = r.out.resume_handle = &handle;
429 r.out.entries_read = &entries_read;
431 status = dcerpc_wkssvc_NetrUseEnum(p, tctx, &r);
432 torture_assert_ntstatus_ok(tctx, status,
433 "NetrUseEnum failed");
434 torture_assert_werr_ok(tctx, r.out.result,
435 "NetrUseEnum failed");
437 for (k=0; k < r.out.info->ctr.ctr0->count; k++) {
439 use_name = r.out.info->ctr.ctr0->array[k].local;
441 for (i=0; i<ARRAY_SIZE(levels); i++) {
443 if (!test_NetrUseGetInfo_level(tctx, p, use_name,
447 if (levels[i] != 0) {
453 use_name = r.out.info->ctr.ctr0->array[k].remote;
455 for (i=0; i<ARRAY_SIZE(levels); i++) {
457 if (!test_NetrUseGetInfo_level(tctx, p, use_name,
461 if (levels[i] != 0) {
471 static bool test_NetrLogonDomainNameAdd(struct torture_context *tctx,
472 struct dcerpc_pipe *p)
475 struct wkssvc_NetrLogonDomainNameAdd r;
477 r.in.domain_name = lp_workgroup(global_loadparm);
479 torture_comment(tctx, "testing NetrLogonDomainNameAdd\n");
481 status = dcerpc_wkssvc_NetrLogonDomainNameAdd(p, tctx, &r);
482 torture_assert_ntstatus_ok(tctx, status,
483 "NetrLogonDomainNameAdd failed");
484 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
485 "NetrLogonDomainNameAdd failed");
489 static bool test_NetrLogonDomainNameDel(struct torture_context *tctx,
490 struct dcerpc_pipe *p)
493 struct wkssvc_NetrLogonDomainNameDel r;
495 r.in.domain_name = lp_workgroup(global_loadparm);
497 torture_comment(tctx, "testing NetrLogonDomainNameDel\n");
499 status = dcerpc_wkssvc_NetrLogonDomainNameDel(p, tctx, &r);
500 torture_assert_ntstatus_ok(tctx, status,
501 "NetrLogonDomainNameDel failed");
502 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
503 "NetrLogonDomainNameDel failed");
507 static bool test_NetrValidateName(struct torture_context *tctx,
508 struct dcerpc_pipe *p)
511 struct wkssvc_NetrValidateName r;
512 uint16_t levels[] = {0,1,2,3,4,5};
515 for (i=0; i<ARRAY_SIZE(levels); i++) {
517 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
518 r.in.name = lp_workgroup(global_loadparm);
520 r.in.Password = NULL;
521 r.in.name_type = levels[i];
523 torture_comment(tctx, "testing NetrValidateName level %u\n",
526 status = dcerpc_wkssvc_NetrValidateName(p, tctx, &r);
527 torture_assert_ntstatus_ok(tctx, status,
528 "NetrValidateName failed");
529 torture_assert_werr_equal(tctx, r.out.result,
531 "NetrValidateName failed");
537 static bool test_NetrValidateName2(struct torture_context *tctx,
538 struct dcerpc_pipe *p)
541 struct wkssvc_NetrValidateName2 r;
542 uint16_t levels[] = {0,1,2,3,4,5};
545 for (i=0; i<ARRAY_SIZE(levels); i++) {
547 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
548 r.in.name = lp_workgroup(global_loadparm);
550 r.in.EncryptedPassword = NULL;
551 r.in.name_type = levels[i];
553 torture_comment(tctx, "testing NetrValidateName2 level %u\n",
556 status = dcerpc_wkssvc_NetrValidateName2(p, tctx, &r);
557 torture_assert_ntstatus_ok(tctx, status,
558 "NetrValidateName2 failed");
559 torture_assert_werr_equal(tctx, r.out.result,
560 WERR_RPC_E_REMOTE_DISABLED,
561 "NetrValidateName2 failed");
567 struct torture_suite *torture_rpc_wkssvc(TALLOC_CTX *mem_ctx)
569 struct torture_suite *suite;
570 struct torture_rpc_tcase *tcase;
572 suite = torture_suite_create(mem_ctx, "WKSSVC");
573 tcase = torture_suite_add_rpc_iface_tcase(suite, "wkssvc",
576 torture_rpc_tcase_add_test(tcase, "NetWkstaGetInfo",
577 test_NetWkstaGetInfo);
579 torture_rpc_tcase_add_test(tcase, "NetWkstaTransportEnum",
580 test_NetWkstaTransportEnum);
581 torture_rpc_tcase_add_test(tcase, "NetrWkstaTransportDel",
582 test_NetrWkstaTransportDel);
583 torture_rpc_tcase_add_test(tcase, "NetrUseGetInfo",
584 test_NetrUseGetInfo);
585 torture_rpc_tcase_add_test(tcase, "NetrWkstaTransportAdd",
586 test_NetrWkstaTransportAdd);
588 torture_rpc_tcase_add_test(tcase, "NetWkstaEnumUsers",
589 test_NetWkstaEnumUsers);
590 torture_rpc_tcase_add_test(tcase, "NetrWkstaUserGetInfo",
591 test_NetrWkstaUserGetInfo);
593 torture_rpc_tcase_add_test(tcase, "NetrUseDel",
595 torture_rpc_tcase_add_test(tcase, "NetrUseEnum",
597 torture_rpc_tcase_add_test(tcase, "NetrUseAdd",
600 torture_rpc_tcase_add_test(tcase, "NetrValidateName",
601 test_NetrValidateName);
602 torture_rpc_tcase_add_test(tcase, "NetrValidateName2",
603 test_NetrValidateName2);
604 torture_rpc_tcase_add_test(tcase, "NetrLogonDomainNameDel",
605 test_NetrLogonDomainNameDel);
606 torture_rpc_tcase_add_test(tcase, "NetrLogonDomainNameAdd",
607 test_NetrLogonDomainNameAdd);