← Back to branch summary

~ubuntu-branches/ubuntu/vivid/samba/vivid

« back to all changes in this revision

Viewing changes to source4/torture/rpc/wkssvc.c

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access.
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
source4/torture/rpc/wkssvc.c
22
22
#include "includes.h"
23
23
#include "torture/torture.h"
24
24
#include "librpc/gen_ndr/ndr_wkssvc_c.h"
25
 
#include "torture/rpc/rpc.h"
 
25
#include "torture/rpc/torture_rpc.h"
26
26
#include "lib/cmdline/popt_common.h"
27
27
#include "param/param.h"
28
28
#include "../lib/crypto/crypto.h"
42
42
        union wkssvc_NetWkstaInfo info;
43
43
        uint16_t levels[] = {100, 101, 102, 502};
44
44
        int i;
 
45
        struct dcerpc_binding_handle *b = p->binding_handle;
45
46
 
46
47
        r.in.server_name = dcerpc_server_name(p);
47
48
        r.out.info = &info;
48
49
 
49
50
        for (i=0;i<ARRAY_SIZE(levels);i++) {
50
51
                r.in.level = levels[i];
51
 
                torture_comment(tctx, "testing NetWkstaGetInfo level %u\n",
 
52
                torture_comment(tctx, "Testing NetWkstaGetInfo level %u\n",
52
53
                                r.in.level);
53
 
                status = dcerpc_wkssvc_NetWkstaGetInfo(p, tctx, &r);
 
54
                status = dcerpc_wkssvc_NetWkstaGetInfo_r(b, tctx, &r);
54
55
                torture_assert_ntstatus_ok(tctx, status,
55
56
                        talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed",
56
57
                                        r.in.level));
72
73
        union wkssvc_NetWkstaTransportCtr ctr;
73
74
        struct wkssvc_NetWkstaTransportCtr0 ctr0;
74
75
        uint32_t total_entries = 0;
 
76
        struct dcerpc_binding_handle *b = p->binding_handle;
75
77
 
76
78
        ZERO_STRUCT(ctr0);
77
79
        ctr.ctr0 = &ctr0;
87
89
        r.out.info = &info;
88
90
        r.out.resume_handle = &resume_handle;
89
91
 
90
 
        torture_comment(tctx, "testing NetWkstaTransportEnum level 0\n");
 
92
        torture_comment(tctx, "Testing NetWkstaTransportEnum level 0\n");
91
93
 
92
 
        status = dcerpc_wkssvc_NetWkstaTransportEnum(p, tctx, &r);
 
94
        status = dcerpc_wkssvc_NetWkstaTransportEnum_r(b, tctx, &r);
93
95
        torture_assert_ntstatus_ok(tctx, status,
94
96
                                   "NetWkstaTransportEnum failed");
95
97
        torture_assert_werr_ok(tctx, r.out.result, talloc_asprintf(tctx,
106
108
        struct wkssvc_NetrWkstaTransportAdd r;
107
109
        struct wkssvc_NetWkstaTransportInfo0 info0;
108
110
        uint32_t parm_err = 0;
 
111
        struct dcerpc_binding_handle *b = p->binding_handle;
109
112
 
110
113
        ZERO_STRUCT(info0);
111
114
 
120
123
        r.in.info0 = &info0;
121
124
        r.in.parm_err = r.out.parm_err = &parm_err;
122
125
 
123
 
        torture_comment(tctx, "testing NetrWkstaTransportAdd level 0\n");
 
126
        torture_comment(tctx, "Testing NetrWkstaTransportAdd level 0\n");
124
127
 
125
 
        status = dcerpc_wkssvc_NetrWkstaTransportAdd(p, tctx, &r);
 
128
        status = dcerpc_wkssvc_NetrWkstaTransportAdd_r(b, tctx, &r);
126
129
        torture_assert_ntstatus_ok(tctx, status,
127
130
                                   "NetrWkstaTransportAdd failed");
128
131
        torture_assert_werr_equal(tctx, r.out.result,
137
140
{
138
141
        NTSTATUS status;
139
142
        struct wkssvc_NetrWkstaTransportDel r;
 
143
        struct dcerpc_binding_handle *b = p->binding_handle;
140
144
 
141
145
        r.in.server_name = dcerpc_server_name(p);
142
146
        r.in.transport_name = SMBTORTURE_TRANSPORT_NAME;
143
147
        r.in.unknown3 = 0;
144
148
 
145
 
        torture_comment(tctx, "testing NetrWkstaTransportDel\n");
 
149
        torture_comment(tctx, "Testing NetrWkstaTransportDel\n");
146
150
 
147
 
        status = dcerpc_wkssvc_NetrWkstaTransportDel(p, tctx, &r);
 
151
        status = dcerpc_wkssvc_NetrWkstaTransportDel_r(b, tctx, &r);
148
152
        torture_assert_ntstatus_ok(tctx, status,
149
153
                                   "NetrWkstaTransportDel failed");
150
154
        torture_assert_werr_ok(tctx, r.out.result,
165
169
        struct wkssvc_NetWkstaEnumUsersCtr1 *user1;
166
170
        uint32_t levels[] = { 0, 1 };
167
171
        int i;
 
172
        struct dcerpc_binding_handle *b = p->binding_handle;
168
173
 
169
174
        for (i=0; i<ARRAY_SIZE(levels); i++) {
170
175
 
193
198
 
194
199
                r.out.entries_read = &entries_read;
195
200
 
196
 
                torture_comment(tctx, "testing NetWkstaEnumUsers level %u\n",
 
201
                torture_comment(tctx, "Testing NetWkstaEnumUsers level %u\n",
197
202
                                levels[i]);
198
203
 
199
 
                status = dcerpc_wkssvc_NetWkstaEnumUsers(p, tctx, &r);
 
204
                status = dcerpc_wkssvc_NetWkstaEnumUsers_r(b, tctx, &r);
200
205
                torture_assert_ntstatus_ok(tctx, status,
201
206
                                           "NetWkstaEnumUsers failed");
202
207
                torture_assert_werr_ok(tctx, r.out.result,
212
217
        NTSTATUS status;
213
218
        struct wkssvc_NetrWkstaUserGetInfo r;
214
219
        union wkssvc_NetrWkstaUserInfo info;
215
 
        const char *dom = lp_workgroup(tctx->lp_ctx);
 
220
        const char *dom = lpcfg_workgroup(tctx->lp_ctx);
216
221
        struct cli_credentials *creds = cmdline_credentials;
217
222
        const char *user = cli_credentials_get_username(creds);
218
223
        int i;
 
224
        struct dcerpc_binding_handle *b = p->binding_handle;
219
225
 
220
226
        const struct {
221
227
                const char *unknown;
238
244
                r.in.level = tests[i].level;
239
245
                r.out.info = &info;
240
246
 
241
 
                torture_comment(tctx, "testing NetrWkstaUserGetInfo level %u\n",
 
247
                torture_comment(tctx, "Testing NetrWkstaUserGetInfo level %u\n",
242
248
                                r.in.level);
243
249
 
244
 
                status = dcerpc_wkssvc_NetrWkstaUserGetInfo(p, tctx, &r);
 
250
                status = dcerpc_wkssvc_NetrWkstaUserGetInfo_r(b, tctx, &r);
245
251
                torture_assert_ntstatus_ok(tctx, status,
246
252
                                           "NetrWkstaUserGetInfo failed");
247
253
                torture_assert_werr_equal(tctx, r.out.result,
265
271
        struct wkssvc_NetrUseEnumCtr2 *use2;
266
272
        uint32_t levels[] = { 0, 1, 2 };
267
273
        int i;
 
274
        struct dcerpc_binding_handle *b = p->binding_handle;
268
275
 
269
276
        for (i=0; i<ARRAY_SIZE(levels); i++) {
270
277
 
295
302
 
296
303
                r.out.entries_read = &entries_read;
297
304
 
298
 
                torture_comment(tctx, "testing NetrUseEnum level %u\n",
 
305
                torture_comment(tctx, "Testing NetrUseEnum level %u\n",
299
306
                                levels[i]);
300
307
 
301
 
                status = dcerpc_wkssvc_NetrUseEnum(p, tctx, &r);
 
308
                status = dcerpc_wkssvc_NetrUseEnum_r(b, tctx, &r);
302
309
                torture_assert_ntstatus_ok(tctx, status,
303
310
                                           "NetrUseEnum failed");
304
311
                torture_assert_werr_ok(tctx, r.out.result,
317
324
        struct wkssvc_NetrUseInfo1 info1;
318
325
        union wkssvc_NetrUseGetInfoCtr *ctr;
319
326
        uint32_t parm_err = 0;
 
327
        struct dcerpc_binding_handle *b = p->binding_handle;
320
328
 
321
329
        ctr = talloc(tctx, union wkssvc_NetrUseGetInfoCtr);
322
330
 
332
340
        r.in.ctr = ctr;
333
341
        r.in.parm_err = r.out.parm_err = &parm_err;
334
342
 
335
 
        torture_comment(tctx, "testing NetrUseAdd level %u\n",
 
343
        torture_comment(tctx, "Testing NetrUseAdd level %u\n",
336
344
                        r.in.level);
337
345
 
338
 
        status = dcerpc_wkssvc_NetrUseAdd(p, tctx, &r);
 
346
        status = dcerpc_wkssvc_NetrUseAdd_r(b, tctx, &r);
339
347
        torture_assert_ntstatus_ok(tctx, status,
340
348
                                   "NetrUseAdd failed");
341
349
        torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
355
363
        r.in.ctr = ctr;
356
364
        r.in.parm_err = r.out.parm_err = &parm_err;
357
365
 
358
 
        torture_comment(tctx, "testing NetrUseAdd level %u\n",
 
366
        torture_comment(tctx, "Testing NetrUseAdd level %u\n",
359
367
                        r.in.level);
360
368
 
361
 
        status = dcerpc_wkssvc_NetrUseAdd(p, tctx, &r);
 
369
        status = dcerpc_wkssvc_NetrUseAdd_r(b, tctx, &r);
362
370
        torture_assert_ntstatus_ok(tctx, status,
363
371
                                   "NetrUseAdd failed");
364
372
        torture_assert_werr_ok(tctx, r.out.result,
372
380
{
373
381
        NTSTATUS status;
374
382
        struct wkssvc_NetrUseDel r;
 
383
        struct dcerpc_binding_handle *b = p->binding_handle;
375
384
 
376
385
        r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
377
386
        r.in.use_name = SMBTORTURE_USE_NAME;
378
387
        r.in.force_cond = 0;
379
388
 
380
 
        torture_comment(tctx, "testing NetrUseDel\n");
 
389
        torture_comment(tctx, "Testing NetrUseDel\n");
381
390
 
382
 
        status = dcerpc_wkssvc_NetrUseDel(p, tctx, &r);
 
391
        status = dcerpc_wkssvc_NetrUseDel_r(b, tctx, &r);
383
392
        torture_assert_ntstatus_ok(tctx, status,
384
393
                                   "NetrUseDel failed");
385
394
        torture_assert_werr_ok(tctx, r.out.result,
396
405
        NTSTATUS status;
397
406
        struct wkssvc_NetrUseGetInfo r;
398
407
        union wkssvc_NetrUseGetInfoCtr ctr;
 
408
        struct dcerpc_binding_handle *b = p->binding_handle;
399
409
 
400
410
        ZERO_STRUCT(ctr);
401
411
 
403
413
        r.in.use_name = use_name;
404
414
        r.in.level = level;
405
415
        r.out.ctr = &ctr;
406
 
        status = dcerpc_wkssvc_NetrUseGetInfo(p, tctx, &r);
 
416
        status = dcerpc_wkssvc_NetrUseGetInfo_r(b, tctx, &r);
407
417
 
408
418
        torture_assert_ntstatus_ok(tctx, status,
409
419
                                   "NetrUseGetInfo failed");
424
434
        uint32_t levels[] = { 0, 1, 2 };
425
435
        const char *use_name = NULL;
426
436
        int i, k;
 
437
        struct dcerpc_binding_handle *b = p->binding_handle;
427
438
 
428
439
        ZERO_STRUCT(info);
429
440
 
437
448
        r.in.resume_handle = r.out.resume_handle = &handle;
438
449
        r.out.entries_read = &entries_read;
439
450
 
440
 
        status = dcerpc_wkssvc_NetrUseEnum(p, tctx, &r);
 
451
        status = dcerpc_wkssvc_NetrUseEnum_r(b, tctx, &r);
441
452
        torture_assert_ntstatus_ok(tctx, status,
442
453
                                   "NetrUseEnum failed");
443
454
        torture_assert_werr_ok(tctx, r.out.result,
482
493
{
483
494
        NTSTATUS status;
484
495
        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);
 
496
        struct dcerpc_binding_handle *b = p->binding_handle;
 
497
 
 
498
        r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
 
499
 
 
500
        torture_comment(tctx, "Testing NetrLogonDomainNameAdd\n");
 
501
 
 
502
        status = dcerpc_wkssvc_NetrLogonDomainNameAdd_r(b, tctx, &r);
491
503
        torture_assert_ntstatus_ok(tctx, status,
492
504
                                   "NetrLogonDomainNameAdd failed");
493
505
        torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
500
512
{
501
513
        NTSTATUS status;
502
514
        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);
 
515
        struct dcerpc_binding_handle *b = p->binding_handle;
 
516
 
 
517
        r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
 
518
 
 
519
        torture_comment(tctx, "Testing NetrLogonDomainNameDel\n");
 
520
 
 
521
        status = dcerpc_wkssvc_NetrLogonDomainNameDel_r(b, tctx, &r);
509
522
        torture_assert_ntstatus_ok(tctx, status,
510
523
                                   "NetrLogonDomainNameDel failed");
511
524
        torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
523
536
        struct wkssvc_NetrEnumerateComputerNames r;
524
537
        struct wkssvc_ComputerNamesCtr *ctr;
525
538
        int i;
 
539
        struct dcerpc_binding_handle *b = p->binding_handle;
526
540
 
527
541
        ctr = talloc_zero(tctx, struct wkssvc_ComputerNamesCtr);
528
542
 
531
545
        r.in.Reserved = 0;
532
546
        r.out.ctr = &ctr;
533
547
 
534
 
        torture_comment(tctx, "testing NetrEnumerateComputerNames level %u\n",
 
548
        torture_comment(tctx, "Testing NetrEnumerateComputerNames level %u\n",
535
549
                        r.in.name_type);
536
550
 
537
 
        status = dcerpc_wkssvc_NetrEnumerateComputerNames(p, tctx, &r);
 
551
        status = dcerpc_wkssvc_NetrEnumerateComputerNames_r(b, tctx, &r);
538
552
        torture_assert_ntstatus_ok(tctx, status,
539
553
                                   "NetrEnumerateComputerNames failed");
540
554
        torture_assert_werr_ok(tctx, r.out.result,
591
605
        struct wkssvc_NetrValidateName r;
592
606
        uint16_t levels[] = {0,1,2,3,4,5};
593
607
        int i;
 
608
        struct dcerpc_binding_handle *b = p->binding_handle;
594
609
 
595
610
        for (i=0; i<ARRAY_SIZE(levels); i++) {
596
611
 
597
612
                r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
598
 
                r.in.name = lp_workgroup(tctx->lp_ctx);
 
613
                r.in.name = lpcfg_workgroup(tctx->lp_ctx);
599
614
                r.in.Account = NULL;
600
615
                r.in.Password = NULL;
601
616
                r.in.name_type = levels[i];
602
617
 
603
 
                torture_comment(tctx, "testing NetrValidateName level %u\n",
 
618
                torture_comment(tctx, "Testing NetrValidateName level %u\n",
604
619
                                r.in.name_type);
605
620
 
606
 
                status = dcerpc_wkssvc_NetrValidateName(p, tctx, &r);
 
621
                status = dcerpc_wkssvc_NetrValidateName_r(b, tctx, &r);
607
622
                torture_assert_ntstatus_ok(tctx, status,
608
623
                                           "NetrValidateName failed");
609
624
                torture_assert_werr_equal(tctx, r.out.result,
621
636
        struct wkssvc_NetrValidateName2 r;
622
637
        uint16_t levels[] = {0,1,2,3,4,5};
623
638
        int i;
 
639
        struct dcerpc_binding_handle *b = p->binding_handle;
624
640
 
625
641
        for (i=0; i<ARRAY_SIZE(levels); i++) {
626
642
 
627
643
                r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
628
 
                r.in.name = lp_workgroup(tctx->lp_ctx);
 
644
                r.in.name = lpcfg_workgroup(tctx->lp_ctx);
629
645
                r.in.Account = NULL;
630
646
                r.in.EncryptedPassword = NULL;
631
647
                r.in.name_type = levels[i];
632
648
 
633
 
                torture_comment(tctx, "testing NetrValidateName2 level %u\n",
 
649
                torture_comment(tctx, "Testing NetrValidateName2 level %u\n",
634
650
                                r.in.name_type);
635
651
 
636
 
                status = dcerpc_wkssvc_NetrValidateName2(p, tctx, &r);
 
652
                status = dcerpc_wkssvc_NetrValidateName2_r(b, tctx, &r);
637
653
                torture_assert_ntstatus_ok(tctx, status,
638
654
                                           "NetrValidateName2 failed");
639
655
                torture_assert_werr_equal(tctx, r.out.result,
652
668
        const char **names = NULL;
653
669
        int num_names = 0;
654
670
        int i;
 
671
        struct dcerpc_binding_handle *b = p->binding_handle;
655
672
 
656
673
        r.in.server_name = dcerpc_server_name(p);
657
674
        r.in.NewAlternateMachineName = SMBTORTURE_ALTERNATE_NAME;
659
676
        r.in.EncryptedPassword = NULL;
660
677
        r.in.Reserved = 0;
661
678
 
662
 
        torture_comment(tctx, "testing NetrAddAlternateComputerName\n");
 
679
        torture_comment(tctx, "Testing NetrAddAlternateComputerName\n");
663
680
 
664
 
        status = dcerpc_wkssvc_NetrAddAlternateComputerName(p, tctx, &r);
 
681
        status = dcerpc_wkssvc_NetrAddAlternateComputerName_r(b, tctx, &r);
665
682
        torture_assert_ntstatus_ok(tctx, status,
666
683
                                   "NetrAddAlternateComputerName failed");
667
684
        torture_assert_werr_ok(tctx, r.out.result,
693
710
        const char **names = NULL;
694
711
        int num_names = 0;
695
712
        int i;
 
713
        struct dcerpc_binding_handle *b = p->binding_handle;
696
714
 
697
715
        r.in.server_name = dcerpc_server_name(p);
698
716
        r.in.AlternateMachineNameToRemove = SMBTORTURE_ALTERNATE_NAME;
700
718
        r.in.EncryptedPassword = NULL;
701
719
        r.in.Reserved = 0;
702
720
 
703
 
        torture_comment(tctx, "testing NetrRemoveAlternateComputerName\n");
 
721
        torture_comment(tctx, "Testing NetrRemoveAlternateComputerName\n");
704
722
 
705
 
        status = dcerpc_wkssvc_NetrRemoveAlternateComputerName(p, tctx, &r);
 
723
        status = dcerpc_wkssvc_NetrRemoveAlternateComputerName_r(b, tctx, &r);
706
724
        torture_assert_ntstatus_ok(tctx, status,
707
725
                                   "NetrRemoveAlternateComputerName failed");
708
726
        torture_assert_werr_ok(tctx, r.out.result,
730
748
{
731
749
        NTSTATUS status;
732
750
        struct wkssvc_NetrSetPrimaryComputername r;
 
751
        struct dcerpc_binding_handle *b = p->binding_handle;
733
752
 
734
753
        r.in.server_name = dcerpc_server_name(p);
735
754
        r.in.primary_name = name;
737
756
        r.in.EncryptedPassword = NULL;
738
757
        r.in.Reserved = 0;
739
758
 
740
 
        status = dcerpc_wkssvc_NetrSetPrimaryComputername(p, tctx, &r);
 
759
        status = dcerpc_wkssvc_NetrSetPrimaryComputername_r(b, tctx, &r);
741
760
        torture_assert_ntstatus_ok(tctx, status,
742
761
                                   "NetrSetPrimaryComputername failed");
743
762
        torture_assert_werr_ok(tctx, r.out.result,
764
783
        const char **names_o = NULL, **names = NULL;
765
784
        int num_names_o = 0, num_names = 0;
766
785
 
767
 
        torture_comment(tctx, "testing NetrSetPrimaryComputername\n");
 
786
        torture_comment(tctx, "Testing NetrSetPrimaryComputername\n");
768
787
 
769
788
        if (!test_NetrAddAlternateComputerName(tctx, p)) {
770
789
                return false;
824
843
{
825
844
        NTSTATUS status;
826
845
        struct wkssvc_NetrRenameMachineInDomain r;
 
846
        struct dcerpc_binding_handle *b = p->binding_handle;
827
847
 
828
848
        r.in.server_name = dcerpc_server_name(p);
829
849
        r.in.NewMachineName = SMBTORTURE_MACHINE_NAME;
831
851
        r.in.password = NULL;
832
852
        r.in.RenameOptions = 0;
833
853
 
834
 
        torture_comment(tctx, "testing NetrRenameMachineInDomain\n");
 
854
        torture_comment(tctx, "Testing NetrRenameMachineInDomain\n");
835
855
 
836
 
        status = dcerpc_wkssvc_NetrRenameMachineInDomain(p, tctx, &r);
 
856
        status = dcerpc_wkssvc_NetrRenameMachineInDomain_r(b, tctx, &r);
837
857
        torture_assert_ntstatus_ok(tctx, status,
838
858
                                   "NetrRenameMachineInDomain failed");
839
859
        torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
847
867
{
848
868
        NTSTATUS status;
849
869
        struct wkssvc_NetrRenameMachineInDomain2 r;
 
870
        struct dcerpc_binding_handle *b = p->binding_handle;
850
871
 
851
872
        r.in.server_name = dcerpc_server_name(p);
852
873
        r.in.NewMachineName = new_name;
854
875
        r.in.EncryptedPassword = NULL;
855
876
        r.in.RenameOptions = 0;
856
877
 
857
 
        status = dcerpc_wkssvc_NetrRenameMachineInDomain2(p, tctx, &r);
 
878
        status = dcerpc_wkssvc_NetrRenameMachineInDomain2_r(b, tctx, &r);
858
879
        torture_assert_ntstatus_ok(tctx, status,
859
880
                                   "NetrRenameMachineInDomain2 failed");
860
881
        torture_assert_werr_ok(tctx, r.out.result,
868
889
        const char **names_o = NULL, **names = NULL;
869
890
        int num_names_o = 0, num_names = 0;
870
891
 
871
 
        torture_comment(tctx, "testing NetrRenameMachineInDomain2\n");
 
892
        torture_comment(tctx, "Testing NetrRenameMachineInDomain2\n");
872
893
 
873
894
        if (!test_NetrEnumerateComputerNames_level(tctx, p,
874
895
                                                   NetPrimaryComputerName,
937
958
        NTSTATUS status;
938
959
        struct wkssvc_NetrWorkstationStatisticsGet r;
939
960
        struct wkssvc_NetrWorkstationStatistics *info;
 
961
        struct dcerpc_binding_handle *b = p->binding_handle;
940
962
 
941
963
        ZERO_STRUCT(r);
942
964
 
945
967
        r.in.server_name = dcerpc_server_name(p);
946
968
        r.out.info = &info;
947
969
 
948
 
        torture_comment(tctx, "testing NetrWorkstationStatisticsGet\n");
 
970
        torture_comment(tctx, "Testing NetrWorkstationStatisticsGet\n");
949
971
 
950
 
        status = dcerpc_wkssvc_NetrWorkstationStatisticsGet(p, tctx, &r);
 
972
        status = dcerpc_wkssvc_NetrWorkstationStatisticsGet_r(b, tctx, &r);
951
973
        torture_assert_ntstatus_ok(tctx, status,
952
974
                                   "NetrWorkstationStatisticsGet failed");
953
975
        torture_assert_werr_ok(tctx, r.out.result,
965
987
        const char *message = SMBTORTURE_MESSAGE;
966
988
        size_t size;
967
989
        uint16_t *msg;
 
990
        struct dcerpc_binding_handle *b = p->binding_handle;
968
991
 
969
992
        if (!push_ucs2_talloc(tctx, &msg, message, &size)) {
970
993
                return false;
976
999
        r.in.message_buffer = (uint8_t *)msg;
977
1000
        r.in.message_size = size;
978
1001
 
979
 
        torture_comment(tctx, "testing NetrMessageBufferSend\n");
 
1002
        torture_comment(tctx, "Testing NetrMessageBufferSend\n");
980
1003
 
981
 
        status = dcerpc_wkssvc_NetrMessageBufferSend(p, tctx, &r);
 
1004
        status = dcerpc_wkssvc_NetrMessageBufferSend_r(b, tctx, &r);
982
1005
        torture_assert_ntstatus_ok(tctx, status,
983
1006
                                   "NetrMessageBufferSend failed");
984
1007
        torture_assert_werr_ok(tctx, r.out.result,
993
1016
        struct wkssvc_NetrGetJoinInformation r;
994
1017
        enum wkssvc_NetJoinStatus join_status;
995
1018
        const char *name_buffer = "";
 
1019
        struct dcerpc_binding_handle *b = p->binding_handle;
996
1020
 
997
1021
        r.in.server_name = dcerpc_server_name(p);
998
1022
        r.in.name_buffer = r.out.name_buffer = &name_buffer;
999
1023
        r.out.name_type = &join_status;
1000
1024
 
1001
 
        torture_comment(tctx, "testing NetrGetJoinInformation\n");
 
1025
        torture_comment(tctx, "Testing NetrGetJoinInformation\n");
1002
1026
 
1003
 
        status = dcerpc_wkssvc_NetrGetJoinInformation(p, tctx, &r);
 
1027
        status = dcerpc_wkssvc_NetrGetJoinInformation_r(b, tctx, &r);
1004
1028
        torture_assert_ntstatus_ok(tctx, status,
1005
1029
                                   "NetrGetJoinInformation failed");
1006
1030
        torture_assert_werr_ok(tctx, r.out.result,
1017
1041
        struct wkssvc_NetrGetJoinInformation r;
1018
1042
        enum wkssvc_NetJoinStatus join_status;
1019
1043
        const char *name_buffer = "";
 
1044
        struct dcerpc_binding_handle *b = p->binding_handle;
1020
1045
 
1021
1046
        r.in.server_name = dcerpc_server_name(p);
1022
1047
        r.in.name_buffer = r.out.name_buffer = &name_buffer;
1023
1048
        r.out.name_type = &join_status;
1024
1049
 
1025
 
        status = dcerpc_wkssvc_NetrGetJoinInformation(p, tctx, &r);
 
1050
        status = dcerpc_wkssvc_NetrGetJoinInformation_r(b, tctx, &r);
1026
1051
        torture_assert_ntstatus_ok(tctx, status,
1027
1052
                                   "NetrGetJoinInformation failed");
1028
1053
        torture_assert_werr_ok(tctx, r.out.result,
1047
1072
        struct wkssvc_NetrGetJoinableOus r;
1048
1073
        uint32_t num_ous = 0;
1049
1074
        const char **ous = NULL;
 
1075
        struct dcerpc_binding_handle *b = p->binding_handle;
1050
1076
 
1051
1077
        r.in.server_name = dcerpc_server_name(p);
1052
 
        r.in.domain_name = lp_workgroup(tctx->lp_ctx);
 
1078
        r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
1053
1079
        r.in.Account = NULL;
1054
1080
        r.in.unknown = NULL;
1055
1081
        r.in.num_ous = r.out.num_ous = &num_ous;
1056
1082
        r.out.ous = &ous;
1057
1083
 
1058
 
        torture_comment(tctx, "testing NetrGetJoinableOus\n");
 
1084
        torture_comment(tctx, "Testing NetrGetJoinableOus\n");
1059
1085
 
1060
 
        status = dcerpc_wkssvc_NetrGetJoinableOus(p, tctx, &r);
 
1086
        status = dcerpc_wkssvc_NetrGetJoinableOus_r(b, tctx, &r);
1061
1087
        torture_assert_ntstatus_ok(tctx, status, "NetrGetJoinableOus failed");
1062
1088
        torture_assert_werr_equal(tctx, r.out.result,
1063
1089
                                  WERR_NOT_SUPPORTED,
1073
1099
        struct wkssvc_NetrGetJoinableOus2 r;
1074
1100
        uint32_t num_ous = 0;
1075
1101
        const char **ous = NULL;
 
1102
        struct dcerpc_binding_handle *b = p->binding_handle;
1076
1103
 
1077
1104
        r.in.server_name = dcerpc_server_name(p);
1078
 
        r.in.domain_name = lp_workgroup(tctx->lp_ctx);
 
1105
        r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
1079
1106
        r.in.Account = NULL;
1080
1107
        r.in.EncryptedPassword = NULL;
1081
1108
        r.in.num_ous = r.out.num_ous = &num_ous;
1082
1109
        r.out.ous = &ous;
1083
1110
 
1084
 
        torture_comment(tctx, "testing NetrGetJoinableOus2\n");
 
1111
        torture_comment(tctx, "Testing NetrGetJoinableOus2\n");
1085
1112
 
1086
 
        status = dcerpc_wkssvc_NetrGetJoinableOus2(p, tctx, &r);
 
1113
        status = dcerpc_wkssvc_NetrGetJoinableOus2_r(b, tctx, &r);
1087
1114
        torture_assert_ntstatus_ok(tctx, status, "NetrGetJoinableOus2 failed");
1088
1115
        torture_assert_werr_equal(tctx, r.out.result,
1089
1116
                                  WERR_RPC_E_REMOTE_DISABLED,
1100
1127
        struct cli_credentials *creds = cmdline_credentials;
1101
1128
        const char *user = cli_credentials_get_username(creds);
1102
1129
        const char *admin_account = NULL;
 
1130
        struct dcerpc_binding_handle *b = p->binding_handle;
1103
1131
 
1104
1132
        admin_account = talloc_asprintf(tctx, "%s\\%s",
1105
 
                                        lp_workgroup(tctx->lp_ctx),
 
1133
                                        lpcfg_workgroup(tctx->lp_ctx),
1106
1134
                                        user);
1107
1135
 
1108
1136
        r.in.server_name = dcerpc_server_name(p);
1110
1138
        r.in.password = NULL;
1111
1139
        r.in.unjoin_flags = 0;
1112
1140
 
1113
 
        torture_comment(tctx, "testing NetrUnjoinDomain\n");
 
1141
        torture_comment(tctx, "Testing NetrUnjoinDomain\n");
1114
1142
 
1115
 
        status = dcerpc_wkssvc_NetrUnjoinDomain(p, tctx, &r);
 
1143
        status = dcerpc_wkssvc_NetrUnjoinDomain_r(b, tctx, &r);
1116
1144
        torture_assert_ntstatus_ok(tctx, status,
1117
1145
                                   "NetrUnjoinDomain failed");
1118
1146
        torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1128
1156
        struct cli_credentials *creds = cmdline_credentials;
1129
1157
        const char *user = cli_credentials_get_username(creds);
1130
1158
        const char *admin_account = NULL;
 
1159
        struct dcerpc_binding_handle *b = p->binding_handle;
1131
1160
 
1132
1161
        admin_account = talloc_asprintf(tctx, "%s\\%s",
1133
 
                                        lp_workgroup(tctx->lp_ctx),
 
1162
                                        lpcfg_workgroup(tctx->lp_ctx),
1134
1163
                                        user);
1135
1164
 
1136
1165
        r.in.server_name = dcerpc_server_name(p);
1137
 
        r.in.domain_name = lp_realm(tctx->lp_ctx);
 
1166
        r.in.domain_name = lpcfg_dnsdomain(tctx->lp_ctx);
1138
1167
        r.in.account_ou = NULL;
1139
1168
        r.in.Account = admin_account;
1140
1169
        r.in.password = NULL;
1141
1170
        r.in.join_flags = 0;
1142
1171
 
1143
 
        torture_comment(tctx, "testing NetrJoinDomain\n");
 
1172
        torture_comment(tctx, "Testing NetrJoinDomain\n");
1144
1173
 
1145
 
        status = dcerpc_wkssvc_NetrJoinDomain(p, tctx, &r);
 
1174
        status = dcerpc_wkssvc_NetrJoinDomain_r(b, tctx, &r);
1146
1175
        torture_assert_ntstatus_ok(tctx, status,
1147
1176
                                   "NetrJoinDomain failed");
1148
1177
        torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1172
1201
        const char *join_name = NULL;
1173
1202
        WERROR expected_err;
1174
1203
        DATA_BLOB session_key;
 
1204
        struct dcerpc_binding_handle *b = p->binding_handle;
1175
1205
 
1176
1206
        /* FIXME: this test assumes to join workstations / servers and does not
1177
1207
         * handle DCs (WERR_SETUP_DOMAIN_CONTROLLER) */
1222
1252
        r.in.join_flags = WKSSVC_JOIN_FLAGS_JOIN_TYPE |
1223
1253
                          WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE;
1224
1254
 
1225
 
        torture_comment(tctx, "testing NetrJoinDomain2 (assuming non-DC)\n");
 
1255
        torture_comment(tctx, "Testing NetrJoinDomain2 (assuming non-DC)\n");
1226
1256
 
1227
 
        status = dcerpc_wkssvc_NetrJoinDomain2(p, tctx, &r);
 
1257
        status = dcerpc_wkssvc_NetrJoinDomain2_r(b, tctx, &r);
1228
1258
        torture_assert_ntstatus_ok(tctx, status,
1229
1259
                                   "NetrJoinDomain2 failed");
1230
1260
        torture_assert_werr_equal(tctx, r.out.result, expected_err,
1256
1286
        const char *join_name = NULL;
1257
1287
        WERROR expected_err;
1258
1288
        DATA_BLOB session_key;
 
1289
        struct dcerpc_binding_handle *b = p->binding_handle;
1259
1290
 
1260
1291
        /* FIXME: this test assumes to join workstations / servers and does not
1261
1292
         * handle DCs (WERR_SETUP_DOMAIN_CONTROLLER) */
1300
1331
        r.in.encrypted_password = pwd_buf;
1301
1332
        r.in.unjoin_flags = 0;
1302
1333
 
1303
 
        torture_comment(tctx, "testing NetrUnjoinDomain2 (assuming non-DC)\n");
 
1334
        torture_comment(tctx, "Testing NetrUnjoinDomain2 (assuming non-DC)\n");
1304
1335
 
1305
 
        status = dcerpc_wkssvc_NetrUnjoinDomain2(p, tctx, &r);
 
1336
        status = dcerpc_wkssvc_NetrUnjoinDomain2_r(b, tctx, &r);
1306
1337
        torture_assert_ntstatus_ok(tctx, status,
1307
1338
                                   "NetrUnjoinDomain2 failed");
1308
1339
        torture_assert_werr_equal(tctx, r.out.result, expected_err,
1335
1366
        struct torture_rpc_tcase *tcase;
1336
1367
        struct torture_test *test;
1337
1368
 
1338
 
        suite = torture_suite_create(mem_ctx, "WKSSVC");
 
1369
        suite = torture_suite_create(mem_ctx, "wkssvc");
1339
1370
        tcase = torture_suite_add_rpc_iface_tcase(suite, "wkssvc",
1340
1371
                                                  &ndr_table_wkssvc);
1341
1372