2 Unix SMB/CIFS implementation.
3 test suite for wkssvc rpc operations
5 Copyright (C) Andrew Tridgell 2003
6 Copyright (C) Günther Deschner 2007
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.
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.
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/>.
23 #include "torture/torture.h"
24 #include "librpc/gen_ndr/ndr_wkssvc_c.h"
25 #include "torture/rpc/torture_rpc.h"
26 #include "lib/cmdline/cmdline.h"
27 #include "param/param.h"
28 #include "libcli/auth/libcli_auth.h"
30 #define SMBTORTURE_MACHINE_NAME "smbtrt_name"
31 #define SMBTORTURE_ALTERNATE_NAME "smbtrt_altname"
32 #define SMBTORTURE_TRANSPORT_NAME "\\Device\\smbtrt_transport_name"
33 #define SMBTORTURE_USE_NAME "S:"
34 #define SMBTORTURE_MESSAGE "You are currently tortured by Samba"
36 static bool test_NetWkstaGetInfo(struct torture_context *tctx,
37 struct dcerpc_pipe *p)
40 struct wkssvc_NetWkstaGetInfo r;
41 union wkssvc_NetWkstaInfo info;
42 uint16_t levels[] = {100, 101, 102, 502};
44 struct dcerpc_binding_handle *b = p->binding_handle;
46 r.in.server_name = dcerpc_server_name(p);
49 for (i=0;i<ARRAY_SIZE(levels);i++) {
50 r.in.level = levels[i];
51 torture_comment(tctx, "Testing NetWkstaGetInfo level %u\n",
53 status = dcerpc_wkssvc_NetWkstaGetInfo_r(b, tctx, &r);
54 torture_assert_ntstatus_ok(tctx, status,
55 talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed",
57 torture_assert_werr_ok(tctx, r.out.result,
58 talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed",
65 static bool test_NetWkstaTransportEnum(struct torture_context *tctx,
66 struct dcerpc_pipe *p)
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 struct dcerpc_binding_handle *b = p->binding_handle;
83 r.in.server_name = dcerpc_server_name(p);
85 r.in.max_buffer = (uint32_t)-1;
86 r.in.resume_handle = &resume_handle;
87 r.out.total_entries = &total_entries;
89 r.out.resume_handle = &resume_handle;
91 torture_comment(tctx, "Testing NetWkstaTransportEnum level 0\n");
93 status = dcerpc_wkssvc_NetWkstaTransportEnum_r(b, tctx, &r);
94 torture_assert_ntstatus_ok(tctx, status,
95 "NetWkstaTransportEnum failed");
96 torture_assert_werr_ok(tctx, r.out.result, talloc_asprintf(tctx,
97 "NetWkstaTransportEnum level %u failed",
103 static bool test_NetrWkstaTransportAdd(struct torture_context *tctx,
104 struct dcerpc_pipe *p)
107 struct wkssvc_NetrWkstaTransportAdd r;
108 struct wkssvc_NetWkstaTransportInfo0 info0;
109 uint32_t parm_err = 0;
110 struct dcerpc_binding_handle *b = p->binding_handle;
114 info0.quality_of_service = 0xffff;
116 info0.name = SMBTORTURE_TRANSPORT_NAME;
117 info0.address = "000000000000";
118 info0.wan_link = 0x400;
120 r.in.server_name = dcerpc_server_name(p);
123 r.in.parm_err = r.out.parm_err = &parm_err;
125 torture_comment(tctx, "Testing NetrWkstaTransportAdd level 0\n");
127 status = dcerpc_wkssvc_NetrWkstaTransportAdd_r(b, tctx, &r);
128 torture_assert_ntstatus_ok(tctx, status,
129 "NetrWkstaTransportAdd failed");
130 torture_assert_werr_equal(tctx, r.out.result,
131 WERR_INVALID_PARAMETER,
132 "NetrWkstaTransportAdd level 0 failed");
137 static bool test_NetrWkstaTransportDel(struct torture_context *tctx,
138 struct dcerpc_pipe *p)
141 struct wkssvc_NetrWkstaTransportDel r;
142 struct dcerpc_binding_handle *b = p->binding_handle;
144 r.in.server_name = dcerpc_server_name(p);
145 r.in.transport_name = SMBTORTURE_TRANSPORT_NAME;
148 torture_comment(tctx, "Testing NetrWkstaTransportDel\n");
150 status = dcerpc_wkssvc_NetrWkstaTransportDel_r(b, tctx, &r);
151 torture_assert_ntstatus_ok(tctx, status,
152 "NetrWkstaTransportDel failed");
153 torture_assert_werr_ok(tctx, r.out.result,
154 "NetrWkstaTransportDel");
159 static bool test_NetWkstaEnumUsers(struct torture_context *tctx,
160 struct dcerpc_pipe *p)
163 struct wkssvc_NetWkstaEnumUsers r;
165 uint32_t entries_read = 0;
166 struct wkssvc_NetWkstaEnumUsersInfo info;
167 struct wkssvc_NetWkstaEnumUsersCtr0 *user0;
168 struct wkssvc_NetWkstaEnumUsersCtr1 *user1;
169 uint32_t levels[] = { 0, 1 };
171 struct dcerpc_binding_handle *b = p->binding_handle;
173 for (i=0; i<ARRAY_SIZE(levels); i++) {
177 info.level = levels[i];
178 switch (info.level) {
180 user0 = talloc_zero(tctx,
181 struct wkssvc_NetWkstaEnumUsersCtr0);
182 info.ctr.user0 = user0;
185 user1 = talloc_zero(tctx,
186 struct wkssvc_NetWkstaEnumUsersCtr1);
187 info.ctr.user1 = user1;
193 r.in.server_name = dcerpc_server_name(p);
194 r.in.prefmaxlen = (uint32_t)-1;
195 r.in.info = r.out.info = &info;
196 r.in.resume_handle = r.out.resume_handle = &handle;
198 r.out.entries_read = &entries_read;
200 torture_comment(tctx, "Testing NetWkstaEnumUsers level %u\n",
203 status = dcerpc_wkssvc_NetWkstaEnumUsers_r(b, tctx, &r);
204 torture_assert_ntstatus_ok(tctx, status,
205 "NetWkstaEnumUsers failed");
206 torture_assert_werr_ok(tctx, r.out.result,
207 "NetWkstaEnumUsers failed");
213 static bool test_NetrWkstaUserGetInfo(struct torture_context *tctx,
214 struct dcerpc_pipe *p)
217 struct wkssvc_NetrWkstaUserGetInfo r;
218 union wkssvc_NetrWkstaUserInfo info;
219 const char *dom = lpcfg_workgroup(tctx->lp_ctx);
220 struct cli_credentials *creds = samba_cmdline_get_creds();
221 const char *user = cli_credentials_get_username(creds);
223 struct dcerpc_binding_handle *b = p->binding_handle;
230 { NULL, 0, WERR_NO_SUCH_LOGON_SESSION },
231 { NULL, 1, WERR_NO_SUCH_LOGON_SESSION },
232 { NULL, 1101, WERR_OK },
233 { dom, 0, WERR_INVALID_PARAMETER },
234 { dom, 1, WERR_INVALID_PARAMETER },
235 { dom, 1101, WERR_INVALID_PARAMETER },
236 { user, 0, WERR_INVALID_PARAMETER },
237 { user, 1, WERR_INVALID_PARAMETER },
238 { user, 1101, WERR_INVALID_PARAMETER },
241 for (i=0; i<ARRAY_SIZE(tests); i++) {
242 r.in.unknown = tests[i].unknown;
243 r.in.level = tests[i].level;
246 torture_comment(tctx, "Testing NetrWkstaUserGetInfo level %u\n",
249 status = dcerpc_wkssvc_NetrWkstaUserGetInfo_r(b, tctx, &r);
250 torture_assert_ntstatus_ok(tctx, status,
251 "NetrWkstaUserGetInfo failed");
252 torture_assert_werr_equal(tctx, r.out.result,
254 "NetrWkstaUserGetInfo failed");
260 static bool test_NetrUseEnum(struct torture_context *tctx,
261 struct dcerpc_pipe *p)
264 struct wkssvc_NetrUseEnum r;
266 uint32_t entries_read = 0;
267 struct wkssvc_NetrUseEnumInfo info;
268 struct wkssvc_NetrUseEnumCtr0 *use0;
269 struct wkssvc_NetrUseEnumCtr1 *use1;
270 struct wkssvc_NetrUseEnumCtr2 *use2;
271 uint32_t levels[] = { 0, 1, 2 };
273 struct dcerpc_binding_handle *b = p->binding_handle;
275 for (i=0; i<ARRAY_SIZE(levels); i++) {
279 info.level = levels[i];
280 switch (info.level) {
282 use0 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr0);
283 info.ctr.ctr0 = use0;
286 use1 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr1);
287 info.ctr.ctr1 = use1;
290 use2 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr2);
291 info.ctr.ctr2 = use2;
297 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
298 r.in.prefmaxlen = (uint32_t)-1;
299 r.in.info = r.out.info = &info;
300 r.in.resume_handle = r.out.resume_handle = &handle;
302 r.out.entries_read = &entries_read;
304 torture_comment(tctx, "Testing NetrUseEnum level %u\n",
307 status = dcerpc_wkssvc_NetrUseEnum_r(b, tctx, &r);
308 torture_assert_ntstatus_ok(tctx, status,
309 "NetrUseEnum failed");
310 torture_assert_werr_ok(tctx, r.out.result,
311 "NetrUseEnum failed");
317 static bool test_NetrUseAdd(struct torture_context *tctx,
318 struct dcerpc_pipe *p)
321 struct wkssvc_NetrUseAdd r;
322 struct wkssvc_NetrUseInfo0 info0;
323 struct wkssvc_NetrUseInfo1 info1;
324 union wkssvc_NetrUseGetInfoCtr *ctr;
325 uint32_t parm_err = 0;
326 struct dcerpc_binding_handle *b = p->binding_handle;
328 ctr = talloc(tctx, union wkssvc_NetrUseGetInfoCtr);
332 info0.local = SMBTORTURE_USE_NAME;
333 info0.remote = "\\\\localhost\\c$";
337 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
340 r.in.parm_err = r.out.parm_err = &parm_err;
342 torture_comment(tctx, "Testing NetrUseAdd level %u\n",
345 status = dcerpc_wkssvc_NetrUseAdd_r(b, tctx, &r);
346 torture_assert_ntstatus_ok(tctx, status,
347 "NetrUseAdd failed");
348 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_LEVEL,
349 "NetrUseAdd failed");
354 info1.local = SMBTORTURE_USE_NAME;
355 info1.remote = "\\\\localhost\\sysvol";
356 info1.password = NULL;
360 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
363 r.in.parm_err = r.out.parm_err = &parm_err;
365 torture_comment(tctx, "Testing NetrUseAdd level %u\n",
368 status = dcerpc_wkssvc_NetrUseAdd_r(b, tctx, &r);
369 torture_assert_ntstatus_ok(tctx, status,
370 "NetrUseAdd failed");
371 torture_assert_werr_ok(tctx, r.out.result,
372 "NetrUseAdd failed");
377 static bool test_NetrUseDel(struct torture_context *tctx,
378 struct dcerpc_pipe *p)
381 struct wkssvc_NetrUseDel r;
382 struct dcerpc_binding_handle *b = p->binding_handle;
384 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
385 r.in.use_name = SMBTORTURE_USE_NAME;
388 torture_comment(tctx, "Testing NetrUseDel\n");
390 status = dcerpc_wkssvc_NetrUseDel_r(b, tctx, &r);
391 torture_assert_ntstatus_ok(tctx, status,
392 "NetrUseDel failed");
393 torture_assert_werr_ok(tctx, r.out.result,
394 "NetrUseDel failed");
398 static bool test_NetrUseGetInfo_level(struct torture_context *tctx,
399 struct dcerpc_pipe *p,
400 const char *use_name,
405 struct wkssvc_NetrUseGetInfo r;
406 union wkssvc_NetrUseGetInfoCtr ctr;
407 struct dcerpc_binding_handle *b = p->binding_handle;
411 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
412 r.in.use_name = use_name;
415 status = dcerpc_wkssvc_NetrUseGetInfo_r(b, tctx, &r);
417 torture_assert_ntstatus_ok(tctx, status,
418 "NetrUseGetInfo failed");
419 torture_assert_werr_equal(tctx, r.out.result, werr,
420 "NetrUseGetInfo failed");
424 static bool test_NetrUseGetInfo(struct torture_context *tctx,
425 struct dcerpc_pipe *p)
428 struct wkssvc_NetrUseEnum r;
430 uint32_t entries_read = 0;
431 struct wkssvc_NetrUseEnumInfo info;
432 struct wkssvc_NetrUseEnumCtr0 *use0;
433 uint32_t levels[] = { 0, 1, 2 };
434 const char *use_name = NULL;
436 struct dcerpc_binding_handle *b = p->binding_handle;
441 use0 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr0);
442 info.ctr.ctr0 = use0;
444 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
445 r.in.prefmaxlen = (uint32_t)-1;
446 r.in.info = r.out.info = &info;
447 r.in.resume_handle = r.out.resume_handle = &handle;
448 r.out.entries_read = &entries_read;
450 status = dcerpc_wkssvc_NetrUseEnum_r(b, tctx, &r);
451 torture_assert_ntstatus_ok(tctx, status,
452 "NetrUseEnum failed");
453 torture_assert_werr_ok(tctx, r.out.result,
454 "NetrUseEnum failed");
456 for (k=0; k < r.out.info->ctr.ctr0->count; k++) {
458 use_name = r.out.info->ctr.ctr0->array[k].local;
460 for (i=0; i<ARRAY_SIZE(levels); i++) {
462 if (!test_NetrUseGetInfo_level(tctx, p, use_name,
466 if (levels[i] != 0) {
472 use_name = r.out.info->ctr.ctr0->array[k].remote;
474 for (i=0; i<ARRAY_SIZE(levels); i++) {
476 if (!test_NetrUseGetInfo_level(tctx, p, use_name,
478 WERR_NERR_USENOTFOUND))
480 if (levels[i] != 0) {
490 static bool test_NetrLogonDomainNameAdd(struct torture_context *tctx,
491 struct dcerpc_pipe *p)
494 struct wkssvc_NetrLogonDomainNameAdd r;
495 struct dcerpc_binding_handle *b = p->binding_handle;
497 r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
499 torture_comment(tctx, "Testing NetrLogonDomainNameAdd\n");
501 status = dcerpc_wkssvc_NetrLogonDomainNameAdd_r(b, tctx, &r);
502 torture_assert_ntstatus_ok(tctx, status,
503 "NetrLogonDomainNameAdd failed");
504 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
505 "NetrLogonDomainNameAdd failed");
509 static bool test_NetrLogonDomainNameDel(struct torture_context *tctx,
510 struct dcerpc_pipe *p)
513 struct wkssvc_NetrLogonDomainNameDel r;
514 struct dcerpc_binding_handle *b = p->binding_handle;
516 r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
518 torture_comment(tctx, "Testing NetrLogonDomainNameDel\n");
520 status = dcerpc_wkssvc_NetrLogonDomainNameDel_r(b, tctx, &r);
521 torture_assert_ntstatus_ok(tctx, status,
522 "NetrLogonDomainNameDel failed");
523 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
524 "NetrLogonDomainNameDel failed");
528 static bool test_NetrEnumerateComputerNames_level(struct torture_context *tctx,
529 struct dcerpc_pipe *p,
535 struct wkssvc_NetrEnumerateComputerNames r;
536 struct wkssvc_ComputerNamesCtr *ctr;
538 struct dcerpc_binding_handle *b = p->binding_handle;
540 ctr = talloc_zero(tctx, struct wkssvc_ComputerNamesCtr);
542 r.in.server_name = dcerpc_server_name(p);
543 r.in.name_type = level;
547 torture_comment(tctx, "Testing NetrEnumerateComputerNames level %u\n",
550 status = dcerpc_wkssvc_NetrEnumerateComputerNames_r(b, tctx, &r);
551 torture_assert_ntstatus_ok(tctx, status,
552 "NetrEnumerateComputerNames failed");
553 torture_assert_werr_ok(tctx, r.out.result,
554 "NetrEnumerateComputerNames failed");
556 if ((level == NetPrimaryComputerName) && ctr->count != 1) {
557 torture_comment(tctx,
558 "NetrEnumerateComputerNames did not return one "
559 "name but %u\n", ctr->count);
563 if (names && num_names) {
566 for (i=0; i<ctr->count; i++) {
567 if (!add_string_to_array(tctx,
568 ctr->computer_name[i].string,
580 static bool test_NetrEnumerateComputerNames(struct torture_context *tctx,
581 struct dcerpc_pipe *p)
583 uint16_t levels[] = {0,1,2};
586 for (i=0; i<ARRAY_SIZE(levels); i++) {
588 if (!test_NetrEnumerateComputerNames_level(tctx,
600 static bool test_NetrValidateName(struct torture_context *tctx,
601 struct dcerpc_pipe *p)
604 struct wkssvc_NetrValidateName r;
605 uint16_t levels[] = {0,1,2,3,4,5};
607 struct dcerpc_binding_handle *b = p->binding_handle;
609 for (i=0; i<ARRAY_SIZE(levels); i++) {
611 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
612 r.in.name = lpcfg_workgroup(tctx->lp_ctx);
614 r.in.Password = NULL;
615 r.in.name_type = levels[i];
617 torture_comment(tctx, "Testing NetrValidateName level %u\n",
620 status = dcerpc_wkssvc_NetrValidateName_r(b, tctx, &r);
621 torture_assert_ntstatus_ok(tctx, status,
622 "NetrValidateName failed");
623 torture_assert_werr_equal(tctx, r.out.result,
625 "NetrValidateName failed");
631 static bool test_NetrValidateName2(struct torture_context *tctx,
632 struct dcerpc_pipe *p)
635 struct wkssvc_NetrValidateName2 r;
636 uint16_t levels[] = {0,1,2,3,4,5};
638 struct dcerpc_binding_handle *b = p->binding_handle;
640 for (i=0; i<ARRAY_SIZE(levels); i++) {
642 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
643 r.in.name = lpcfg_workgroup(tctx->lp_ctx);
645 r.in.EncryptedPassword = NULL;
646 r.in.name_type = levels[i];
648 torture_comment(tctx, "Testing NetrValidateName2 level %u\n",
651 status = dcerpc_wkssvc_NetrValidateName2_r(b, tctx, &r);
652 torture_assert_ntstatus_ok(tctx, status,
653 "NetrValidateName2 failed");
654 torture_assert_werr_equal(tctx, r.out.result,
655 W_ERROR(HRES_ERROR_V(HRES_RPC_E_REMOTE_DISABLED)),
656 "NetrValidateName2 failed");
662 static bool test_NetrAddAlternateComputerName(struct torture_context *tctx,
663 struct dcerpc_pipe *p)
666 struct wkssvc_NetrAddAlternateComputerName r;
667 const char **names = NULL;
668 size_t num_names = 0;
670 struct dcerpc_binding_handle *b = p->binding_handle;
672 r.in.server_name = dcerpc_server_name(p);
673 r.in.NewAlternateMachineName = SMBTORTURE_ALTERNATE_NAME;
675 r.in.EncryptedPassword = NULL;
678 torture_comment(tctx, "Testing NetrAddAlternateComputerName\n");
680 status = dcerpc_wkssvc_NetrAddAlternateComputerName_r(b, tctx, &r);
681 torture_assert_ntstatus_ok(tctx, status,
682 "NetrAddAlternateComputerName failed");
683 torture_assert_werr_ok(tctx, r.out.result,
684 "NetrAddAlternateComputerName failed");
686 if (!test_NetrEnumerateComputerNames_level(tctx, p,
687 NetAlternateComputerNames,
693 for (i=0; i<num_names; i++) {
694 if (strequal(names[i], SMBTORTURE_ALTERNATE_NAME)) {
699 torture_comment(tctx, "new alternate name not set\n");
704 static bool test_NetrRemoveAlternateComputerName(struct torture_context *tctx,
705 struct dcerpc_pipe *p)
708 struct wkssvc_NetrRemoveAlternateComputerName r;
709 const char **names = NULL;
710 size_t num_names = 0;
712 struct dcerpc_binding_handle *b = p->binding_handle;
714 r.in.server_name = dcerpc_server_name(p);
715 r.in.AlternateMachineNameToRemove = SMBTORTURE_ALTERNATE_NAME;
717 r.in.EncryptedPassword = NULL;
720 torture_comment(tctx, "Testing NetrRemoveAlternateComputerName\n");
722 status = dcerpc_wkssvc_NetrRemoveAlternateComputerName_r(b, tctx, &r);
723 torture_assert_ntstatus_ok(tctx, status,
724 "NetrRemoveAlternateComputerName failed");
725 torture_assert_werr_ok(tctx, r.out.result,
726 "NetrRemoveAlternateComputerName failed");
728 if (!test_NetrEnumerateComputerNames_level(tctx, p,
729 NetAlternateComputerNames,
735 for (i=0; i<num_names; i++) {
736 if (strequal(names[i], SMBTORTURE_ALTERNATE_NAME)) {
744 static bool test_NetrSetPrimaryComputername_name(struct torture_context *tctx,
745 struct dcerpc_pipe *p,
749 struct wkssvc_NetrSetPrimaryComputername r;
750 struct dcerpc_binding_handle *b = p->binding_handle;
752 r.in.server_name = dcerpc_server_name(p);
753 r.in.primary_name = name;
755 r.in.EncryptedPassword = NULL;
758 status = dcerpc_wkssvc_NetrSetPrimaryComputername_r(b, tctx, &r);
759 torture_assert_ntstatus_ok(tctx, status,
760 "NetrSetPrimaryComputername failed");
761 torture_assert_werr_ok(tctx, r.out.result,
762 "NetrSetPrimaryComputername failed");
767 static bool test_NetrSetPrimaryComputername(struct torture_context *tctx,
768 struct dcerpc_pipe *p)
774 set new primary (alternate)
776 later: check if del is possible
777 set primary back to origin
782 const char **names_o = NULL, **names = NULL;
783 size_t num_names_o = 0, num_names = 0;
785 torture_comment(tctx, "Testing NetrSetPrimaryComputername\n");
787 if (!test_NetrAddAlternateComputerName(tctx, p)) {
791 if (!test_NetrEnumerateComputerNames_level(tctx, p,
792 NetPrimaryComputerName,
793 &names_o, &num_names_o))
798 if (num_names_o != 1) {
802 if (!test_NetrSetPrimaryComputername_name(tctx, p,
803 SMBTORTURE_ALTERNATE_NAME))
808 if (!test_NetrEnumerateComputerNames_level(tctx, p,
809 NetPrimaryComputerName,
815 if (num_names != 1) {
819 if (!strequal(names[0], SMBTORTURE_ALTERNATE_NAME)) {
820 torture_comment(tctx,
821 "name mismatch (%s != %s) after NetrSetPrimaryComputername!\n",
822 names[0], SMBTORTURE_ALTERNATE_NAME);
826 if (!test_NetrSetPrimaryComputername_name(tctx, p,
832 if (!test_NetrRemoveAlternateComputerName(tctx, p)) {
840 static bool test_NetrRenameMachineInDomain(struct torture_context *tctx,
841 struct dcerpc_pipe *p)
844 struct wkssvc_NetrRenameMachineInDomain r;
845 struct dcerpc_binding_handle *b = p->binding_handle;
847 r.in.server_name = dcerpc_server_name(p);
848 r.in.NewMachineName = SMBTORTURE_MACHINE_NAME;
850 r.in.password = NULL;
851 r.in.RenameOptions = 0;
853 torture_comment(tctx, "Testing NetrRenameMachineInDomain\n");
855 status = dcerpc_wkssvc_NetrRenameMachineInDomain_r(b, tctx, &r);
856 torture_assert_ntstatus_ok(tctx, status,
857 "NetrRenameMachineInDomain failed");
858 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
859 "NetrRenameMachineInDomain failed");
863 static bool test_NetrRenameMachineInDomain2_name(struct torture_context *tctx,
864 struct dcerpc_pipe *p,
865 const char *new_name)
868 struct wkssvc_NetrRenameMachineInDomain2 r;
869 struct dcerpc_binding_handle *b = p->binding_handle;
871 r.in.server_name = dcerpc_server_name(p);
872 r.in.NewMachineName = new_name;
874 r.in.EncryptedPassword = NULL;
875 r.in.RenameOptions = 0;
877 status = dcerpc_wkssvc_NetrRenameMachineInDomain2_r(b, tctx, &r);
878 torture_assert_ntstatus_ok(tctx, status,
879 "NetrRenameMachineInDomain2 failed");
880 torture_assert_werr_ok(tctx, r.out.result,
881 "NetrRenameMachineInDomain2 failed");
885 static bool test_NetrRenameMachineInDomain2(struct torture_context *tctx,
886 struct dcerpc_pipe *p)
888 const char **names_o = NULL, **names = NULL;
889 size_t num_names_o = 0, num_names = 0;
891 torture_comment(tctx, "Testing NetrRenameMachineInDomain2\n");
893 if (!test_NetrEnumerateComputerNames_level(tctx, p,
894 NetPrimaryComputerName,
895 &names_o, &num_names_o))
900 if (num_names_o != 1) {
904 if (!test_NetrRenameMachineInDomain2_name(tctx, p,
905 SMBTORTURE_MACHINE_NAME))
910 if (!test_NetrEnumerateComputerNames_level(tctx, p,
911 NetPrimaryComputerName,
917 if (num_names != 1) {
921 if (strequal(names[0], names_o[0])) {
922 test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]);
926 if (!strequal(names[0], SMBTORTURE_MACHINE_NAME)) {
927 test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]);
931 if (!test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]))
936 if (!test_NetrEnumerateComputerNames_level(tctx, p,
937 NetPrimaryComputerName,
943 if (num_names != 1) {
947 if (!strequal(names[0], names_o[0])) {
954 static bool test_NetrWorkstationStatisticsGet(struct torture_context *tctx,
955 struct dcerpc_pipe *p)
958 struct wkssvc_NetrWorkstationStatisticsGet r;
959 struct wkssvc_NetrWorkstationStatistics *info;
960 struct dcerpc_binding_handle *b = p->binding_handle;
964 info = talloc_zero(tctx, struct wkssvc_NetrWorkstationStatistics);
966 r.in.server_name = dcerpc_server_name(p);
969 torture_comment(tctx, "Testing NetrWorkstationStatisticsGet\n");
971 status = dcerpc_wkssvc_NetrWorkstationStatisticsGet_r(b, tctx, &r);
972 torture_assert_ntstatus_ok(tctx, status,
973 "NetrWorkstationStatisticsGet failed");
974 torture_assert_werr_ok(tctx, r.out.result,
975 "NetrWorkstationStatisticsGet failed");
979 /* only succeeds as long as the local messenger service is running - Guenther */
981 static bool test_NetrMessageBufferSend(struct torture_context *tctx,
982 struct dcerpc_pipe *p)
985 struct wkssvc_NetrMessageBufferSend r;
986 const char *message = SMBTORTURE_MESSAGE;
989 struct dcerpc_binding_handle *b = p->binding_handle;
991 if (!push_ucs2_talloc(tctx, &msg, message, &size)) {
995 r.in.server_name = dcerpc_server_name(p);
996 r.in.message_name = dcerpc_server_name(p);
997 r.in.message_sender_name = dcerpc_server_name(p);
998 r.in.message_buffer = (uint8_t *)msg;
999 r.in.message_size = size;
1001 torture_comment(tctx, "Testing NetrMessageBufferSend\n");
1003 status = dcerpc_wkssvc_NetrMessageBufferSend_r(b, tctx, &r);
1004 torture_assert_ntstatus_ok(tctx, status,
1005 "NetrMessageBufferSend failed");
1006 torture_assert_werr_ok(tctx, r.out.result,
1007 "NetrMessageBufferSend failed");
1011 static bool test_NetrGetJoinInformation(struct torture_context *tctx,
1012 struct dcerpc_pipe *p)
1015 struct wkssvc_NetrGetJoinInformation r;
1016 enum wkssvc_NetJoinStatus join_status;
1017 const char *name_buffer = "";
1018 struct dcerpc_binding_handle *b = p->binding_handle;
1020 r.in.server_name = dcerpc_server_name(p);
1021 r.in.name_buffer = r.out.name_buffer = &name_buffer;
1022 r.out.name_type = &join_status;
1024 torture_comment(tctx, "Testing NetrGetJoinInformation\n");
1026 status = dcerpc_wkssvc_NetrGetJoinInformation_r(b, tctx, &r);
1027 torture_assert_ntstatus_ok(tctx, status,
1028 "NetrGetJoinInformation failed");
1029 torture_assert_werr_ok(tctx, r.out.result,
1030 "NetrGetJoinInformation failed");
1034 static bool test_GetJoinInformation(struct torture_context *tctx,
1035 struct dcerpc_pipe *p,
1036 enum wkssvc_NetJoinStatus *join_status_p,
1040 struct wkssvc_NetrGetJoinInformation r;
1041 enum wkssvc_NetJoinStatus join_status;
1042 const char *name_buffer = "";
1043 struct dcerpc_binding_handle *b = p->binding_handle;
1045 r.in.server_name = dcerpc_server_name(p);
1046 r.in.name_buffer = r.out.name_buffer = &name_buffer;
1047 r.out.name_type = &join_status;
1049 status = dcerpc_wkssvc_NetrGetJoinInformation_r(b, tctx, &r);
1050 torture_assert_ntstatus_ok(tctx, status,
1051 "NetrGetJoinInformation failed");
1052 torture_assert_werr_ok(tctx, r.out.result,
1053 "NetrGetJoinInformation failed");
1055 if (join_status_p) {
1056 *join_status_p = join_status;
1060 *name = talloc_strdup(tctx, name_buffer);
1067 static bool test_NetrGetJoinableOus(struct torture_context *tctx,
1068 struct dcerpc_pipe *p)
1071 struct wkssvc_NetrGetJoinableOus r;
1072 uint32_t num_ous = 0;
1073 const char **ous = NULL;
1074 struct dcerpc_binding_handle *b = p->binding_handle;
1076 r.in.server_name = dcerpc_server_name(p);
1077 r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
1078 r.in.Account = NULL;
1079 r.in.unknown = NULL;
1080 r.in.num_ous = r.out.num_ous = &num_ous;
1083 torture_comment(tctx, "Testing NetrGetJoinableOus\n");
1085 status = dcerpc_wkssvc_NetrGetJoinableOus_r(b, tctx, &r);
1086 torture_assert_ntstatus_ok(tctx, status, "NetrGetJoinableOus failed");
1087 torture_assert_werr_equal(tctx, r.out.result,
1089 "NetrGetJoinableOus failed");
1094 static bool test_NetrGetJoinableOus2(struct torture_context *tctx,
1095 struct dcerpc_pipe *p)
1098 struct wkssvc_NetrGetJoinableOus2 r;
1099 uint32_t num_ous = 0;
1100 const char **ous = NULL;
1101 struct dcerpc_binding_handle *b = p->binding_handle;
1103 r.in.server_name = dcerpc_server_name(p);
1104 r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
1105 r.in.Account = NULL;
1106 r.in.EncryptedPassword = NULL;
1107 r.in.num_ous = r.out.num_ous = &num_ous;
1110 torture_comment(tctx, "Testing NetrGetJoinableOus2\n");
1112 status = dcerpc_wkssvc_NetrGetJoinableOus2_r(b, tctx, &r);
1113 torture_assert_ntstatus_ok(tctx, status, "NetrGetJoinableOus2 failed");
1114 torture_assert_werr_equal(tctx, r.out.result,
1115 W_ERROR(HRES_ERROR_V(HRES_RPC_E_REMOTE_DISABLED)),
1116 "NetrGetJoinableOus2 failed");
1121 static bool test_NetrUnjoinDomain(struct torture_context *tctx,
1122 struct dcerpc_pipe *p)
1125 struct wkssvc_NetrUnjoinDomain r;
1126 struct cli_credentials *creds = samba_cmdline_get_creds();
1127 const char *user = cli_credentials_get_username(creds);
1128 const char *admin_account = NULL;
1129 struct dcerpc_binding_handle *b = p->binding_handle;
1131 admin_account = talloc_asprintf(tctx, "%s\\%s",
1132 lpcfg_workgroup(tctx->lp_ctx),
1135 r.in.server_name = dcerpc_server_name(p);
1136 r.in.Account = admin_account;
1137 r.in.password = NULL;
1138 r.in.unjoin_flags = 0;
1140 torture_comment(tctx, "Testing NetrUnjoinDomain\n");
1142 status = dcerpc_wkssvc_NetrUnjoinDomain_r(b, tctx, &r);
1143 torture_assert_ntstatus_ok(tctx, status,
1144 "NetrUnjoinDomain failed");
1145 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1146 "NetrUnjoinDomain failed");
1150 static bool test_NetrJoinDomain(struct torture_context *tctx,
1151 struct dcerpc_pipe *p)
1154 struct wkssvc_NetrJoinDomain r;
1155 struct cli_credentials *creds = samba_cmdline_get_creds();
1156 const char *user = cli_credentials_get_username(creds);
1157 const char *admin_account = NULL;
1158 struct dcerpc_binding_handle *b = p->binding_handle;
1160 admin_account = talloc_asprintf(tctx, "%s\\%s",
1161 lpcfg_workgroup(tctx->lp_ctx),
1164 r.in.server_name = dcerpc_server_name(p);
1165 r.in.domain_name = lpcfg_dnsdomain(tctx->lp_ctx);
1166 r.in.account_ou = NULL;
1167 r.in.Account = admin_account;
1168 r.in.password = NULL;
1169 r.in.join_flags = 0;
1171 torture_comment(tctx, "Testing NetrJoinDomain\n");
1173 status = dcerpc_wkssvc_NetrJoinDomain_r(b, tctx, &r);
1174 torture_assert_ntstatus_ok(tctx, status,
1175 "NetrJoinDomain failed");
1176 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1177 "NetrJoinDomain failed");
1182 * prerequisites for remotely joining an unjoined XP SP2 workstation:
1183 * - firewall needs to be disabled (or open for ncacn_np access)
1184 * - HKLM\System\CurrentControlSet\Control\Lsa\forceguest needs to 0
1186 * http://support.microsoft.com/kb/294355/EN-US/ and
1187 * http://support.microsoft.com/kb/290403/EN-US/
1190 static bool test_NetrJoinDomain2(struct torture_context *tctx,
1191 struct dcerpc_pipe *p)
1194 struct wkssvc_NetrJoinDomain2 r;
1195 const char *domain_admin_account = NULL;
1196 const char *domain_admin_password = NULL;
1197 const char *domain_name = NULL;
1198 struct wkssvc_PasswordBuffer *pwd_buf;
1199 enum wkssvc_NetJoinStatus join_status;
1200 const char *join_name = NULL;
1201 WERROR expected_err;
1203 DATA_BLOB session_key;
1204 struct dcerpc_binding_handle *b = p->binding_handle;
1206 /* FIXME: this test assumes to join workstations / servers and does not
1207 * handle DCs (WERR_NERR_SETUPDOMAINCONTROLLER) */
1209 if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1214 switch (join_status) {
1215 case NET_SETUP_DOMAIN_NAME:
1216 expected_err = WERR_NERR_SETUPALREADYJOINED;
1218 case NET_SETUP_UNKNOWN_STATUS:
1219 case NET_SETUP_UNJOINED:
1220 case NET_SETUP_WORKGROUP_NAME:
1222 expected_err = WERR_OK;
1226 domain_admin_account = torture_setting_string(tctx, "domain_admin_account", NULL);
1228 domain_admin_password = torture_setting_string(tctx, "domain_admin_password", NULL);
1230 domain_name = torture_setting_string(tctx, "domain_name", NULL);
1232 if ((domain_admin_account == NULL) ||
1233 (domain_admin_password == NULL) ||
1234 (domain_name == NULL)) {
1235 torture_comment(tctx, "not enough input parameter\n");
1239 status = dcerpc_fetch_session_key(p, &session_key);
1240 if (!NT_STATUS_IS_OK(status)) {
1244 werr = encode_wkssvc_join_password_buffer(tctx,
1245 domain_admin_password,
1248 if (!W_ERROR_IS_OK(werr)) {
1252 r.in.server_name = dcerpc_server_name(p);
1253 r.in.domain_name = domain_name;
1254 r.in.account_ou = NULL;
1255 r.in.admin_account = domain_admin_account;
1256 r.in.encrypted_password = pwd_buf;
1257 r.in.join_flags = WKSSVC_JOIN_FLAGS_JOIN_TYPE |
1258 WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE;
1260 torture_comment(tctx, "Testing NetrJoinDomain2 (assuming non-DC)\n");
1262 status = dcerpc_wkssvc_NetrJoinDomain2_r(b, tctx, &r);
1263 torture_assert_ntstatus_ok(tctx, status,
1264 "NetrJoinDomain2 failed");
1265 torture_assert_werr_equal(tctx, r.out.result, expected_err,
1266 "NetrJoinDomain2 failed");
1268 if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1273 if (join_status != NET_SETUP_DOMAIN_NAME) {
1274 torture_comment(tctx,
1275 "Join verify failed: got %d\n", join_status);
1282 static bool test_NetrUnjoinDomain2(struct torture_context *tctx,
1283 struct dcerpc_pipe *p)
1286 struct wkssvc_NetrUnjoinDomain2 r;
1287 const char *domain_admin_account = NULL;
1288 const char *domain_admin_password = NULL;
1289 struct wkssvc_PasswordBuffer *pwd_buf;
1290 enum wkssvc_NetJoinStatus join_status;
1291 const char *join_name = NULL;
1292 WERROR expected_err;
1294 DATA_BLOB session_key;
1295 struct dcerpc_binding_handle *b = p->binding_handle;
1297 /* FIXME: this test assumes to join workstations / servers and does not
1298 * handle DCs (WERR_NERR_SETUPDOMAINCONTROLLER) */
1300 if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1305 switch (join_status) {
1306 case NET_SETUP_UNJOINED:
1307 expected_err = WERR_NERR_SETUPNOTJOINED;
1309 case NET_SETUP_DOMAIN_NAME:
1310 case NET_SETUP_UNKNOWN_STATUS:
1311 case NET_SETUP_WORKGROUP_NAME:
1313 expected_err = WERR_OK;
1317 domain_admin_account = torture_setting_string(tctx, "domain_admin_account", NULL);
1319 domain_admin_password = torture_setting_string(tctx, "domain_admin_password", NULL);
1321 if ((domain_admin_account == NULL) ||
1322 (domain_admin_password == NULL)) {
1323 torture_comment(tctx, "not enough input parameter\n");
1327 status = dcerpc_fetch_session_key(p, &session_key);
1328 if (!NT_STATUS_IS_OK(status)) {
1332 werr = encode_wkssvc_join_password_buffer(tctx,
1333 domain_admin_password,
1336 if (!W_ERROR_IS_OK(werr)) {
1340 r.in.server_name = dcerpc_server_name(p);
1341 r.in.account = domain_admin_account;
1342 r.in.encrypted_password = pwd_buf;
1343 r.in.unjoin_flags = 0;
1345 torture_comment(tctx, "Testing NetrUnjoinDomain2 (assuming non-DC)\n");
1347 status = dcerpc_wkssvc_NetrUnjoinDomain2_r(b, tctx, &r);
1348 torture_assert_ntstatus_ok(tctx, status,
1349 "NetrUnjoinDomain2 failed");
1350 torture_assert_werr_equal(tctx, r.out.result, expected_err,
1351 "NetrUnjoinDomain2 failed");
1353 if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1358 switch (join_status) {
1359 case NET_SETUP_UNJOINED:
1360 case NET_SETUP_WORKGROUP_NAME:
1362 case NET_SETUP_UNKNOWN_STATUS:
1363 case NET_SETUP_DOMAIN_NAME:
1365 torture_comment(tctx,
1366 "Unjoin verify failed: got %d\n", join_status);
1374 struct torture_suite *torture_rpc_wkssvc(TALLOC_CTX *mem_ctx)
1376 struct torture_suite *suite;
1377 struct torture_rpc_tcase *tcase;
1378 struct torture_test *test;
1380 suite = torture_suite_create(mem_ctx, "wkssvc");
1381 tcase = torture_suite_add_rpc_iface_tcase(suite, "wkssvc",
1384 torture_rpc_tcase_add_test(tcase, "NetWkstaGetInfo",
1385 test_NetWkstaGetInfo);
1387 torture_rpc_tcase_add_test(tcase, "NetWkstaTransportEnum",
1388 test_NetWkstaTransportEnum);
1389 torture_rpc_tcase_add_test(tcase, "NetrWkstaTransportDel",
1390 test_NetrWkstaTransportDel);
1391 torture_rpc_tcase_add_test(tcase, "NetrWkstaTransportAdd",
1392 test_NetrWkstaTransportAdd);
1394 torture_rpc_tcase_add_test(tcase, "NetWkstaEnumUsers",
1395 test_NetWkstaEnumUsers);
1396 torture_rpc_tcase_add_test(tcase, "NetrWkstaUserGetInfo",
1397 test_NetrWkstaUserGetInfo);
1399 torture_rpc_tcase_add_test(tcase, "NetrUseDel",
1401 torture_rpc_tcase_add_test(tcase, "NetrUseGetInfo",
1402 test_NetrUseGetInfo);
1403 torture_rpc_tcase_add_test(tcase, "NetrUseEnum",
1405 torture_rpc_tcase_add_test(tcase, "NetrUseAdd",
1408 torture_rpc_tcase_add_test(tcase, "NetrValidateName",
1409 test_NetrValidateName);
1410 torture_rpc_tcase_add_test(tcase, "NetrValidateName2",
1411 test_NetrValidateName2);
1412 torture_rpc_tcase_add_test(tcase, "NetrLogonDomainNameDel",
1413 test_NetrLogonDomainNameDel);
1414 torture_rpc_tcase_add_test(tcase, "NetrLogonDomainNameAdd",
1415 test_NetrLogonDomainNameAdd);
1416 torture_rpc_tcase_add_test(tcase, "NetrRemoveAlternateComputerName",
1417 test_NetrRemoveAlternateComputerName);
1418 torture_rpc_tcase_add_test(tcase, "NetrAddAlternateComputerName",
1419 test_NetrAddAlternateComputerName);
1420 test = torture_rpc_tcase_add_test(tcase, "NetrSetPrimaryComputername",
1421 test_NetrSetPrimaryComputername);
1422 test->dangerous = true;
1423 test = torture_rpc_tcase_add_test(tcase, "NetrRenameMachineInDomain",
1424 test_NetrRenameMachineInDomain);
1425 test->dangerous = true;
1426 test = torture_rpc_tcase_add_test(tcase, "NetrRenameMachineInDomain2",
1427 test_NetrRenameMachineInDomain2);
1428 test->dangerous = true;
1429 torture_rpc_tcase_add_test(tcase, "NetrEnumerateComputerNames",
1430 test_NetrEnumerateComputerNames);
1432 test = torture_rpc_tcase_add_test(tcase, "NetrJoinDomain2",
1433 test_NetrJoinDomain2);
1434 test->dangerous = true;
1435 test = torture_rpc_tcase_add_test(tcase, "NetrUnjoinDomain2",
1436 test_NetrUnjoinDomain2);
1437 test->dangerous = true;
1439 torture_rpc_tcase_add_test(tcase, "NetrJoinDomain",
1440 test_NetrJoinDomain);
1441 test->dangerous = true;
1442 torture_rpc_tcase_add_test(tcase, "NetrUnjoinDomain",
1443 test_NetrUnjoinDomain);
1444 test->dangerous = true;
1445 torture_rpc_tcase_add_test(tcase, "NetrGetJoinInformation",
1446 test_NetrGetJoinInformation);
1447 torture_rpc_tcase_add_test(tcase, "NetrGetJoinableOus",
1448 test_NetrGetJoinableOus);
1449 torture_rpc_tcase_add_test(tcase, "NetrGetJoinableOus2",
1450 test_NetrGetJoinableOus2);
1452 torture_rpc_tcase_add_test(tcase, "NetrWorkstationStatisticsGet",
1453 test_NetrWorkstationStatisticsGet);
1454 torture_rpc_tcase_add_test(tcase, "NetrMessageBufferSend",
1455 test_NetrMessageBufferSend);