source4/torture/rpc/wkssvc.c

   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/torture_rpc.h"
  26 #include "lib/cmdline/cmdline.h"
  27 #include "param/param.h"
  28 #include "libcli/auth/libcli_auth.h"
  29
  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"
  35
  36 static bool test_NetWkstaGetInfo(struct torture_context *tctx,
  37                                  struct dcerpc_pipe *p)
  38 {
  39         NTSTATUS status;
  40         struct wkssvc_NetWkstaGetInfo r;
  41         union wkssvc_NetWkstaInfo info;
  42         uint16_t levels[] = {100, 101, 102, 502};
  43         int i;
  44         struct dcerpc_binding_handle *b = p->binding_handle;
  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_r(b, 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
  65 static 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         struct dcerpc_binding_handle *b = p->binding_handle;
  76
  77         ZERO_STRUCT(ctr0);
  78         ctr.ctr0 = &ctr0;
  79
  80         info.level = 0;
  81         info.ctr = ctr;
  82
  83         r.in.server_name = dcerpc_server_name(p);
  84         r.in.info = &info;
  85         r.in.max_buffer = (uint32_t)-1;
  86         r.in.resume_handle = &resume_handle;
  87         r.out.total_entries = &total_entries;
  88         r.out.info = &info;
  89         r.out.resume_handle = &resume_handle;
  90
  91         torture_comment(tctx, "Testing NetWkstaTransportEnum level 0\n");
  92
  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",
  98                                info.level));
  99
 100         return true;
 101 }
 102
 103 static bool test_NetrWkstaTransportAdd(struct torture_context *tctx,
 104                                        struct dcerpc_pipe *p)
 105 {
 106         NTSTATUS status;
 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;
 111
 112         ZERO_STRUCT(info0);
 113
 114         info0.quality_of_service = 0xffff;
 115         info0.vc_count = 0;
 116         info0.name = SMBTORTURE_TRANSPORT_NAME;
 117         info0.address = "000000000000";
 118         info0.wan_link = 0x400;
 119
 120         r.in.server_name = dcerpc_server_name(p);
 121         r.in.level = 0;
 122         r.in.info0 = &info0;
 123         r.in.parm_err = r.out.parm_err = &parm_err;
 124
 125         torture_comment(tctx, "Testing NetrWkstaTransportAdd level 0\n");
 126
 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");
 133
 134         return true;
 135 }
 136
 137 static bool test_NetrWkstaTransportDel(struct torture_context *tctx,
 138                                        struct dcerpc_pipe *p)
 139 {
 140         NTSTATUS status;
 141         struct wkssvc_NetrWkstaTransportDel r;
 142         struct dcerpc_binding_handle *b = p->binding_handle;
 143
 144         r.in.server_name = dcerpc_server_name(p);
 145         r.in.transport_name = SMBTORTURE_TRANSPORT_NAME;
 146         r.in.unknown3 = 0;
 147
 148         torture_comment(tctx, "Testing NetrWkstaTransportDel\n");
 149
 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");
 155
 156         return true;
 157 }
 158
 159 static bool test_NetWkstaEnumUsers(struct torture_context *tctx,
 160                                    struct dcerpc_pipe *p)
 161 {
 162         NTSTATUS status;
 163         struct wkssvc_NetWkstaEnumUsers r;
 164         uint32_t handle = 0;
 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 };
 170         int i;
 171         struct dcerpc_binding_handle *b = p->binding_handle;
 172
 173         for (i=0; i<ARRAY_SIZE(levels); i++) {
 174
 175                 ZERO_STRUCT(info);
 176
 177                 info.level = levels[i];
 178                 switch (info.level) {
 179                 case 0:
 180                         user0 = talloc_zero(tctx,
 181                                             struct wkssvc_NetWkstaEnumUsersCtr0);
 182                         info.ctr.user0 = user0;
 183                         break;
 184                 case 1:
 185                         user1 = talloc_zero(tctx,
 186                                             struct wkssvc_NetWkstaEnumUsersCtr1);
 187                         info.ctr.user1 = user1;
 188                         break;
 189                 default:
 190                         break;
 191                 }
 192
 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;
 197
 198                 r.out.entries_read = &entries_read;
 199
 200                 torture_comment(tctx, "Testing NetWkstaEnumUsers level %u\n",
 201                                 levels[i]);
 202
 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");
 208         }
 209
 210         return true;
 211 }
 212
 213 static bool test_NetrWkstaUserGetInfo(struct torture_context *tctx,
 214                                       struct dcerpc_pipe *p)
 215 {
 216         NTSTATUS status;
 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);
 222         int i;
 223         struct dcerpc_binding_handle *b = p->binding_handle;
 224
 225         const struct {
 226                 const char *unknown;
 227                 uint32_t level;
 228                 WERROR result;
 229         } tests[] = {
 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 },
 239         };
 240
 241         for (i=0; i<ARRAY_SIZE(tests); i++) {
 242                 r.in.unknown = tests[i].unknown;
 243                 r.in.level = tests[i].level;
 244                 r.out.info = &info;
 245
 246                 torture_comment(tctx, "Testing NetrWkstaUserGetInfo level %u\n",
 247                                 r.in.level);
 248
 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,
 253                                           tests[i].result,
 254                                           "NetrWkstaUserGetInfo failed");
 255         }
 256
 257         return true;
 258 }
 259
 260 static bool test_NetrUseEnum(struct torture_context *tctx,
 261                              struct dcerpc_pipe *p)
 262 {
 263         NTSTATUS status;
 264         struct wkssvc_NetrUseEnum r;
 265         uint32_t handle = 0;
 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 };
 272         int i;
 273         struct dcerpc_binding_handle *b = p->binding_handle;
 274
 275         for (i=0; i<ARRAY_SIZE(levels); i++) {
 276
 277                 ZERO_STRUCT(info);
 278
 279                 info.level = levels[i];
 280                 switch (info.level) {
 281                 case 0:
 282                         use0 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr0);
 283                         info.ctr.ctr0 = use0;
 284                         break;
 285                 case 1:
 286                         use1 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr1);
 287                         info.ctr.ctr1 = use1;
 288                         break;
 289                 case 2:
 290                         use2 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr2);
 291                         info.ctr.ctr2 = use2;
 292                         break;
 293                 default:
 294                         break;
 295                 }
 296
 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;
 301
 302                 r.out.entries_read = &entries_read;
 303
 304                 torture_comment(tctx, "Testing NetrUseEnum level %u\n",
 305                                 levels[i]);
 306
 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");
 312         }
 313
 314         return true;
 315 }
 316
 317 static bool test_NetrUseAdd(struct torture_context *tctx,
 318                             struct dcerpc_pipe *p)
 319 {
 320         NTSTATUS status;
 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;
 327
 328         ctr = talloc(tctx, union wkssvc_NetrUseGetInfoCtr);
 329
 330         ZERO_STRUCT(info0);
 331
 332         info0.local = SMBTORTURE_USE_NAME;
 333         info0.remote = "\\\\localhost\\c$";
 334
 335         ctr->info0 = &info0;
 336
 337         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 338         r.in.level = 0;
 339         r.in.ctr = ctr;
 340         r.in.parm_err = r.out.parm_err = &parm_err;
 341
 342         torture_comment(tctx, "Testing NetrUseAdd level %u\n",
 343                         r.in.level);
 344
 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");
 350
 351         ZERO_STRUCT(r);
 352         ZERO_STRUCT(info1);
 353
 354         info1.local = SMBTORTURE_USE_NAME;
 355         info1.remote = "\\\\localhost\\sysvol";
 356         info1.password = NULL;
 357
 358         ctr->info1 = &info1;
 359
 360         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 361         r.in.level = 1;
 362         r.in.ctr = ctr;
 363         r.in.parm_err = r.out.parm_err = &parm_err;
 364
 365         torture_comment(tctx, "Testing NetrUseAdd level %u\n",
 366                         r.in.level);
 367
 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");
 373
 374         return true;
 375 }
 376
 377 static bool test_NetrUseDel(struct torture_context *tctx,
 378                             struct dcerpc_pipe *p)
 379 {
 380         NTSTATUS status;
 381         struct wkssvc_NetrUseDel r;
 382         struct dcerpc_binding_handle *b = p->binding_handle;
 383
 384         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 385         r.in.use_name = SMBTORTURE_USE_NAME;
 386         r.in.force_cond = 0;
 387
 388         torture_comment(tctx, "Testing NetrUseDel\n");
 389
 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");
 395         return true;
 396 }
 397
 398 static bool test_NetrUseGetInfo_level(struct torture_context *tctx,
 399                                       struct dcerpc_pipe *p,
 400                                       const char *use_name,
 401                                       uint32_t level,
 402                                       WERROR werr)
 403 {
 404         NTSTATUS status;
 405         struct wkssvc_NetrUseGetInfo r;
 406         union wkssvc_NetrUseGetInfoCtr ctr;
 407         struct dcerpc_binding_handle *b = p->binding_handle;
 408
 409         ZERO_STRUCT(ctr);
 410
 411         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 412         r.in.use_name = use_name;
 413         r.in.level = level;
 414         r.out.ctr = &ctr;
 415         status = dcerpc_wkssvc_NetrUseGetInfo_r(b, tctx, &r);
 416
 417         torture_assert_ntstatus_ok(tctx, status,
 418                                    "NetrUseGetInfo failed");
 419         torture_assert_werr_equal(tctx, r.out.result, werr,
 420                                   "NetrUseGetInfo failed");
 421         return true;
 422 }
 423
 424 static bool test_NetrUseGetInfo(struct torture_context *tctx,
 425                                 struct dcerpc_pipe *p)
 426 {
 427         NTSTATUS status;
 428         struct wkssvc_NetrUseEnum r;
 429         uint32_t handle = 0;
 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;
 435         int i, k;
 436         struct dcerpc_binding_handle *b = p->binding_handle;
 437
 438         ZERO_STRUCT(info);
 439
 440         info.level = 0;
 441         use0 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr0);
 442         info.ctr.ctr0 = use0;
 443
 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;
 449
 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");
 455
 456         for (k=0; k < r.out.info->ctr.ctr0->count; k++) {
 457
 458                 use_name = r.out.info->ctr.ctr0->array[k].local;
 459
 460                 for (i=0; i<ARRAY_SIZE(levels); i++) {
 461
 462                         if (!test_NetrUseGetInfo_level(tctx, p, use_name,
 463                                                        levels[i],
 464                                                        WERR_OK))
 465                         {
 466                                 if (levels[i] != 0) {
 467                                         return false;
 468                                 }
 469                         }
 470                 }
 471
 472                 use_name = r.out.info->ctr.ctr0->array[k].remote;
 473
 474                 for (i=0; i<ARRAY_SIZE(levels); i++) {
 475
 476                         if (!test_NetrUseGetInfo_level(tctx, p, use_name,
 477                                                        levels[i],
 478                                                        WERR_NERR_USENOTFOUND))
 479                         {
 480                                 if (levels[i] != 0) {
 481                                         return false;
 482                                 }
 483                         }
 484                 }
 485         }
 486
 487         return true;
 488 }
 489
 490 static bool test_NetrLogonDomainNameAdd(struct torture_context *tctx,
 491                                         struct dcerpc_pipe *p)
 492 {
 493         NTSTATUS status;
 494         struct wkssvc_NetrLogonDomainNameAdd r;
 495         struct dcerpc_binding_handle *b = p->binding_handle;
 496
 497         r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
 498
 499         torture_comment(tctx, "Testing NetrLogonDomainNameAdd\n");
 500
 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");
 506         return true;
 507 }
 508
 509 static bool test_NetrLogonDomainNameDel(struct torture_context *tctx,
 510                                         struct dcerpc_pipe *p)
 511 {
 512         NTSTATUS status;
 513         struct wkssvc_NetrLogonDomainNameDel r;
 514         struct dcerpc_binding_handle *b = p->binding_handle;
 515
 516         r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
 517
 518         torture_comment(tctx, "Testing NetrLogonDomainNameDel\n");
 519
 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");
 525         return true;
 526 }
 527
 528 static bool test_NetrEnumerateComputerNames_level(struct torture_context *tctx,
 529                                                   struct dcerpc_pipe *p,
 530                                                   uint16_t level,
 531                                                   const char ***names,
 532                                                   size_t *num_names)
 533 {
 534         NTSTATUS status;
 535         struct wkssvc_NetrEnumerateComputerNames r;
 536         struct wkssvc_ComputerNamesCtr *ctr;
 537         int i;
 538         struct dcerpc_binding_handle *b = p->binding_handle;
 539
 540         ctr = talloc_zero(tctx, struct wkssvc_ComputerNamesCtr);
 541
 542         r.in.server_name = dcerpc_server_name(p);
 543         r.in.name_type = level;
 544         r.in.Reserved = 0;
 545         r.out.ctr = &ctr;
 546
 547         torture_comment(tctx, "Testing NetrEnumerateComputerNames level %u\n",
 548                         r.in.name_type);
 549
 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");
 555
 556         if ((level == NetPrimaryComputerName) && ctr->count != 1) {
 557                 torture_comment(tctx,
 558                                 "NetrEnumerateComputerNames did not return one "
 559                                 "name but %u\n", ctr->count);
 560                 return false;
 561         }
 562
 563         if (names && num_names) {
 564                 *num_names = 0;
 565                 *names = NULL;
 566                 for (i=0; i<ctr->count; i++) {
 567                         if (!add_string_to_array(tctx,
 568                                                  ctr->computer_name[i].string,
 569                                                  names,
 570                                                  num_names))
 571                         {
 572                                 return false;
 573                         }
 574                 }
 575         }
 576
 577         return true;
 578 }
 579
 580 static bool test_NetrEnumerateComputerNames(struct torture_context *tctx,
 581                                             struct dcerpc_pipe *p)
 582 {
 583         uint16_t levels[] = {0,1,2};
 584         int i;
 585
 586         for (i=0; i<ARRAY_SIZE(levels); i++) {
 587
 588                 if (!test_NetrEnumerateComputerNames_level(tctx,
 589                                                            p,
 590                                                            levels[i],
 591                                                            NULL, NULL))
 592                 {
 593                         return false;
 594                 }
 595         }
 596
 597         return true;
 598 }
 599
 600 static bool test_NetrValidateName(struct torture_context *tctx,
 601                                   struct dcerpc_pipe *p)
 602 {
 603         NTSTATUS status;
 604         struct wkssvc_NetrValidateName r;
 605         uint16_t levels[] = {0,1,2,3,4,5};
 606         int i;
 607         struct dcerpc_binding_handle *b = p->binding_handle;
 608
 609         for (i=0; i<ARRAY_SIZE(levels); i++) {
 610
 611                 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 612                 r.in.name = lpcfg_workgroup(tctx->lp_ctx);
 613                 r.in.Account = NULL;
 614                 r.in.Password = NULL;
 615                 r.in.name_type = levels[i];
 616
 617                 torture_comment(tctx, "Testing NetrValidateName level %u\n",
 618                                 r.in.name_type);
 619
 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,
 624                                           WERR_NOT_SUPPORTED,
 625                                           "NetrValidateName failed");
 626         }
 627
 628         return true;
 629 }
 630
 631 static bool test_NetrValidateName2(struct torture_context *tctx,
 632                                    struct dcerpc_pipe *p)
 633 {
 634         NTSTATUS status;
 635         struct wkssvc_NetrValidateName2 r;
 636         uint16_t levels[] = {0,1,2,3,4,5};
 637         int i;
 638         struct dcerpc_binding_handle *b = p->binding_handle;
 639
 640         for (i=0; i<ARRAY_SIZE(levels); i++) {
 641
 642                 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 643                 r.in.name = lpcfg_workgroup(tctx->lp_ctx);
 644                 r.in.Account = NULL;
 645                 r.in.EncryptedPassword = NULL;
 646                 r.in.name_type = levels[i];
 647
 648                 torture_comment(tctx, "Testing NetrValidateName2 level %u\n",
 649                                 r.in.name_type);
 650
 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");
 657         }
 658
 659         return true;
 660 }
 661
 662 static bool test_NetrAddAlternateComputerName(struct torture_context *tctx,
 663                                               struct dcerpc_pipe *p)
 664 {
 665         NTSTATUS status;
 666         struct wkssvc_NetrAddAlternateComputerName r;
 667         const char **names = NULL;
 668         size_t num_names = 0;
 669         int i;
 670         struct dcerpc_binding_handle *b = p->binding_handle;
 671
 672         r.in.server_name = dcerpc_server_name(p);
 673         r.in.NewAlternateMachineName = SMBTORTURE_ALTERNATE_NAME;
 674         r.in.Account = NULL;
 675         r.in.EncryptedPassword = NULL;
 676         r.in.Reserved = 0;
 677
 678         torture_comment(tctx, "Testing NetrAddAlternateComputerName\n");
 679
 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");
 685
 686         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 687                                                    NetAlternateComputerNames,
 688                                                    &names, &num_names))
 689         {
 690                 return false;
 691         }
 692
 693         for (i=0; i<num_names; i++) {
 694                 if (strequal(names[i], SMBTORTURE_ALTERNATE_NAME)) {
 695                         return true;
 696                 }
 697         }
 698
 699         torture_comment(tctx, "new alternate name not set\n");
 700
 701         return false;
 702 }
 703
 704 static bool test_NetrRemoveAlternateComputerName(struct torture_context *tctx,
 705                                                  struct dcerpc_pipe *p)
 706 {
 707         NTSTATUS status;
 708         struct wkssvc_NetrRemoveAlternateComputerName r;
 709         const char **names = NULL;
 710         size_t num_names = 0;
 711         int i;
 712         struct dcerpc_binding_handle *b = p->binding_handle;
 713
 714         r.in.server_name = dcerpc_server_name(p);
 715         r.in.AlternateMachineNameToRemove = SMBTORTURE_ALTERNATE_NAME;
 716         r.in.Account = NULL;
 717         r.in.EncryptedPassword = NULL;
 718         r.in.Reserved = 0;
 719
 720         torture_comment(tctx, "Testing NetrRemoveAlternateComputerName\n");
 721
 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");
 727
 728         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 729                                                    NetAlternateComputerNames,
 730                                                    &names, &num_names))
 731         {
 732                 return false;
 733         }
 734
 735         for (i=0; i<num_names; i++) {
 736                 if (strequal(names[i], SMBTORTURE_ALTERNATE_NAME)) {
 737                         return false;
 738                 }
 739         }
 740
 741         return true;
 742 }
 743
 744 static bool test_NetrSetPrimaryComputername_name(struct torture_context *tctx,
 745                                                  struct dcerpc_pipe *p,
 746                                                  const char *name)
 747 {
 748         NTSTATUS status;
 749         struct wkssvc_NetrSetPrimaryComputername r;
 750         struct dcerpc_binding_handle *b = p->binding_handle;
 751
 752         r.in.server_name = dcerpc_server_name(p);
 753         r.in.primary_name = name;
 754         r.in.Account = NULL;
 755         r.in.EncryptedPassword = NULL;
 756         r.in.Reserved = 0;
 757
 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");
 763         return true;
 764 }
 765
 766
 767 static bool test_NetrSetPrimaryComputername(struct torture_context *tctx,
 768                                             struct dcerpc_pipe *p)
 769 {
 770         /*
 771           add alternate,
 772           check if there
 773           store old primary
 774           set new primary (alternate)
 775           check if there
 776           later: check if del is possible
 777           set primary back to origin
 778           check if there
 779           del alternate
 780         */
 781
 782         const char **names_o = NULL, **names = NULL;
 783         size_t num_names_o = 0, num_names = 0;
 784
 785         torture_comment(tctx, "Testing NetrSetPrimaryComputername\n");
 786
 787         if (!test_NetrAddAlternateComputerName(tctx, p)) {
 788                 return false;
 789         }
 790
 791         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 792                                                    NetPrimaryComputerName,
 793                                                    &names_o, &num_names_o))
 794         {
 795                 return false;
 796         }
 797
 798         if (num_names_o != 1) {
 799                 return false;
 800         }
 801
 802         if (!test_NetrSetPrimaryComputername_name(tctx, p,
 803                                                   SMBTORTURE_ALTERNATE_NAME))
 804         {
 805                 return false;
 806         }
 807
 808         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 809                                                    NetPrimaryComputerName,
 810                                                    &names, &num_names))
 811         {
 812                 return false;
 813         }
 814
 815         if (num_names != 1) {
 816                 return false;
 817         }
 818
 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);
 823                 /*return false */;
 824         }
 825
 826         if (!test_NetrSetPrimaryComputername_name(tctx, p,
 827                                                   names_o[0]))
 828         {
 829                 return false;
 830         }
 831
 832         if (!test_NetrRemoveAlternateComputerName(tctx, p)) {
 833                 return false;
 834         }
 835
 836
 837         return true;
 838 }
 839
 840 static bool test_NetrRenameMachineInDomain(struct torture_context *tctx,
 841                                            struct dcerpc_pipe *p)
 842 {
 843         NTSTATUS status;
 844         struct wkssvc_NetrRenameMachineInDomain r;
 845         struct dcerpc_binding_handle *b = p->binding_handle;
 846
 847         r.in.server_name = dcerpc_server_name(p);
 848         r.in.NewMachineName = SMBTORTURE_MACHINE_NAME;
 849         r.in.Account = NULL;
 850         r.in.password = NULL;
 851         r.in.RenameOptions = 0;
 852
 853         torture_comment(tctx, "Testing NetrRenameMachineInDomain\n");
 854
 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");
 860         return true;
 861 }
 862
 863 static bool test_NetrRenameMachineInDomain2_name(struct torture_context *tctx,
 864                                                  struct dcerpc_pipe *p,
 865                                                  const char *new_name)
 866 {
 867         NTSTATUS status;
 868         struct wkssvc_NetrRenameMachineInDomain2 r;
 869         struct dcerpc_binding_handle *b = p->binding_handle;
 870
 871         r.in.server_name = dcerpc_server_name(p);
 872         r.in.NewMachineName = new_name;
 873         r.in.Account = NULL;
 874         r.in.EncryptedPassword = NULL;
 875         r.in.RenameOptions = 0;
 876
 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");
 882         return true;
 883 }
 884
 885 static bool test_NetrRenameMachineInDomain2(struct torture_context *tctx,
 886                                             struct dcerpc_pipe *p)
 887 {
 888         const char **names_o = NULL, **names = NULL;
 889         size_t num_names_o = 0, num_names = 0;
 890
 891         torture_comment(tctx, "Testing NetrRenameMachineInDomain2\n");
 892
 893         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 894                                                    NetPrimaryComputerName,
 895                                                    &names_o, &num_names_o))
 896         {
 897                 return false;
 898         }
 899
 900         if (num_names_o != 1) {
 901                 return false;
 902         }
 903
 904         if (!test_NetrRenameMachineInDomain2_name(tctx, p,
 905                                                   SMBTORTURE_MACHINE_NAME))
 906         {
 907                 return false;
 908         }
 909
 910         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 911                                                    NetPrimaryComputerName,
 912                                                    &names, &num_names))
 913         {
 914                 return false;
 915         }
 916
 917         if (num_names != 1) {
 918                 return false;
 919         }
 920
 921         if (strequal(names[0], names_o[0])) {
 922                 test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]);
 923                 return false;
 924         }
 925
 926         if (!strequal(names[0], SMBTORTURE_MACHINE_NAME)) {
 927                 test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]);
 928                 return false;
 929         }
 930
 931         if (!test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]))
 932         {
 933                 return false;
 934         }
 935
 936         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 937                                                    NetPrimaryComputerName,
 938                                                    &names, &num_names))
 939         {
 940                 return false;
 941         }
 942
 943         if (num_names != 1) {
 944                 return false;
 945         }
 946
 947         if (!strequal(names[0], names_o[0])) {
 948                 return false;
 949         }
 950
 951         return true;
 952 }
 953
 954 static bool test_NetrWorkstationStatisticsGet(struct torture_context *tctx,
 955                                               struct dcerpc_pipe *p)
 956 {
 957         NTSTATUS status;
 958         struct wkssvc_NetrWorkstationStatisticsGet r;
 959         struct wkssvc_NetrWorkstationStatistics *info;
 960         struct dcerpc_binding_handle *b = p->binding_handle;
 961
 962         ZERO_STRUCT(r);
 963
 964         info = talloc_zero(tctx, struct wkssvc_NetrWorkstationStatistics);
 965
 966         r.in.server_name = dcerpc_server_name(p);
 967         r.out.info = &info;
 968
 969         torture_comment(tctx, "Testing NetrWorkstationStatisticsGet\n");
 970
 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");
 976         return true;
 977 }
 978
 979 /* only succeeds as long as the local messenger service is running - Guenther */
 980
 981 static bool test_NetrMessageBufferSend(struct torture_context *tctx,
 982                                        struct dcerpc_pipe *p)
 983 {
 984         NTSTATUS status;
 985         struct wkssvc_NetrMessageBufferSend r;
 986         const char *message = SMBTORTURE_MESSAGE;
 987         size_t size;
 988         uint16_t *msg;
 989         struct dcerpc_binding_handle *b = p->binding_handle;
 990
 991         if (!push_ucs2_talloc(tctx, &msg, message, &size)) {
 992                 return false;
 993         }
 994
 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;
1000
1001         torture_comment(tctx, "Testing NetrMessageBufferSend\n");
1002
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");
1008         return true;
1009 }
1010
1011 static bool test_NetrGetJoinInformation(struct torture_context *tctx,
1012                                         struct dcerpc_pipe *p)
1013 {
1014         NTSTATUS status;
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;
1019
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;
1023
1024         torture_comment(tctx, "Testing NetrGetJoinInformation\n");
1025
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");
1031         return true;
1032 }
1033
1034 static bool test_GetJoinInformation(struct torture_context *tctx,
1035                                     struct dcerpc_pipe *p,
1036                                     enum wkssvc_NetJoinStatus *join_status_p,
1037                                     const char **name)
1038 {
1039         NTSTATUS status;
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;
1044
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;
1048
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");
1054
1055         if (join_status_p) {
1056                 *join_status_p = join_status;
1057         }
1058
1059         if (*name) {
1060                 *name = talloc_strdup(tctx, name_buffer);
1061         }
1062
1063         return true;
1064
1065 }
1066
1067 static bool test_NetrGetJoinableOus(struct torture_context *tctx,
1068                                     struct dcerpc_pipe *p)
1069 {
1070         NTSTATUS status;
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;
1075
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;
1081         r.out.ous = &ous;
1082
1083         torture_comment(tctx, "Testing NetrGetJoinableOus\n");
1084
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,
1088                                   WERR_NOT_SUPPORTED,
1089                                   "NetrGetJoinableOus failed");
1090
1091         return true;
1092 }
1093
1094 static bool test_NetrGetJoinableOus2(struct torture_context *tctx,
1095                                      struct dcerpc_pipe *p)
1096 {
1097         NTSTATUS status;
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;
1102
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;
1108         r.out.ous = &ous;
1109
1110         torture_comment(tctx, "Testing NetrGetJoinableOus2\n");
1111
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");
1117
1118         return true;
1119 }
1120
1121 static bool test_NetrUnjoinDomain(struct torture_context *tctx,
1122                                   struct dcerpc_pipe *p)
1123 {
1124         NTSTATUS status;
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;
1130
1131         admin_account = talloc_asprintf(tctx, "%s\\%s",
1132                                         lpcfg_workgroup(tctx->lp_ctx),
1133                                         user);
1134
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;
1139
1140         torture_comment(tctx, "Testing NetrUnjoinDomain\n");
1141
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");
1147         return true;
1148 }
1149
1150 static bool test_NetrJoinDomain(struct torture_context *tctx,
1151                                 struct dcerpc_pipe *p)
1152 {
1153         NTSTATUS status;
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;
1159
1160         admin_account = talloc_asprintf(tctx, "%s\\%s",
1161                                         lpcfg_workgroup(tctx->lp_ctx),
1162                                         user);
1163
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;
1170
1171         torture_comment(tctx, "Testing NetrJoinDomain\n");
1172
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");
1178         return true;
1179 }
1180
1181 /*
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
1185  * see also:
1186  * http://support.microsoft.com/kb/294355/EN-US/ and
1187  * http://support.microsoft.com/kb/290403/EN-US/
1188  */
1189
1190 static bool test_NetrJoinDomain2(struct torture_context *tctx,
1191                                  struct dcerpc_pipe *p)
1192 {
1193         NTSTATUS status;
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;
1202         WERROR werr;
1203         DATA_BLOB session_key;
1204         struct dcerpc_binding_handle *b = p->binding_handle;
1205
1206         /* FIXME: this test assumes to join workstations / servers and does not
1207          * handle DCs (WERR_NERR_SETUPDOMAINCONTROLLER) */
1208
1209         if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1210         {
1211                 return false;
1212         }
1213
1214         switch (join_status) {
1215                 case NET_SETUP_DOMAIN_NAME:
1216                         expected_err = WERR_NERR_SETUPALREADYJOINED;
1217                         break;
1218                 case NET_SETUP_UNKNOWN_STATUS:
1219                 case NET_SETUP_UNJOINED:
1220                 case NET_SETUP_WORKGROUP_NAME:
1221                 default:
1222                         expected_err = WERR_OK;
1223                         break;
1224         }
1225
1226         domain_admin_account = torture_setting_string(tctx, "domain_admin_account", NULL);
1227
1228         domain_admin_password = torture_setting_string(tctx, "domain_admin_password", NULL);
1229
1230         domain_name = torture_setting_string(tctx, "domain_name", NULL);
1231
1232         if ((domain_admin_account == NULL) ||
1233             (domain_admin_password == NULL) ||
1234             (domain_name == NULL)) {
1235                 torture_comment(tctx, "not enough input parameter\n");
1236                 return false;
1237         }
1238
1239         status = dcerpc_binding_handle_transport_session_key(b, tctx, &session_key);
1240         if (!NT_STATUS_IS_OK(status)) {
1241                 return false;
1242         }
1243
1244         werr = encode_wkssvc_join_password_buffer(tctx,
1245                                                   domain_admin_password,
1246                                                   &session_key,
1247                                                   &pwd_buf);
1248         if (!W_ERROR_IS_OK(werr)) {
1249                 return false;
1250         }
1251
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;
1259
1260         torture_comment(tctx, "Testing NetrJoinDomain2 (assuming non-DC)\n");
1261
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");
1267
1268         if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1269         {
1270                 return false;
1271         }
1272
1273         if (join_status != NET_SETUP_DOMAIN_NAME) {
1274                 torture_comment(tctx,
1275                                 "Join verify failed: got %d\n", join_status);
1276                 return false;
1277         }
1278
1279         return true;
1280 }
1281
1282 static bool test_NetrUnjoinDomain2(struct torture_context *tctx,
1283                                    struct dcerpc_pipe *p)
1284 {
1285         NTSTATUS status;
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;
1293         WERROR werr;
1294         DATA_BLOB session_key;
1295         struct dcerpc_binding_handle *b = p->binding_handle;
1296
1297         /* FIXME: this test assumes to join workstations / servers and does not
1298          * handle DCs (WERR_NERR_SETUPDOMAINCONTROLLER) */
1299
1300         if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1301         {
1302                 return false;
1303         }
1304
1305         switch (join_status) {
1306                 case NET_SETUP_UNJOINED:
1307                         expected_err = WERR_NERR_SETUPNOTJOINED;
1308                         break;
1309                 case NET_SETUP_DOMAIN_NAME:
1310                 case NET_SETUP_UNKNOWN_STATUS:
1311                 case NET_SETUP_WORKGROUP_NAME:
1312                 default:
1313                         expected_err = WERR_OK;
1314                         break;
1315         }
1316
1317         domain_admin_account = torture_setting_string(tctx, "domain_admin_account", NULL);
1318
1319         domain_admin_password = torture_setting_string(tctx, "domain_admin_password", NULL);
1320
1321         if ((domain_admin_account == NULL) ||
1322             (domain_admin_password == NULL)) {
1323                 torture_comment(tctx, "not enough input parameter\n");
1324                 return false;
1325         }
1326
1327         status = dcerpc_binding_handle_transport_session_key(b, tctx, &session_key);
1328         if (!NT_STATUS_IS_OK(status)) {
1329                 return false;
1330         }
1331
1332         werr = encode_wkssvc_join_password_buffer(tctx,
1333                                                   domain_admin_password,
1334                                                   &session_key,
1335                                                   &pwd_buf);
1336         if (!W_ERROR_IS_OK(werr)) {
1337                 return false;
1338         }
1339
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;
1344
1345         torture_comment(tctx, "Testing NetrUnjoinDomain2 (assuming non-DC)\n");
1346
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");
1352
1353         if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1354         {
1355                 return false;
1356         }
1357
1358         switch (join_status) {
1359                 case NET_SETUP_UNJOINED:
1360                 case NET_SETUP_WORKGROUP_NAME:
1361                         break;
1362                 case NET_SETUP_UNKNOWN_STATUS:
1363                 case NET_SETUP_DOMAIN_NAME:
1364                 default:
1365                         torture_comment(tctx,
1366                                 "Unjoin verify failed: got %d\n", join_status);
1367                         return false;
1368         }
1369
1370         return true;
1371 }
1372
1373
1374 struct torture_suite *torture_rpc_wkssvc(TALLOC_CTX *mem_ctx)
1375 {
1376         struct torture_suite *suite;
1377         struct torture_rpc_tcase *tcase;
1378         struct torture_test *test;
1379
1380         suite = torture_suite_create(mem_ctx, "wkssvc");
1381         tcase = torture_suite_add_rpc_iface_tcase(suite, "wkssvc",
1382                                                   &ndr_table_wkssvc);
1383
1384         torture_rpc_tcase_add_test(tcase, "NetWkstaGetInfo",
1385                                    test_NetWkstaGetInfo);
1386
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);
1393
1394         torture_rpc_tcase_add_test(tcase, "NetWkstaEnumUsers",
1395                                    test_NetWkstaEnumUsers);
1396         torture_rpc_tcase_add_test(tcase, "NetrWkstaUserGetInfo",
1397                                    test_NetrWkstaUserGetInfo);
1398
1399         torture_rpc_tcase_add_test(tcase, "NetrUseDel",
1400                                    test_NetrUseDel);
1401         torture_rpc_tcase_add_test(tcase, "NetrUseGetInfo",
1402                                    test_NetrUseGetInfo);
1403         torture_rpc_tcase_add_test(tcase, "NetrUseEnum",
1404                                    test_NetrUseEnum);
1405         torture_rpc_tcase_add_test(tcase, "NetrUseAdd",
1406                                    test_NetrUseAdd);
1407
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);
1431
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;
1438
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);
1451
1452         torture_rpc_tcase_add_test(tcase, "NetrWorkstationStatisticsGet",
1453                                    test_NetrWorkstationStatisticsGet);
1454         torture_rpc_tcase_add_test(tcase, "NetrMessageBufferSend",
1455                                    test_NetrMessageBufferSend);
1456
1457         return suite;
1458 }