source4/torture/rpc/spoolss.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    test suite for spoolss rpc operations
   4
   5    Copyright (C) Tim Potter 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 "librpc/gen_ndr/ndr_spoolss.h"
  24
  25 static BOOL test_GetPrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
  26                      struct policy_handle *handle)
  27 {
  28         NTSTATUS status;
  29         struct spoolss_GetPrinter r;
  30         uint16_t levels[] = {1, 2, 3, 4, 5, 6, 7};
  31         int i;
  32         BOOL ret = True;
  33
  34         for (i=0;i<ARRAY_SIZE(levels);i++) {
  35                 uint32_t buf_size = 0;
  36                 r.in.handle = handle;
  37                 r.in.level = levels[i];
  38                 r.in.buffer = NULL;
  39                 r.in.buf_size = &buf_size;
  40                 r.out.buf_size = &buf_size;
  41
  42                 printf("Testing GetPrinter level %u\n", r.in.level);
  43
  44                 status = dcerpc_spoolss_GetPrinter(p, mem_ctx, &r);
  45                 if (!NT_STATUS_IS_OK(status)) {
  46                         printf("GetPrinter failed - %s\n", nt_errstr(status));
  47                         ret = False;
  48                         continue;
  49                 }
  50
  51                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
  52                         DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, buf_size);
  53                         data_blob_clear(&blob);
  54                         r.in.buffer = &blob;
  55                         status = dcerpc_spoolss_GetPrinter(p, mem_ctx, &r);
  56                 }
  57
  58                 if (!NT_STATUS_IS_OK(status) ||
  59                     !W_ERROR_IS_OK(r.out.result)) {
  60                         printf("GetPrinter failed - %s/%s\n",
  61                                nt_errstr(status), win_errstr(r.out.result));
  62                         ret = False;
  63                         continue;
  64                 }
  65         }
  66
  67         return ret;
  68 }
  69
  70
  71 static BOOL test_ClosePrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
  72                        struct policy_handle *handle)
  73 {
  74         NTSTATUS status;
  75         struct spoolss_ClosePrinter r;
  76
  77         r.in.handle = handle;
  78         r.out.handle = handle;
  79
  80         printf("Testing ClosePrinter\n");
  81
  82         status = dcerpc_spoolss_ClosePrinter(p, mem_ctx, &r);
  83         if (!NT_STATUS_IS_OK(status)) {
  84                 printf("ClosePrinter failed - %s\n", nt_errstr(status));
  85                 return False;
  86         }
  87
  88         return True;
  89 }
  90
  91 static BOOL test_GetForm(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
  92                          struct policy_handle *handle,
  93                          const char *formname)
  94 {
  95         NTSTATUS status;
  96         struct spoolss_GetForm r;
  97         uint32_t buf_size;
  98
  99         r.in.handle = handle;
 100         r.in.formname = formname;
 101         r.in.level = 1;
 102         r.in.buffer = NULL;
 103         buf_size = 0;
 104         r.in.buf_size = r.out.buf_size = &buf_size;
 105
 106         printf("Testing GetForm\n");
 107
 108         status = dcerpc_spoolss_GetForm(p, mem_ctx, &r);
 109
 110         if (!NT_STATUS_IS_OK(status)) {
 111                 printf("GetForm failed - %s\n", nt_errstr(status));
 112                 return False;
 113         }
 114
 115         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 116                 DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, buf_size);
 117
 118                 data_blob_clear(&blob);
 119                 r.in.buffer = &blob;
 120
 121                 status = dcerpc_spoolss_GetForm(p, mem_ctx, &r);
 122
 123                 if (!r.out.info) {
 124                         printf("No form info returned");
 125                         return False;
 126                 }
 127         }
 128
 129         return True;
 130 }
 131
 132 static BOOL test_EnumForms(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 133                     struct policy_handle *handle)
 134 {
 135         NTSTATUS status;
 136         struct spoolss_EnumForms r;
 137         uint32_t buf_size;
 138
 139         r.in.handle = handle;
 140         r.in.level = 1;
 141         r.in.buffer = NULL;
 142         buf_size = 0;
 143         r.in.buf_size = &buf_size;
 144         r.out.buf_size = &buf_size;
 145
 146         printf("Testing EnumForms\n");
 147
 148         status = dcerpc_spoolss_EnumForms(p, mem_ctx, &r);
 149
 150         if (!NT_STATUS_IS_OK(status)) {
 151                 printf("EnumForms failed - %s\n", nt_errstr(status));
 152                 return False;
 153         }
 154
 155         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 156                 DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, buf_size);
 157                 union spoolss_FormInfo *info;
 158                 int j;
 159
 160                 data_blob_clear(&blob);
 161                 r.in.buffer = &blob;
 162
 163                 status = dcerpc_spoolss_EnumForms(p, mem_ctx, &r);
 164
 165                 if (!r.out.info) {
 166                         printf("No forms returned");
 167                         return False;
 168                 }
 169
 170                 info = *r.out.info;
 171
 172                 for (j = 0; j < r.out.count; j++) {
 173                         test_GetForm(p, mem_ctx, handle, info[j].info1.formname);
 174                 }
 175         }
 176
 177         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
 178                 printf("EnumForms failed - %s/%s\n",
 179                        nt_errstr(status), win_errstr(r.out.result));
 180                 return False;
 181         }
 182
 183         return True;
 184 }
 185
 186 static BOOL test_DeleteForm(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 187                             struct policy_handle *handle,
 188                             const char *formname)
 189 {
 190         NTSTATUS status;
 191         struct spoolss_DeleteForm r;
 192
 193         r.in.handle = handle;
 194         r.in.formname = formname;
 195
 196         status = dcerpc_spoolss_DeleteForm(p, mem_ctx, &r);
 197
 198         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
 199                 printf("DeleteForm failed - %s/%s\n",
 200                        nt_errstr(status), win_errstr(r.out.result));
 201                 return False;
 202         }
 203
 204         return True;
 205 }
 206
 207 static BOOL test_AddForm(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 208                   struct policy_handle *handle)
 209 {
 210         struct spoolss_AddForm r;
 211         struct spoolss_AddFormInfo1 form;
 212         NTSTATUS status;
 213         const char *formname = "testform3";
 214         BOOL ret = True;
 215
 216         r.in.handle = handle;
 217         r.in.level = 1;
 218         form.flags = 2;         /* User form */
 219         form.formname = formname;
 220         form.width = 1;
 221         form.length = 2;
 222         form.left = 3;
 223         form.top = 4;
 224         form.right = 5;
 225         form.bottom = 6;
 226         r.in.info.info1 = &form;
 227
 228         status = dcerpc_spoolss_AddForm(p, mem_ctx, &r);
 229
 230         if (!NT_STATUS_IS_OK(status)) {
 231                 printf("AddForm failed - %s\n", nt_errstr(status));
 232                 return False;
 233         }
 234
 235         if (!W_ERROR_IS_OK(r.out.result)) {
 236                 printf("AddForm failed - %s\n", nt_errstr(status));
 237                 goto done;
 238         }
 239
 240         {
 241                 struct spoolss_SetForm sf;
 242
 243                 sf.in.handle = handle;
 244                 sf.in.formname = formname;
 245                 sf.in.level = 1;
 246                 sf.in.info.info1 = &form;
 247                 form.width = 1234;
 248
 249                 status = dcerpc_spoolss_SetForm(p, mem_ctx, &sf);
 250
 251                 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
 252                         printf("SetForm failed - %s/%s\n",
 253                                nt_errstr(status), win_errstr(r.out.result));
 254                         ret = False;
 255                         /* Fall through to delete */
 256                 }
 257         }
 258
 259  done:
 260         if (!test_DeleteForm(p, mem_ctx, handle, formname)) {
 261                 printf("DeleteForm failed\n");
 262                 ret = False;
 263         }
 264
 265         return ret;
 266 }
 267
 268 static BOOL test_EnumPorts(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 269 {
 270         NTSTATUS status;
 271         struct spoolss_EnumPorts r;
 272         uint32_t buf_size;
 273
 274         r.in.servername = talloc_asprintf(mem_ctx, "\\\\%s",
 275                                           dcerpc_server_name(p));
 276         r.in.level = 2;
 277         r.in.buffer = NULL;
 278         buf_size = 0;
 279         r.in.buf_size = &buf_size;
 280         r.out.buf_size = &buf_size;
 281
 282         printf("Testing EnumPorts\n");
 283
 284         status = dcerpc_spoolss_EnumPorts(p, mem_ctx, &r);
 285
 286         if (!NT_STATUS_IS_OK(status)) {
 287                 printf("EnumPorts failed -- %s\n", nt_errstr(status));
 288                 return False;
 289         }
 290
 291         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 292                 DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, buf_size);
 293
 294                 data_blob_clear(&blob);
 295                 r.in.buffer = &blob;
 296
 297                 status = dcerpc_spoolss_EnumPorts(p, mem_ctx, &r);
 298
 299                 if (!NT_STATUS_IS_OK(status)) {
 300                         printf("EnumPorts failed -- %s\n", nt_errstr(status));
 301                         return False;
 302                 }
 303
 304                 if (!r.out.info) {
 305                         printf("No ports returned");
 306                         return False;
 307                 }
 308         }
 309
 310         return True;
 311 }
 312
 313 static BOOL test_GetJob(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 314                   struct policy_handle *handle, uint32_t job_id)
 315 {
 316         NTSTATUS status;
 317         struct spoolss_GetJob r;
 318         uint32_t buf_size;
 319
 320         r.in.handle = handle;
 321         r.in.job_id = job_id;
 322         r.in.level = 1;
 323         r.in.buffer = NULL;
 324         buf_size = 0;
 325         r.in.buf_size = r.out.buf_size = &buf_size;
 326
 327         printf("Testing GetJob\n");
 328
 329         status = dcerpc_spoolss_GetJob(p, mem_ctx, &r);
 330
 331         if (!NT_STATUS_IS_OK(status)) {
 332                 printf("GetJob failed - %s\n", nt_errstr(status));
 333                 return False;
 334         }
 335
 336         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 337                 DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, buf_size);
 338
 339                 data_blob_clear(&blob);
 340                 r.in.buffer = &blob;
 341
 342                 status = dcerpc_spoolss_GetJob(p, mem_ctx, &r);
 343
 344                 if (!r.out.info) {
 345                         printf("No job info returned");
 346                         return False;
 347                 }
 348         }
 349
 350         return True;
 351 }
 352
 353 static BOOL test_SetJob(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 354                  struct policy_handle *handle, uint32_t job_id, uint32_t command)
 355 {
 356         NTSTATUS status;
 357         struct spoolss_SetJob r;
 358
 359         r.in.handle = handle;
 360         r.in.job_id = job_id;
 361         r.in.level = 0;
 362         r.in.command = command;
 363
 364         printf("Testing SetJob\n");
 365
 366         status = dcerpc_spoolss_SetJob(p, mem_ctx, &r);
 367
 368         if (!NT_STATUS_IS_OK(status)) {
 369                 printf("SetJob failed - %s\n", nt_errstr(status));
 370                 return False;
 371         }
 372
 373         return True;
 374 }
 375
 376 static BOOL test_EnumJobs(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 377                    struct policy_handle *handle)
 378 {
 379         NTSTATUS status;
 380         struct spoolss_EnumJobs r;
 381         uint32_t buf_size;
 382
 383         r.in.handle = handle;
 384         r.in.firstjob = 0;
 385         r.in.numjobs = 0xffffffff;
 386         r.in.level = 1;
 387         r.in.buffer = NULL;
 388         buf_size = 0;
 389         r.in.buf_size = &buf_size;
 390         r.out.buf_size = &buf_size;
 391
 392         printf("Testing EnumJobs\n");
 393
 394         status = dcerpc_spoolss_EnumJobs(p, mem_ctx, &r);
 395
 396         if (!NT_STATUS_IS_OK(status)) {
 397                 printf("EnumJobs failed - %s\n", nt_errstr(status));
 398                 return False;
 399         }
 400
 401         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 402                 DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, buf_size);
 403                 union spoolss_JobInfo *info;
 404                 int j;
 405
 406                 data_blob_clear(&blob);
 407                 r.in.buffer = &blob;
 408
 409                 status = dcerpc_spoolss_EnumJobs(p, mem_ctx, &r);
 410
 411                 if (!r.out.info) {
 412                         printf("No jobs returned");
 413                         return True;
 414                 }
 415
 416                 info = *r.out.info;
 417
 418                 for (j = 0; j < r.out.count; j++) {
 419                         test_GetJob(p, mem_ctx, handle, info[j].info1.job_id);
 420                         test_SetJob(p, mem_ctx, handle, info[j].info1.job_id, 1);
 421                 }
 422
 423         } else if (!W_ERROR_IS_OK(r.out.result)) {
 424                 printf("EnumJobs failed - %s\n", win_errstr(r.out.result));
 425                 return False;
 426         }
 427
 428         return True;
 429 }
 430
 431 static BOOL test_GetPrinterData(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 432                                 struct policy_handle *handle,
 433                                 const char *value_name)
 434 {
 435         NTSTATUS status;
 436         struct spoolss_GetPrinterData r;
 437         uint32_t buf_size;
 438
 439         r.in.handle = handle;
 440         r.in.value_name = value_name;
 441         buf_size = 0;
 442         r.in.buf_size = r.out.buf_size = &buf_size;
 443
 444         printf("Testing GetPrinterData\n");
 445
 446         status = dcerpc_spoolss_GetPrinterData(p, mem_ctx, &r);
 447
 448         if (!NT_STATUS_IS_OK(status)) {
 449                 printf("GetPrinterData failed - %s\n", nt_errstr(status));
 450                 return False;
 451         }
 452
 453         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
 454
 455                 status = dcerpc_spoolss_GetPrinterData(p, mem_ctx, &r);
 456
 457                 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
 458                         printf("GetPrinterData failed - %s/%s\n",
 459                                nt_errstr(status), win_errstr(r.out.result));
 460                         return False;
 461                 }
 462         }
 463
 464         return True;
 465 }
 466
 467 static BOOL test_GetPrinterDataEx(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 468                                   struct policy_handle *handle,
 469                                   const char *key_name,
 470                                   const char *value_name)
 471 {
 472         NTSTATUS status;
 473         struct spoolss_GetPrinterDataEx r;
 474         uint32_t buf_size;
 475
 476         r.in.handle = handle;
 477         r.in.key_name = key_name;
 478         r.in.value_name = value_name;
 479         buf_size = 0;
 480         r.in.buf_size = r.out.buf_size = &buf_size;
 481
 482         printf("Testing GetPrinterDataEx\n");
 483
 484         status = dcerpc_spoolss_GetPrinterDataEx(p, mem_ctx, &r);
 485
 486         if (!NT_STATUS_IS_OK(status)) {
 487                 printf("GetPrinterDataEx failed - %s\n", nt_errstr(status));
 488                 return False;
 489         }
 490
 491         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
 492
 493                 status = dcerpc_spoolss_GetPrinterDataEx(p, mem_ctx, &r);
 494
 495                 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
 496                         printf("GetPrinterDataEx failed - %s/%s\n",
 497                                nt_errstr(status), win_errstr(r.out.result));
 498                         return False;
 499                 }
 500         }
 501
 502         return True;
 503 }
 504
 505 static BOOL test_EnumPrinterData(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 506                           struct policy_handle *handle)
 507 {
 508         NTSTATUS status;
 509         struct spoolss_EnumPrinterData r;
 510
 511         r.in.handle = handle;
 512         r.in.enum_index = 0;
 513
 514         do {
 515                 uint32_t data_size;
 516
 517                 r.in.value_offered = 0;
 518                 data_size = 0;
 519                 r.in.data_size = &data_size;
 520                 r.out.data_size = &data_size;
 521
 522                 printf("Testing EnumPrinterData\n");
 523
 524                 status = dcerpc_spoolss_EnumPrinterData(p, mem_ctx, &r);
 525
 526                 if (!NT_STATUS_IS_OK(status)) {
 527                         printf("EnumPrinterData failed - %s\n", nt_errstr(status));
 528                         return False;
 529                 }
 530
 531                 r.in.value_offered = r.out.value_needed;
 532
 533                 status = dcerpc_spoolss_EnumPrinterData(p, mem_ctx, &r);
 534
 535                 if (!NT_STATUS_IS_OK(status)) {
 536                         printf("EnumPrinterData failed - %s\n", nt_errstr(status));
 537                         return False;
 538                 }
 539
 540                 test_GetPrinterData(p, mem_ctx, handle, r.out.value_name);
 541
 542                 test_GetPrinterDataEx(
 543                         p, mem_ctx, handle, "PrinterDriverData",
 544                         r.out.value_name);
 545
 546                 r.in.enum_index++;
 547
 548         } while (W_ERROR_IS_OK(r.out.result));
 549
 550         return True;
 551 }
 552
 553 static BOOL test_DeletePrinterData(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 554                                    struct policy_handle *handle,
 555                                    const char *value_name)
 556 {
 557         NTSTATUS status;
 558         struct spoolss_DeletePrinterData r;
 559
 560         r.in.handle = handle;
 561         r.in.value_name = value_name;
 562
 563         printf("Testing DeletePrinterData\n");
 564
 565         status = dcerpc_spoolss_DeletePrinterData(p, mem_ctx, &r);
 566
 567         if (!NT_STATUS_IS_OK(status)) {
 568                 printf("DeletePrinterData failed - %s\n", nt_errstr(status));
 569                 return False;
 570         }
 571
 572         return True;
 573 }
 574
 575 static BOOL test_SetPrinterData(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 576                          struct policy_handle *handle)
 577 {
 578         NTSTATUS status;
 579         struct spoolss_SetPrinterData r;
 580         const char *value_name = "spottyfoot";
 581
 582         r.in.handle = handle;
 583         r.in.value_name = value_name;
 584         r.in.type = 0;
 585         r.in.buffer = data_blob_talloc(mem_ctx, "dog", 4);
 586         r.in.real_len = 4;
 587
 588         printf("Testing SetPrinterData\n");
 589
 590         status = dcerpc_spoolss_SetPrinterData(p, mem_ctx, &r);
 591
 592         if (!NT_STATUS_IS_OK(status)) {
 593                 printf("SetPrinterData failed - %s\n", nt_errstr(status));
 594                 return False;
 595         }
 596
 597         if (!test_DeletePrinterData(p, mem_ctx, handle, value_name)) {
 598                 return False;
 599         }
 600
 601         return True;
 602 }
 603
 604 static BOOL test_SecondaryClosePrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 605                                        struct policy_handle *handle)
 606 {
 607         NTSTATUS status;
 608         struct dcerpc_pipe *p2;
 609         BOOL ret = True;
 610
 611         /* only makes sense on SMB */
 612         if (p->conn->transport.transport != NCACN_NP) {
 613                 return True;
 614         }
 615
 616         printf("testing close on secondary pipe\n");
 617
 618         status = dcerpc_secondary_connection(p, &p2,
 619                                              DCERPC_SPOOLSS_NAME,
 620                                              DCERPC_SPOOLSS_UUID,
 621                                              DCERPC_SPOOLSS_VERSION);
 622         if (!NT_STATUS_IS_OK(status)) {
 623                 printf("Failed to create secondary connection\n");
 624                 return False;
 625         }
 626
 627         if (test_ClosePrinter(p2, mem_ctx, handle)) {
 628                 printf("ERROR: Allowed close on secondary connection!\n");
 629                 ret = False;
 630         }
 631
 632         if (p2->last_fault_code != DCERPC_FAULT_CONTEXT_MISMATCH) {
 633                 printf("Unexpected fault code 0x%x - expected 0x%x\n",
 634                        p2->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH);
 635                 ret = False;
 636         }
 637
 638         dcerpc_pipe_close(p2);
 639
 640         return ret;
 641 }
 642
 643 static BOOL test_OpenPrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 644                              const char *name)
 645 {
 646         NTSTATUS status;
 647         struct spoolss_OpenPrinter r;
 648         struct policy_handle handle;
 649         DATA_BLOB blob;
 650         BOOL ret = True;
 651
 652         blob = data_blob(NULL, 0);
 653
 654         r.in.server = talloc_asprintf(mem_ctx, "\\\\%s\\%s", dcerpc_server_name(p), name);
 655         r.in.printer = NULL;
 656         r.in.buffer = &blob;
 657         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
 658         r.out.handle = &handle;
 659
 660         printf("\nTesting OpenPrinter(%s)\n", r.in.server);
 661
 662         status = dcerpc_spoolss_OpenPrinter(p, mem_ctx, &r);
 663         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
 664                 printf("OpenPrinter failed - %s/%s\n",
 665                        nt_errstr(status), win_errstr(r.out.result));
 666                 /* don't consider failing this an error until we understand it */
 667                 return True;
 668         }
 669
 670
 671         if (!test_GetPrinter(p, mem_ctx, &handle)) {
 672                 ret = False;
 673         }
 674
 675         if (!test_SecondaryClosePrinter(p, mem_ctx, &handle)) {
 676                 ret = False;
 677         }
 678
 679         if (!test_ClosePrinter(p, mem_ctx, &handle)) {
 680                 ret = False;
 681         }
 682
 683         return ret;
 684 }
 685
 686 static BOOL call_OpenPrinterEx(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 687                                const char *name, struct policy_handle *handle)
 688 {
 689         struct spoolss_OpenPrinterEx r;
 690         struct spoolss_UserLevel1 userlevel1;
 691         NTSTATUS status;
 692
 693         if (name && name[0])
 694                 r.in.printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
 695                                                    dcerpc_server_name(p), name);
 696         else
 697                 r.in.printername = talloc_asprintf(mem_ctx, "\\\\%s",
 698                                                    dcerpc_server_name(p));
 699
 700         r.in.datatype = NULL;
 701         r.in.devmode_ctr.size = 0;
 702         r.in.devmode_ctr.devmode = NULL;
 703         r.in.access_mask = 0x02000000;
 704         r.in.level = 1;
 705         r.out.handle = handle;
 706
 707         userlevel1.size = 1234;
 708         userlevel1.client = "hello";
 709         userlevel1.user = "spottyfoot!";
 710         userlevel1.build = 1;
 711         userlevel1.major = 2;
 712         userlevel1.minor = 3;
 713         userlevel1.processor = 4;
 714         r.in.userlevel.level1 = &userlevel1;
 715
 716         printf("Testing OpenPrinterEx(%s)\n", r.in.printername);
 717
 718         status = dcerpc_spoolss_OpenPrinterEx(p, mem_ctx, &r);
 719
 720         if (!NT_STATUS_IS_OK(status)) {
 721                 printf("OpenPrinterEx failed - %s\n", nt_errstr(status));
 722                 return False;
 723         }
 724
 725         if (!W_ERROR_IS_OK(r.out.result)) {
 726                 printf("OpenPrinterEx failed - %s\n", win_errstr(r.out.result));
 727                 return False;
 728         }
 729
 730         return True;
 731 }
 732
 733 static BOOL test_OpenPrinterEx(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 734                                const char *name)
 735 {
 736         struct policy_handle handle;
 737         BOOL ret = True;
 738
 739         if (!call_OpenPrinterEx(p, mem_ctx, name, &handle)) {
 740                 return False;
 741         }
 742
 743         if (!test_GetPrinter(p, mem_ctx, &handle)) {
 744                 ret = False;
 745         }
 746
 747         if (!test_EnumForms(p, mem_ctx, &handle)) {
 748                 ret = False;
 749         }
 750
 751         if (!test_AddForm(p, mem_ctx, &handle)) {
 752                 ret = False;
 753         }
 754
 755         if (!test_EnumPrinterData(p, mem_ctx, &handle)) {
 756                 ret = False;
 757         }
 758
 759         if (!test_EnumJobs(p, mem_ctx, &handle)) {
 760                 ret = False;
 761         }
 762
 763         if (!test_SetPrinterData(p, mem_ctx, &handle)) {
 764                 ret = False;
 765         }
 766
 767         if (!test_SecondaryClosePrinter(p, mem_ctx, &handle)) {
 768                 ret = False;
 769         }
 770
 771         if (!test_ClosePrinter(p, mem_ctx, &handle)) {
 772                 ret = False;
 773         }
 774
 775         return ret;
 776 }
 777
 778 static BOOL test_EnumPrinters(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 779 {
 780         struct spoolss_EnumPrinters r;
 781         NTSTATUS status;
 782         uint16_t levels[] = {1, 2, 4, 5};
 783         int i;
 784         BOOL ret = True;
 785
 786         for (i=0;i<ARRAY_SIZE(levels);i++) {
 787                 uint32_t buf_size = 0;
 788                 union spoolss_PrinterInfo *info;
 789                 int j;
 790
 791                 r.in.flags = 0x02;
 792                 r.in.server = "";
 793                 r.in.level = levels[i];
 794                 r.in.buffer = NULL;
 795                 r.in.buf_size = &buf_size;
 796                 r.out.buf_size = &buf_size;
 797
 798                 printf("\nTesting EnumPrinters level %u\n", r.in.level);
 799
 800                 status = dcerpc_spoolss_EnumPrinters(p, mem_ctx, &r);
 801                 if (!NT_STATUS_IS_OK(status)) {
 802                         printf("EnumPrinters failed - %s\n", nt_errstr(status));
 803                         ret = False;
 804                         continue;
 805                 }
 806
 807                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 808                         DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, buf_size);
 809                         data_blob_clear(&blob);
 810                         r.in.buffer = &blob;
 811                         status = dcerpc_spoolss_EnumPrinters(p, mem_ctx, &r);
 812                 }
 813
 814                 if (!NT_STATUS_IS_OK(status) ||
 815                     !W_ERROR_IS_OK(r.out.result)) {
 816                         printf("EnumPrinters failed - %s/%s\n",
 817                                nt_errstr(status), win_errstr(r.out.result));
 818                         continue;
 819                 }
 820
 821                 if (!r.out.info) {
 822                         printf("No printers returned");
 823                         continue;
 824                 }
 825
 826                 info = *r.out.info;
 827
 828                 for (j=0;j<r.out.count;j++) {
 829                         if (r.in.level == 1) {
 830                                 /* the names appear to be comma-separated name lists? */
 831                                 char *name = talloc_strdup(mem_ctx, info[j].info1.name);
 832                                 char *comma = strchr(name, ',');
 833                                 if (comma) *comma = 0;
 834                                 if (!test_OpenPrinter(p, mem_ctx, name)) {
 835                                         ret = False;
 836                                 }
 837                                 if (!test_OpenPrinterEx(p, mem_ctx, name)) {
 838                                         ret = False;
 839                                 }
 840                         }
 841                 }
 842         }
 843
 844         return ret;
 845 }
 846
 847 static BOOL test_GetPrinterDriver2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 848                                    struct policy_handle *handle,
 849                                    const char *driver_name)
 850 {
 851         NTSTATUS status;
 852         struct spoolss_GetPrinterDriver2 r;
 853         uint32_t buf_size;
 854
 855         r.in.handle = handle;
 856         r.in.architecture = "W32X86";
 857         r.in.level = 1;
 858         buf_size = 0;
 859         r.in.buffer = NULL;
 860         r.in.buf_size = r.out.buf_size = &buf_size;
 861         r.in.client_major_version = 0;
 862         r.in.client_minor_version = 0;
 863
 864         printf("Testing GetPrinterDriver2\n");
 865
 866         status = dcerpc_spoolss_GetPrinterDriver2(p, mem_ctx, &r);
 867
 868         if (!NT_STATUS_IS_OK(status)) {
 869                 printf("GetPrinterDriver2 failed - %s\n", nt_errstr(status));
 870                 return False;
 871         }
 872
 873         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 874                 status = dcerpc_spoolss_GetPrinterDriver2(p, mem_ctx, &r);
 875         }
 876
 877         if (!NT_STATUS_IS_OK(status) ||
 878             !W_ERROR_IS_OK(r.out.result)) {
 879                 printf("GetPrinterDriver2 failed - %s/%s\n",
 880                        nt_errstr(status), win_errstr(r.out.result));
 881                 return False;
 882         }
 883
 884         return True;
 885 }
 886
 887 static BOOL test_EnumPrinterDrivers(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 888 {
 889         struct spoolss_EnumPrinterDrivers r;
 890         NTSTATUS status;
 891         uint16_t levels[] = {1, 2, 3};
 892         int i;
 893         BOOL ret = True;
 894
 895         for (i=0;i<ARRAY_SIZE(levels);i++) {
 896                 uint32_t buf_size;
 897                 union spoolss_DriverInfo *info;
 898                 uint32_t j;
 899
 900                 r.in.server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
 901                 r.in.environment = "Windows NT x86";
 902                 r.in.level = levels[i];
 903                 r.in.buffer = NULL;
 904                 buf_size = 0;
 905                 r.in.buf_size = &buf_size;
 906                 r.out.buf_size = &buf_size;
 907
 908                 printf("\nTesting EnumPrinterDrivers level %u\n", r.in.level);
 909
 910                 status = dcerpc_spoolss_EnumPrinterDrivers(p, mem_ctx, &r);
 911
 912                 if (!NT_STATUS_IS_OK(status)) {
 913                         printf("EnumPrinterDrivers failed - %s\n",
 914                                nt_errstr(status));
 915                         ret = False;
 916                         continue;
 917                 }
 918
 919                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 920                         DATA_BLOB blob = data_blob_talloc(
 921                                 mem_ctx, NULL, buf_size);
 922
 923                         data_blob_clear(&blob);
 924                         r.in.buffer = &blob;
 925                         status = dcerpc_spoolss_EnumPrinterDrivers(p, mem_ctx, &r);
 926                 }
 927
 928                 if (!NT_STATUS_IS_OK(status) ||
 929                     !W_ERROR_IS_OK(r.out.result)) {
 930                         printf("EnumPrinterDrivers failed - %s/%s\n",
 931                                nt_errstr(status), win_errstr(r.out.result));
 932                         break;
 933                 }
 934
 935                 if (!r.out.info) {
 936                         printf("No printer drivers returned");
 937                         break;
 938                 }
 939
 940                 info = *r.out.info;
 941
 942                 if (r.in.level != 1) continue;
 943
 944                 for (j=0;j<r.out.count;j++) {
 945                         struct policy_handle handle;
 946
 947                         if (!call_OpenPrinterEx(p, mem_ctx, "",&handle)) {
 948                                 continue;
 949                         }
 950                         ret &=test_GetPrinterDriver2(p, mem_ctx, &handle, info[j].info1.driver_name);
 951                 }
 952         }
 953
 954         return ret;
 955 }
 956
 957 BOOL torture_rpc_spoolss(void)
 958 {
 959         NTSTATUS status;
 960         struct dcerpc_pipe *p;
 961         TALLOC_CTX *mem_ctx;
 962         BOOL ret = True;
 963
 964         status = torture_rpc_connection(&p,
 965                                         DCERPC_SPOOLSS_NAME,
 966                                         DCERPC_SPOOLSS_UUID,
 967                                         DCERPC_SPOOLSS_VERSION);
 968         if (!NT_STATUS_IS_OK(status)) {
 969                 return False;
 970         }
 971
 972         mem_ctx = talloc_init("torture_rpc_spoolss");
 973
 974         if (!test_EnumPorts(p, mem_ctx)) {
 975                 ret = False;
 976         }
 977
 978         if (!test_EnumPrinters(p, mem_ctx)) {
 979                 ret = False;
 980         }
 981
 982         if (!test_EnumPrinterDrivers(p, mem_ctx)) {
 983                 ret = False;
 984         }
 985 printf("blub\n");
 986         talloc_free(mem_ctx);
 987
 988         torture_rpc_close(p);
 989
 990         return ret;
 991 }