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_ALTERNATE_NAME "smbtrt_altname"
  29 #define SMBTORTURE_TRANSPORT_NAME "\\Device\\smbtrt_transport_name"
  30 #define SMBTORTURE_USE_NAME "S:"
  31
  32 static bool test_NetWkstaGetInfo(struct torture_context *tctx,
  33                                  struct dcerpc_pipe *p)
  34 {
  35         NTSTATUS status;
  36         struct wkssvc_NetWkstaGetInfo r;
  37         union wkssvc_NetWkstaInfo info;
  38         uint16_t levels[] = {100, 101, 102, 502};
  39         int i;
  40
  41         r.in.server_name = dcerpc_server_name(p);
  42         r.out.info = &info;
  43
  44         for (i=0;i<ARRAY_SIZE(levels);i++) {
  45                 r.in.level = levels[i];
  46                 torture_comment(tctx, "testing NetWkstaGetInfo level %u\n", r.in.level);
  47                 status = dcerpc_wkssvc_NetWkstaGetInfo(p, tctx, &r);
  48                 torture_assert_ntstatus_ok(tctx, status,
  49                         talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed", r.in.level));
  50                 torture_assert_werr_ok(tctx, r.out.result,
  51                         talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed", r.in.level));
  52         }
  53
  54         return true;
  55 }
  56
  57 static bool test_NetWkstaTransportEnum(struct torture_context *tctx,
  58                                        struct dcerpc_pipe *p)
  59 {
  60         NTSTATUS status;
  61         struct wkssvc_NetWkstaTransportEnum r;
  62         uint32_t resume_handle = 0;
  63         struct wkssvc_NetWkstaTransportInfo info;
  64         union wkssvc_NetWkstaTransportCtr ctr;
  65         struct wkssvc_NetWkstaTransportCtr0 ctr0;
  66         uint32_t total_entries = 0;
  67
  68         ZERO_STRUCT(ctr0);
  69         ctr.ctr0 = &ctr0;
  70
  71         info.level = 0;
  72         info.ctr = ctr;
  73
  74         r.in.server_name = dcerpc_server_name(p);
  75         r.in.info = &info;
  76         r.in.max_buffer = (uint32_t)-1;
  77         r.in.resume_handle = &resume_handle;
  78         r.out.total_entries = &total_entries;
  79         r.out.info = &info;
  80         r.out.resume_handle = &resume_handle;
  81
  82         torture_comment(tctx, "testing NetWkstaTransportEnum level 0\n");
  83
  84         status = dcerpc_wkssvc_NetWkstaTransportEnum(p, tctx, &r);
  85         torture_assert_ntstatus_ok(tctx, status,
  86                                    "NetWkstaTransportEnum failed");
  87         torture_assert_werr_ok(tctx, r.out.result, talloc_asprintf(tctx,
  88                                "NetWkstaTransportEnum level %u failed",
  89                                info.level));
  90
  91         return true;
  92 }
  93
  94 static bool test_NetrWkstaTransportAdd(struct torture_context *tctx,
  95                                        struct dcerpc_pipe *p)
  96 {
  97         NTSTATUS status;
  98         struct wkssvc_NetrWkstaTransportAdd r;
  99         struct wkssvc_NetWkstaTransportInfo0 info0;
 100         uint32_t parm_err = 0;
 101
 102         ZERO_STRUCT(info0);
 103
 104         info0.quality_of_service = 0xffff;
 105         info0.vc_count = 0;
 106         info0.name = SMBTORTURE_TRANSPORT_NAME;
 107         info0.address = "000000000000";
 108         info0.wan_link = 0x400;
 109
 110         r.in.server_name = dcerpc_server_name(p);
 111         r.in.level = 0;
 112         r.in.info0 = &info0;
 113         r.in.parm_err = r.out.parm_err = &parm_err;
 114
 115         torture_comment(tctx, "testing NetrWkstaTransportAdd level 0\n");
 116
 117         status = dcerpc_wkssvc_NetrWkstaTransportAdd(p, tctx, &r);
 118         torture_assert_ntstatus_ok(tctx, status,
 119                                    "NetrWkstaTransportAdd failed");
 120         torture_assert_werr_equal(tctx, r.out.result,
 121                                   WERR_INVALID_PARAM,
 122                                   "NetrWkstaTransportAdd level 0 failed");
 123
 124         return true;
 125 }
 126
 127 static bool test_NetrWkstaTransportDel(struct torture_context *tctx,
 128                                        struct dcerpc_pipe *p)
 129 {
 130         NTSTATUS status;
 131         struct wkssvc_NetrWkstaTransportDel r;
 132
 133         r.in.server_name = dcerpc_server_name(p);
 134         r.in.transport_name = SMBTORTURE_TRANSPORT_NAME;
 135         r.in.unknown3 = 0;
 136
 137         torture_comment(tctx, "testing NetrWkstaTransportDel\n");
 138
 139         status = dcerpc_wkssvc_NetrWkstaTransportDel(p, tctx, &r);
 140         torture_assert_ntstatus_ok(tctx, status,
 141                                    "NetrWkstaTransportDel failed");
 142         torture_assert_werr_ok(tctx, r.out.result,
 143                                "NetrWkstaTransportDel");
 144
 145         return true;
 146 }
 147
 148 static bool test_NetWkstaEnumUsers(struct torture_context *tctx,
 149                                    struct dcerpc_pipe *p)
 150 {
 151         NTSTATUS status;
 152         struct wkssvc_NetWkstaEnumUsers r;
 153         uint32_t handle = 0;
 154         uint32_t entries_read = 0;
 155         struct wkssvc_NetWkstaEnumUsersInfo info;
 156         struct wkssvc_NetWkstaEnumUsersCtr0 *user0;
 157         struct wkssvc_NetWkstaEnumUsersCtr1 *user1;
 158         uint32_t levels[] = { 0, 1 };
 159         int i;
 160
 161         for (i=0; i<ARRAY_SIZE(levels); i++) {
 162
 163                 ZERO_STRUCT(info);
 164
 165                 info.level = levels[i];
 166                 switch (info.level) {
 167                 case 0:
 168                         user0 = talloc_zero(tctx,
 169                                             struct wkssvc_NetWkstaEnumUsersCtr0);
 170                         info.ctr.user0 = user0;
 171                         break;
 172                 case 1:
 173                         user1 = talloc_zero(tctx,
 174                                             struct wkssvc_NetWkstaEnumUsersCtr1);
 175                         info.ctr.user1 = user1;
 176                         break;
 177                 default:
 178                         break;
 179                 }
 180
 181                 r.in.server_name = dcerpc_server_name(p);
 182                 r.in.prefmaxlen = (uint32_t)-1;
 183                 r.in.info = r.out.info = &info;
 184                 r.in.resume_handle = r.out.resume_handle = &handle;
 185
 186                 r.out.entries_read = &entries_read;
 187
 188                 torture_comment(tctx, "testing NetWkstaEnumUsers level %u\n",
 189                                 levels[i]);
 190
 191                 status = dcerpc_wkssvc_NetWkstaEnumUsers(p, tctx, &r);
 192                 torture_assert_ntstatus_ok(tctx, status,
 193                                            "NetWkstaEnumUsers failed");
 194                 torture_assert_werr_ok(tctx, r.out.result,
 195                                        "NetWkstaEnumUsers failed");
 196         }
 197
 198         return true;
 199 }
 200
 201 static bool test_NetrWkstaUserGetInfo(struct torture_context *tctx,
 202                                       struct dcerpc_pipe *p)
 203 {
 204         NTSTATUS status;
 205         struct wkssvc_NetrWkstaUserGetInfo r;
 206         union wkssvc_NetrWkstaUserInfo info;
 207         const char *dom = lp_workgroup(global_loadparm);
 208         struct cli_credentials *creds = cmdline_credentials;
 209         const char *user = cli_credentials_get_username(creds);
 210         int i;
 211
 212         const struct {
 213                 const char *unknown;
 214                 uint32_t level;
 215                 WERROR result;
 216         } tests[] = {
 217                 { NULL, 0, WERR_NO_SUCH_LOGON_SESSION },
 218                 { NULL, 1, WERR_NO_SUCH_LOGON_SESSION },
 219                 { NULL, 1101, WERR_OK },
 220                 { dom, 0, WERR_INVALID_PARAM },
 221                 { dom, 1, WERR_INVALID_PARAM },
 222                 { dom, 1101, WERR_INVALID_PARAM },
 223                 { user, 0, WERR_INVALID_PARAM },
 224                 { user, 1, WERR_INVALID_PARAM },
 225                 { user, 1101, WERR_INVALID_PARAM },
 226         };
 227
 228         for (i=0; i<ARRAY_SIZE(tests); i++) {
 229                 r.in.unknown = tests[i].unknown;
 230                 r.in.level = tests[i].level;
 231                 r.out.info = &info;
 232
 233                 torture_comment(tctx, "testing NetrWkstaUserGetInfo level %u\n",
 234                                 r.in.level);
 235
 236                 status = dcerpc_wkssvc_NetrWkstaUserGetInfo(p, tctx, &r);
 237                 torture_assert_ntstatus_ok(tctx, status,
 238                                            "NetrWkstaUserGetInfo failed");
 239                 torture_assert_werr_equal(tctx, r.out.result,
 240                                           tests[i].result,
 241                                           "NetrWkstaUserGetInfo failed");
 242         }
 243
 244         return true;
 245 }
 246
 247 static bool test_NetrUseEnum(struct torture_context *tctx,
 248                              struct dcerpc_pipe *p)
 249 {
 250         NTSTATUS status;
 251         struct wkssvc_NetrUseEnum r;
 252         uint32_t handle = 0;
 253         uint32_t entries_read = 0;
 254         struct wkssvc_NetrUseEnumInfo info;
 255         struct wkssvc_NetrUseEnumCtr0 *use0;
 256         struct wkssvc_NetrUseEnumCtr1 *use1;
 257         struct wkssvc_NetrUseEnumCtr2 *use2;
 258         uint32_t levels[] = { 0, 1, 2 };
 259         int i;
 260
 261         for (i=0; i<ARRAY_SIZE(levels); i++) {
 262
 263                 ZERO_STRUCT(info);
 264
 265                 info.level = levels[i];
 266                 switch (info.level) {
 267                 case 0:
 268                         use0 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr0);
 269                         info.ctr.ctr0 = use0;
 270                         break;
 271                 case 1:
 272                         use1 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr1);
 273                         info.ctr.ctr1 = use1;
 274                         break;
 275                 case 2:
 276                         use2 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr2);
 277                         info.ctr.ctr2 = use2;
 278                         break;
 279                 default:
 280                         break;
 281                 }
 282
 283                 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 284                 r.in.prefmaxlen = (uint32_t)-1;
 285                 r.in.info = r.out.info = &info;
 286                 r.in.resume_handle = r.out.resume_handle = &handle;
 287
 288                 r.out.entries_read = &entries_read;
 289
 290                 torture_comment(tctx, "testing NetrUseEnum level %u\n",
 291                                 levels[i]);
 292
 293                 status = dcerpc_wkssvc_NetrUseEnum(p, tctx, &r);
 294                 torture_assert_ntstatus_ok(tctx, status,
 295                                            "NetrUseEnum failed");
 296                 torture_assert_werr_ok(tctx, r.out.result,
 297                                        "NetrUseEnum failed");
 298         }
 299
 300         return true;
 301 }
 302
 303 static bool test_NetrUseAdd(struct torture_context *tctx,
 304                             struct dcerpc_pipe *p)
 305 {
 306         NTSTATUS status;
 307         struct wkssvc_NetrUseAdd r;
 308         struct wkssvc_NetrUseInfo0 info0;
 309         struct wkssvc_NetrUseInfo1 info1;
 310         union wkssvc_NetrUseGetInfoCtr *ctr;
 311         uint32_t parm_err = 0;
 312
 313         ctr = talloc(tctx, union wkssvc_NetrUseGetInfoCtr);
 314
 315         ZERO_STRUCT(info0);
 316
 317         info0.local = SMBTORTURE_USE_NAME;
 318         info0.remote = "\\\\localhost\\c$";
 319
 320         ctr->info0 = &info0;
 321
 322         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 323         r.in.level = 0;
 324         r.in.ctr = ctr;
 325         r.in.parm_err = r.out.parm_err = &parm_err;
 326
 327         torture_comment(tctx, "testing NetrUseAdd level %u\n",
 328                         r.in.level);
 329
 330         status = dcerpc_wkssvc_NetrUseAdd(p, tctx, &r);
 331         torture_assert_ntstatus_ok(tctx, status,
 332                                    "NetrUseAdd failed");
 333         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
 334                                "NetrUseAdd failed");
 335
 336         ZERO_STRUCT(r);
 337         ZERO_STRUCT(info1);
 338
 339         info1.local = SMBTORTURE_USE_NAME;
 340         info1.remote = "\\\\localhost\\sysvol";
 341         info1.password = NULL;
 342
 343         ctr->info1 = &info1;
 344
 345         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 346         r.in.level = 1;
 347         r.in.ctr = ctr;
 348         r.in.parm_err = r.out.parm_err = &parm_err;
 349
 350         torture_comment(tctx, "testing NetrUseAdd level %u\n",
 351                         r.in.level);
 352
 353         status = dcerpc_wkssvc_NetrUseAdd(p, tctx, &r);
 354         torture_assert_ntstatus_ok(tctx, status,
 355                                    "NetrUseAdd failed");
 356         torture_assert_werr_ok(tctx, r.out.result,
 357                                "NetrUseAdd failed");
 358
 359         return true;
 360 }
 361
 362 static bool test_NetrUseDel(struct torture_context *tctx,
 363                             struct dcerpc_pipe *p)
 364 {
 365         NTSTATUS status;
 366         struct wkssvc_NetrUseDel r;
 367
 368         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 369         r.in.use_name = SMBTORTURE_USE_NAME;
 370         r.in.force_cond = 0;
 371
 372         torture_comment(tctx, "testing NetrUseDel\n");
 373
 374         status = dcerpc_wkssvc_NetrUseDel(p, tctx, &r);
 375         torture_assert_ntstatus_ok(tctx, status,
 376                                    "NetrUseDel failed");
 377         torture_assert_werr_ok(tctx, r.out.result,
 378                                "NetrUseDel failed");
 379         return true;
 380 }
 381
 382 static bool test_NetrUseGetInfo_level(struct torture_context *tctx,
 383                                       struct dcerpc_pipe *p,
 384                                       const char *use_name,
 385                                       uint32_t level,
 386                                       WERROR werr)
 387 {
 388         NTSTATUS status;
 389         struct wkssvc_NetrUseGetInfo r;
 390         union wkssvc_NetrUseGetInfoCtr ctr;
 391
 392         ZERO_STRUCT(ctr);
 393
 394         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 395         r.in.use_name = use_name;
 396         r.in.level = level;
 397         r.out.ctr = &ctr;
 398         status = dcerpc_wkssvc_NetrUseGetInfo(p, tctx, &r);
 399
 400         torture_assert_ntstatus_ok(tctx, status,
 401                                    "NetrUseGetInfo failed");
 402         torture_assert_werr_equal(tctx, r.out.result, werr,
 403                                   "NetrUseGetInfo failed");
 404         return true;
 405 }
 406
 407 static bool test_NetrUseGetInfo(struct torture_context *tctx,
 408                                 struct dcerpc_pipe *p)
 409 {
 410         NTSTATUS status;
 411         struct wkssvc_NetrUseEnum r;
 412         uint32_t handle = 0;
 413         uint32_t entries_read = 0;
 414         struct wkssvc_NetrUseEnumInfo info;
 415         struct wkssvc_NetrUseEnumCtr0 *use0;
 416         uint32_t levels[] = { 0, 1, 2 };
 417         const char *use_name = NULL;
 418         int i, k;
 419
 420         ZERO_STRUCT(info);
 421
 422         info.level = 0;
 423         use0 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr0);
 424         info.ctr.ctr0 = use0;
 425
 426         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 427         r.in.prefmaxlen = (uint32_t)-1;
 428         r.in.info = r.out.info = &info;
 429         r.in.resume_handle = r.out.resume_handle = &handle;
 430         r.out.entries_read = &entries_read;
 431
 432         status = dcerpc_wkssvc_NetrUseEnum(p, tctx, &r);
 433         torture_assert_ntstatus_ok(tctx, status,
 434                                    "NetrUseEnum failed");
 435         torture_assert_werr_ok(tctx, r.out.result,
 436                                "NetrUseEnum failed");
 437
 438         for (k=0; k < r.out.info->ctr.ctr0->count; k++) {
 439
 440                 use_name = r.out.info->ctr.ctr0->array[k].local;
 441
 442                 for (i=0; i<ARRAY_SIZE(levels); i++) {
 443
 444                         if (!test_NetrUseGetInfo_level(tctx, p, use_name,
 445                                                        levels[i],
 446                                                        WERR_OK))
 447                         {
 448                                 if (levels[i] != 0) {
 449                                         return false;
 450                                 }
 451                         }
 452                 }
 453
 454                 use_name = r.out.info->ctr.ctr0->array[k].remote;
 455
 456                 for (i=0; i<ARRAY_SIZE(levels); i++) {
 457
 458                         if (!test_NetrUseGetInfo_level(tctx, p, use_name,
 459                                                        levels[i],
 460                                                        WERR_NOT_CONNECTED))
 461                         {
 462                                 if (levels[i] != 0) {
 463                                         return false;
 464                                 }
 465                         }
 466                 }
 467         }
 468
 469         return true;
 470 }
 471
 472 static bool test_NetrLogonDomainNameAdd(struct torture_context *tctx,
 473                                         struct dcerpc_pipe *p)
 474 {
 475         NTSTATUS status;
 476         struct wkssvc_NetrLogonDomainNameAdd r;
 477
 478         r.in.domain_name = lp_workgroup(global_loadparm);
 479
 480         torture_comment(tctx, "testing NetrLogonDomainNameAdd\n");
 481
 482         status = dcerpc_wkssvc_NetrLogonDomainNameAdd(p, tctx, &r);
 483         torture_assert_ntstatus_ok(tctx, status,
 484                                    "NetrLogonDomainNameAdd failed");
 485         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
 486                                   "NetrLogonDomainNameAdd failed");
 487         return true;
 488 }
 489
 490 static bool test_NetrLogonDomainNameDel(struct torture_context *tctx,
 491                                         struct dcerpc_pipe *p)
 492 {
 493         NTSTATUS status;
 494         struct wkssvc_NetrLogonDomainNameDel r;
 495
 496         r.in.domain_name = lp_workgroup(global_loadparm);
 497
 498         torture_comment(tctx, "testing NetrLogonDomainNameDel\n");
 499
 500         status = dcerpc_wkssvc_NetrLogonDomainNameDel(p, tctx, &r);
 501         torture_assert_ntstatus_ok(tctx, status,
 502                                    "NetrLogonDomainNameDel failed");
 503         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
 504                                   "NetrLogonDomainNameDel failed");
 505         return true;
 506 }
 507
 508 static bool test_NetrEnumerateComputerNames_level(struct torture_context *tctx,
 509                                                   struct dcerpc_pipe *p,
 510                                                   uint16_t level,
 511                                                   const char ***names,
 512                                                   int *num_names)
 513 {
 514         NTSTATUS status;
 515         struct wkssvc_NetrEnumerateComputerNames r;
 516         struct wkssvc_ComputerNamesCtr *ctr;
 517         int i;
 518
 519         ctr = talloc_zero(tctx, struct wkssvc_ComputerNamesCtr);
 520
 521         r.in.server_name = dcerpc_server_name(p);
 522         r.in.name_type = level;
 523         r.in.Reserved = 0;
 524         r.out.ctr = &ctr;
 525
 526         torture_comment(tctx, "testing NetrEnumerateComputerNames level %u\n",
 527                         r.in.name_type);
 528
 529         status = dcerpc_wkssvc_NetrEnumerateComputerNames(p, tctx, &r);
 530         torture_assert_ntstatus_ok(tctx, status,
 531                                    "NetrEnumerateComputerNames failed");
 532         torture_assert_werr_ok(tctx, r.out.result,
 533                                "NetrEnumerateComputerNames failed");
 534
 535         if ((level == NetPrimaryComputerName) && ctr->count != 1) {
 536                 torture_comment(tctx,
 537                                 "NetrEnumerateComputerNames did not return one "
 538                                 "name but %u\n", ctr->count);
 539                 return false;
 540         }
 541
 542         if (names && num_names) {
 543                 *num_names = 0;
 544                 *names = NULL;
 545                 for (i=0; i<ctr->count; i++) {
 546                         if (!add_string_to_array(tctx,
 547                                                  ctr->computer_name[i].string,
 548                                                  names,
 549                                                  num_names))
 550                         {
 551                                 return false;
 552                         }
 553                 }
 554         }
 555
 556         return true;
 557 }
 558
 559 static bool test_NetrEnumerateComputerNames(struct torture_context *tctx,
 560                                             struct dcerpc_pipe *p)
 561 {
 562         uint16_t levels[] = {0,1,2};
 563         int i;
 564
 565         for (i=0; i<ARRAY_SIZE(levels); i++) {
 566
 567                 if (!test_NetrEnumerateComputerNames_level(tctx,
 568                                                            p,
 569                                                            levels[i],
 570                                                            NULL, NULL))
 571                 {
 572                         return false;
 573                 }
 574         }
 575
 576         return true;
 577 }
 578
 579 static bool test_NetrValidateName(struct torture_context *tctx,
 580                                   struct dcerpc_pipe *p)
 581 {
 582         NTSTATUS status;
 583         struct wkssvc_NetrValidateName r;
 584         uint16_t levels[] = {0,1,2,3,4,5};
 585         int i;
 586
 587         for (i=0; i<ARRAY_SIZE(levels); i++) {
 588
 589                 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 590                 r.in.name = lp_workgroup(global_loadparm);
 591                 r.in.Account = NULL;
 592                 r.in.Password = NULL;
 593                 r.in.name_type = levels[i];
 594
 595                 torture_comment(tctx, "testing NetrValidateName level %u\n",
 596                                 r.in.name_type);
 597
 598                 status = dcerpc_wkssvc_NetrValidateName(p, tctx, &r);
 599                 torture_assert_ntstatus_ok(tctx, status,
 600                                            "NetrValidateName failed");
 601                 torture_assert_werr_equal(tctx, r.out.result,
 602                                           WERR_NOT_SUPPORTED,
 603                                           "NetrValidateName failed");
 604         }
 605
 606         return true;
 607 }
 608
 609 static bool test_NetrValidateName2(struct torture_context *tctx,
 610                                    struct dcerpc_pipe *p)
 611 {
 612         NTSTATUS status;
 613         struct wkssvc_NetrValidateName2 r;
 614         uint16_t levels[] = {0,1,2,3,4,5};
 615         int i;
 616
 617         for (i=0; i<ARRAY_SIZE(levels); i++) {
 618
 619                 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 620                 r.in.name = lp_workgroup(global_loadparm);
 621                 r.in.Account = NULL;
 622                 r.in.EncryptedPassword = NULL;
 623                 r.in.name_type = levels[i];
 624
 625                 torture_comment(tctx, "testing NetrValidateName2 level %u\n",
 626                                 r.in.name_type);
 627
 628                 status = dcerpc_wkssvc_NetrValidateName2(p, tctx, &r);
 629                 torture_assert_ntstatus_ok(tctx, status,
 630                                            "NetrValidateName2 failed");
 631                 torture_assert_werr_equal(tctx, r.out.result,
 632                                           WERR_RPC_E_REMOTE_DISABLED,
 633                                           "NetrValidateName2 failed");
 634         }
 635
 636         return true;
 637 }
 638
 639 static bool test_NetrAddAlternateComputerName(struct torture_context *tctx,
 640                                               struct dcerpc_pipe *p)
 641 {
 642         NTSTATUS status;
 643         struct wkssvc_NetrAddAlternateComputerName r;
 644         const char **names = NULL;
 645         int num_names = 0;
 646         int i;
 647
 648         r.in.server_name = dcerpc_server_name(p);
 649         r.in.NewAlternateMachineName = SMBTORTURE_ALTERNATE_NAME;
 650         r.in.Account = NULL;
 651         r.in.EncryptedPassword = NULL;
 652         r.in.Reserved = 0;
 653
 654         torture_comment(tctx, "testing NetrAddAlternateComputerName\n");
 655
 656         status = dcerpc_wkssvc_NetrAddAlternateComputerName(p, tctx, &r);
 657         torture_assert_ntstatus_ok(tctx, status,
 658                                    "NetrAddAlternateComputerName failed");
 659         torture_assert_werr_ok(tctx, r.out.result,
 660                                "NetrAddAlternateComputerName failed");
 661
 662         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 663                                                    NetAlternateComputerNames,
 664                                                    &names, &num_names))
 665         {
 666                 return false;
 667         }
 668
 669         for (i=0; i<num_names; i++) {
 670                 if (strequal(names[i], SMBTORTURE_ALTERNATE_NAME)) {
 671                         return true;
 672                 }
 673         }
 674
 675         torture_comment(tctx, "new alternate name not set\n");
 676
 677         return false;
 678 }
 679
 680 static bool test_NetrRemoveAlternateComputerName(struct torture_context *tctx,
 681                                                  struct dcerpc_pipe *p)
 682 {
 683         NTSTATUS status;
 684         struct wkssvc_NetrRemoveAlternateComputerName r;
 685         const char **names = NULL;
 686         int num_names = 0;
 687         int i;
 688
 689         r.in.server_name = dcerpc_server_name(p);
 690         r.in.AlternateMachineNameToRemove = SMBTORTURE_ALTERNATE_NAME;
 691         r.in.Account = NULL;
 692         r.in.EncryptedPassword = NULL;
 693         r.in.Reserved = 0;
 694
 695         torture_comment(tctx, "testing NetrRemoveAlternateComputerName\n");
 696
 697         status = dcerpc_wkssvc_NetrRemoveAlternateComputerName(p, tctx, &r);
 698         torture_assert_ntstatus_ok(tctx, status,
 699                                    "NetrRemoveAlternateComputerName failed");
 700         torture_assert_werr_ok(tctx, r.out.result,
 701                                "NetrRemoveAlternateComputerName failed");
 702
 703         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 704                                                    NetAlternateComputerNames,
 705                                                    &names, &num_names))
 706         {
 707                 return false;
 708         }
 709
 710         for (i=0; i<num_names; i++) {
 711                 if (strequal(names[i], SMBTORTURE_ALTERNATE_NAME)) {
 712                         return false;
 713                 }
 714         }
 715
 716         return true;
 717 }
 718
 719 struct torture_suite *torture_rpc_wkssvc(TALLOC_CTX *mem_ctx)
 720 {
 721         struct torture_suite *suite;
 722         struct torture_rpc_tcase *tcase;
 723
 724         suite = torture_suite_create(mem_ctx, "WKSSVC");
 725         tcase = torture_suite_add_rpc_iface_tcase(suite, "wkssvc",
 726                                                   &ndr_table_wkssvc);
 727
 728         torture_rpc_tcase_add_test(tcase, "NetWkstaGetInfo",
 729                                    test_NetWkstaGetInfo);
 730
 731         torture_rpc_tcase_add_test(tcase, "NetWkstaTransportEnum",
 732                                    test_NetWkstaTransportEnum);
 733         torture_rpc_tcase_add_test(tcase, "NetrWkstaTransportDel",
 734                                    test_NetrWkstaTransportDel);
 735         torture_rpc_tcase_add_test(tcase, "NetrUseGetInfo",
 736                                    test_NetrUseGetInfo);
 737         torture_rpc_tcase_add_test(tcase, "NetrWkstaTransportAdd",
 738                                    test_NetrWkstaTransportAdd);
 739
 740         torture_rpc_tcase_add_test(tcase, "NetWkstaEnumUsers",
 741                                    test_NetWkstaEnumUsers);
 742         torture_rpc_tcase_add_test(tcase, "NetrWkstaUserGetInfo",
 743                                    test_NetrWkstaUserGetInfo);
 744
 745         torture_rpc_tcase_add_test(tcase, "NetrUseDel",
 746                                    test_NetrUseDel);
 747         torture_rpc_tcase_add_test(tcase, "NetrUseEnum",
 748                                    test_NetrUseEnum);
 749         torture_rpc_tcase_add_test(tcase, "NetrUseAdd",
 750                                    test_NetrUseAdd);
 751
 752         torture_rpc_tcase_add_test(tcase, "NetrValidateName",
 753                                    test_NetrValidateName);
 754         torture_rpc_tcase_add_test(tcase, "NetrValidateName2",
 755                                    test_NetrValidateName2);
 756         torture_rpc_tcase_add_test(tcase, "NetrLogonDomainNameDel",
 757                                    test_NetrLogonDomainNameDel);
 758         torture_rpc_tcase_add_test(tcase, "NetrLogonDomainNameAdd",
 759                                    test_NetrLogonDomainNameAdd);
 760         torture_rpc_tcase_add_test(tcase, "NetrRemoveAlternateComputerName",
 761                                    test_NetrRemoveAlternateComputerName);
 762         torture_rpc_tcase_add_test(tcase, "NetrAddAlternateComputerName",
 763                                    test_NetrAddAlternateComputerName);
 764         torture_rpc_tcase_add_test(tcase, "NetrEnumerateComputerNames",
 765                                    test_NetrEnumerateComputerNames);
 766
 767         return suite;
 768 }