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
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "includes.h"
  22 #include "torture/torture.h"
  23 #include "librpc/gen_ndr/ndr_wkssvc_c.h"
  24 #include "torture/rpc/rpc.h"
  25 #include "lib/cmdline/popt_common.h"
  26 #include "param/param.h"
  27
  28 #define SMBTORTURE_MACHINE_NAME "smbtrt_name"
  29 #define SMBTORTURE_ALTERNATE_NAME "smbtrt_altname"
  30 #define SMBTORTURE_TRANSPORT_NAME "\\Device\\smbtrt_transport_name"
  31 #define SMBTORTURE_USE_NAME "S:"
  32 #define SMBTORTURE_MESSAGE "You are currently tortured by Samba"
  33
  34 static bool test_NetWkstaGetInfo(struct torture_context *tctx,
  35                                  struct dcerpc_pipe *p)
  36 {
  37         NTSTATUS status;
  38         struct wkssvc_NetWkstaGetInfo r;
  39         union wkssvc_NetWkstaInfo info;
  40         uint16_t levels[] = {100, 101, 102, 502};
  41         int i;
  42
  43         r.in.server_name = dcerpc_server_name(p);
  44         r.out.info = &info;
  45
  46         for (i=0;i<ARRAY_SIZE(levels);i++) {
  47                 r.in.level = levels[i];
  48                 torture_comment(tctx, "testing NetWkstaGetInfo level %u\n", r.in.level);
  49                 status = dcerpc_wkssvc_NetWkstaGetInfo(p, tctx, &r);
  50                 torture_assert_ntstatus_ok(tctx, status,
  51                         talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed", r.in.level));
  52                 torture_assert_werr_ok(tctx, r.out.result,
  53                         talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed", r.in.level));
  54         }
  55
  56         return true;
  57 }
  58
  59 static bool test_NetWkstaTransportEnum(struct torture_context *tctx,
  60                                        struct dcerpc_pipe *p)
  61 {
  62         NTSTATUS status;
  63         struct wkssvc_NetWkstaTransportEnum r;
  64         uint32_t resume_handle = 0;
  65         struct wkssvc_NetWkstaTransportInfo info;
  66         union wkssvc_NetWkstaTransportCtr ctr;
  67         struct wkssvc_NetWkstaTransportCtr0 ctr0;
  68         uint32_t total_entries = 0;
  69
  70         ZERO_STRUCT(ctr0);
  71         ctr.ctr0 = &ctr0;
  72
  73         info.level = 0;
  74         info.ctr = ctr;
  75
  76         r.in.server_name = dcerpc_server_name(p);
  77         r.in.info = &info;
  78         r.in.max_buffer = (uint32_t)-1;
  79         r.in.resume_handle = &resume_handle;
  80         r.out.total_entries = &total_entries;
  81         r.out.info = &info;
  82         r.out.resume_handle = &resume_handle;
  83
  84         torture_comment(tctx, "testing NetWkstaTransportEnum level 0\n");
  85
  86         status = dcerpc_wkssvc_NetWkstaTransportEnum(p, tctx, &r);
  87         torture_assert_ntstatus_ok(tctx, status,
  88                                    "NetWkstaTransportEnum failed");
  89         torture_assert_werr_ok(tctx, r.out.result, talloc_asprintf(tctx,
  90                                "NetWkstaTransportEnum level %u failed",
  91                                info.level));
  92
  93         return true;
  94 }
  95
  96 static bool test_NetrWkstaTransportAdd(struct torture_context *tctx,
  97                                        struct dcerpc_pipe *p)
  98 {
  99         NTSTATUS status;
 100         struct wkssvc_NetrWkstaTransportAdd r;
 101         struct wkssvc_NetWkstaTransportInfo0 info0;
 102         uint32_t parm_err = 0;
 103
 104         ZERO_STRUCT(info0);
 105
 106         info0.quality_of_service = 0xffff;
 107         info0.vc_count = 0;
 108         info0.name = SMBTORTURE_TRANSPORT_NAME;
 109         info0.address = "000000000000";
 110         info0.wan_link = 0x400;
 111
 112         r.in.server_name = dcerpc_server_name(p);
 113         r.in.level = 0;
 114         r.in.info0 = &info0;
 115         r.in.parm_err = r.out.parm_err = &parm_err;
 116
 117         torture_comment(tctx, "testing NetrWkstaTransportAdd level 0\n");
 118
 119         status = dcerpc_wkssvc_NetrWkstaTransportAdd(p, tctx, &r);
 120         torture_assert_ntstatus_ok(tctx, status,
 121                                    "NetrWkstaTransportAdd failed");
 122         torture_assert_werr_equal(tctx, r.out.result,
 123                                   WERR_INVALID_PARAM,
 124                                   "NetrWkstaTransportAdd level 0 failed");
 125
 126         return true;
 127 }
 128
 129 static bool test_NetrWkstaTransportDel(struct torture_context *tctx,
 130                                        struct dcerpc_pipe *p)
 131 {
 132         NTSTATUS status;
 133         struct wkssvc_NetrWkstaTransportDel r;
 134
 135         r.in.server_name = dcerpc_server_name(p);
 136         r.in.transport_name = SMBTORTURE_TRANSPORT_NAME;
 137         r.in.unknown3 = 0;
 138
 139         torture_comment(tctx, "testing NetrWkstaTransportDel\n");
 140
 141         status = dcerpc_wkssvc_NetrWkstaTransportDel(p, tctx, &r);
 142         torture_assert_ntstatus_ok(tctx, status,
 143                                    "NetrWkstaTransportDel failed");
 144         torture_assert_werr_ok(tctx, r.out.result,
 145                                "NetrWkstaTransportDel");
 146
 147         return true;
 148 }
 149
 150 static bool test_NetWkstaEnumUsers(struct torture_context *tctx,
 151                                    struct dcerpc_pipe *p)
 152 {
 153         NTSTATUS status;
 154         struct wkssvc_NetWkstaEnumUsers r;
 155         uint32_t handle = 0;
 156         uint32_t entries_read = 0;
 157         struct wkssvc_NetWkstaEnumUsersInfo info;
 158         struct wkssvc_NetWkstaEnumUsersCtr0 *user0;
 159         struct wkssvc_NetWkstaEnumUsersCtr1 *user1;
 160         uint32_t levels[] = { 0, 1 };
 161         int i;
 162
 163         for (i=0; i<ARRAY_SIZE(levels); i++) {
 164
 165                 ZERO_STRUCT(info);
 166
 167                 info.level = levels[i];
 168                 switch (info.level) {
 169                 case 0:
 170                         user0 = talloc_zero(tctx,
 171                                             struct wkssvc_NetWkstaEnumUsersCtr0);
 172                         info.ctr.user0 = user0;
 173                         break;
 174                 case 1:
 175                         user1 = talloc_zero(tctx,
 176                                             struct wkssvc_NetWkstaEnumUsersCtr1);
 177                         info.ctr.user1 = user1;
 178                         break;
 179                 default:
 180                         break;
 181                 }
 182
 183                 r.in.server_name = dcerpc_server_name(p);
 184                 r.in.prefmaxlen = (uint32_t)-1;
 185                 r.in.info = r.out.info = &info;
 186                 r.in.resume_handle = r.out.resume_handle = &handle;
 187
 188                 r.out.entries_read = &entries_read;
 189
 190                 torture_comment(tctx, "testing NetWkstaEnumUsers level %u\n",
 191                                 levels[i]);
 192
 193                 status = dcerpc_wkssvc_NetWkstaEnumUsers(p, tctx, &r);
 194                 torture_assert_ntstatus_ok(tctx, status,
 195                                            "NetWkstaEnumUsers failed");
 196                 torture_assert_werr_ok(tctx, r.out.result,
 197                                        "NetWkstaEnumUsers failed");
 198         }
 199
 200         return true;
 201 }
 202
 203 static bool test_NetrWkstaUserGetInfo(struct torture_context *tctx,
 204                                       struct dcerpc_pipe *p)
 205 {
 206         NTSTATUS status;
 207         struct wkssvc_NetrWkstaUserGetInfo r;
 208         union wkssvc_NetrWkstaUserInfo info;
 209         const char *dom = lp_workgroup(global_loadparm);
 210         struct cli_credentials *creds = cmdline_credentials;
 211         const char *user = cli_credentials_get_username(creds);
 212         int i;
 213
 214         const struct {
 215                 const char *unknown;
 216                 uint32_t level;
 217                 WERROR result;
 218         } tests[] = {
 219                 { NULL, 0, WERR_NO_SUCH_LOGON_SESSION },
 220                 { NULL, 1, WERR_NO_SUCH_LOGON_SESSION },
 221                 { NULL, 1101, WERR_OK },
 222                 { dom, 0, WERR_INVALID_PARAM },
 223                 { dom, 1, WERR_INVALID_PARAM },
 224                 { dom, 1101, WERR_INVALID_PARAM },
 225                 { user, 0, WERR_INVALID_PARAM },
 226                 { user, 1, WERR_INVALID_PARAM },
 227                 { user, 1101, WERR_INVALID_PARAM },
 228         };
 229
 230         for (i=0; i<ARRAY_SIZE(tests); i++) {
 231                 r.in.unknown = tests[i].unknown;
 232                 r.in.level = tests[i].level;
 233                 r.out.info = &info;
 234
 235                 torture_comment(tctx, "testing NetrWkstaUserGetInfo level %u\n",
 236                                 r.in.level);
 237
 238                 status = dcerpc_wkssvc_NetrWkstaUserGetInfo(p, tctx, &r);
 239                 torture_assert_ntstatus_ok(tctx, status,
 240                                            "NetrWkstaUserGetInfo failed");
 241                 torture_assert_werr_equal(tctx, r.out.result,
 242                                           tests[i].result,
 243                                           "NetrWkstaUserGetInfo failed");
 244         }
 245
 246         return true;
 247 }
 248
 249 static bool test_NetrUseEnum(struct torture_context *tctx,
 250                              struct dcerpc_pipe *p)
 251 {
 252         NTSTATUS status;
 253         struct wkssvc_NetrUseEnum r;
 254         uint32_t handle = 0;
 255         uint32_t entries_read = 0;
 256         struct wkssvc_NetrUseEnumInfo info;
 257         struct wkssvc_NetrUseEnumCtr0 *use0;
 258         struct wkssvc_NetrUseEnumCtr1 *use1;
 259         struct wkssvc_NetrUseEnumCtr2 *use2;
 260         uint32_t levels[] = { 0, 1, 2 };
 261         int i;
 262
 263         for (i=0; i<ARRAY_SIZE(levels); i++) {
 264
 265                 ZERO_STRUCT(info);
 266
 267                 info.level = levels[i];
 268                 switch (info.level) {
 269                 case 0:
 270                         use0 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr0);
 271                         info.ctr.ctr0 = use0;
 272                         break;
 273                 case 1:
 274                         use1 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr1);
 275                         info.ctr.ctr1 = use1;
 276                         break;
 277                 case 2:
 278                         use2 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr2);
 279                         info.ctr.ctr2 = use2;
 280                         break;
 281                 default:
 282                         break;
 283                 }
 284
 285                 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 286                 r.in.prefmaxlen = (uint32_t)-1;
 287                 r.in.info = r.out.info = &info;
 288                 r.in.resume_handle = r.out.resume_handle = &handle;
 289
 290                 r.out.entries_read = &entries_read;
 291
 292                 torture_comment(tctx, "testing NetrUseEnum level %u\n",
 293                                 levels[i]);
 294
 295                 status = dcerpc_wkssvc_NetrUseEnum(p, tctx, &r);
 296                 torture_assert_ntstatus_ok(tctx, status,
 297                                            "NetrUseEnum failed");
 298                 torture_assert_werr_ok(tctx, r.out.result,
 299                                        "NetrUseEnum failed");
 300         }
 301
 302         return true;
 303 }
 304
 305 static bool test_NetrUseAdd(struct torture_context *tctx,
 306                             struct dcerpc_pipe *p)
 307 {
 308         NTSTATUS status;
 309         struct wkssvc_NetrUseAdd r;
 310         struct wkssvc_NetrUseInfo0 info0;
 311         struct wkssvc_NetrUseInfo1 info1;
 312         union wkssvc_NetrUseGetInfoCtr *ctr;
 313         uint32_t parm_err = 0;
 314
 315         ctr = talloc(tctx, union wkssvc_NetrUseGetInfoCtr);
 316
 317         ZERO_STRUCT(info0);
 318
 319         info0.local = SMBTORTURE_USE_NAME;
 320         info0.remote = "\\\\localhost\\c$";
 321
 322         ctr->info0 = &info0;
 323
 324         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 325         r.in.level = 0;
 326         r.in.ctr = ctr;
 327         r.in.parm_err = r.out.parm_err = &parm_err;
 328
 329         torture_comment(tctx, "testing NetrUseAdd level %u\n",
 330                         r.in.level);
 331
 332         status = dcerpc_wkssvc_NetrUseAdd(p, tctx, &r);
 333         torture_assert_ntstatus_ok(tctx, status,
 334                                    "NetrUseAdd failed");
 335         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
 336                                "NetrUseAdd failed");
 337
 338         ZERO_STRUCT(r);
 339         ZERO_STRUCT(info1);
 340
 341         info1.local = SMBTORTURE_USE_NAME;
 342         info1.remote = "\\\\localhost\\sysvol";
 343         info1.password = NULL;
 344
 345         ctr->info1 = &info1;
 346
 347         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 348         r.in.level = 1;
 349         r.in.ctr = ctr;
 350         r.in.parm_err = r.out.parm_err = &parm_err;
 351
 352         torture_comment(tctx, "testing NetrUseAdd level %u\n",
 353                         r.in.level);
 354
 355         status = dcerpc_wkssvc_NetrUseAdd(p, tctx, &r);
 356         torture_assert_ntstatus_ok(tctx, status,
 357                                    "NetrUseAdd failed");
 358         torture_assert_werr_ok(tctx, r.out.result,
 359                                "NetrUseAdd failed");
 360
 361         return true;
 362 }
 363
 364 static bool test_NetrUseDel(struct torture_context *tctx,
 365                             struct dcerpc_pipe *p)
 366 {
 367         NTSTATUS status;
 368         struct wkssvc_NetrUseDel r;
 369
 370         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 371         r.in.use_name = SMBTORTURE_USE_NAME;
 372         r.in.force_cond = 0;
 373
 374         torture_comment(tctx, "testing NetrUseDel\n");
 375
 376         status = dcerpc_wkssvc_NetrUseDel(p, tctx, &r);
 377         torture_assert_ntstatus_ok(tctx, status,
 378                                    "NetrUseDel failed");
 379         torture_assert_werr_ok(tctx, r.out.result,
 380                                "NetrUseDel failed");
 381         return true;
 382 }
 383
 384 static bool test_NetrUseGetInfo_level(struct torture_context *tctx,
 385                                       struct dcerpc_pipe *p,
 386                                       const char *use_name,
 387                                       uint32_t level,
 388                                       WERROR werr)
 389 {
 390         NTSTATUS status;
 391         struct wkssvc_NetrUseGetInfo r;
 392         union wkssvc_NetrUseGetInfoCtr ctr;
 393
 394         ZERO_STRUCT(ctr);
 395
 396         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 397         r.in.use_name = use_name;
 398         r.in.level = level;
 399         r.out.ctr = &ctr;
 400         status = dcerpc_wkssvc_NetrUseGetInfo(p, tctx, &r);
 401
 402         torture_assert_ntstatus_ok(tctx, status,
 403                                    "NetrUseGetInfo failed");
 404         torture_assert_werr_equal(tctx, r.out.result, werr,
 405                                   "NetrUseGetInfo failed");
 406         return true;
 407 }
 408
 409 static bool test_NetrUseGetInfo(struct torture_context *tctx,
 410                                 struct dcerpc_pipe *p)
 411 {
 412         NTSTATUS status;
 413         struct wkssvc_NetrUseEnum r;
 414         uint32_t handle = 0;
 415         uint32_t entries_read = 0;
 416         struct wkssvc_NetrUseEnumInfo info;
 417         struct wkssvc_NetrUseEnumCtr0 *use0;
 418         uint32_t levels[] = { 0, 1, 2 };
 419         const char *use_name = NULL;
 420         int i, k;
 421
 422         ZERO_STRUCT(info);
 423
 424         info.level = 0;
 425         use0 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr0);
 426         info.ctr.ctr0 = use0;
 427
 428         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 429         r.in.prefmaxlen = (uint32_t)-1;
 430         r.in.info = r.out.info = &info;
 431         r.in.resume_handle = r.out.resume_handle = &handle;
 432         r.out.entries_read = &entries_read;
 433
 434         status = dcerpc_wkssvc_NetrUseEnum(p, tctx, &r);
 435         torture_assert_ntstatus_ok(tctx, status,
 436                                    "NetrUseEnum failed");
 437         torture_assert_werr_ok(tctx, r.out.result,
 438                                "NetrUseEnum failed");
 439
 440         for (k=0; k < r.out.info->ctr.ctr0->count; k++) {
 441
 442                 use_name = r.out.info->ctr.ctr0->array[k].local;
 443
 444                 for (i=0; i<ARRAY_SIZE(levels); i++) {
 445
 446                         if (!test_NetrUseGetInfo_level(tctx, p, use_name,
 447                                                        levels[i],
 448                                                        WERR_OK))
 449                         {
 450                                 if (levels[i] != 0) {
 451                                         return false;
 452                                 }
 453                         }
 454                 }
 455
 456                 use_name = r.out.info->ctr.ctr0->array[k].remote;
 457
 458                 for (i=0; i<ARRAY_SIZE(levels); i++) {
 459
 460                         if (!test_NetrUseGetInfo_level(tctx, p, use_name,
 461                                                        levels[i],
 462                                                        WERR_NOT_CONNECTED))
 463                         {
 464                                 if (levels[i] != 0) {
 465                                         return false;
 466                                 }
 467                         }
 468                 }
 469         }
 470
 471         return true;
 472 }
 473
 474 static bool test_NetrLogonDomainNameAdd(struct torture_context *tctx,
 475                                         struct dcerpc_pipe *p)
 476 {
 477         NTSTATUS status;
 478         struct wkssvc_NetrLogonDomainNameAdd r;
 479
 480         r.in.domain_name = lp_workgroup(global_loadparm);
 481
 482         torture_comment(tctx, "testing NetrLogonDomainNameAdd\n");
 483
 484         status = dcerpc_wkssvc_NetrLogonDomainNameAdd(p, tctx, &r);
 485         torture_assert_ntstatus_ok(tctx, status,
 486                                    "NetrLogonDomainNameAdd failed");
 487         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
 488                                   "NetrLogonDomainNameAdd failed");
 489         return true;
 490 }
 491
 492 static bool test_NetrLogonDomainNameDel(struct torture_context *tctx,
 493                                         struct dcerpc_pipe *p)
 494 {
 495         NTSTATUS status;
 496         struct wkssvc_NetrLogonDomainNameDel r;
 497
 498         r.in.domain_name = lp_workgroup(global_loadparm);
 499
 500         torture_comment(tctx, "testing NetrLogonDomainNameDel\n");
 501
 502         status = dcerpc_wkssvc_NetrLogonDomainNameDel(p, tctx, &r);
 503         torture_assert_ntstatus_ok(tctx, status,
 504                                    "NetrLogonDomainNameDel failed");
 505         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
 506                                   "NetrLogonDomainNameDel failed");
 507         return true;
 508 }
 509
 510 static bool test_NetrEnumerateComputerNames_level(struct torture_context *tctx,
 511                                                   struct dcerpc_pipe *p,
 512                                                   uint16_t level,
 513                                                   const char ***names,
 514                                                   int *num_names)
 515 {
 516         NTSTATUS status;
 517         struct wkssvc_NetrEnumerateComputerNames r;
 518         struct wkssvc_ComputerNamesCtr *ctr;
 519         int i;
 520
 521         ctr = talloc_zero(tctx, struct wkssvc_ComputerNamesCtr);
 522
 523         r.in.server_name = dcerpc_server_name(p);
 524         r.in.name_type = level;
 525         r.in.Reserved = 0;
 526         r.out.ctr = &ctr;
 527
 528         torture_comment(tctx, "testing NetrEnumerateComputerNames level %u\n",
 529                         r.in.name_type);
 530
 531         status = dcerpc_wkssvc_NetrEnumerateComputerNames(p, tctx, &r);
 532         torture_assert_ntstatus_ok(tctx, status,
 533                                    "NetrEnumerateComputerNames failed");
 534         torture_assert_werr_ok(tctx, r.out.result,
 535                                "NetrEnumerateComputerNames failed");
 536
 537         if ((level == NetPrimaryComputerName) && ctr->count != 1) {
 538                 torture_comment(tctx,
 539                                 "NetrEnumerateComputerNames did not return one "
 540                                 "name but %u\n", ctr->count);
 541                 return false;
 542         }
 543
 544         if (names && num_names) {
 545                 *num_names = 0;
 546                 *names = NULL;
 547                 for (i=0; i<ctr->count; i++) {
 548                         if (!add_string_to_array(tctx,
 549                                                  ctr->computer_name[i].string,
 550                                                  names,
 551                                                  num_names))
 552                         {
 553                                 return false;
 554                         }
 555                 }
 556         }
 557
 558         return true;
 559 }
 560
 561 static bool test_NetrEnumerateComputerNames(struct torture_context *tctx,
 562                                             struct dcerpc_pipe *p)
 563 {
 564         uint16_t levels[] = {0,1,2};
 565         int i;
 566
 567         for (i=0; i<ARRAY_SIZE(levels); i++) {
 568
 569                 if (!test_NetrEnumerateComputerNames_level(tctx,
 570                                                            p,
 571                                                            levels[i],
 572                                                            NULL, NULL))
 573                 {
 574                         return false;
 575                 }
 576         }
 577
 578         return true;
 579 }
 580
 581 static bool test_NetrValidateName(struct torture_context *tctx,
 582                                   struct dcerpc_pipe *p)
 583 {
 584         NTSTATUS status;
 585         struct wkssvc_NetrValidateName r;
 586         uint16_t levels[] = {0,1,2,3,4,5};
 587         int i;
 588
 589         for (i=0; i<ARRAY_SIZE(levels); i++) {
 590
 591                 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 592                 r.in.name = lp_workgroup(global_loadparm);
 593                 r.in.Account = NULL;
 594                 r.in.Password = NULL;
 595                 r.in.name_type = levels[i];
 596
 597                 torture_comment(tctx, "testing NetrValidateName level %u\n",
 598                                 r.in.name_type);
 599
 600                 status = dcerpc_wkssvc_NetrValidateName(p, tctx, &r);
 601                 torture_assert_ntstatus_ok(tctx, status,
 602                                            "NetrValidateName failed");
 603                 torture_assert_werr_equal(tctx, r.out.result,
 604                                           WERR_NOT_SUPPORTED,
 605                                           "NetrValidateName failed");
 606         }
 607
 608         return true;
 609 }
 610
 611 static bool test_NetrValidateName2(struct torture_context *tctx,
 612                                    struct dcerpc_pipe *p)
 613 {
 614         NTSTATUS status;
 615         struct wkssvc_NetrValidateName2 r;
 616         uint16_t levels[] = {0,1,2,3,4,5};
 617         int i;
 618
 619         for (i=0; i<ARRAY_SIZE(levels); i++) {
 620
 621                 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 622                 r.in.name = lp_workgroup(global_loadparm);
 623                 r.in.Account = NULL;
 624                 r.in.EncryptedPassword = NULL;
 625                 r.in.name_type = levels[i];
 626
 627                 torture_comment(tctx, "testing NetrValidateName2 level %u\n",
 628                                 r.in.name_type);
 629
 630                 status = dcerpc_wkssvc_NetrValidateName2(p, tctx, &r);
 631                 torture_assert_ntstatus_ok(tctx, status,
 632                                            "NetrValidateName2 failed");
 633                 torture_assert_werr_equal(tctx, r.out.result,
 634                                           WERR_RPC_E_REMOTE_DISABLED,
 635                                           "NetrValidateName2 failed");
 636         }
 637
 638         return true;
 639 }
 640
 641 static bool test_NetrAddAlternateComputerName(struct torture_context *tctx,
 642                                               struct dcerpc_pipe *p)
 643 {
 644         NTSTATUS status;
 645         struct wkssvc_NetrAddAlternateComputerName r;
 646         const char **names = NULL;
 647         int num_names = 0;
 648         int i;
 649
 650         r.in.server_name = dcerpc_server_name(p);
 651         r.in.NewAlternateMachineName = SMBTORTURE_ALTERNATE_NAME;
 652         r.in.Account = NULL;
 653         r.in.EncryptedPassword = NULL;
 654         r.in.Reserved = 0;
 655
 656         torture_comment(tctx, "testing NetrAddAlternateComputerName\n");
 657
 658         status = dcerpc_wkssvc_NetrAddAlternateComputerName(p, tctx, &r);
 659         torture_assert_ntstatus_ok(tctx, status,
 660                                    "NetrAddAlternateComputerName failed");
 661         torture_assert_werr_ok(tctx, r.out.result,
 662                                "NetrAddAlternateComputerName failed");
 663
 664         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 665                                                    NetAlternateComputerNames,
 666                                                    &names, &num_names))
 667         {
 668                 return false;
 669         }
 670
 671         for (i=0; i<num_names; i++) {
 672                 if (strequal(names[i], SMBTORTURE_ALTERNATE_NAME)) {
 673                         return true;
 674                 }
 675         }
 676
 677         torture_comment(tctx, "new alternate name not set\n");
 678
 679         return false;
 680 }
 681
 682 static bool test_NetrRemoveAlternateComputerName(struct torture_context *tctx,
 683                                                  struct dcerpc_pipe *p)
 684 {
 685         NTSTATUS status;
 686         struct wkssvc_NetrRemoveAlternateComputerName r;
 687         const char **names = NULL;
 688         int num_names = 0;
 689         int i;
 690
 691         r.in.server_name = dcerpc_server_name(p);
 692         r.in.AlternateMachineNameToRemove = SMBTORTURE_ALTERNATE_NAME;
 693         r.in.Account = NULL;
 694         r.in.EncryptedPassword = NULL;
 695         r.in.Reserved = 0;
 696
 697         torture_comment(tctx, "testing NetrRemoveAlternateComputerName\n");
 698
 699         status = dcerpc_wkssvc_NetrRemoveAlternateComputerName(p, tctx, &r);
 700         torture_assert_ntstatus_ok(tctx, status,
 701                                    "NetrRemoveAlternateComputerName failed");
 702         torture_assert_werr_ok(tctx, r.out.result,
 703                                "NetrRemoveAlternateComputerName failed");
 704
 705         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 706                                                    NetAlternateComputerNames,
 707                                                    &names, &num_names))
 708         {
 709                 return false;
 710         }
 711
 712         for (i=0; i<num_names; i++) {
 713                 if (strequal(names[i], SMBTORTURE_ALTERNATE_NAME)) {
 714                         return false;
 715                 }
 716         }
 717
 718         return true;
 719 }
 720
 721 static bool test_NetrSetPrimaryComputername_name(struct torture_context *tctx,
 722                                                  struct dcerpc_pipe *p,
 723                                                  const char *name)
 724 {
 725         NTSTATUS status;
 726         struct wkssvc_NetrSetPrimaryComputername r;
 727
 728         r.in.server_name = dcerpc_server_name(p);
 729         r.in.primary_name = name;
 730         r.in.Account = NULL;
 731         r.in.EncryptedPassword = NULL;
 732         r.in.Reserved = 0;
 733
 734         status = dcerpc_wkssvc_NetrSetPrimaryComputername(p, tctx, &r);
 735         torture_assert_ntstatus_ok(tctx, status,
 736                                    "NetrSetPrimaryComputername failed");
 737         torture_assert_werr_ok(tctx, r.out.result,
 738                                "NetrSetPrimaryComputername failed");
 739         return true;
 740 }
 741
 742
 743 static bool test_NetrSetPrimaryComputername(struct torture_context *tctx,
 744                                             struct dcerpc_pipe *p)
 745 {
 746         /*
 747           add alternate,
 748           check if there
 749           store old primary
 750           set new primary (alternate)
 751           check if there
 752           later: check if del is possible
 753           set primary back to origin
 754           check if there
 755           del alternate
 756         */
 757
 758         const char **names_o = NULL, **names = NULL;
 759         int num_names_o = 0, num_names = 0;
 760
 761         torture_comment(tctx, "testing NetrSetPrimaryComputername\n");
 762
 763         if (!test_NetrAddAlternateComputerName(tctx, p)) {
 764                 return false;
 765         }
 766
 767         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 768                                                    NetPrimaryComputerName,
 769                                                    &names_o, &num_names_o))
 770         {
 771                 return false;
 772         }
 773
 774         if (num_names_o != 1) {
 775                 return false;
 776         }
 777
 778         if (!test_NetrSetPrimaryComputername_name(tctx, p,
 779                                                   SMBTORTURE_ALTERNATE_NAME))
 780         {
 781                 return false;
 782         }
 783
 784         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 785                                                    NetPrimaryComputerName,
 786                                                    &names, &num_names))
 787         {
 788                 return false;
 789         }
 790
 791         if (num_names != 1) {
 792                 return false;
 793         }
 794
 795         if (!strequal(names[0], SMBTORTURE_ALTERNATE_NAME)) {
 796                 torture_comment(tctx,
 797                                 "name mismatch (%s != %s) after NetrSetPrimaryComputername!\n",
 798                                 names[0], SMBTORTURE_ALTERNATE_NAME);
 799                 /*return false */;
 800         }
 801
 802         if (!test_NetrSetPrimaryComputername_name(tctx, p,
 803                                                   names_o[0]))
 804         {
 805                 return false;
 806         }
 807
 808         if (!test_NetrRemoveAlternateComputerName(tctx, p)) {
 809                 return false;
 810         }
 811
 812
 813         return true;
 814 }
 815
 816 static bool test_NetrRenameMachineInDomain(struct torture_context *tctx,
 817                                            struct dcerpc_pipe *p)
 818 {
 819         NTSTATUS status;
 820         struct wkssvc_NetrRenameMachineInDomain r;
 821
 822         r.in.server_name = dcerpc_server_name(p);
 823         r.in.NewMachineName = SMBTORTURE_MACHINE_NAME;
 824         r.in.Account = NULL;
 825         r.in.password = NULL;
 826         r.in.RenameOptions = 0;
 827
 828         torture_comment(tctx, "testing NetrRenameMachineInDomain\n");
 829
 830         status = dcerpc_wkssvc_NetrRenameMachineInDomain(p, tctx, &r);
 831         torture_assert_ntstatus_ok(tctx, status,
 832                                    "NetrRenameMachineInDomain failed");
 833         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
 834                                   "NetrRenameMachineInDomain failed");
 835         return true;
 836 }
 837
 838 static bool test_NetrRenameMachineInDomain2_name(struct torture_context *tctx,
 839                                                  struct dcerpc_pipe *p,
 840                                                  const char *new_name)
 841 {
 842         NTSTATUS status;
 843         struct wkssvc_NetrRenameMachineInDomain2 r;
 844
 845         r.in.server_name = dcerpc_server_name(p);
 846         r.in.NewMachineName = new_name;
 847         r.in.Account = NULL;
 848         r.in.EncryptedPassword = NULL;
 849         r.in.RenameOptions = 0;
 850
 851         status = dcerpc_wkssvc_NetrRenameMachineInDomain2(p, tctx, &r);
 852         torture_assert_ntstatus_ok(tctx, status,
 853                                    "NetrRenameMachineInDomain2 failed");
 854         torture_assert_werr_ok(tctx, r.out.result,
 855                                "NetrRenameMachineInDomain2 failed");
 856         return true;
 857 }
 858
 859 static bool test_NetrRenameMachineInDomain2(struct torture_context *tctx,
 860                                             struct dcerpc_pipe *p)
 861 {
 862         const char **names_o = NULL, **names = NULL;
 863         int num_names_o = 0, num_names = 0;
 864
 865         torture_comment(tctx, "testing NetrRenameMachineInDomain2\n");
 866
 867         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 868                                                    NetPrimaryComputerName,
 869                                                    &names_o, &num_names_o))
 870         {
 871                 return false;
 872         }
 873
 874         if (num_names_o != 1) {
 875                 return false;
 876         }
 877
 878         if (!test_NetrRenameMachineInDomain2_name(tctx, p,
 879                                                   SMBTORTURE_MACHINE_NAME))
 880         {
 881                 return false;
 882         }
 883
 884         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 885                                                    NetPrimaryComputerName,
 886                                                    &names, &num_names))
 887         {
 888                 return false;
 889         }
 890
 891         if (num_names != 1) {
 892                 return false;
 893         }
 894
 895         if (strequal(names[0], names_o[0])) {
 896                 test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]);
 897                 return false;
 898         }
 899
 900         if (!strequal(names[0], SMBTORTURE_MACHINE_NAME)) {
 901                 test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]);
 902                 return false;
 903         }
 904
 905         if (!test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]))
 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                 return false;
 923         }
 924
 925         return true;
 926 }
 927
 928 static bool test_NetrWorkstationStatisticsGet(struct torture_context *tctx,
 929                                               struct dcerpc_pipe *p)
 930 {
 931         NTSTATUS status;
 932         struct wkssvc_NetrWorkstationStatisticsGet r;
 933         struct wkssvc_NetrWorkstationStatistics *info;
 934
 935         ZERO_STRUCT(r);
 936
 937         info = talloc_zero(tctx, struct wkssvc_NetrWorkstationStatistics);
 938
 939         r.in.server_name = dcerpc_server_name(p);
 940         r.out.info = &info;
 941
 942         torture_comment(tctx, "testing NetrWorkstationStatisticsGet\n");
 943
 944         status = dcerpc_wkssvc_NetrWorkstationStatisticsGet(p, tctx, &r);
 945         torture_assert_ntstatus_ok(tctx, status,
 946                                    "NetrWorkstationStatisticsGet failed");
 947         torture_assert_werr_ok(tctx, r.out.result,
 948                                "NetrWorkstationStatisticsGet failed");
 949         return true;
 950 }
 951
 952 /* only succeeds as long as the local messenger service is running - Guenther */
 953
 954 static bool test_NetrMessageBufferSend(struct torture_context *tctx,
 955                                        struct dcerpc_pipe *p)
 956 {
 957         NTSTATUS status;
 958         struct wkssvc_NetrMessageBufferSend r;
 959         const char *message = SMBTORTURE_MESSAGE;
 960         size_t size;
 961         uint8_t *msg;
 962
 963         size = push_ucs2_talloc(tctx, (void **)&msg, message);
 964
 965         r.in.server_name = dcerpc_server_name(p);
 966         r.in.message_name = dcerpc_server_name(p);
 967         r.in.message_sender_name = dcerpc_server_name(p);
 968         r.in.message_buffer = msg;
 969         r.in.message_size = size;
 970
 971         torture_comment(tctx, "testing NetrMessageBufferSend\n");
 972
 973         status = dcerpc_wkssvc_NetrMessageBufferSend(p, tctx, &r);
 974         torture_assert_ntstatus_ok(tctx, status,
 975                                    "NetrMessageBufferSend failed");
 976         torture_assert_werr_ok(tctx, r.out.result,
 977                                "NetrMessageBufferSend failed");
 978         return true;
 979 }
 980
 981 static bool test_NetrGetJoinInformation(struct torture_context *tctx,
 982                                         struct dcerpc_pipe *p)
 983 {
 984         NTSTATUS status;
 985         struct wkssvc_NetrGetJoinInformation r;
 986         enum wkssvc_NetJoinStatus join_status;
 987         const char *name_buffer = "";
 988
 989         r.in.server_name = dcerpc_server_name(p);
 990         r.in.name_buffer = r.out.name_buffer = &name_buffer;
 991         r.out.name_type = &join_status;
 992
 993         torture_comment(tctx, "testing NetrGetJoinInformation\n");
 994
 995         status = dcerpc_wkssvc_NetrGetJoinInformation(p, tctx, &r);
 996         torture_assert_ntstatus_ok(tctx, status,
 997                                    "NetrGetJoinInformation failed");
 998         torture_assert_werr_ok(tctx, r.out.result,
 999                                "NetrGetJoinInformation failed");
1000         return true;
1001 }
1002
1003 static bool test_NetrGetJoinableOus(struct torture_context *tctx,
1004                                     struct dcerpc_pipe *p)
1005 {
1006         NTSTATUS status;
1007         struct wkssvc_NetrGetJoinableOus r;
1008         uint32_t num_ous = 0;
1009         const char **ous = NULL;
1010
1011         r.in.server_name = dcerpc_server_name(p);
1012         r.in.domain_name = lp_workgroup(global_loadparm);
1013         r.in.Account = NULL;
1014         r.in.unknown = NULL;
1015         r.in.num_ous = r.out.num_ous = &num_ous;
1016         r.out.ous = &ous;
1017
1018         torture_comment(tctx, "testing NetrGetJoinableOus\n");
1019
1020         status = dcerpc_wkssvc_NetrGetJoinableOus(p, tctx, &r);
1021         torture_assert_ntstatus_ok(tctx, status, "NetrGetJoinableOus failed");
1022         torture_assert_werr_equal(tctx, r.out.result,
1023                                   WERR_NOT_SUPPORTED,
1024                                   "NetrGetJoinableOus failed");
1025
1026         return true;
1027 }
1028
1029 static bool test_NetrGetJoinableOus2(struct torture_context *tctx,
1030                                      struct dcerpc_pipe *p)
1031 {
1032         NTSTATUS status;
1033         struct wkssvc_NetrGetJoinableOus2 r;
1034         uint32_t num_ous = 0;
1035         const char **ous = NULL;
1036
1037         r.in.server_name = dcerpc_server_name(p);
1038         r.in.domain_name = lp_workgroup(global_loadparm);
1039         r.in.Account = NULL;
1040         r.in.EncryptedPassword = NULL;
1041         r.in.num_ous = r.out.num_ous = &num_ous;
1042         r.out.ous = &ous;
1043
1044         torture_comment(tctx, "testing NetrGetJoinableOus2\n");
1045
1046         status = dcerpc_wkssvc_NetrGetJoinableOus2(p, tctx, &r);
1047         torture_assert_ntstatus_ok(tctx, status, "NetrGetJoinableOus2 failed");
1048         torture_assert_werr_equal(tctx, r.out.result,
1049                                   WERR_RPC_E_REMOTE_DISABLED,
1050                                   "NetrGetJoinableOus2 failed");
1051
1052         return true;
1053 }
1054 struct torture_suite *torture_rpc_wkssvc(TALLOC_CTX *mem_ctx)
1055 {
1056         struct torture_suite *suite;
1057         struct torture_rpc_tcase *tcase;
1058         struct torture_test *test;
1059
1060         suite = torture_suite_create(mem_ctx, "WKSSVC");
1061         tcase = torture_suite_add_rpc_iface_tcase(suite, "wkssvc",
1062                                                   &ndr_table_wkssvc);
1063
1064         torture_rpc_tcase_add_test(tcase, "NetWkstaGetInfo",
1065                                    test_NetWkstaGetInfo);
1066
1067         torture_rpc_tcase_add_test(tcase, "NetWkstaTransportEnum",
1068                                    test_NetWkstaTransportEnum);
1069         torture_rpc_tcase_add_test(tcase, "NetrWkstaTransportDel",
1070                                    test_NetrWkstaTransportDel);
1071         torture_rpc_tcase_add_test(tcase, "NetrUseGetInfo",
1072                                    test_NetrUseGetInfo);
1073         torture_rpc_tcase_add_test(tcase, "NetrWkstaTransportAdd",
1074                                    test_NetrWkstaTransportAdd);
1075
1076         torture_rpc_tcase_add_test(tcase, "NetWkstaEnumUsers",
1077                                    test_NetWkstaEnumUsers);
1078         torture_rpc_tcase_add_test(tcase, "NetrWkstaUserGetInfo",
1079                                    test_NetrWkstaUserGetInfo);
1080
1081         torture_rpc_tcase_add_test(tcase, "NetrUseDel",
1082                                    test_NetrUseDel);
1083         torture_rpc_tcase_add_test(tcase, "NetrUseEnum",
1084                                    test_NetrUseEnum);
1085         torture_rpc_tcase_add_test(tcase, "NetrUseAdd",
1086                                    test_NetrUseAdd);
1087
1088         torture_rpc_tcase_add_test(tcase, "NetrValidateName",
1089                                    test_NetrValidateName);
1090         torture_rpc_tcase_add_test(tcase, "NetrValidateName2",
1091                                    test_NetrValidateName2);
1092         torture_rpc_tcase_add_test(tcase, "NetrLogonDomainNameDel",
1093                                    test_NetrLogonDomainNameDel);
1094         torture_rpc_tcase_add_test(tcase, "NetrLogonDomainNameAdd",
1095                                    test_NetrLogonDomainNameAdd);
1096         torture_rpc_tcase_add_test(tcase, "NetrRemoveAlternateComputerName",
1097                                    test_NetrRemoveAlternateComputerName);
1098         torture_rpc_tcase_add_test(tcase, "NetrAddAlternateComputerName",
1099                                    test_NetrAddAlternateComputerName);
1100         test = torture_rpc_tcase_add_test(tcase, "NetrSetPrimaryComputername",
1101                                           test_NetrSetPrimaryComputername);
1102         test->dangerous = true;
1103         test = torture_rpc_tcase_add_test(tcase, "NetrRenameMachineInDomain",
1104                                           test_NetrRenameMachineInDomain);
1105         test->dangerous = true;
1106         test = torture_rpc_tcase_add_test(tcase, "NetrRenameMachineInDomain2",
1107                                           test_NetrRenameMachineInDomain2);
1108         test->dangerous = true;
1109         torture_rpc_tcase_add_test(tcase, "NetrEnumerateComputerNames",
1110                                    test_NetrEnumerateComputerNames);
1111
1112         torture_rpc_tcase_add_test(tcase, "NetrGetJoinInformation",
1113                                    test_NetrGetJoinInformation);
1114         torture_rpc_tcase_add_test(tcase, "NetrGetJoinableOus",
1115                                    test_NetrGetJoinableOus);
1116         torture_rpc_tcase_add_test(tcase, "NetrGetJoinableOus2",
1117                                    test_NetrGetJoinableOus2);
1118
1119         torture_rpc_tcase_add_test(tcase, "NetrWorkstationStatisticsGet",
1120                                    test_NetrWorkstationStatisticsGet);
1121         torture_rpc_tcase_add_test(tcase, "NetrMessageBufferSend",
1122                                    test_NetrMessageBufferSend);
1123
1124         return suite;
1125 }