source/torture/rpc/srvsvc.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    test suite for srvsvc rpc operations
   4
   5    Copyright (C) Stefan (metze) Metzmacher 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 2 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, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23 #include "torture/torture.h"
  24 #include "librpc/gen_ndr/ndr_srvsvc.h"
  25 #include "librpc/gen_ndr/ndr_srvsvc_c.h"
  26 #include "torture/rpc/rpc.h"
  27
  28 /**************************/
  29 /* srvsvc_NetCharDev      */
  30 /**************************/
  31 static BOOL test_NetCharDevGetInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
  32                                 const char *devname)
  33 {
  34         NTSTATUS status;
  35         struct srvsvc_NetCharDevGetInfo r;
  36         uint32_t levels[] = {0, 1};
  37         int i;
  38         BOOL ret = True;
  39
  40         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
  41         r.in.device_name = devname;
  42
  43         for (i=0;i<ARRAY_SIZE(levels);i++) {
  44                 ZERO_STRUCT(r.out);
  45                 r.in.level = levels[i];
  46                 printf("testing NetCharDevGetInfo level %u on device '%s'\n",
  47                         r.in.level, r.in.device_name);
  48                 status = dcerpc_srvsvc_NetCharDevGetInfo(p, mem_ctx, &r);
  49                 if (!NT_STATUS_IS_OK(status)) {
  50                         printf("NetCharDevGetInfo level %u on device '%s' failed - %s\n",
  51                                 r.in.level, r.in.device_name, nt_errstr(status));
  52                         ret = False;
  53                         continue;
  54                 }
  55                 if (!W_ERROR_IS_OK(r.out.result)) {
  56                         printf("NetCharDevGetInfo level %u on device '%s' failed - %s\n",
  57                                 r.in.level, r.in.device_name, win_errstr(r.out.result));
  58                         continue;
  59                 }
  60         }
  61
  62         return ret;
  63 }
  64
  65 static BOOL test_NetCharDevControl(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
  66                                 const char *devname)
  67 {
  68         NTSTATUS status;
  69         struct srvsvc_NetCharDevControl r;
  70         uint32_t opcodes[] = {0, 1};
  71         int i;
  72         BOOL ret = True;
  73
  74         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
  75         r.in.device_name = devname;
  76
  77         for (i=0;i<ARRAY_SIZE(opcodes);i++) {
  78                 ZERO_STRUCT(r.out);
  79                 r.in.opcode = opcodes[i];
  80                 printf("testing NetCharDevControl opcode %u on device '%s'\n",
  81                         r.in.opcode, r.in.device_name);
  82                 status = dcerpc_srvsvc_NetCharDevControl(p, mem_ctx, &r);
  83                 if (!NT_STATUS_IS_OK(status)) {
  84                         printf("NetCharDevControl opcode %u failed - %s\n", r.in.opcode, nt_errstr(status));
  85                         ret = False;
  86                         continue;
  87                 }
  88                 if (!W_ERROR_IS_OK(r.out.result)) {
  89                         printf("NetCharDevControl opcode %u failed - %s\n", r.in.opcode, win_errstr(r.out.result));
  90                         continue;
  91                 }
  92         }
  93
  94         return ret;
  95 }
  96
  97 static BOOL test_NetCharDevEnum(struct dcerpc_pipe *p,
  98                            TALLOC_CTX *mem_ctx)
  99 {
 100         NTSTATUS status;
 101         struct srvsvc_NetCharDevEnum r;
 102         struct srvsvc_NetCharDevCtr0 c0;
 103         uint32_t levels[] = {0, 1};
 104         int i;
 105         BOOL ret = True;
 106
 107         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
 108         r.in.ctr.ctr0 = &c0;
 109         r.in.ctr.ctr0->count = 0;
 110         r.in.ctr.ctr0->array = NULL;
 111         r.in.max_buffer = (uint32_t)-1;
 112         r.in.resume_handle = NULL;
 113
 114         for (i=0;i<ARRAY_SIZE(levels);i++) {
 115                 int j;
 116
 117
 118                 ZERO_STRUCT(r.out);
 119                 r.in.level = levels[i];
 120                 printf("testing NetCharDevEnum level %u\n", r.in.level);
 121                 status = dcerpc_srvsvc_NetCharDevEnum(p, mem_ctx, &r);
 122                 if (!NT_STATUS_IS_OK(status)) {
 123                         printf("NetCharDevEnum level %u failed - %s\n", r.in.level, nt_errstr(status));
 124                         ret = False;
 125                         continue;
 126                 }
 127                 if (!W_ERROR_IS_OK(r.out.result)) {
 128                         printf("NetCharDevEnum level %u failed - %s\n", r.in.level, win_errstr(r.out.result));
 129                         continue;
 130                 }
 131
 132                 /* call test_NetCharDevGetInfo and test_NetCharDevControl for each returned share */
 133                 if (r.in.level == 1) {
 134                         for (j=0;j<r.out.ctr.ctr1->count;j++) {
 135                                 const char *device;
 136                                 device = r.out.ctr.ctr1->array[j].device;
 137                                 if (!test_NetCharDevGetInfo(p, mem_ctx, device)) {
 138                                         ret = False;
 139                                 }
 140                                 if (!test_NetCharDevControl(p, mem_ctx, device)) {
 141                                         ret = False;
 142                                 }
 143                         }
 144                 }
 145         }
 146
 147         return ret;
 148 }
 149
 150 /**************************/
 151 /* srvsvc_NetCharDevQ     */
 152 /**************************/
 153 static BOOL test_NetCharDevQGetInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 154                                 const char *devicequeue)
 155 {
 156         NTSTATUS status;
 157         struct srvsvc_NetCharDevQGetInfo r;
 158         uint32_t levels[] = {0, 1};
 159         int i;
 160         BOOL ret = True;
 161
 162         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
 163         r.in.queue_name = devicequeue;
 164         r.in.user = talloc_asprintf(mem_ctx,"Administrator");
 165
 166         for (i=0;i<ARRAY_SIZE(levels);i++) {
 167                 ZERO_STRUCT(r.out);
 168                 r.in.level = levels[i];
 169                 printf("testing NetCharDevQGetInfo level %u on devicequeue '%s'\n",
 170                         r.in.level, r.in.queue_name);
 171                 status = dcerpc_srvsvc_NetCharDevQGetInfo(p, mem_ctx, &r);
 172                 if (!NT_STATUS_IS_OK(status)) {
 173                         printf("NetCharDevQGetInfo level %u on devicequeue '%s' failed - %s\n",
 174                                 r.in.level, r.in.queue_name, nt_errstr(status));
 175                         ret = False;
 176                         continue;
 177                 }
 178                 if (!W_ERROR_IS_OK(r.out.result)) {
 179                         printf("NetCharDevQGetInfo level %u on devicequeue '%s' failed - %s\n",
 180                                 r.in.level, r.in.queue_name, win_errstr(r.out.result));
 181                         continue;
 182                 }
 183         }
 184
 185         return ret;
 186 }
 187
 188 #if 0
 189 static BOOL test_NetCharDevQSetInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 190                                 const char *devicequeue)
 191 {
 192         NTSTATUS status;
 193         struct srvsvc_NetCharDevQSetInfo r;
 194         uint32_t parm_error;
 195         uint32_t levels[] = {0, 1};
 196         int i;
 197         BOOL ret = True;
 198
 199         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
 200         r.in.queue_name = devicequeue;
 201
 202         for (i=0;i<ARRAY_SIZE(levels);i++) {
 203                 ZERO_STRUCT(r.out);
 204                 parm_error = 0;
 205                 r.in.level = levels[i];
 206                 printf("testing NetCharDevQSetInfo level %u on devicequeue '%s'\n",
 207                         r.in.level, devicequeue);
 208                 switch (r.in.level) {
 209                 case 0:
 210                         r.in.info.info0 = talloc(mem_ctx, struct srvsvc_NetCharDevQInfo0);
 211                         r.in.info.info0->device = r.in.queue_name;
 212                         break;
 213                 case 1:
 214                         r.in.info.info1 = talloc(mem_ctx, struct srvsvc_NetCharDevQInfo1);
 215                         r.in.info.info1->device = r.in.queue_name;
 216                         r.in.info.info1->priority = 0x000;
 217                         r.in.info.info1->devices = r.in.queue_name;
 218                         r.in.info.info1->users = 0x000;
 219                         r.in.info.info1->num_ahead = 0x000;
 220                         break;
 221                 default:
 222                         break;
 223                 }
 224                 r.in.parm_error = &parm_error;
 225                 status = dcerpc_srvsvc_NetCharDevQSetInfo(p, mem_ctx, &r);
 226                 if (!NT_STATUS_IS_OK(status)) {
 227                         printf("NetCharDevQSetInfo level %u on devicequeue '%s' failed - %s\n",
 228                                 r.in.level, r.in.queue_name, nt_errstr(status));
 229                         ret = False;
 230                         continue;
 231                 }
 232                 if (!W_ERROR_IS_OK(r.out.result)) {
 233                         printf("NetCharDevQSetInfo level %u on devicequeue '%s' failed - %s\n",
 234                                 r.in.level, r.in.queue_name, win_errstr(r.out.result));
 235                         continue;
 236                 }
 237         }
 238
 239         return ret;
 240 }
 241 #endif
 242
 243 static BOOL test_NetCharDevQEnum(struct dcerpc_pipe *p,
 244                            TALLOC_CTX *mem_ctx)
 245 {
 246         NTSTATUS status;
 247         struct srvsvc_NetCharDevQEnum r;
 248         struct srvsvc_NetCharDevQCtr0 c0;
 249         uint32_t levels[] = {0, 1};
 250         int i;
 251         BOOL ret = True;
 252
 253         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
 254         r.in.user = talloc_asprintf(mem_ctx,"%s","Administrator");
 255         r.in.ctr.ctr0 = &c0;
 256         r.in.ctr.ctr0->count = 0;
 257         r.in.ctr.ctr0->array = NULL;
 258         r.in.max_buffer = (uint32_t)-1;
 259         r.in.resume_handle = NULL;
 260
 261         for (i=0;i<ARRAY_SIZE(levels);i++) {
 262                 int j;
 263
 264                 ZERO_STRUCT(r.out);
 265                 r.in.level = levels[i];
 266                 printf("testing NetCharDevQEnum level %u\n", r.in.level);
 267                 status = dcerpc_srvsvc_NetCharDevQEnum(p, mem_ctx, &r);
 268                 if (!NT_STATUS_IS_OK(status)) {
 269                         printf("NetCharDevQEnum level %u failed - %s\n", r.in.level, nt_errstr(status));
 270                         ret = False;
 271                         continue;
 272                 }
 273                 if (!W_ERROR_IS_OK(r.out.result)) {
 274                         printf("NetCharDevQEnum level %u failed - %s\n", r.in.level, win_errstr(r.out.result));
 275                         continue;
 276                 }
 277
 278                 /* call test_NetCharDevGetInfo and test_NetCharDevControl for each returned share */
 279                 if (r.in.level == 1) {
 280                         for (j=0;j<r.out.ctr.ctr1->count;j++) {
 281                                 const char *device;
 282                                 device = r.out.ctr.ctr1->array[j].device;
 283                                 if (!test_NetCharDevQGetInfo(p, mem_ctx, device)) {
 284                                         ret = False;
 285                                 }
 286                         }
 287                 }
 288         }
 289
 290         return ret;
 291 }
 292
 293 /**************************/
 294 /* srvsvc_NetConn         */
 295 /**************************/
 296 static BOOL test_NetConnEnum(struct dcerpc_pipe *p,
 297                            TALLOC_CTX *mem_ctx)
 298 {
 299         NTSTATUS status;
 300         struct srvsvc_NetConnEnum r;
 301         struct srvsvc_NetConnCtr0 c0;
 302         uint32_t levels[] = {0, 1};
 303         int i;
 304         BOOL ret = True;
 305
 306         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
 307         r.in.path = talloc_asprintf(mem_ctx,"%s","ADMIN$");
 308         r.in.ctr.ctr0 = &c0;
 309         r.in.ctr.ctr0->count = 0;
 310         r.in.ctr.ctr0->array = NULL;
 311         r.in.max_buffer = (uint32_t)-1;
 312         r.in.resume_handle = NULL;
 313
 314         for (i=0;i<ARRAY_SIZE(levels);i++) {
 315                 ZERO_STRUCT(r.out);
 316                 r.in.level = levels[i];
 317                 printf("testing NetConnEnum level %u\n", r.in.level);
 318                 status = dcerpc_srvsvc_NetConnEnum(p, mem_ctx, &r);
 319                 if (!NT_STATUS_IS_OK(status)) {
 320                         printf("NetConnEnum level %u failed - %s\n", r.in.level, nt_errstr(status));
 321                         ret = False;
 322                         continue;
 323                 }
 324                 if (!W_ERROR_IS_OK(r.out.result)) {
 325                         printf("NetConnEnum level %u failed - %s\n", r.in.level, win_errstr(r.out.result));
 326                         continue;
 327                 }
 328         }
 329
 330         return ret;
 331 }
 332
 333 /**************************/
 334 /* srvsvc_NetFile         */
 335 /**************************/
 336 static BOOL test_NetFileEnum(struct dcerpc_pipe *p,
 337                            TALLOC_CTX *mem_ctx)
 338 {
 339         NTSTATUS status;
 340         struct srvsvc_NetFileEnum r;
 341         struct srvsvc_NetFileCtr3 c3;
 342         uint32_t levels[] = {2, 3};
 343         int i;
 344         BOOL ret = True;
 345
 346         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
 347         r.in.path = NULL;
 348         r.in.user = NULL;
 349         r.in.ctr.ctr3 = &c3;
 350         r.in.ctr.ctr3->count = 0;
 351         r.in.ctr.ctr3->array = NULL;
 352         r.in.max_buffer = (uint32_t)4096;
 353         r.in.resume_handle = NULL;
 354
 355         for (i=0;i<ARRAY_SIZE(levels);i++) {
 356                 ZERO_STRUCT(r.out);
 357                 r.in.level = levels[i];
 358                 printf("testing NetFileEnum level %u\n", r.in.level);
 359                 status = dcerpc_srvsvc_NetFileEnum(p, mem_ctx, &r);
 360                 if (!NT_STATUS_IS_OK(status)) {
 361                         printf("NetFileEnum level %u failed - %s\n", r.in.level, nt_errstr(status));
 362                         ret = False;
 363                         continue;
 364                 }
 365                 if (!W_ERROR_IS_OK(r.out.result)) {
 366                         printf("NetFileEnum level %u failed - %s\n", r.in.level, win_errstr(r.out.result));
 367                         continue;
 368                 }
 369         }
 370
 371         return ret;
 372 }
 373
 374 /**************************/
 375 /* srvsvc_NetSess         */
 376 /**************************/
 377 static BOOL test_NetSessEnum(struct dcerpc_pipe *p,
 378                            TALLOC_CTX *mem_ctx)
 379 {
 380         NTSTATUS status;
 381         struct srvsvc_NetSessEnum r;
 382         struct srvsvc_NetSessCtr0 c0;
 383         uint32_t levels[] = {0, 1, 2, 10, 502};
 384         int i;
 385         BOOL ret = True;
 386
 387         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
 388         r.in.client = NULL;
 389         r.in.user = NULL;
 390         r.in.ctr.ctr0 = &c0;
 391         r.in.ctr.ctr0->count = 0;
 392         r.in.ctr.ctr0->array = NULL;
 393         r.in.max_buffer = (uint32_t)-1;
 394         r.in.resume_handle = NULL;
 395
 396         for (i=0;i<ARRAY_SIZE(levels);i++) {
 397                 ZERO_STRUCT(r.out);
 398                 r.in.level = levels[i];
 399                 printf("testing NetSessEnum level %u\n", r.in.level);
 400                 status = dcerpc_srvsvc_NetSessEnum(p, mem_ctx, &r);
 401                 if (!NT_STATUS_IS_OK(status)) {
 402                         printf("NetSessEnum level %u failed - %s\n", r.in.level, nt_errstr(status));
 403                         ret = False;
 404                         continue;
 405                 }
 406                 if (!W_ERROR_IS_OK(r.out.result)) {
 407                         printf("NetSessEnum level %u failed - %s\n", r.in.level, win_errstr(r.out.result));
 408                         continue;
 409                 }
 410         }
 411
 412         return ret;
 413 }
 414
 415 /**************************/
 416 /* srvsvc_NetShare        */
 417 /**************************/
 418 static BOOL test_NetShareCheck(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 419                                const char *device_name)
 420 {
 421         NTSTATUS status;
 422         struct srvsvc_NetShareCheck r;
 423         BOOL ret = True;
 424
 425         r.in.server_unc = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
 426         r.in.device_name = device_name;
 427
 428         printf("testing NetShareCheck on device '%s'\n", r.in.device_name);
 429
 430         status = dcerpc_srvsvc_NetShareCheck(p, mem_ctx, &r);
 431         if (!NT_STATUS_IS_OK(status)) {
 432                 printf("dcerpc_srvsvc_NetShareCheck on device '%s' failed - %s\n",
 433                         r.in.device_name, nt_errstr(status));
 434                 ret = False;
 435         } else if (!W_ERROR_IS_OK(r.out.result)) {
 436                 printf("NetShareCheck on device '%s' failed - %s\n",
 437                         r.in.device_name, win_errstr(r.out.result));
 438                 ret = False;
 439         }
 440
 441         return ret;
 442 }
 443
 444 static BOOL test_NetShareGetInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 445                                  const char *sharename, BOOL admin)
 446 {
 447         NTSTATUS status;
 448         struct srvsvc_NetShareGetInfo r;
 449         struct {
 450                 uint32_t level;
 451                 WERROR anon_status;
 452                 WERROR admin_status;
 453         } levels[] = {
 454                  { 0,           WERR_OK,                WERR_OK },
 455                  { 1,           WERR_OK,                WERR_OK },
 456                  { 2,           WERR_ACCESS_DENIED,     WERR_OK },
 457                  { 501,         WERR_OK,                WERR_OK },
 458                  { 502,         WERR_ACCESS_DENIED,     WERR_OK },
 459                  { 1005,        WERR_OK,                WERR_OK },
 460         };
 461         int i;
 462         BOOL ret = True;
 463
 464         r.in.server_unc = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
 465         r.in.share_name = sharename;
 466
 467         for (i=0;i<ARRAY_SIZE(levels);i++) {
 468                 WERROR expected;
 469
 470                 r.in.level = levels[i].level;
 471                 expected = levels[i].anon_status;
 472                 if (admin) expected = levels[i].admin_status;
 473                 ZERO_STRUCT(r.out);
 474
 475                 printf("testing NetShareGetInfo level %u on share '%s'\n",
 476                        r.in.level, r.in.share_name);
 477
 478                 status = dcerpc_srvsvc_NetShareGetInfo(p, mem_ctx, &r);
 479                 if (!NT_STATUS_IS_OK(status)) {
 480                         printf("NetShareGetInfo level %u on share '%s' failed - %s\n",
 481                                 r.in.level, r.in.share_name, nt_errstr(status));
 482                         ret = False;
 483                         continue;
 484                 }
 485                 if (!W_ERROR_EQUAL(r.out.result, expected)) {
 486                         printf("NetShareGetInfo level %u on share '%s' failed - %s (expected %s)\n",
 487                                 r.in.level, r.in.share_name, win_errstr(r.out.result),
 488                                 win_errstr(expected));
 489                         ret = False;
 490                         continue;
 491                 }
 492
 493                 if (r.in.level != 2) continue;
 494                 if (!r.out.info.info2 || !r.out.info.info2->path) continue;
 495                 if (!test_NetShareCheck(p, mem_ctx, r.out.info.info2->path)) {
 496                         ret = False;
 497                 }
 498         }
 499
 500         return ret;
 501 }
 502
 503 /**************************/
 504 /* srvsvc_NetShare        */
 505 /**************************/
 506 static BOOL test_NetShareEnumAll(struct dcerpc_pipe *p,
 507                                  TALLOC_CTX *mem_ctx, BOOL admin)
 508 {
 509         NTSTATUS status;
 510         struct srvsvc_NetShareEnumAll r;
 511         struct srvsvc_NetShareCtr0 c0;
 512         struct {
 513                 uint32_t level;
 514                 WERROR anon_status;
 515                 WERROR admin_status;
 516         } levels[] = {
 517                  { 0,   WERR_OK,                WERR_OK },
 518                  { 1,   WERR_OK,                WERR_OK },
 519                  { 2,   WERR_ACCESS_DENIED,     WERR_OK },
 520                  { 501, WERR_ACCESS_DENIED,     WERR_OK },
 521                  { 502, WERR_ACCESS_DENIED,     WERR_OK },
 522         };
 523         int i;
 524         BOOL ret = True;
 525         uint32_t resume_handle;
 526
 527         ZERO_STRUCT(c0);
 528
 529         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
 530         r.in.ctr.ctr0 = &c0;
 531         r.in.max_buffer = (uint32_t)-1;
 532         r.in.resume_handle = &resume_handle;
 533         r.out.resume_handle = &resume_handle;
 534
 535         for (i=0;i<ARRAY_SIZE(levels);i++) {
 536                 int j;
 537                 WERROR expected;
 538
 539                 r.in.level = levels[i].level;
 540                 expected = levels[i].anon_status;
 541                 if (admin) expected = levels[i].admin_status;
 542
 543                 ZERO_STRUCT(r.out);
 544                 resume_handle = 0;
 545
 546                 printf("testing NetShareEnumAll level %u\n", r.in.level);
 547                 status = dcerpc_srvsvc_NetShareEnumAll(p, mem_ctx, &r);
 548                 if (!NT_STATUS_IS_OK(status)) {
 549                         printf("NetShareEnumAll level %u failed - %s\n", r.in.level, nt_errstr(status));
 550                         ret = False;
 551                         continue;
 552                 }
 553                 if (!W_ERROR_EQUAL(r.out.result, expected)) {
 554                         printf("NetShareEnumAll level %u failed - %s (expected %s)\n",
 555                                 r.in.level, win_errstr(r.out.result),
 556                                 win_errstr(expected));
 557                         continue;
 558                 }
 559
 560                 /* call srvsvc_NetShareGetInfo for each returned share */
 561                 if (r.in.level == 2 && r.out.ctr.ctr2) {
 562                         for (j=0;j<r.out.ctr.ctr2->count;j++) {
 563                                 const char *name;
 564                                 name = r.out.ctr.ctr2->array[j].name;
 565                                 if (!test_NetShareGetInfo(p, mem_ctx, name, admin)) {
 566                                         ret = False;
 567                                 }
 568                         }
 569                 }
 570         }
 571
 572         return ret;
 573 }
 574
 575 static BOOL test_NetShareEnum(struct dcerpc_pipe *p,
 576                               TALLOC_CTX *mem_ctx, BOOL admin)
 577 {
 578         NTSTATUS status;
 579         struct srvsvc_NetShareEnum r;
 580         struct srvsvc_NetShareCtr0 c0;
 581         struct {
 582                 uint32_t level;
 583                 WERROR anon_status;
 584                 WERROR admin_status;
 585         } levels[] = {
 586                  { 0,   WERR_OK,                WERR_OK },
 587                  { 1,   WERR_OK,                WERR_OK },
 588                  { 2,   WERR_ACCESS_DENIED,     WERR_OK },
 589                  { 501, WERR_UNKNOWN_LEVEL,     WERR_UNKNOWN_LEVEL },
 590                  { 502, WERR_ACCESS_DENIED,     WERR_OK },
 591         };
 592         int i;
 593         BOOL ret = True;
 594
 595         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
 596         r.in.ctr.ctr0 = &c0;
 597         r.in.ctr.ctr0->count = 0;
 598         r.in.ctr.ctr0->array = NULL;
 599         r.in.max_buffer = (uint32_t)-1;
 600         r.in.resume_handle = NULL;
 601
 602         for (i=0;i<ARRAY_SIZE(levels);i++) {
 603                 WERROR expected;
 604
 605                 r.in.level = levels[i].level;
 606                 expected = levels[i].anon_status;
 607                 if (admin) expected = levels[i].admin_status;
 608
 609                 ZERO_STRUCT(r.out);
 610
 611                 printf("testing NetShareEnum level %u\n", r.in.level);
 612                 status = dcerpc_srvsvc_NetShareEnum(p, mem_ctx, &r);
 613                 if (!NT_STATUS_IS_OK(status)) {
 614                         printf("NetShareEnum level %u failed - %s\n", r.in.level, nt_errstr(status));
 615                         ret = False;
 616                         continue;
 617                 }
 618                 if (!W_ERROR_EQUAL(r.out.result, expected)) {
 619                         printf("NetShareEnum level %u failed - %s (expected %s)\n",
 620                                 r.in.level, win_errstr(r.out.result),
 621                                 win_errstr(expected));
 622                         continue;
 623                 }
 624         }
 625
 626         return ret;
 627 }
 628
 629 /**************************/
 630 /* srvsvc_NetSrv          */
 631 /**************************/
 632 static BOOL test_NetSrvGetInfo(struct dcerpc_pipe *p,
 633                                  TALLOC_CTX *mem_ctx)
 634 {
 635         NTSTATUS status;
 636         struct srvsvc_NetSrvGetInfo r;
 637         struct srvsvc_NetSrvInfo503 i503;
 638         uint32_t levels[] = {100, 101, 102, 502, 503};
 639         int i;
 640         BOOL ret = True;
 641         uint32_t resume_handle;
 642
 643         ZERO_STRUCT(i503);
 644
 645         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
 646
 647         for (i=0;i<ARRAY_SIZE(levels);i++) {
 648                 ZERO_STRUCT(r.out);
 649                 resume_handle = 0;
 650                 r.in.level = levels[i];
 651                 printf("testing NetSrvGetInfo level %u\n", r.in.level);
 652                 status = dcerpc_srvsvc_NetSrvGetInfo(p, mem_ctx, &r);
 653                 if (!NT_STATUS_IS_OK(status)) {
 654                         printf("NetSrvGetInfo level %u failed - %s\n", r.in.level, nt_errstr(status));
 655                         ret = False;
 656                         continue;
 657                 }
 658                 if (!W_ERROR_IS_OK(r.out.result)) {
 659                         printf("NetSrvGetInfo level %u failed - %s\n", r.in.level, win_errstr(r.out.result));
 660                         continue;
 661                 }
 662         }
 663
 664         return ret;
 665 }
 666
 667 /**************************/
 668 /* srvsvc_NetDisk         */
 669 /**************************/
 670 static BOOL test_NetDiskEnum(struct dcerpc_pipe *p,
 671                            TALLOC_CTX *mem_ctx)
 672 {
 673         NTSTATUS status;
 674         struct srvsvc_NetDiskEnum r;
 675         uint32_t levels[] = {0};
 676         int i;
 677         BOOL ret = True;
 678         uint32_t resume_handle=0;
 679
 680         ZERO_STRUCT(r.in);
 681         r.in.server_unc = NULL;
 682         r.in.resume_handle = &resume_handle;
 683
 684         for (i=0;i<ARRAY_SIZE(levels);i++) {
 685                 ZERO_STRUCT(r.out);
 686                 r.in.level = levels[i];
 687                 printf("testing NetDiskEnum level %u\n", r.in.level);
 688                 status = dcerpc_srvsvc_NetDiskEnum(p, mem_ctx, &r);
 689                 if (!NT_STATUS_IS_OK(status)) {
 690                         NDR_PRINT_OUT_DEBUG(srvsvc_NetDiskEnum, &r);
 691                         printf("NetDiskEnum level %u failed - %s\n", r.in.level, nt_errstr(status));
 692                         ret = False;
 693                         continue;
 694                 }
 695                 if (!W_ERROR_IS_OK(r.out.result)) {
 696                         printf("NetDiskEnum level %u failed - %s\n", r.in.level, win_errstr(r.out.result));
 697                         continue;
 698                 }
 699         }
 700
 701         return ret;
 702 }
 703
 704 /**************************/
 705 /* srvsvc_NetTransport    */
 706 /**************************/
 707 static BOOL test_NetTransportEnum(struct dcerpc_pipe *p,
 708                            TALLOC_CTX *mem_ctx)
 709 {
 710         NTSTATUS status;
 711         struct srvsvc_NetTransportEnum r;
 712         struct srvsvc_NetTransportCtr0 c0;
 713         uint32_t levels[] = {0, 1};
 714         int i;
 715         BOOL ret = True;
 716
 717         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
 718         r.in.transports.ctr0 = &c0;
 719         r.in.transports.ctr0->count = 0;
 720         r.in.transports.ctr0->array = NULL;
 721         r.in.max_buffer = (uint32_t)-1;
 722         r.in.resume_handle = NULL;
 723
 724         for (i=0;i<ARRAY_SIZE(levels);i++) {
 725                 ZERO_STRUCT(r.out);
 726                 r.in.level = levels[i];
 727                 printf("testing NetTransportEnum level %u\n", r.in.level);
 728                 status = dcerpc_srvsvc_NetTransportEnum(p, mem_ctx, &r);
 729                 if (!NT_STATUS_IS_OK(status)) {
 730                         printf("NetTransportEnum level %u failed - %s\n", r.in.level, nt_errstr(status));
 731                         ret = False;
 732                         continue;
 733                 }
 734                 if (!W_ERROR_IS_OK(r.out.result)) {
 735                         printf("NetTransportEnum level %u failed - %s\n", r.in.level, win_errstr(r.out.result));
 736                         continue;
 737                 }
 738         }
 739
 740         return ret;
 741 }
 742
 743 /**************************/
 744 /* srvsvc_NetRemoteTOD    */
 745 /**************************/
 746 static BOOL test_NetRemoteTOD(struct dcerpc_pipe *p,
 747                            TALLOC_CTX *mem_ctx)
 748 {
 749         NTSTATUS status;
 750         struct srvsvc_NetRemoteTOD r;
 751         BOOL ret = True;
 752
 753         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
 754
 755         ZERO_STRUCT(r.out);
 756         printf("testing NetRemoteTOD\n");
 757         status = dcerpc_srvsvc_NetRemoteTOD(p, mem_ctx, &r);
 758         if (!NT_STATUS_IS_OK(status)) {
 759                 printf("NetRemoteTOD failed - %s\n", nt_errstr(status));
 760                 ret = False;
 761         }
 762         if (!W_ERROR_IS_OK(r.out.result)) {
 763                 printf("NetRemoteTOD failed - %s\n", win_errstr(r.out.result));
 764         }
 765
 766         return ret;
 767 }
 768
 769 BOOL torture_rpc_srvsvc(struct torture_context *torture)
 770 {
 771         NTSTATUS status;
 772         struct dcerpc_pipe *p;
 773         TALLOC_CTX *mem_ctx;
 774         BOOL ret = True;
 775         const char *binding = lp_parm_string(-1, "torture", "binding");
 776         struct cli_credentials *anon_credentials;
 777
 778         mem_ctx = talloc_init("torture_rpc_srvsvc");
 779
 780         status = torture_rpc_connection(mem_ctx, &p, &dcerpc_table_srvsvc);
 781         if (!NT_STATUS_IS_OK(status)) {
 782                 talloc_free(mem_ctx);
 783                 return False;
 784         }
 785
 786         ret &= test_NetCharDevEnum(p, mem_ctx);
 787         ret &= test_NetCharDevQEnum(p, mem_ctx);
 788         ret &= test_NetConnEnum(p, mem_ctx);
 789         ret &= test_NetFileEnum(p, mem_ctx);
 790         ret &= test_NetSessEnum(p, mem_ctx);
 791         ret &= test_NetShareEnumAll(p, mem_ctx, True);
 792         ret &= test_NetSrvGetInfo(p, mem_ctx);
 793         ret &= test_NetDiskEnum(p, mem_ctx);
 794         ret &= test_NetTransportEnum(p, mem_ctx);
 795         ret &= test_NetRemoteTOD(p, mem_ctx);
 796         ret &= test_NetShareEnum(p, mem_ctx, True);
 797         ret &= test_NetShareGetInfo(p, mem_ctx, "ADMIN$", True);
 798
 799         status = torture_rpc_connection(mem_ctx, &p, &dcerpc_table_srvsvc);
 800
 801         if (!binding) {
 802                 printf("You must specify a ncacn binding string\n");
 803                 return False;
 804         }
 805
 806         anon_credentials = cli_credentials_init(mem_ctx);
 807         cli_credentials_set_conf(anon_credentials);
 808         cli_credentials_set_anonymous(anon_credentials);
 809
 810         status = dcerpc_pipe_connect(mem_ctx,
 811                                      &p, binding, &dcerpc_table_srvsvc,
 812                                      anon_credentials, NULL);
 813         if (!NT_STATUS_IS_OK(status)) {
 814                 talloc_free(mem_ctx);
 815                 return False;
 816         }
 817
 818         ret &= test_NetShareEnumAll(p, mem_ctx, False);
 819         ret &= test_NetShareEnum(p, mem_ctx, False);
 820         ret &= test_NetShareGetInfo(p, mem_ctx, "ADMIN$", False);
 821
 822         talloc_free(mem_ctx);
 823
 824         return ret;
 825 }