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    Copyright (C) Stefan Metzmacher 2005
   7    Copyright (C) Jelmer Vernooij 2007
   8    Copyright (C) Guenther Deschner 2009
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25 #include "torture/torture.h"
  26 #include "torture/rpc/rpc.h"
  27 #include "librpc/gen_ndr/ndr_misc.h"
  28 #include "librpc/gen_ndr/ndr_spoolss_c.h"
  29 #include "param/param.h"
  30
  31 #define TORTURE_WELLKNOWN_PRINTER       "torture_wkn_printer"
  32 #define TORTURE_PRINTER                 "torture_printer"
  33 #define TORTURE_WELLKNOWN_PRINTER_EX    "torture_wkn_printer_ex"
  34 #define TORTURE_PRINTER_EX              "torture_printer_ex"
  35
  36 struct test_spoolss_context {
  37         /* print server handle */
  38         struct policy_handle server_handle;
  39
  40         /* for EnumPorts */
  41         uint32_t port_count[3];
  42         union spoolss_PortInfo *ports[3];
  43
  44         /* for EnumPrinterDrivers */
  45         uint32_t driver_count[7];
  46         union spoolss_DriverInfo *drivers[7];
  47
  48         /* for EnumMonitors */
  49         uint32_t monitor_count[3];
  50         union spoolss_MonitorInfo *monitors[3];
  51
  52         /* for EnumPrintProcessors */
  53         uint32_t print_processor_count[2];
  54         union spoolss_PrintProcessorInfo *print_processors[2];
  55
  56         /* for EnumPrinters */
  57         uint32_t printer_count[6];
  58         union spoolss_PrinterInfo *printers[6];
  59 };
  60
  61 #define COMPARE_STRING(tctx, c,r,e) \
  62         torture_assert_str_equal(tctx, c.e, r.e, "invalid value")
  63
  64 /* not every compiler supports __typeof__() */
  65 #if (__GNUC__ >= 3)
  66 #define _CHECK_FIELD_SIZE(c,r,e,type) do {\
  67         if (sizeof(__typeof__(c.e)) != sizeof(type)) { \
  68                 torture_fail(tctx, #c "." #e "field is not " #type "\n"); \
  69         }\
  70         if (sizeof(__typeof__(r.e)) != sizeof(type)) { \
  71                 torture_fail(tctx, #r "." #e "field is not " #type "\n"); \
  72         }\
  73 } while(0)
  74 #else
  75 #define _CHECK_FIELD_SIZE(c,r,e,type) do {} while(0)
  76 #endif
  77
  78 #define COMPARE_UINT32(tctx, c, r, e) do {\
  79         _CHECK_FIELD_SIZE(c, r, e, uint32_t); \
  80         torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
  81 } while(0)
  82
  83 #define COMPARE_STRING_ARRAY(tctx, c,r,e)
  84
  85 static bool test_OpenPrinter_server(struct torture_context *tctx,
  86                                     struct dcerpc_pipe *p,
  87                                     struct policy_handle *server_handle)
  88 {
  89         NTSTATUS status;
  90         struct spoolss_OpenPrinter op;
  91
  92         op.in.printername       = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
  93         op.in.datatype          = NULL;
  94         op.in.devmode_ctr.devmode= NULL;
  95         op.in.access_mask       = 0;
  96         op.out.handle           = server_handle;
  97
  98         torture_comment(tctx, "Testing OpenPrinter(%s)\n", op.in.printername);
  99
 100         status = dcerpc_spoolss_OpenPrinter(p, tctx, &op);
 101         torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_OpenPrinter failed");
 102         torture_assert_werr_ok(tctx, op.out.result, "dcerpc_spoolss_OpenPrinter failed");
 103
 104         return true;
 105 }
 106
 107 static bool test_EnumPorts(struct torture_context *tctx,
 108                            struct dcerpc_pipe *p,
 109                            struct test_spoolss_context *ctx)
 110 {
 111         NTSTATUS status;
 112         struct spoolss_EnumPorts r;
 113         uint16_t levels[] = { 1, 2 };
 114         int i, j;
 115
 116         for (i=0;i<ARRAY_SIZE(levels);i++) {
 117                 int level = levels[i];
 118                 DATA_BLOB blob;
 119                 uint32_t needed;
 120                 uint32_t count;
 121                 union spoolss_PortInfo *info;
 122
 123                 r.in.servername = "";
 124                 r.in.level = level;
 125                 r.in.buffer = NULL;
 126                 r.in.offered = 0;
 127                 r.out.needed = &needed;
 128                 r.out.count = &count;
 129                 r.out.info = &info;
 130
 131                 torture_comment(tctx, "Testing EnumPorts level %u\n", r.in.level);
 132
 133                 status = dcerpc_spoolss_EnumPorts(p, ctx, &r);
 134                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
 135                 if (W_ERROR_IS_OK(r.out.result)) {
 136                         /* TODO: do some more checks here */
 137                         continue;
 138                 }
 139                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 140                         "EnumPorts unexpected return code");
 141
 142                 blob = data_blob_talloc(ctx, NULL, needed);
 143                 data_blob_clear(&blob);
 144                 r.in.buffer = &blob;
 145                 r.in.offered = needed;
 146
 147                 status = dcerpc_spoolss_EnumPorts(p, ctx, &r);
 148                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
 149
 150                 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
 151
 152                 torture_assert(tctx, info, "EnumPorts returned no info");
 153
 154                 ctx->port_count[level]  = count;
 155                 ctx->ports[level]       = info;
 156         }
 157
 158         for (i=1;i<ARRAY_SIZE(levels);i++) {
 159                 int level = levels[i];
 160                 int old_level = levels[i-1];
 161                 torture_assert_int_equal(tctx, ctx->port_count[level], ctx->port_count[old_level],
 162                         "EnumPorts invalid value");
 163         }
 164         /* if the array sizes are not the same we would maybe segfault in the following code */
 165
 166         for (i=0;i<ARRAY_SIZE(levels);i++) {
 167                 int level = levels[i];
 168                 for (j=0;j<ctx->port_count[level];j++) {
 169                         union spoolss_PortInfo *cur = &ctx->ports[level][j];
 170                         union spoolss_PortInfo *ref = &ctx->ports[2][j];
 171                         switch (level) {
 172                         case 1:
 173                                 COMPARE_STRING(tctx, cur->info1, ref->info2, port_name);
 174                                 break;
 175                         case 2:
 176                                 /* level 2 is our reference, and it makes no sense to compare it to itself */
 177                                 break;
 178                         }
 179                 }
 180         }
 181
 182         return true;
 183 }
 184
 185 static bool test_GetPrintProcessorDirectory(struct torture_context *tctx,
 186                                             struct dcerpc_pipe *p,
 187                                             struct test_spoolss_context *ctx)
 188 {
 189         NTSTATUS status;
 190         struct spoolss_GetPrintProcessorDirectory r;
 191         struct {
 192                 uint16_t level;
 193                 const char *server;
 194         } levels[] = {{
 195                         .level  = 1,
 196                         .server = NULL
 197                 },{
 198                         .level  = 1,
 199                         .server = ""
 200                 },{
 201                         .level  = 78,
 202                         .server = ""
 203                 },{
 204                         .level  = 1,
 205                         .server = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p))
 206                 },{
 207                         .level  = 1024,
 208                         .server = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p))
 209                 }
 210         };
 211         int i;
 212         uint32_t needed;
 213
 214         for (i=0;i<ARRAY_SIZE(levels);i++) {
 215                 int level = levels[i].level;
 216                 DATA_BLOB blob;
 217
 218                 r.in.server             = levels[i].server;
 219                 r.in.environment        = SPOOLSS_ARCHITECTURE_NT_X86;
 220                 r.in.level              = level;
 221                 r.in.buffer             = NULL;
 222                 r.in.offered            = 0;
 223                 r.out.needed            = &needed;
 224
 225                 torture_comment(tctx, "Testing GetPrintProcessorDirectory level %u\n", r.in.level);
 226
 227                 status = dcerpc_spoolss_GetPrintProcessorDirectory(p, ctx, &r);
 228                 torture_assert_ntstatus_ok(tctx, status,
 229                         "dcerpc_spoolss_GetPrintProcessorDirectory failed");
 230                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 231                         "GetPrintProcessorDirectory unexpected return code");
 232
 233                 blob = data_blob_talloc(ctx, NULL, needed);
 234                 data_blob_clear(&blob);
 235                 r.in.buffer = &blob;
 236                 r.in.offered = needed;
 237
 238                 status = dcerpc_spoolss_GetPrintProcessorDirectory(p, ctx, &r);
 239                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrintProcessorDirectory failed");
 240
 241                 torture_assert_werr_ok(tctx, r.out.result, "GetPrintProcessorDirectory failed");
 242         }
 243
 244         return true;
 245 }
 246
 247
 248 static bool test_GetPrinterDriverDirectory(struct torture_context *tctx,
 249                                            struct dcerpc_pipe *p,
 250                                            struct test_spoolss_context *ctx)
 251 {
 252         NTSTATUS status;
 253         struct spoolss_GetPrinterDriverDirectory r;
 254         struct {
 255                 uint16_t level;
 256                 const char *server;
 257         } levels[] = {{
 258                         .level  = 1,
 259                         .server = NULL
 260                 },{
 261                         .level  = 1,
 262                         .server = ""
 263                 },{
 264                         .level  = 78,
 265                         .server = ""
 266                 },{
 267                         .level  = 1,
 268                         .server = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p))
 269                 },{
 270                         .level  = 1024,
 271                         .server = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p))
 272                 }
 273         };
 274         int i;
 275         uint32_t needed;
 276
 277         for (i=0;i<ARRAY_SIZE(levels);i++) {
 278                 int level = levels[i].level;
 279                 DATA_BLOB blob;
 280
 281                 r.in.server             = levels[i].server;
 282                 r.in.environment        = SPOOLSS_ARCHITECTURE_NT_X86;
 283                 r.in.level              = level;
 284                 r.in.buffer             = NULL;
 285                 r.in.offered            = 0;
 286                 r.out.needed            = &needed;
 287
 288                 torture_comment(tctx, "Testing GetPrinterDriverDirectory level %u\n", r.in.level);
 289
 290                 status = dcerpc_spoolss_GetPrinterDriverDirectory(p, ctx, &r);
 291                 torture_assert_ntstatus_ok(tctx, status,
 292                         "dcerpc_spoolss_GetPrinterDriverDirectory failed");
 293                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 294                         "GetPrinterDriverDirectory unexpected return code");
 295
 296                 blob = data_blob_talloc(ctx, NULL, needed);
 297                 data_blob_clear(&blob);
 298                 r.in.buffer = &blob;
 299                 r.in.offered = needed;
 300
 301                 status = dcerpc_spoolss_GetPrinterDriverDirectory(p, ctx, &r);
 302                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrinterDriverDirectory failed");
 303
 304                 torture_assert_werr_ok(tctx, r.out.result, "GetPrinterDriverDirectory failed");
 305         }
 306
 307         return true;
 308 }
 309
 310 static bool test_EnumPrinterDrivers(struct torture_context *tctx,
 311                                     struct dcerpc_pipe *p,
 312                                     struct test_spoolss_context *ctx)
 313 {
 314         NTSTATUS status;
 315         struct spoolss_EnumPrinterDrivers r;
 316         uint16_t levels[] = { 1, 2, 3, 4, 5, 6 };
 317         int i, j, a;
 318         const char *architectures[] = {
 319                 SPOOLSS_ARCHITECTURE_NT_X86,
 320                 SPOOLSS_ARCHITECTURE_ALL
 321         };
 322
 323         for (i=0;i<ARRAY_SIZE(levels);i++) {
 324         for (a=0;a<ARRAY_SIZE(architectures);a++) {
 325                 int level = levels[i];
 326                 DATA_BLOB blob;
 327                 uint32_t needed;
 328                 uint32_t count;
 329                 union spoolss_DriverInfo *info;
 330
 331                 /* FIXME: gd, come back and fix "" as server, and handle
 332                  * priority of returned error codes in torture test and samba 3
 333                  * server */
 334
 335                 r.in.server             = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 336                 r.in.environment        = architectures[a];
 337                 r.in.level              = level;
 338                 r.in.buffer             = NULL;
 339                 r.in.offered            = 0;
 340                 r.out.needed            = &needed;
 341                 r.out.count             = &count;
 342                 r.out.info              = &info;
 343
 344                 torture_comment(tctx, "Testing EnumPrinterDrivers level %u (%s)\n", r.in.level, r.in.environment);
 345
 346                 status = dcerpc_spoolss_EnumPrinterDrivers(p, ctx, &r);
 347                 torture_assert_ntstatus_ok(tctx, status,
 348                                            "dcerpc_spoolss_EnumPrinterDrivers failed");
 349                 if (W_ERROR_IS_OK(r.out.result)) {
 350                         /* TODO: do some more checks here */
 351                         continue;
 352                 }
 353                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 354                         blob = data_blob_talloc(ctx, NULL, needed);
 355                         data_blob_clear(&blob);
 356                         r.in.buffer = &blob;
 357                         r.in.offered = needed;
 358
 359                         status = dcerpc_spoolss_EnumPrinterDrivers(p, ctx, &r);
 360                         torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinterDrivers failed");
 361                 }
 362
 363                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDrivers failed");
 364
 365                 /* don't do cross-architecture comparison */
 366                 if (strequal(r.in.environment, SPOOLSS_ARCHITECTURE_ALL)) {
 367                         continue;
 368                 }
 369
 370                 ctx->driver_count[level]        = count;
 371                 ctx->drivers[level]             = info;
 372         }
 373         }
 374
 375         for (i=1;i<ARRAY_SIZE(levels);i++) {
 376                 int level = levels[i];
 377                 int old_level = levels[i-1];
 378
 379                 /* don't do cross-architecture comparison */
 380                 if (strequal(r.in.environment, SPOOLSS_ARCHITECTURE_ALL)) {
 381                         continue;
 382                 }
 383
 384                 torture_assert_int_equal(tctx, ctx->driver_count[level], ctx->driver_count[old_level],
 385                         "EnumPrinterDrivers invalid value");
 386         }
 387
 388         for (i=0;i<ARRAY_SIZE(levels);i++) {
 389                 int level = levels[i];
 390
 391                 /* don't do cross-architecture comparison */
 392                 if (strequal(r.in.environment, SPOOLSS_ARCHITECTURE_ALL)) {
 393                         continue;
 394                 }
 395
 396                 for (j=0;j<ctx->driver_count[level];j++) {
 397                         union spoolss_DriverInfo *cur = &ctx->drivers[level][j];
 398                         union spoolss_DriverInfo *ref = &ctx->drivers[6][j];
 399                         switch (level) {
 400                         case 1:
 401                                 COMPARE_STRING(tctx, cur->info1, ref->info6, driver_name);
 402                                 break;
 403                         case 2:
 404                                 COMPARE_UINT32(tctx, cur->info2, ref->info6, version);
 405                                 COMPARE_STRING(tctx, cur->info2, ref->info6, driver_name);
 406                                 COMPARE_STRING(tctx, cur->info2, ref->info6, architecture);
 407                                 COMPARE_STRING(tctx, cur->info2, ref->info6, driver_path);
 408                                 COMPARE_STRING(tctx, cur->info2, ref->info6, data_file);
 409                                 COMPARE_STRING(tctx, cur->info2, ref->info6, config_file);
 410                                 break;
 411                         case 3:
 412                                 COMPARE_UINT32(tctx, cur->info3, ref->info6, version);
 413                                 COMPARE_STRING(tctx, cur->info3, ref->info6, driver_name);
 414                                 COMPARE_STRING(tctx, cur->info3, ref->info6, architecture);
 415                                 COMPARE_STRING(tctx, cur->info3, ref->info6, driver_path);
 416                                 COMPARE_STRING(tctx, cur->info3, ref->info6, data_file);
 417                                 COMPARE_STRING(tctx, cur->info3, ref->info6, config_file);
 418                                 COMPARE_STRING(tctx, cur->info3, ref->info6, help_file);
 419                                 COMPARE_STRING_ARRAY(tctx, cur->info3, ref->info6, dependent_files);
 420                                 COMPARE_STRING(tctx, cur->info3, ref->info6, monitor_name);
 421                                 COMPARE_STRING(tctx, cur->info3, ref->info6, default_datatype);
 422                                 break;
 423                         case 4:
 424                                 COMPARE_UINT32(tctx, cur->info4, ref->info6, version);
 425                                 COMPARE_STRING(tctx, cur->info4, ref->info6, driver_name);
 426                                 COMPARE_STRING(tctx, cur->info4, ref->info6, architecture);
 427                                 COMPARE_STRING(tctx, cur->info4, ref->info6, driver_path);
 428                                 COMPARE_STRING(tctx, cur->info4, ref->info6, data_file);
 429                                 COMPARE_STRING(tctx, cur->info4, ref->info6, config_file);
 430                                 COMPARE_STRING(tctx, cur->info4, ref->info6, help_file);
 431                                 COMPARE_STRING_ARRAY(tctx, cur->info4, ref->info6, dependent_files);
 432                                 COMPARE_STRING(tctx, cur->info4, ref->info6, monitor_name);
 433                                 COMPARE_STRING(tctx, cur->info4, ref->info6, default_datatype);
 434                                 COMPARE_STRING_ARRAY(tctx, cur->info4, ref->info6, previous_names);
 435                                 break;
 436                         case 5:
 437                                 COMPARE_UINT32(tctx, cur->info5, ref->info6, version);
 438                                 COMPARE_STRING(tctx, cur->info5, ref->info6, driver_name);
 439                                 COMPARE_STRING(tctx, cur->info5, ref->info6, architecture);
 440                                 COMPARE_STRING(tctx, cur->info5, ref->info6, driver_path);
 441                                 COMPARE_STRING(tctx, cur->info5, ref->info6, data_file);
 442                                 COMPARE_STRING(tctx, cur->info5, ref->info6, config_file);
 443                                 /*COMPARE_UINT32(tctx, cur->info5, ref->info6, driver_attributes);*/
 444                                 /*COMPARE_UINT32(tctx, cur->info5, ref->info6, config_version);*/
 445                                 /*TODO: ! COMPARE_UINT32(tctx, cur->info5, ref->info6, driver_version); */
 446                                 break;
 447                         case 6:
 448                                 /* level 6 is our reference, and it makes no sense to compare it to itself */
 449                                 break;
 450                         }
 451                 }
 452         }
 453
 454         return true;
 455 }
 456
 457 static bool test_EnumMonitors(struct torture_context *tctx,
 458                               struct dcerpc_pipe *p,
 459                               struct test_spoolss_context *ctx)
 460 {
 461         NTSTATUS status;
 462         struct spoolss_EnumMonitors r;
 463         uint16_t levels[] = { 1, 2 };
 464         int i, j;
 465
 466         for (i=0;i<ARRAY_SIZE(levels);i++) {
 467                 int level = levels[i];
 468                 DATA_BLOB blob;
 469                 uint32_t needed;
 470                 uint32_t count;
 471                 union spoolss_MonitorInfo *info;
 472
 473                 r.in.servername = "";
 474                 r.in.level = level;
 475                 r.in.buffer = NULL;
 476                 r.in.offered = 0;
 477                 r.out.needed = &needed;
 478                 r.out.count = &count;
 479                 r.out.info = &info;
 480
 481                 torture_comment(tctx, "Testing EnumMonitors level %u\n", r.in.level);
 482
 483                 status = dcerpc_spoolss_EnumMonitors(p, ctx, &r);
 484                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
 485                 if (W_ERROR_IS_OK(r.out.result)) {
 486                         /* TODO: do some more checks here */
 487                         continue;
 488                 }
 489                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 490                         "EnumMonitors failed");
 491
 492                 blob = data_blob_talloc(ctx, NULL, needed);
 493                 data_blob_clear(&blob);
 494                 r.in.buffer = &blob;
 495                 r.in.offered = needed;
 496
 497                 status = dcerpc_spoolss_EnumMonitors(p, ctx, &r);
 498                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
 499
 500                 torture_assert_werr_ok(tctx, r.out.result, "EnumMonitors failed");
 501
 502                 ctx->monitor_count[level]       = count;
 503                 ctx->monitors[level]            = info;
 504         }
 505
 506         for (i=1;i<ARRAY_SIZE(levels);i++) {
 507                 int level = levels[i];
 508                 int old_level = levels[i-1];
 509                 torture_assert_int_equal(tctx, ctx->monitor_count[level], ctx->monitor_count[old_level],
 510                                          "EnumMonitors invalid value");
 511         }
 512
 513         for (i=0;i<ARRAY_SIZE(levels);i++) {
 514                 int level = levels[i];
 515                 for (j=0;j<ctx->monitor_count[level];j++) {
 516                         union spoolss_MonitorInfo *cur = &ctx->monitors[level][j];
 517                         union spoolss_MonitorInfo *ref = &ctx->monitors[2][j];
 518                         switch (level) {
 519                         case 1:
 520                                 COMPARE_STRING(tctx, cur->info1, ref->info2, monitor_name);
 521                                 break;
 522                         case 2:
 523                                 /* level 2 is our reference, and it makes no sense to compare it to itself */
 524                                 break;
 525                         }
 526                 }
 527         }
 528
 529         return true;
 530 }
 531
 532 static bool test_EnumPrintProcessors(struct torture_context *tctx,
 533                                      struct dcerpc_pipe *p,
 534                                      struct test_spoolss_context *ctx)
 535 {
 536         NTSTATUS status;
 537         struct spoolss_EnumPrintProcessors r;
 538         uint16_t levels[] = { 1 };
 539         int i, j;
 540
 541         for (i=0;i<ARRAY_SIZE(levels);i++) {
 542                 int level = levels[i];
 543                 DATA_BLOB blob;
 544                 uint32_t needed;
 545                 uint32_t count;
 546                 union spoolss_PrintProcessorInfo *info;
 547
 548                 r.in.servername = "";
 549                 r.in.environment = SPOOLSS_ARCHITECTURE_NT_X86;
 550                 r.in.level = level;
 551                 r.in.buffer = NULL;
 552                 r.in.offered = 0;
 553                 r.out.needed = &needed;
 554                 r.out.count = &count;
 555                 r.out.info = &info;
 556
 557                 torture_comment(tctx, "Testing EnumPrintProcessors level %u\n", r.in.level);
 558
 559                 status = dcerpc_spoolss_EnumPrintProcessors(p, ctx, &r);
 560                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcessors failed");
 561                 if (W_ERROR_IS_OK(r.out.result)) {
 562                         /* TODO: do some more checks here */
 563                         continue;
 564                 }
 565                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 566                         "EnumPrintProcessors unexpected return code");
 567
 568                 blob = data_blob_talloc(ctx, NULL, needed);
 569                 data_blob_clear(&blob);
 570                 r.in.buffer = &blob;
 571                 r.in.offered = needed;
 572
 573                 status = dcerpc_spoolss_EnumPrintProcessors(p, ctx, &r);
 574                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcessors failed");
 575
 576                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcessors failed");
 577
 578                 ctx->print_processor_count[level]       = count;
 579                 ctx->print_processors[level]            = info;
 580         }
 581
 582         for (i=1;i<ARRAY_SIZE(levels);i++) {
 583                 int level = levels[i];
 584                 int old_level = levels[i-1];
 585                 torture_assert_int_equal(tctx, ctx->print_processor_count[level], ctx->print_processor_count[old_level],
 586                         "EnumPrintProcessors failed");
 587         }
 588
 589         for (i=0;i<ARRAY_SIZE(levels);i++) {
 590                 int level = levels[i];
 591                 for (j=0;j<ctx->print_processor_count[level];j++) {
 592 #if 0
 593                         union spoolss_PrintProcessorInfo *cur = &ctx->print_processors[level][j];
 594                         union spoolss_PrintProcessorInfo *ref = &ctx->print_processors[1][j];
 595 #endif
 596                         switch (level) {
 597                         case 1:
 598                                 /* level 1 is our reference, and it makes no sense to compare it to itself */
 599                                 break;
 600                         }
 601                 }
 602         }
 603
 604         return true;
 605 }
 606
 607 static bool test_EnumPrintProcDataTypes(struct torture_context *tctx,
 608                                         struct dcerpc_pipe *p,
 609                                         struct test_spoolss_context *ctx)
 610 {
 611         NTSTATUS status;
 612         struct spoolss_EnumPrintProcDataTypes r;
 613         uint16_t levels[] = { 1 };
 614         int i;
 615
 616         for (i=0;i<ARRAY_SIZE(levels);i++) {
 617                 int level = levels[i];
 618                 DATA_BLOB blob;
 619                 uint32_t needed;
 620                 uint32_t count;
 621                 union spoolss_PrintProcDataTypesInfo *info;
 622
 623                 r.in.servername = "";
 624                 r.in.print_processor_name = "winprint";
 625                 r.in.level = level;
 626                 r.in.buffer = NULL;
 627                 r.in.offered = 0;
 628                 r.out.needed = &needed;
 629                 r.out.count = &count;
 630                 r.out.info = &info;
 631
 632                 torture_comment(tctx, "Testing EnumPrintProcDataTypes level %u\n", r.in.level);
 633
 634                 status = dcerpc_spoolss_EnumPrintProcDataTypes(p, ctx, &r);
 635                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcDataType failed");
 636                 if (W_ERROR_IS_OK(r.out.result)) {
 637                         /* TODO: do some more checks here */
 638                         continue;
 639                 }
 640                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 641                         "EnumPrintProcDataTypes unexpected return code");
 642
 643                 blob = data_blob_talloc(ctx, NULL, needed);
 644                 data_blob_clear(&blob);
 645                 r.in.buffer = &blob;
 646                 r.in.offered = needed;
 647
 648                 status = dcerpc_spoolss_EnumPrintProcDataTypes(p, ctx, &r);
 649                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcDataTypes failed");
 650
 651                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcDataTypes failed");
 652         }
 653
 654         return true;
 655 }
 656
 657
 658 static bool test_EnumPrinters(struct torture_context *tctx,
 659                               struct dcerpc_pipe *p,
 660                               struct test_spoolss_context *ctx)
 661 {
 662         struct spoolss_EnumPrinters r;
 663         NTSTATUS status;
 664         uint16_t levels[] = { 0, 1, 2, 4, 5 };
 665         int i, j;
 666
 667         for (i=0;i<ARRAY_SIZE(levels);i++) {
 668                 int level = levels[i];
 669                 DATA_BLOB blob;
 670                 uint32_t needed;
 671                 uint32_t count;
 672                 union spoolss_PrinterInfo *info;
 673
 674                 r.in.flags      = PRINTER_ENUM_LOCAL;
 675                 r.in.server     = "";
 676                 r.in.level      = level;
 677                 r.in.buffer     = NULL;
 678                 r.in.offered    = 0;
 679                 r.out.needed    = &needed;
 680                 r.out.count     = &count;
 681                 r.out.info      = &info;
 682
 683                 torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
 684
 685                 status = dcerpc_spoolss_EnumPrinters(p, ctx, &r);
 686                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
 687                 if (W_ERROR_IS_OK(r.out.result)) {
 688                         /* TODO: do some more checks here */
 689                         continue;
 690                 }
 691                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 692                         "EnumPrinters unexpected return code");
 693
 694                 blob = data_blob_talloc(ctx, NULL, needed);
 695                 data_blob_clear(&blob);
 696                 r.in.buffer = &blob;
 697                 r.in.offered = needed;
 698
 699                 status = dcerpc_spoolss_EnumPrinters(p, ctx, &r);
 700                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
 701
 702                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
 703
 704                 ctx->printer_count[level]       = count;
 705                 ctx->printers[level]            = info;
 706         }
 707
 708         for (i=1;i<ARRAY_SIZE(levels);i++) {
 709                 int level = levels[i];
 710                 int old_level = levels[i-1];
 711                 torture_assert_int_equal(tctx, ctx->printer_count[level], ctx->printer_count[old_level],
 712                                          "EnumPrinters invalid value");
 713         }
 714
 715         for (i=0;i<ARRAY_SIZE(levels);i++) {
 716                 int level = levels[i];
 717                 for (j=0;j<ctx->printer_count[level];j++) {
 718                         union spoolss_PrinterInfo *cur = &ctx->printers[level][j];
 719                         union spoolss_PrinterInfo *ref = &ctx->printers[2][j];
 720                         switch (level) {
 721                         case 0:
 722                                 COMPARE_STRING(tctx, cur->info0, ref->info2, printername);
 723                                 COMPARE_STRING(tctx, cur->info0, ref->info2, servername);
 724                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, cjobs);
 725                                 /*COMPARE_UINT32(tctx, cur->info0, ref->info2, total_jobs);
 726                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, total_bytes);
 727                                 COMPARE_SPOOLSS_TIME(cur->info0, ref->info2, spoolss_Time time);
 728                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, global_counter);
 729                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, total_pages);
 730                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, version);
 731                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown10);
 732                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown11);
 733                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown12);
 734                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, session_counter);
 735                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown14);
 736                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, printer_errors);
 737                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown16);
 738                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown17);
 739                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown18);
 740                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown19);
 741                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, change_id);
 742                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown21);*/
 743                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, status);
 744                                 /*COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown23);
 745                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, c_setprinter);
 746                                 COMPARE_UINT16(cur->info0, ref->info2, unknown25);
 747                                 COMPARE_UINT16(cur->info0, ref->info2, unknown26);
 748                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown27);
 749                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown28);
 750                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown29);*/
 751                                 break;
 752                         case 1:
 753                                 /*COMPARE_UINT32(tctx, cur->info1, ref->info2, flags);*/
 754                                 /*COMPARE_STRING(tctx, cur->info1, ref->info2, name);*/
 755                                 /*COMPARE_STRING(tctx, cur->info1, ref->info2, description);*/
 756                                 COMPARE_STRING(tctx, cur->info1, ref->info2, comment);
 757                                 break;
 758                         case 2:
 759                                 /* level 2 is our reference, and it makes no sense to compare it to itself */
 760                                 break;
 761                         case 4:
 762                                 COMPARE_STRING(tctx, cur->info4, ref->info2, printername);
 763                                 COMPARE_STRING(tctx, cur->info4, ref->info2, servername);
 764                                 COMPARE_UINT32(tctx, cur->info4, ref->info2, attributes);
 765                                 break;
 766                         case 5:
 767                                 COMPARE_STRING(tctx, cur->info5, ref->info2, printername);
 768                                 COMPARE_STRING(tctx, cur->info5, ref->info2, portname);
 769                                 COMPARE_UINT32(tctx, cur->info5, ref->info2, attributes);
 770                                 /*COMPARE_UINT32(tctx, cur->info5, ref->info2, device_not_selected_timeout);
 771                                 COMPARE_UINT32(tctx, cur->info5, ref->info2, transmission_retry_timeout);*/
 772                                 break;
 773                         }
 774                 }
 775         }
 776
 777         /* TODO:
 778          *      - verify that the port of a printer was in the list returned by EnumPorts
 779          */
 780
 781         return true;
 782 }
 783
 784 static bool test_GetPrinter(struct torture_context *tctx,
 785                             struct dcerpc_pipe *p,
 786                      struct policy_handle *handle)
 787 {
 788         NTSTATUS status;
 789         struct spoolss_GetPrinter r;
 790         uint16_t levels[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
 791         int i;
 792         uint32_t needed;
 793
 794         for (i=0;i<ARRAY_SIZE(levels);i++) {
 795                 r.in.handle = handle;
 796                 r.in.level = levels[i];
 797                 r.in.buffer = NULL;
 798                 r.in.offered = 0;
 799                 r.out.needed = &needed;
 800
 801                 torture_comment(tctx, "Testing GetPrinter level %u\n", r.in.level);
 802
 803                 status = dcerpc_spoolss_GetPrinter(p, tctx, &r);
 804                 torture_assert_ntstatus_ok(tctx, status, "GetPrinter failed");
 805
 806                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 807                         DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
 808                         data_blob_clear(&blob);
 809                         r.in.buffer = &blob;
 810                         r.in.offered = needed;
 811                         status = dcerpc_spoolss_GetPrinter(p, tctx, &r);
 812                 }
 813
 814                 torture_assert_ntstatus_ok(tctx, status, "GetPrinter failed");
 815
 816                 torture_assert_werr_ok(tctx, r.out.result, "GetPrinter failed");
 817         }
 818
 819         return true;
 820 }
 821
 822 static bool test_SetPrinter_errors(struct torture_context *tctx,
 823                                    struct dcerpc_pipe *p,
 824                                    struct policy_handle *handle)
 825 {
 826         struct spoolss_SetPrinter r;
 827         uint16_t levels[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 828         int i;
 829
 830         struct spoolss_SetPrinterInfoCtr info_ctr;
 831         struct spoolss_DevmodeContainer devmode_ctr;
 832         struct sec_desc_buf secdesc_ctr;
 833
 834         info_ctr.level = 0;
 835         info_ctr.info.info0 = NULL;
 836
 837         ZERO_STRUCT(devmode_ctr);
 838         ZERO_STRUCT(secdesc_ctr);
 839
 840         r.in.handle = handle;
 841         r.in.info_ctr = &info_ctr;
 842         r.in.devmode_ctr = &devmode_ctr;
 843         r.in.secdesc_ctr = &secdesc_ctr;
 844         r.in.command = 0;
 845
 846         torture_comment(tctx, "Testing SetPrinter all zero\n");
 847
 848         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter(p, tctx, &r),
 849                 "failed to call SetPrinter");
 850         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
 851                 "failed to call SetPrinter");
 852
 853  again:
 854         for (i=0; i < ARRAY_SIZE(levels); i++) {
 855
 856                 struct spoolss_SetPrinterInfo0 info0;
 857                 struct spoolss_SetPrinterInfo1 info1;
 858                 struct spoolss_SetPrinterInfo2 info2;
 859                 struct spoolss_SetPrinterInfo3 info3;
 860                 struct spoolss_SetPrinterInfo4 info4;
 861                 struct spoolss_SetPrinterInfo5 info5;
 862                 struct spoolss_SetPrinterInfo6 info6;
 863                 struct spoolss_SetPrinterInfo7 info7;
 864                 struct spoolss_DeviceModeInfo info8;
 865                 struct spoolss_DeviceModeInfo info9;
 866
 867
 868                 info_ctr.level = levels[i];
 869                 switch (levels[i]) {
 870                 case 0:
 871                         ZERO_STRUCT(info0);
 872                         info_ctr.info.info0 = &info0;
 873                         break;
 874                 case 1:
 875                         ZERO_STRUCT(info1);
 876                         info_ctr.info.info1 = &info1;
 877                         break;
 878                 case 2:
 879                         ZERO_STRUCT(info2);
 880                         info_ctr.info.info2 = &info2;
 881                         break;
 882                 case 3:
 883                         ZERO_STRUCT(info3);
 884                         info_ctr.info.info3 = &info3;
 885                         break;
 886                 case 4:
 887                         ZERO_STRUCT(info4);
 888                         info_ctr.info.info4 = &info4;
 889                         break;
 890                 case 5:
 891                         ZERO_STRUCT(info5);
 892                         info_ctr.info.info5 = &info5;
 893                         break;
 894                 case 6:
 895                         ZERO_STRUCT(info6);
 896                         info_ctr.info.info6 = &info6;
 897                         break;
 898                 case 7:
 899                         ZERO_STRUCT(info7);
 900                         info_ctr.info.info7 = &info7;
 901                         break;
 902                 case 8:
 903                         ZERO_STRUCT(info8);
 904                         info_ctr.info.info8 = &info8;
 905                         break;
 906                 case 9:
 907                         ZERO_STRUCT(info9);
 908                         info_ctr.info.info9 = &info9;
 909                         break;
 910                 }
 911
 912                 torture_comment(tctx, "Testing SetPrinter level %d, command %d\n",
 913                         info_ctr.level, r.in.command);
 914
 915                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter(p, tctx, &r),
 916                         "failed to call SetPrinter");
 917
 918                 switch (r.in.command) {
 919                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: /* 0 */
 920                         /* is ignored for all levels other then 0 */
 921                         if (info_ctr.level > 0) {
 922                                 /* ignored then */
 923                                 break;
 924                         }
 925                 case SPOOLSS_PRINTER_CONTROL_PAUSE: /* 1 */
 926                 case SPOOLSS_PRINTER_CONTROL_RESUME: /* 2 */
 927                 case SPOOLSS_PRINTER_CONTROL_PURGE: /* 3 */
 928                         if (info_ctr.level > 0) {
 929                                 /* is invalid for all levels other then 0 */
 930                                 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PRINTER_COMMAND,
 931                                         "unexpected error code returned");
 932                                 continue;
 933                         } else {
 934                                 torture_assert_werr_ok(tctx, r.out.result,
 935                                         "failed to call SetPrinter with non 0 command");
 936                                 continue;
 937                         }
 938                         break;
 939
 940                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: /* 4 */
 941                         /* FIXME: gd needs further investigation */
 942                 default:
 943                         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PRINTER_COMMAND,
 944                                 "unexpected error code returned");
 945                         continue;
 946                 }
 947
 948                 switch (info_ctr.level) {
 949                 case 1:
 950                         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
 951                                 "unexpected error code returned");
 952                         break;
 953                 case 2:
 954                         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_PRINTER_DRIVER,
 955                                 "unexpected error code returned");
 956                         break;
 957                 case 3:
 958                 case 4:
 959                 case 5:
 960                 case 7:
 961                         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
 962                                 "unexpected error code returned");
 963                         break;
 964                 case 9:
 965                         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
 966                                 "unexpected error code returned");
 967                         break;
 968                 default:
 969                         torture_assert_werr_ok(tctx, r.out.result,
 970                                 "failed to call SetPrinter");
 971                         break;
 972                 }
 973         }
 974
 975         if (r.in.command < 5) {
 976                 r.in.command++;
 977                 goto again;
 978         }
 979
 980         return true;
 981 }
 982
 983 static void clear_info2(struct spoolss_SetPrinterInfoCtr *r)
 984 {
 985         if ((r->level == 2) && (r->info.info2)) {
 986                 r->info.info2->secdesc = NULL;
 987                 r->info.info2->devmode = NULL;
 988         }
 989 }
 990
 991 static bool test_PrinterInfo(struct torture_context *tctx,
 992                              struct dcerpc_pipe *p,
 993                              struct policy_handle *handle)
 994 {
 995         NTSTATUS status;
 996         struct spoolss_SetPrinter s;
 997         struct spoolss_GetPrinter q;
 998         struct spoolss_GetPrinter q0;
 999         struct spoolss_SetPrinterInfoCtr info_ctr;
1000         union spoolss_PrinterInfo info;
1001         struct spoolss_DevmodeContainer devmode_ctr;
1002         struct sec_desc_buf secdesc_ctr;
1003         uint32_t needed;
1004         bool ret = true;
1005         int i;
1006
1007         uint32_t status_list[] = {
1008                 /* these do not stick
1009                 PRINTER_STATUS_PAUSED,
1010                 PRINTER_STATUS_ERROR,
1011                 PRINTER_STATUS_PENDING_DELETION, */
1012                 PRINTER_STATUS_PAPER_JAM,
1013                 PRINTER_STATUS_PAPER_OUT,
1014                 PRINTER_STATUS_MANUAL_FEED,
1015                 PRINTER_STATUS_PAPER_PROBLEM,
1016                 PRINTER_STATUS_OFFLINE,
1017                 PRINTER_STATUS_IO_ACTIVE,
1018                 PRINTER_STATUS_BUSY,
1019                 PRINTER_STATUS_PRINTING,
1020                 PRINTER_STATUS_OUTPUT_BIN_FULL,
1021                 PRINTER_STATUS_NOT_AVAILABLE,
1022                 PRINTER_STATUS_WAITING,
1023                 PRINTER_STATUS_PROCESSING,
1024                 PRINTER_STATUS_INITIALIZING,
1025                 PRINTER_STATUS_WARMING_UP,
1026                 PRINTER_STATUS_TONER_LOW,
1027                 PRINTER_STATUS_NO_TONER,
1028                 PRINTER_STATUS_PAGE_PUNT,
1029                 PRINTER_STATUS_USER_INTERVENTION,
1030                 PRINTER_STATUS_OUT_OF_MEMORY,
1031                 PRINTER_STATUS_DOOR_OPEN,
1032                 PRINTER_STATUS_SERVER_UNKNOWN,
1033                 PRINTER_STATUS_POWER_SAVE,
1034                 /* these do not stick
1035                 0x02000000,
1036                 0x04000000,
1037                 0x08000000,
1038                 0x10000000,
1039                 0x20000000,
1040                 0x40000000,
1041                 0x80000000 */
1042         };
1043         uint32_t default_attribute = PRINTER_ATTRIBUTE_LOCAL;
1044         uint32_t attribute_list[] = {
1045                 PRINTER_ATTRIBUTE_QUEUED,
1046                 /* fails with WERR_INVALID_DATATYPE:
1047                 PRINTER_ATTRIBUTE_DIRECT, */
1048                 /* does not stick
1049                 PRINTER_ATTRIBUTE_DEFAULT, */
1050                 PRINTER_ATTRIBUTE_SHARED,
1051                 /* does not stick
1052                 PRINTER_ATTRIBUTE_NETWORK, */
1053                 PRINTER_ATTRIBUTE_HIDDEN,
1054                 PRINTER_ATTRIBUTE_LOCAL,
1055                 PRINTER_ATTRIBUTE_ENABLE_DEVQ,
1056                 PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS,
1057                 PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST,
1058                 PRINTER_ATTRIBUTE_WORK_OFFLINE,
1059                 /* does not stick
1060                 PRINTER_ATTRIBUTE_ENABLE_BIDI, */
1061                 /* fails with WERR_INVALID_DATATYPE:
1062                 PRINTER_ATTRIBUTE_RAW_ONLY, */
1063                 /* these do not stick
1064                 PRINTER_ATTRIBUTE_PUBLISHED,
1065                 PRINTER_ATTRIBUTE_FAX,
1066                 PRINTER_ATTRIBUTE_TS,
1067                 0x00010000,
1068                 0x00020000,
1069                 0x00040000,
1070                 0x00080000,
1071                 0x00100000,
1072                 0x00200000,
1073                 0x00400000,
1074                 0x00800000,
1075                 0x01000000,
1076                 0x02000000,
1077                 0x04000000,
1078                 0x08000000,
1079                 0x10000000,
1080                 0x20000000,
1081                 0x40000000,
1082                 0x80000000 */
1083         };
1084
1085         ZERO_STRUCT(devmode_ctr);
1086         ZERO_STRUCT(secdesc_ctr);
1087
1088         s.in.handle = handle;
1089         s.in.command = 0;
1090         s.in.info_ctr = &info_ctr;
1091         s.in.devmode_ctr = &devmode_ctr;
1092         s.in.secdesc_ctr = &secdesc_ctr;
1093
1094         q.in.handle = handle;
1095         q.out.info = &info;
1096         q0 = q;
1097
1098 #define TESTGETCALL(call, r) \
1099                 r.in.buffer = NULL; \
1100                 r.in.offered = 0;\
1101                 r.out.needed = &needed; \
1102                 status = dcerpc_spoolss_ ##call(p, tctx, &r); \
1103                 if (!NT_STATUS_IS_OK(status)) { \
1104                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1105                                r.in.level, nt_errstr(status), __location__); \
1106                         ret = false; \
1107                         break; \
1108                 }\
1109                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {\
1110                         DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed); \
1111                         data_blob_clear(&blob); \
1112                         r.in.buffer = &blob; \
1113                         r.in.offered = needed; \
1114                 }\
1115                 status = dcerpc_spoolss_ ##call(p, tctx, &r); \
1116                 if (!NT_STATUS_IS_OK(status)) { \
1117                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1118                                r.in.level, nt_errstr(status), __location__); \
1119                         ret = false; \
1120                         break; \
1121                 } \
1122                 if (!W_ERROR_IS_OK(r.out.result)) { \
1123                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1124                                r.in.level, win_errstr(r.out.result), __location__); \
1125                         ret = false; \
1126                         break; \
1127                 }
1128
1129
1130 #define TESTSETCALL_EXP(call, r, err) \
1131                 clear_info2(&info_ctr);\
1132                 status = dcerpc_spoolss_ ##call(p, tctx, &r); \
1133                 if (!NT_STATUS_IS_OK(status)) { \
1134                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1135                                r.in.info_ctr->level, nt_errstr(status), __location__); \
1136                         ret = false; \
1137                         break; \
1138                 } \
1139                 if (!W_ERROR_IS_OK(err)) { \
1140                         if (!W_ERROR_EQUAL(err, r.out.result)) { \
1141                                 torture_comment(tctx, #call " level %u failed - %s, expected %s (%s)\n", \
1142                                        r.in.info_ctr->level, win_errstr(r.out.result), win_errstr(err), __location__); \
1143                                 ret = false; \
1144                         } \
1145                         break; \
1146                 } \
1147                 if (!W_ERROR_IS_OK(r.out.result)) { \
1148                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1149                                r.in.info_ctr->level, win_errstr(r.out.result), __location__); \
1150                         ret = false; \
1151                         break; \
1152                 }
1153
1154 #define TESTSETCALL(call, r) \
1155         TESTSETCALL_EXP(call, r, WERR_OK)
1156
1157 #define STRING_EQUAL(s1, s2, field) \
1158                 if ((s1 && !s2) || (s2 && !s1) || strcmp(s1, s2)) { \
1159                         torture_comment(tctx, "Failed to set %s to '%s' (%s)\n", \
1160                                #field, s2, __location__); \
1161                         ret = false; \
1162                         break; \
1163                 }
1164
1165 #define MEM_EQUAL(s1, s2, length, field) \
1166                 if ((s1 && !s2) || (s2 && !s1) || memcmp(s1, s2, length)) { \
1167                         torture_comment(tctx, "Failed to set %s to '%s' (%s)\n", \
1168                                #field, (const char *)s2, __location__); \
1169                         ret = false; \
1170                         break; \
1171                 }
1172
1173 #define INT_EQUAL(i1, i2, field) \
1174                 if (i1 != i2) { \
1175                         torture_comment(tctx, "Failed to set %s to 0x%llx - got 0x%llx (%s)\n", \
1176                                #field, (unsigned long long)i2, (unsigned long long)i1, __location__); \
1177                         ret = false; \
1178                         break; \
1179                 }
1180
1181 #define TEST_PRINTERINFO_STRING_EXP_ERR(lvl1, field1, lvl2, field2, value, err) do { \
1182                 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
1183                 q.in.level = lvl1; \
1184                 TESTGETCALL(GetPrinter, q) \
1185                 info_ctr.level = lvl1; \
1186                 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)&q.out.info->info ## lvl1; \
1187                 info_ctr.info.info ## lvl1->field1 = value;\
1188                 TESTSETCALL_EXP(SetPrinter, s, err) \
1189                 info_ctr.info.info ## lvl1->field1 = ""; \
1190                 TESTGETCALL(GetPrinter, q) \
1191                 info_ctr.info.info ## lvl1->field1 = value; \
1192                 STRING_EQUAL(info_ctr.info.info ## lvl1->field1, value, field1); \
1193                 q.in.level = lvl2; \
1194                 TESTGETCALL(GetPrinter, q) \
1195                 info_ctr.info.info ## lvl2 = (struct spoolss_SetPrinterInfo ## lvl2 *)&q.out.info->info ## lvl2; \
1196                 STRING_EQUAL(info_ctr.info.info ## lvl2->field2, value, field2); \
1197         } while (0)
1198
1199 #define TEST_PRINTERINFO_STRING(lvl1, field1, lvl2, field2, value) do { \
1200         TEST_PRINTERINFO_STRING_EXP_ERR(lvl1, field1, lvl2, field2, value, WERR_OK); \
1201         } while (0);
1202
1203 #define TEST_PRINTERINFO_INT_EXP(lvl1, field1, lvl2, field2, value, exp_value) do { \
1204                 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
1205                 q.in.level = lvl1; \
1206                 TESTGETCALL(GetPrinter, q) \
1207                 info_ctr.level = lvl1; \
1208                 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)&q.out.info->info ## lvl1; \
1209                 info_ctr.info.info ## lvl1->field1 = value; \
1210                 TESTSETCALL(SetPrinter, s) \
1211                 info_ctr.info.info ## lvl1->field1 = 0; \
1212                 TESTGETCALL(GetPrinter, q) \
1213                 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)&q.out.info->info ## lvl1; \
1214                 INT_EQUAL(info_ctr.info.info ## lvl1->field1, exp_value, field1); \
1215                 q.in.level = lvl2; \
1216                 TESTGETCALL(GetPrinter, q) \
1217                 info_ctr.info.info ## lvl2 = (struct spoolss_SetPrinterInfo ## lvl2 *)&q.out.info->info ## lvl2; \
1218                 INT_EQUAL(info_ctr.info.info ## lvl2->field2, exp_value, field1); \
1219         } while (0)
1220
1221 #define TEST_PRINTERINFO_INT(lvl1, field1, lvl2, field2, value) do { \
1222         TEST_PRINTERINFO_INT_EXP(lvl1, field1, lvl2, field2, value, value); \
1223         } while (0)
1224
1225         q0.in.level = 0;
1226         do { TESTGETCALL(GetPrinter, q0) } while (0);
1227
1228         TEST_PRINTERINFO_STRING(2, comment,  1, comment, "xx2-1 comment");
1229         TEST_PRINTERINFO_STRING(2, comment,  2, comment, "xx2-2 comment");
1230
1231         /* level 0 printername does not stick */
1232 /*      TEST_PRINTERINFO_STRING(2, printername,  0, printername, "xx2-0 printer"); */
1233         TEST_PRINTERINFO_STRING(2, printername,  1, name,        "xx2-1 printer");
1234         TEST_PRINTERINFO_STRING(2, printername,  2, printername, "xx2-2 printer");
1235         TEST_PRINTERINFO_STRING(2, printername,  4, printername, "xx2-4 printer");
1236         TEST_PRINTERINFO_STRING(2, printername,  5, printername, "xx2-5 printer");
1237 /*      TEST_PRINTERINFO_STRING(4, printername,  0, printername, "xx4-0 printer"); */
1238         TEST_PRINTERINFO_STRING(4, printername,  1, name,        "xx4-1 printer");
1239         TEST_PRINTERINFO_STRING(4, printername,  2, printername, "xx4-2 printer");
1240         TEST_PRINTERINFO_STRING(4, printername,  4, printername, "xx4-4 printer");
1241         TEST_PRINTERINFO_STRING(4, printername,  5, printername, "xx4-5 printer");
1242 /*      TEST_PRINTERINFO_STRING(5, printername,  0, printername, "xx5-0 printer"); */
1243         TEST_PRINTERINFO_STRING(5, printername,  1, name,        "xx5-1 printer");
1244         TEST_PRINTERINFO_STRING(5, printername,  2, printername, "xx5-2 printer");
1245         TEST_PRINTERINFO_STRING(5, printername,  4, printername, "xx5-4 printer");
1246         TEST_PRINTERINFO_STRING(5, printername,  5, printername, "xx5-5 printer");
1247
1248         /* servername can be set but does not stick
1249         TEST_PRINTERINFO_STRING(2, servername,  0, servername, "xx2-0 servername");
1250         TEST_PRINTERINFO_STRING(2, servername,  2, servername, "xx2-2 servername");
1251         TEST_PRINTERINFO_STRING(2, servername,  4, servername, "xx2-4 servername");
1252         */
1253
1254         /* passing an invalid port will result in WERR_UNKNOWN_PORT */
1255         TEST_PRINTERINFO_STRING_EXP_ERR(2, portname,  2, portname, "xx2-2 portname", WERR_UNKNOWN_PORT);
1256         TEST_PRINTERINFO_STRING_EXP_ERR(2, portname,  5, portname, "xx2-5 portname", WERR_UNKNOWN_PORT);
1257         TEST_PRINTERINFO_STRING_EXP_ERR(5, portname,  2, portname, "xx5-2 portname", WERR_UNKNOWN_PORT);
1258         TEST_PRINTERINFO_STRING_EXP_ERR(5, portname,  5, portname, "xx5-5 portname", WERR_UNKNOWN_PORT);
1259
1260         TEST_PRINTERINFO_STRING(2, sharename,   2, sharename,   "xx2-2 sharename");
1261         /* passing an invalid driver will result in WERR_UNKNOWN_PRINTER_DRIVER */
1262         TEST_PRINTERINFO_STRING_EXP_ERR(2, drivername,  2, drivername,  "xx2-2 drivername", WERR_UNKNOWN_PRINTER_DRIVER);
1263         TEST_PRINTERINFO_STRING(2, location,    2, location,    "xx2-2 location");
1264         /* passing an invalid sepfile will result in WERR_INVALID_SEPARATOR_FILE */
1265         TEST_PRINTERINFO_STRING_EXP_ERR(2, sepfile,     2, sepfile,     "xx2-2 sepfile", WERR_INVALID_SEPARATOR_FILE);
1266         /* passing an invalid printprocessor will result in WERR_UNKNOWN_PRINTPROCESSOR */
1267         TEST_PRINTERINFO_STRING_EXP_ERR(2, printprocessor, 2, printprocessor, "xx2-2 printprocessor", WERR_UNKNOWN_PRINTPROCESSOR);
1268         TEST_PRINTERINFO_STRING(2, datatype,    2, datatype,    "xx2-2 datatype");
1269         TEST_PRINTERINFO_STRING(2, parameters,  2, parameters,  "xx2-2 parameters");
1270
1271         for (i=0; i < ARRAY_SIZE(attribute_list); i++) {
1272 /*              TEST_PRINTERINFO_INT_EXP(2, attributes, 1, flags,
1273                         attribute_list[i],
1274                         (attribute_list[i] | default_attribute)
1275                         ); */
1276                 TEST_PRINTERINFO_INT_EXP(2, attributes, 2, attributes,
1277                         attribute_list[i],
1278                         (attribute_list[i] | default_attribute)
1279                         );
1280                 TEST_PRINTERINFO_INT_EXP(2, attributes, 4, attributes,
1281                         attribute_list[i],
1282                         (attribute_list[i] | default_attribute)
1283                         );
1284                 TEST_PRINTERINFO_INT_EXP(2, attributes, 5, attributes,
1285                         attribute_list[i],
1286                         (attribute_list[i] | default_attribute)
1287                         );
1288 /*              TEST_PRINTERINFO_INT_EXP(4, attributes, 1, flags,
1289                         attribute_list[i],
1290                         (attribute_list[i] | default_attribute)
1291                         ); */
1292                 TEST_PRINTERINFO_INT_EXP(4, attributes, 2, attributes,
1293                         attribute_list[i],
1294                         (attribute_list[i] | default_attribute)
1295                         );
1296                 TEST_PRINTERINFO_INT_EXP(4, attributes, 4, attributes,
1297                         attribute_list[i],
1298                         (attribute_list[i] | default_attribute)
1299                         );
1300                 TEST_PRINTERINFO_INT_EXP(4, attributes, 5, attributes,
1301                         attribute_list[i],
1302                         (attribute_list[i] | default_attribute)
1303                         );
1304 /*              TEST_PRINTERINFO_INT_EXP(5, attributes, 1, flags,
1305                         attribute_list[i],
1306                         (attribute_list[i] | default_attribute)
1307                         ); */
1308                 TEST_PRINTERINFO_INT_EXP(5, attributes, 2, attributes,
1309                         attribute_list[i],
1310                         (attribute_list[i] | default_attribute)
1311                         );
1312                 TEST_PRINTERINFO_INT_EXP(5, attributes, 4, attributes,
1313                         attribute_list[i],
1314                         (attribute_list[i] | default_attribute)
1315                         );
1316                 TEST_PRINTERINFO_INT_EXP(5, attributes, 5, attributes,
1317                         attribute_list[i],
1318                         (attribute_list[i] | default_attribute)
1319                         );
1320         }
1321
1322         for (i=0; i < ARRAY_SIZE(status_list); i++) {
1323                 /* level 2 sets do not stick
1324                 TEST_PRINTERINFO_INT(2, status, 0, status, status_list[i]);
1325                 TEST_PRINTERINFO_INT(2, status, 2, status, status_list[i]);
1326                 TEST_PRINTERINFO_INT(2, status, 6, status, status_list[i]); */
1327                 TEST_PRINTERINFO_INT(6, status, 0, status, status_list[i]);
1328                 TEST_PRINTERINFO_INT(6, status, 2, status, status_list[i]);
1329                 TEST_PRINTERINFO_INT(6, status, 6, status, status_list[i]);
1330         }
1331
1332         /* priorities need to be between 0 and 99
1333            passing an invalid priority will result in WERR_INVALID_PRIORITY */
1334         TEST_PRINTERINFO_INT(2, priority,       2, priority, 0);
1335         TEST_PRINTERINFO_INT(2, priority,       2, priority, 1);
1336         TEST_PRINTERINFO_INT(2, priority,       2, priority, 99);
1337         /* TEST_PRINTERINFO_INT(2, priority,    2, priority, 100); */
1338         TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 0);
1339         TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 1);
1340         TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 99);
1341         /* TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 100); */
1342
1343         TEST_PRINTERINFO_INT(2, starttime,      2, starttime, __LINE__);
1344         TEST_PRINTERINFO_INT(2, untiltime,      2, untiltime, __LINE__);
1345
1346         /* does not stick
1347         TEST_PRINTERINFO_INT(2, cjobs,          2, cjobs, __LINE__);
1348         TEST_PRINTERINFO_INT(2, averageppm,     2, averageppm, __LINE__); */
1349
1350         /* does not stick
1351         TEST_PRINTERINFO_INT(5, device_not_selected_timeout, 5, device_not_selected_timeout, __LINE__);
1352         TEST_PRINTERINFO_INT(5, transmission_retry_timeout, 5, transmission_retry_timeout, __LINE__); */
1353
1354         /* FIXME: gd also test devmode and secdesc behavior */
1355
1356         {
1357                 /* verify composition of level 1 description field */
1358                 const char *description;
1359                 const char *tmp;
1360
1361                 q0.in.level = 1;
1362                 do { TESTGETCALL(GetPrinter, q0) } while (0);
1363
1364                 description = talloc_strdup(tctx, q0.out.info->info1.description);
1365
1366                 q0.in.level = 2;
1367                 do { TESTGETCALL(GetPrinter, q0) } while (0);
1368
1369                 tmp = talloc_asprintf(tctx, "%s,%s,%s",
1370                         q0.out.info->info2.printername,
1371                         q0.out.info->info2.drivername,
1372                         q0.out.info->info2.location);
1373
1374                 do { STRING_EQUAL(description, tmp, "description")} while (0);
1375         }
1376
1377         return ret;
1378 }
1379
1380
1381 static bool test_ClosePrinter(struct torture_context *tctx,
1382                               struct dcerpc_pipe *p,
1383                               struct policy_handle *handle)
1384 {
1385         NTSTATUS status;
1386         struct spoolss_ClosePrinter r;
1387
1388         r.in.handle = handle;
1389         r.out.handle = handle;
1390
1391         torture_comment(tctx, "Testing ClosePrinter\n");
1392
1393         status = dcerpc_spoolss_ClosePrinter(p, tctx, &r);
1394         torture_assert_ntstatus_ok(tctx, status, "ClosePrinter failed");
1395
1396         return true;
1397 }
1398
1399 static bool test_GetForm(struct torture_context *tctx,
1400                          struct dcerpc_pipe *p,
1401                          struct policy_handle *handle,
1402                          const char *form_name,
1403                          uint32_t level)
1404 {
1405         NTSTATUS status;
1406         struct spoolss_GetForm r;
1407         uint32_t needed;
1408
1409         r.in.handle = handle;
1410         r.in.form_name = form_name;
1411         r.in.level = level;
1412         r.in.buffer = NULL;
1413         r.in.offered = 0;
1414         r.out.needed = &needed;
1415
1416         torture_comment(tctx, "Testing GetForm level %d\n", r.in.level);
1417
1418         status = dcerpc_spoolss_GetForm(p, tctx, &r);
1419         torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
1420
1421         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
1422                 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
1423                 data_blob_clear(&blob);
1424                 r.in.buffer = &blob;
1425                 r.in.offered = needed;
1426                 status = dcerpc_spoolss_GetForm(p, tctx, &r);
1427                 torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
1428
1429                 torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
1430
1431                 torture_assert(tctx, r.out.info, "No form info returned");
1432         }
1433
1434         torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
1435
1436         return true;
1437 }
1438
1439 static bool test_EnumForms(struct torture_context *tctx,
1440                            struct dcerpc_pipe *p,
1441                            struct policy_handle *handle, bool print_server)
1442 {
1443         NTSTATUS status;
1444         struct spoolss_EnumForms r;
1445         bool ret = true;
1446         uint32_t needed;
1447         uint32_t count;
1448         uint32_t levels[] = { 1, 2 };
1449         int i;
1450
1451         for (i=0; i<ARRAY_SIZE(levels); i++) {
1452
1453                 union spoolss_FormInfo *info;
1454
1455                 r.in.handle = handle;
1456                 r.in.level = levels[i];
1457                 r.in.buffer = NULL;
1458                 r.in.offered = 0;
1459                 r.out.needed = &needed;
1460                 r.out.count = &count;
1461                 r.out.info = &info;
1462
1463                 torture_comment(tctx, "Testing EnumForms level %d\n", levels[i]);
1464
1465                 status = dcerpc_spoolss_EnumForms(p, tctx, &r);
1466                 torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
1467
1468                 if ((r.in.level == 2) && (W_ERROR_EQUAL(r.out.result, WERR_UNKNOWN_LEVEL))) {
1469                         break;
1470                 }
1471
1472                 if (print_server && W_ERROR_EQUAL(r.out.result, WERR_BADFID))
1473                         torture_fail(tctx, "EnumForms on the PrintServer isn't supported by test server (NT4)");
1474
1475                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
1476                         int j;
1477                         DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
1478                         data_blob_clear(&blob);
1479                         r.in.buffer = &blob;
1480                         r.in.offered = needed;
1481
1482                         status = dcerpc_spoolss_EnumForms(p, tctx, &r);
1483
1484                         torture_assert(tctx, info, "No forms returned");
1485
1486                         for (j = 0; j < count; j++) {
1487                                 if (!print_server)
1488                                         ret &= test_GetForm(tctx, p, handle, info[j].info1.form_name, levels[i]);
1489                         }
1490                 }
1491
1492                 torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
1493
1494                 torture_assert_werr_ok(tctx, r.out.result, "EnumForms failed");
1495         }
1496
1497         return true;
1498 }
1499
1500 static bool test_DeleteForm(struct torture_context *tctx,
1501                             struct dcerpc_pipe *p,
1502                             struct policy_handle *handle,
1503                             const char *form_name)
1504 {
1505         NTSTATUS status;
1506         struct spoolss_DeleteForm r;
1507
1508         r.in.handle = handle;
1509         r.in.form_name = form_name;
1510
1511         status = dcerpc_spoolss_DeleteForm(p, tctx, &r);
1512
1513         torture_assert_ntstatus_ok(tctx, status, "DeleteForm failed");
1514
1515         torture_assert_werr_ok(tctx, r.out.result, "DeleteForm failed");
1516
1517         return true;
1518 }
1519
1520 static bool test_AddForm(struct torture_context *tctx,
1521                          struct dcerpc_pipe *p,
1522                          struct policy_handle *handle, bool print_server)
1523 {
1524         struct spoolss_AddForm r;
1525         struct spoolss_AddFormInfo1 addform;
1526         const char *form_name = "testform3";
1527         NTSTATUS status;
1528         bool ret = true;
1529
1530         r.in.handle     = handle;
1531         r.in.level      = 1;
1532         r.in.info.info1 = &addform;
1533         addform.flags           = SPOOLSS_FORM_USER;
1534         addform.form_name       = form_name;
1535         addform.size.width      = 50;
1536         addform.size.height     = 25;
1537         addform.area.left       = 5;
1538         addform.area.top        = 10;
1539         addform.area.right      = 45;
1540         addform.area.bottom     = 15;
1541
1542         status = dcerpc_spoolss_AddForm(p, tctx, &r);
1543
1544         torture_assert_ntstatus_ok(tctx, status, "AddForm failed");
1545
1546         torture_assert_werr_ok(tctx, r.out.result, "AddForm failed");
1547
1548         if (!print_server) ret &= test_GetForm(tctx, p, handle, form_name, 1);
1549
1550         {
1551                 struct spoolss_SetForm sf;
1552                 struct spoolss_AddFormInfo1 setform;
1553
1554                 sf.in.handle    = handle;
1555                 sf.in.form_name = form_name;
1556                 sf.in.level     = 1;
1557                 sf.in.info.info1= &setform;
1558                 setform.flags           = addform.flags;
1559                 setform.form_name       = addform.form_name;
1560                 setform.size            = addform.size;
1561                 setform.area            = addform.area;
1562
1563                 setform.size.width      = 1234;
1564
1565                 status = dcerpc_spoolss_SetForm(p, tctx, &sf);
1566
1567                 torture_assert_ntstatus_ok(tctx, status, "SetForm failed");
1568
1569                 torture_assert_werr_ok(tctx, r.out.result, "SetForm failed");
1570         }
1571
1572         if (!print_server) ret &= test_GetForm(tctx, p, handle, form_name, 1);
1573
1574         {
1575                 struct spoolss_EnumForms e;
1576                 union spoolss_FormInfo *info;
1577                 uint32_t needed;
1578                 uint32_t count;
1579                 bool found = false;
1580
1581                 e.in.handle = handle;
1582                 e.in.level = 1;
1583                 e.in.buffer = NULL;
1584                 e.in.offered = 0;
1585                 e.out.needed = &needed;
1586                 e.out.count = &count;
1587                 e.out.info = &info;
1588
1589                 torture_comment(tctx, "Testing EnumForms level 1\n");
1590
1591                 status = dcerpc_spoolss_EnumForms(p, tctx, &e);
1592                 torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
1593
1594                 if (print_server && W_ERROR_EQUAL(e.out.result, WERR_BADFID))
1595                         torture_fail(tctx, "EnumForms on the PrintServer isn't supported by test server (NT4)");
1596
1597                 if (W_ERROR_EQUAL(e.out.result, WERR_INSUFFICIENT_BUFFER)) {
1598                         int j;
1599                         DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
1600                         data_blob_clear(&blob);
1601                         e.in.buffer = &blob;
1602                         e.in.offered = needed;
1603
1604                         status = dcerpc_spoolss_EnumForms(p, tctx, &e);
1605
1606                         torture_assert(tctx, info, "No forms returned");
1607
1608                         for (j = 0; j < count; j++) {
1609                                 if (strequal(form_name, info[j].info1.form_name)) {
1610                                         found = true;
1611                                         break;
1612                                 }
1613                         }
1614                 }
1615                 torture_assert(tctx, found, "Newly added form not found in enum call");
1616         }
1617
1618         if (!test_DeleteForm(tctx, p, handle, form_name)) {
1619                 ret = false;
1620         }
1621
1622         return ret;
1623 }
1624
1625 static bool test_EnumPorts_old(struct torture_context *tctx,
1626                                struct dcerpc_pipe *p)
1627 {
1628         NTSTATUS status;
1629         struct spoolss_EnumPorts r;
1630         uint32_t needed;
1631         uint32_t count;
1632         union spoolss_PortInfo *info;
1633
1634         r.in.servername = talloc_asprintf(tctx, "\\\\%s",
1635                                           dcerpc_server_name(p));
1636         r.in.level = 2;
1637         r.in.buffer = NULL;
1638         r.in.offered = 0;
1639         r.out.needed = &needed;
1640         r.out.count = &count;
1641         r.out.info = &info;
1642
1643         torture_comment(tctx, "Testing EnumPorts\n");
1644
1645         status = dcerpc_spoolss_EnumPorts(p, tctx, &r);
1646
1647         torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
1648
1649         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
1650                 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
1651                 data_blob_clear(&blob);
1652                 r.in.buffer = &blob;
1653                 r.in.offered = needed;
1654
1655                 status = dcerpc_spoolss_EnumPorts(p, tctx, &r);
1656                 torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
1657
1658                 torture_assert(tctx, info, "No ports returned");
1659         }
1660
1661         return true;
1662 }
1663
1664 static bool test_AddPort(struct torture_context *tctx,
1665                          struct dcerpc_pipe *p)
1666 {
1667         NTSTATUS status;
1668         struct spoolss_AddPort r;
1669
1670         r.in.server_name = talloc_asprintf(tctx, "\\\\%s",
1671                                            dcerpc_server_name(p));
1672         r.in.unknown = 0;
1673         r.in.monitor_name = "foo";
1674
1675         torture_comment(tctx, "Testing AddPort\n");
1676
1677         status = dcerpc_spoolss_AddPort(p, tctx, &r);
1678
1679         torture_assert_ntstatus_ok(tctx, status, "AddPort failed");
1680
1681         /* win2k3 returns WERR_NOT_SUPPORTED */
1682
1683 #if 0
1684
1685         if (!W_ERROR_IS_OK(r.out.result)) {
1686                 printf("AddPort failed - %s\n", win_errstr(r.out.result));
1687                 return false;
1688         }
1689
1690 #endif
1691
1692         return true;
1693 }
1694
1695 static bool test_GetJob(struct torture_context *tctx,
1696                         struct dcerpc_pipe *p,
1697                         struct policy_handle *handle, uint32_t job_id)
1698 {
1699         NTSTATUS status;
1700         struct spoolss_GetJob r;
1701         union spoolss_JobInfo info;
1702         uint32_t needed;
1703         uint32_t levels[] = {1, 2 /* 3, 4 */};
1704         uint32_t i;
1705
1706         r.in.handle = handle;
1707         r.in.job_id = job_id;
1708         r.in.level = 0;
1709         r.in.buffer = NULL;
1710         r.in.offered = 0;
1711         r.out.needed = &needed;
1712         r.out.info = &info;
1713
1714         torture_comment(tctx, "Testing GetJob level %d\n", r.in.level);
1715
1716         status = dcerpc_spoolss_GetJob(p, tctx, &r);
1717         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "Unexpected return code");
1718
1719         for (i = 0; i < ARRAY_SIZE(levels); i++) {
1720
1721                 torture_comment(tctx, "Testing GetJob level %d\n", r.in.level);
1722
1723                 needed = 0;
1724
1725                 r.in.level = levels[i];
1726                 r.in.offered = 0;
1727                 r.in.buffer = NULL;
1728
1729                 status = dcerpc_spoolss_GetJob(p, tctx, &r);
1730                 torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
1731
1732                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
1733                         DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
1734                         data_blob_clear(&blob);
1735                         r.in.buffer = &blob;
1736                         r.in.offered = needed;
1737
1738                         status = dcerpc_spoolss_GetJob(p, tctx, &r);
1739                         torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
1740
1741                 }
1742                 torture_assert(tctx, r.out.info, "No job info returned");
1743                 torture_assert_werr_ok(tctx, r.out.result, "GetJob failed");
1744         }
1745
1746         return true;
1747 }
1748
1749 static bool test_SetJob(struct torture_context *tctx,
1750                         struct dcerpc_pipe *p,
1751                         struct policy_handle *handle, uint32_t job_id,
1752                         enum spoolss_JobControl command)
1753 {
1754         NTSTATUS status;
1755         struct spoolss_SetJob r;
1756
1757         r.in.handle     = handle;
1758         r.in.job_id     = job_id;
1759         r.in.ctr        = NULL;
1760         r.in.command    = command;
1761
1762         switch (command) {
1763         case SPOOLSS_JOB_CONTROL_PAUSE:
1764                 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_PAUSE\n");
1765                 break;
1766         case SPOOLSS_JOB_CONTROL_RESUME:
1767                 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RESUME\n");
1768                 break;
1769         case SPOOLSS_JOB_CONTROL_CANCEL:
1770                 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_CANCEL\n");
1771                 break;
1772         case SPOOLSS_JOB_CONTROL_RESTART:
1773                 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RESTART\n");
1774                 break;
1775         case SPOOLSS_JOB_CONTROL_DELETE:
1776                 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_DELETE\n");
1777                 break;
1778         case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER:
1779                 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER\n");
1780                 break;
1781         case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED:
1782                 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED\n");
1783                 break;
1784         case SPOOLSS_JOB_CONTROL_RETAIN:
1785                 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RETAIN\n");
1786                 break;
1787         case SPOOLSS_JOB_CONTROL_RELEASE:
1788                 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RELEASE\n");
1789                 break;
1790         default:
1791                 torture_comment(tctx, "Testing SetJob\n");
1792                 break;
1793         }
1794
1795         status = dcerpc_spoolss_SetJob(p, tctx, &r);
1796         torture_assert_ntstatus_ok(tctx, status, "SetJob failed");
1797         torture_assert_werr_ok(tctx, r.out.result, "SetJob failed");
1798
1799         return true;
1800 }
1801
1802 static bool test_AddJob(struct torture_context *tctx,
1803                         struct dcerpc_pipe *p,
1804                         struct policy_handle *handle)
1805 {
1806         NTSTATUS status;
1807         struct spoolss_AddJob r;
1808         uint32_t needed;
1809
1810         r.in.level = 0;
1811         r.in.handle = handle;
1812         r.in.offered = 0;
1813         r.out.needed = &needed;
1814         r.in.buffer = r.out.buffer = NULL;
1815
1816         torture_comment(tctx, "Testing AddJob\n");
1817
1818         status = dcerpc_spoolss_AddJob(p, tctx, &r);
1819         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "AddJob failed");
1820
1821         r.in.level = 1;
1822
1823         status = dcerpc_spoolss_AddJob(p, tctx, &r);
1824         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM, "AddJob failed");
1825
1826         return true;
1827 }
1828
1829
1830 static bool test_EnumJobs(struct torture_context *tctx,
1831                           struct dcerpc_pipe *p,
1832                           struct policy_handle *handle)
1833 {
1834         NTSTATUS status;
1835         struct spoolss_EnumJobs r;
1836         uint32_t needed;
1837         uint32_t count;
1838         union spoolss_JobInfo *info;
1839
1840         r.in.handle = handle;
1841         r.in.firstjob = 0;
1842         r.in.numjobs = 0xffffffff;
1843         r.in.level = 1;
1844         r.in.buffer = NULL;
1845         r.in.offered = 0;
1846         r.out.needed = &needed;
1847         r.out.count = &count;
1848         r.out.info = &info;
1849
1850         torture_comment(tctx, "Testing EnumJobs\n");
1851
1852         status = dcerpc_spoolss_EnumJobs(p, tctx, &r);
1853
1854         torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
1855
1856         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
1857                 int j;
1858                 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
1859                 data_blob_clear(&blob);
1860                 r.in.buffer = &blob;
1861                 r.in.offered = needed;
1862
1863                 status = dcerpc_spoolss_EnumJobs(p, tctx, &r);
1864
1865                 torture_assert(tctx, info, "No jobs returned");
1866
1867                 for (j = 0; j < count; j++) {
1868
1869                         test_GetJob(tctx, p, handle, info[j].info1.job_id);
1870
1871                         /* FIXME - gd */
1872                         if (!torture_setting_bool(tctx, "samba3", false)) {
1873                                 test_SetJob(tctx, p, handle, info[j].info1.job_id, SPOOLSS_JOB_CONTROL_PAUSE);
1874                                 test_SetJob(tctx, p, handle, info[j].info1.job_id, SPOOLSS_JOB_CONTROL_RESUME);
1875                         }
1876                 }
1877
1878         } else {
1879                 torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
1880         }
1881
1882         return true;
1883 }
1884
1885 static bool test_DoPrintTest(struct torture_context *tctx,
1886                              struct dcerpc_pipe *p,
1887                              struct policy_handle *handle)
1888 {
1889         bool ret = true;
1890         NTSTATUS status;
1891         struct spoolss_StartDocPrinter s;
1892         struct spoolss_DocumentInfo1 info1;
1893         struct spoolss_StartPagePrinter sp;
1894         struct spoolss_WritePrinter w;
1895         struct spoolss_EndPagePrinter ep;
1896         struct spoolss_EndDocPrinter e;
1897         int i;
1898         uint32_t job_id;
1899         uint32_t num_written;
1900
1901         torture_comment(tctx, "Testing StartDocPrinter\n");
1902
1903         s.in.handle             = handle;
1904         s.in.level              = 1;
1905         s.in.info.info1         = &info1;
1906         s.out.job_id            = &job_id;
1907         info1.document_name     = "TorturePrintJob";
1908         info1.output_file       = NULL;
1909         info1.datatype          = "RAW";
1910
1911         status = dcerpc_spoolss_StartDocPrinter(p, tctx, &s);
1912         torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_StartDocPrinter failed");
1913         torture_assert_werr_ok(tctx, s.out.result, "StartDocPrinter failed");
1914
1915         for (i=1; i < 4; i++) {
1916                 torture_comment(tctx, "Testing StartPagePrinter: Page[%d]\n", i);
1917
1918                 sp.in.handle            = handle;
1919
1920                 status = dcerpc_spoolss_StartPagePrinter(p, tctx, &sp);
1921                 torture_assert_ntstatus_ok(tctx, status,
1922                                            "dcerpc_spoolss_StartPagePrinter failed");
1923                 torture_assert_werr_ok(tctx, sp.out.result, "StartPagePrinter failed");
1924
1925                 torture_comment(tctx, "Testing WritePrinter: Page[%d]\n", i);
1926
1927                 w.in.handle             = handle;
1928                 w.in.data               = data_blob_string_const(talloc_asprintf(tctx,"TortureTestPage: %d\nData\n",i));
1929                 w.out.num_written       = &num_written;
1930
1931                 status = dcerpc_spoolss_WritePrinter(p, tctx, &w);
1932                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_WritePrinter failed");
1933                 torture_assert_werr_ok(tctx, w.out.result, "WritePrinter failed");
1934
1935                 torture_comment(tctx, "Testing EndPagePrinter: Page[%d]\n", i);
1936
1937                 ep.in.handle            = handle;
1938
1939                 status = dcerpc_spoolss_EndPagePrinter(p, tctx, &ep);
1940                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndPagePrinter failed");
1941                 torture_assert_werr_ok(tctx, ep.out.result, "EndPagePrinter failed");
1942         }
1943
1944         torture_comment(tctx, "Testing EndDocPrinter\n");
1945
1946         e.in.handle = handle;
1947
1948         status = dcerpc_spoolss_EndDocPrinter(p, tctx, &e);
1949         torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndDocPrinter failed");
1950         torture_assert_werr_ok(tctx, e.out.result, "EndDocPrinter failed");
1951
1952         ret &= test_AddJob(tctx, p, handle);
1953         ret &= test_EnumJobs(tctx, p, handle);
1954
1955         ret &= test_SetJob(tctx, p, handle, job_id, SPOOLSS_JOB_CONTROL_DELETE);
1956
1957         return ret;
1958 }
1959
1960 static bool test_PausePrinter(struct torture_context *tctx,
1961                               struct dcerpc_pipe *p,
1962                               struct policy_handle *handle)
1963 {
1964         NTSTATUS status;
1965         struct spoolss_SetPrinter r;
1966         struct spoolss_SetPrinterInfoCtr info_ctr;
1967         struct spoolss_DevmodeContainer devmode_ctr;
1968         struct sec_desc_buf secdesc_ctr;
1969
1970         info_ctr.level = 0;
1971         info_ctr.info.info0 = NULL;
1972
1973         ZERO_STRUCT(devmode_ctr);
1974         ZERO_STRUCT(secdesc_ctr);
1975
1976         r.in.handle             = handle;
1977         r.in.info_ctr           = &info_ctr;
1978         r.in.devmode_ctr        = &devmode_ctr;
1979         r.in.secdesc_ctr        = &secdesc_ctr;
1980         r.in.command            = SPOOLSS_PRINTER_CONTROL_PAUSE;
1981
1982         torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_PAUSE\n");
1983
1984         status = dcerpc_spoolss_SetPrinter(p, tctx, &r);
1985
1986         torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
1987
1988         torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
1989
1990         return true;
1991 }
1992
1993 static bool test_ResumePrinter(struct torture_context *tctx,
1994                                struct dcerpc_pipe *p,
1995                                struct policy_handle *handle)
1996 {
1997         NTSTATUS status;
1998         struct spoolss_SetPrinter r;
1999         struct spoolss_SetPrinterInfoCtr info_ctr;
2000         struct spoolss_DevmodeContainer devmode_ctr;
2001         struct sec_desc_buf secdesc_ctr;
2002
2003         info_ctr.level = 0;
2004         info_ctr.info.info0 = NULL;
2005
2006         ZERO_STRUCT(devmode_ctr);
2007         ZERO_STRUCT(secdesc_ctr);
2008
2009         r.in.handle             = handle;
2010         r.in.info_ctr           = &info_ctr;
2011         r.in.devmode_ctr        = &devmode_ctr;
2012         r.in.secdesc_ctr        = &secdesc_ctr;
2013         r.in.command            = SPOOLSS_PRINTER_CONTROL_RESUME;
2014
2015         torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_RESUME\n");
2016
2017         status = dcerpc_spoolss_SetPrinter(p, tctx, &r);
2018
2019         torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
2020
2021         torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
2022
2023         return true;
2024 }
2025
2026 static bool test_GetPrinterData(struct torture_context *tctx,
2027                                 struct dcerpc_pipe *p,
2028                                 struct policy_handle *handle,
2029                                 const char *value_name)
2030 {
2031         NTSTATUS status;
2032         struct spoolss_GetPrinterData r;
2033         uint32_t needed;
2034         enum winreg_Type type;
2035         union spoolss_PrinterData data;
2036
2037         r.in.handle = handle;
2038         r.in.value_name = value_name;
2039         r.in.offered = 0;
2040         r.out.needed = &needed;
2041         r.out.type = &type;
2042         r.out.data = &data;
2043
2044         torture_comment(tctx, "Testing GetPrinterData\n");
2045
2046         status = dcerpc_spoolss_GetPrinterData(p, tctx, &r);
2047         torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
2048
2049         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
2050                 r.in.offered = needed;
2051
2052                 status = dcerpc_spoolss_GetPrinterData(p, tctx, &r);
2053                 torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
2054
2055                 torture_assert_werr_ok(tctx, r.out.result, "GetPrinterData failed");
2056         }
2057
2058         return true;
2059 }
2060
2061 static bool test_GetPrinterDataEx(struct torture_context *tctx,
2062                                   struct dcerpc_pipe *p,
2063                                   struct policy_handle *handle,
2064                                   const char *key_name,
2065                                   const char *value_name)
2066 {
2067         NTSTATUS status;
2068         struct spoolss_GetPrinterDataEx r;
2069         enum winreg_Type type;
2070         uint32_t needed;
2071
2072         r.in.handle = handle;
2073         r.in.key_name = key_name;
2074         r.in.value_name = value_name;
2075         r.in.offered = 0;
2076         r.out.type = &type;
2077         r.out.needed = &needed;
2078         r.out.buffer = NULL;
2079
2080         torture_comment(tctx, "Testing GetPrinterDataEx\n");
2081
2082         status = dcerpc_spoolss_GetPrinterDataEx(p, tctx, &r);
2083         if (!NT_STATUS_IS_OK(status)) {
2084                 if (NT_STATUS_EQUAL(status,NT_STATUS_NET_WRITE_FAULT) &&
2085                     p->last_fault_code == DCERPC_FAULT_OP_RNG_ERROR) {
2086                         torture_skip(tctx, "GetPrinterDataEx not supported by server\n");
2087                 }
2088                 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
2089         }
2090
2091         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
2092                 r.in.offered = needed;
2093                 r.out.buffer = talloc_array(tctx, uint8_t, needed);
2094
2095                 status = dcerpc_spoolss_GetPrinterDataEx(p, tctx, &r);
2096                 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
2097
2098                 torture_assert_werr_ok(tctx, r.out.result,  "GetPrinterDataEx failed");
2099         }
2100
2101         return true;
2102 }
2103
2104 static bool test_EnumPrinterData(struct torture_context *tctx, struct dcerpc_pipe *p,
2105                                  struct policy_handle *handle)
2106 {
2107         NTSTATUS status;
2108         struct spoolss_EnumPrinterData r;
2109
2110         ZERO_STRUCT(r);
2111         r.in.handle = handle;
2112         r.in.enum_index = 0;
2113
2114         do {
2115                 uint32_t value_size = 0;
2116                 uint32_t data_size = 0;
2117                 enum winreg_Type type = 0;
2118
2119                 r.in.value_offered = value_size;
2120                 r.out.value_needed = &value_size;
2121                 r.in.data_offered = data_size;
2122                 r.out.data_needed = &data_size;
2123
2124                 r.out.type = &type;
2125                 r.out.data = talloc_zero_array(tctx, uint8_t, 0);
2126
2127                 torture_comment(tctx, "Testing EnumPrinterData\n");
2128
2129                 status = dcerpc_spoolss_EnumPrinterData(p, tctx, &r);
2130
2131                 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterData failed");
2132
2133                 r.in.value_offered = value_size;
2134                 r.out.value_name = talloc_zero_array(tctx, const char, value_size);
2135                 r.in.data_offered = data_size;
2136                 r.out.data = talloc_zero_array(tctx, uint8_t, data_size);
2137
2138                 status = dcerpc_spoolss_EnumPrinterData(p, tctx, &r);
2139
2140                 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterData failed");
2141
2142                 torture_assert(tctx, test_GetPrinterData(tctx, p, handle, r.out.value_name),
2143                         talloc_asprintf(tctx, "failed to call GetPrinterData for %s\n", r.out.value_name));
2144
2145                 torture_assert(tctx, test_GetPrinterDataEx(tctx, p, handle, "PrinterDriverData", r.out.value_name),
2146                         talloc_asprintf(tctx, "failed to call GetPrinterDataEx on PrinterDriverData for %s\n", r.out.value_name));
2147
2148                 r.in.enum_index++;
2149
2150         } while (W_ERROR_IS_OK(r.out.result));
2151
2152         return true;
2153 }
2154
2155 static bool test_EnumPrinterDataEx(struct torture_context *tctx,
2156                                    struct dcerpc_pipe *p,
2157                                    struct policy_handle *handle)
2158 {
2159         NTSTATUS status;
2160         struct spoolss_EnumPrinterDataEx r;
2161         struct spoolss_PrinterEnumValues *info;
2162         uint32_t needed;
2163         uint32_t count;
2164
2165         r.in.handle = handle;
2166         r.in.key_name = "PrinterDriverData";
2167         r.in.offered = 0;
2168         r.out.needed = &needed;
2169         r.out.count = &count;
2170         r.out.info = &info;
2171
2172         torture_comment(tctx, "Testing EnumPrinterDataEx\n");
2173
2174         status = dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &r);
2175         torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDataEx failed");
2176
2177         r.in.offered = needed;
2178
2179         status = dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &r);
2180
2181         torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDataEx failed");
2182
2183         return true;
2184 }
2185
2186
2187 static bool test_DeletePrinterData(struct torture_context *tctx,
2188                                    struct dcerpc_pipe *p,
2189                                    struct policy_handle *handle,
2190                                    const char *value_name)
2191 {
2192         NTSTATUS status;
2193         struct spoolss_DeletePrinterData r;
2194
2195         r.in.handle = handle;
2196         r.in.value_name = value_name;
2197
2198         torture_comment(tctx, "Testing DeletePrinterData\n");
2199
2200         status = dcerpc_spoolss_DeletePrinterData(p, tctx, &r);
2201
2202         torture_assert_ntstatus_ok(tctx, status, "DeletePrinterData failed");
2203
2204         return true;
2205 }
2206
2207 static bool test_SetPrinterData(struct torture_context *tctx,
2208                                 struct dcerpc_pipe *p,
2209                                 struct policy_handle *handle)
2210 {
2211         NTSTATUS status;
2212         struct spoolss_SetPrinterData r;
2213         const char *value_name = "spottyfoot";
2214
2215         r.in.handle = handle;
2216         r.in.value_name = value_name;
2217         r.in.type = REG_SZ;
2218         r.in.data.string = "dog";
2219
2220         torture_comment(tctx, "Testing SetPrinterData\n");
2221
2222         status = dcerpc_spoolss_SetPrinterData(p, tctx, &r);
2223
2224         torture_assert_ntstatus_ok(tctx, status, "SetPrinterData failed");
2225
2226         if (!test_GetPrinterData(tctx, p, handle, value_name)) {
2227                 return false;
2228         }
2229
2230         if (!test_DeletePrinterData(tctx, p, handle, value_name)) {
2231                 return false;
2232         }
2233
2234         return true;
2235 }
2236
2237 static bool test_SecondaryClosePrinter(struct torture_context *tctx,
2238                                        struct dcerpc_pipe *p,
2239                                        struct policy_handle *handle)
2240 {
2241         NTSTATUS status;
2242         struct dcerpc_binding *b;
2243         struct dcerpc_pipe *p2;
2244         struct spoolss_ClosePrinter cp;
2245
2246         /* only makes sense on SMB */
2247         if (p->conn->transport.transport != NCACN_NP) {
2248                 return true;
2249         }
2250
2251         torture_comment(tctx, "testing close on secondary pipe\n");
2252
2253         status = dcerpc_parse_binding(tctx, p->conn->binding_string, &b);
2254         torture_assert_ntstatus_ok(tctx, status, "Failed to parse dcerpc binding");
2255
2256         status = dcerpc_secondary_connection(p, &p2, b);
2257         torture_assert_ntstatus_ok(tctx, status, "Failed to create secondary connection");
2258
2259         status = dcerpc_bind_auth_none(p2, &ndr_table_spoolss);
2260         torture_assert_ntstatus_ok(tctx, status, "Failed to create bind on secondary connection");
2261
2262         cp.in.handle = handle;
2263         cp.out.handle = handle;
2264
2265         status = dcerpc_spoolss_ClosePrinter(p2, tctx, &cp);
2266         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_NET_WRITE_FAULT,
2267                         "ERROR: Allowed close on secondary connection");
2268
2269         torture_assert_int_equal(tctx, p2->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
2270                                  "Unexpected fault code");
2271
2272         talloc_free(p2);
2273
2274         return true;
2275 }
2276
2277 static bool test_OpenPrinter_badname(struct torture_context *tctx,
2278                                      struct dcerpc_pipe *p, const char *name)
2279 {
2280         NTSTATUS status;
2281         struct spoolss_OpenPrinter op;
2282         struct spoolss_OpenPrinterEx opEx;
2283         struct policy_handle handle;
2284         bool ret = true;
2285
2286         op.in.printername       = name;
2287         op.in.datatype          = NULL;
2288         op.in.devmode_ctr.devmode= NULL;
2289         op.in.access_mask       = 0;
2290         op.out.handle           = &handle;
2291
2292         torture_comment(tctx, "\nTesting OpenPrinter(%s) with bad name\n", op.in.printername);
2293
2294         status = dcerpc_spoolss_OpenPrinter(p, tctx, &op);
2295         torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
2296         if (!W_ERROR_EQUAL(WERR_INVALID_PRINTER_NAME,op.out.result)) {
2297                 torture_comment(tctx, "OpenPrinter(%s) unexpected result[%s] should be WERR_INVALID_PRINTER_NAME\n",
2298                         name, win_errstr(op.out.result));
2299         }
2300
2301         if (W_ERROR_IS_OK(op.out.result)) {
2302                 ret &=test_ClosePrinter(tctx, p, &handle);
2303         }
2304
2305         opEx.in.printername             = name;
2306         opEx.in.datatype                = NULL;
2307         opEx.in.devmode_ctr.devmode     = NULL;
2308         opEx.in.access_mask             = 0;
2309         opEx.in.level                   = 1;
2310         opEx.in.userlevel.level1        = NULL;
2311         opEx.out.handle                 = &handle;
2312
2313         torture_comment(tctx, "Testing OpenPrinterEx(%s) with bad name\n", opEx.in.printername);
2314
2315         status = dcerpc_spoolss_OpenPrinterEx(p, tctx, &opEx);
2316         torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
2317         if (!W_ERROR_EQUAL(WERR_INVALID_PARAM,opEx.out.result)) {
2318                 torture_comment(tctx, "OpenPrinterEx(%s) unexpected result[%s] should be WERR_INVALID_PARAM\n",
2319                         name, win_errstr(opEx.out.result));
2320         }
2321
2322         if (W_ERROR_IS_OK(opEx.out.result)) {
2323                 ret &=test_ClosePrinter(tctx, p, &handle);
2324         }
2325
2326         return ret;
2327 }
2328
2329 static bool test_OpenPrinter(struct torture_context *tctx,
2330                              struct dcerpc_pipe *p,
2331                              const char *name)
2332 {
2333         NTSTATUS status;
2334         struct spoolss_OpenPrinter r;
2335         struct policy_handle handle;
2336         bool ret = true;
2337
2338         r.in.printername        = talloc_asprintf(tctx, "\\\\%s\\%s", dcerpc_server_name(p), name);
2339         r.in.datatype           = NULL;
2340         r.in.devmode_ctr.devmode= NULL;
2341         r.in.access_mask        = SEC_FLAG_MAXIMUM_ALLOWED;
2342         r.out.handle            = &handle;
2343
2344         torture_comment(tctx, "Testing OpenPrinter(%s)\n", r.in.printername);
2345
2346         status = dcerpc_spoolss_OpenPrinter(p, tctx, &r);
2347
2348         torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
2349
2350         torture_assert_werr_ok(tctx, r.out.result, "OpenPrinter failed");
2351
2352         if (!test_GetPrinter(tctx, p, &handle)) {
2353                 ret = false;
2354         }
2355
2356         if (!torture_setting_bool(tctx, "samba3", false)) {
2357                 if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
2358                         ret = false;
2359                 }
2360         }
2361
2362         if (!test_ClosePrinter(tctx, p, &handle)) {
2363                 ret = false;
2364         }
2365
2366         return ret;
2367 }
2368
2369 static bool call_OpenPrinterEx(struct torture_context *tctx,
2370                                struct dcerpc_pipe *p,
2371                                const char *name, struct policy_handle *handle)
2372 {
2373         struct spoolss_OpenPrinterEx r;
2374         struct spoolss_UserLevel1 userlevel1;
2375         NTSTATUS status;
2376
2377         if (name && name[0]) {
2378                 r.in.printername = talloc_asprintf(tctx, "\\\\%s\\%s",
2379                                                    dcerpc_server_name(p), name);
2380         } else {
2381                 r.in.printername = talloc_asprintf(tctx, "\\\\%s",
2382                                                    dcerpc_server_name(p));
2383         }
2384
2385         r.in.datatype           = NULL;
2386         r.in.devmode_ctr.devmode= NULL;
2387         r.in.access_mask        = SEC_FLAG_MAXIMUM_ALLOWED;
2388         r.in.level              = 1;
2389         r.in.userlevel.level1   = &userlevel1;
2390         r.out.handle = handle;
2391
2392         userlevel1.size = 1234;
2393         userlevel1.client = "hello";
2394         userlevel1.user = "spottyfoot!";
2395         userlevel1.build = 1;
2396         userlevel1.major = 2;
2397         userlevel1.minor = 3;
2398         userlevel1.processor = 4;
2399
2400         torture_comment(tctx, "Testing OpenPrinterEx(%s)\n", r.in.printername);
2401
2402         status = dcerpc_spoolss_OpenPrinterEx(p, tctx, &r);
2403
2404         torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
2405
2406         torture_assert_werr_ok(tctx, r.out.result, "OpenPrinterEx failed");
2407
2408         return true;
2409 }
2410
2411 static bool test_OpenPrinterEx(struct torture_context *tctx,
2412                                struct dcerpc_pipe *p,
2413                                const char *name)
2414 {
2415         struct policy_handle handle;
2416         bool ret = true;
2417
2418         if (!call_OpenPrinterEx(tctx, p, name, &handle)) {
2419                 return false;
2420         }
2421
2422         if (!test_GetPrinter(tctx, p, &handle)) {
2423                 ret = false;
2424         }
2425
2426         if (!test_EnumForms(tctx, p, &handle, false)) {
2427                 ret = false;
2428         }
2429
2430         if (!test_AddForm(tctx, p, &handle, false)) {
2431                 ret = false;
2432         }
2433
2434         if (!test_EnumPrinterData(tctx, p, &handle)) {
2435                 ret = false;
2436         }
2437
2438         if (!test_EnumPrinterDataEx(tctx, p, &handle)) {
2439                 ret = false;
2440         }
2441
2442         if (!test_printer_keys(tctx, p, &handle)) {
2443                 ret = false;
2444         }
2445
2446         if (!test_PausePrinter(tctx, p, &handle)) {
2447                 ret = false;
2448         }
2449
2450         if (!test_DoPrintTest(tctx, p, &handle)) {
2451                 ret = false;
2452         }
2453
2454         if (!test_ResumePrinter(tctx, p, &handle)) {
2455                 ret = false;
2456         }
2457
2458         if (!test_SetPrinterData(tctx, p, &handle)) {
2459                 ret = false;
2460         }
2461
2462         if (!torture_setting_bool(tctx, "samba3", false)) {
2463                 if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
2464                         ret = false;
2465                 }
2466         }
2467
2468         if (!test_ClosePrinter(tctx, p, &handle)) {
2469                 ret = false;
2470         }
2471
2472         return ret;
2473 }
2474
2475 static bool test_EnumPrinters_old(struct torture_context *tctx, struct dcerpc_pipe *p)
2476 {
2477         struct spoolss_EnumPrinters r;
2478         NTSTATUS status;
2479         uint16_t levels[] = {1, 2, 4, 5};
2480         int i;
2481         bool ret = true;
2482
2483         for (i=0;i<ARRAY_SIZE(levels);i++) {
2484                 union spoolss_PrinterInfo *info;
2485                 int j;
2486                 uint32_t needed;
2487                 uint32_t count;
2488
2489                 r.in.flags      = PRINTER_ENUM_LOCAL;
2490                 r.in.server     = "";
2491                 r.in.level      = levels[i];
2492                 r.in.buffer     = NULL;
2493                 r.in.offered    = 0;
2494                 r.out.needed    = &needed;
2495                 r.out.count     = &count;
2496                 r.out.info      = &info;
2497
2498                 torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
2499
2500                 status = dcerpc_spoolss_EnumPrinters(p, tctx, &r);
2501                 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
2502
2503                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2504                         DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
2505                         data_blob_clear(&blob);
2506                         r.in.buffer = &blob;
2507                         r.in.offered = needed;
2508                         status = dcerpc_spoolss_EnumPrinters(p, tctx, &r);
2509                 }
2510
2511                 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
2512
2513                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
2514
2515                 if (!info) {
2516                         torture_comment(tctx, "No printers returned\n");
2517                         return true;
2518                 }
2519
2520                 for (j=0;j<count;j++) {
2521                         if (r.in.level == 1) {
2522                                 char *unc = talloc_strdup(tctx, info[j].info1.name);
2523                                 char *slash, *name;
2524                                 name = unc;
2525                                 if (unc[0] == '\\' && unc[1] == '\\') {
2526                                         unc +=2;
2527                                 }
2528                                 slash = strchr(unc, '\\');
2529                                 if (slash) {
2530                                         slash++;
2531                                         name = slash;
2532                                 }
2533                                 if (!test_OpenPrinter(tctx, p, name)) {
2534                                         ret = false;
2535                                 }
2536                                 if (!test_OpenPrinterEx(tctx, p, name)) {
2537                                         ret = false;
2538                                 }
2539                         }
2540                 }
2541         }
2542
2543         return ret;
2544 }
2545
2546 static bool test_GetPrinterDriver(struct torture_context *tctx,
2547                                   struct dcerpc_pipe *p,
2548                                   struct policy_handle *handle,
2549                                   const char *driver_name)
2550 {
2551         struct spoolss_GetPrinterDriver r;
2552         uint32_t needed;
2553
2554         r.in.handle = handle;
2555         r.in.architecture = "W32X86";
2556         r.in.level = 1;
2557         r.in.buffer = NULL;
2558         r.in.offered = 0;
2559         r.out.needed = &needed;
2560
2561         torture_comment(tctx, "Testing GetPrinterDriver level %d\n", r.in.level);
2562
2563         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver(p, tctx, &r),
2564                 "failed to call GetPrinterDriver");
2565         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2566                 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
2567                 data_blob_clear(&blob);
2568                 r.in.buffer = &blob;
2569                 r.in.offered = needed;
2570                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver(p, tctx, &r),
2571                         "failed to call GetPrinterDriver");
2572         }
2573
2574         torture_assert_werr_ok(tctx, r.out.result,
2575                 "failed to call GetPrinterDriver");
2576
2577         return true;
2578 }
2579
2580 static bool test_GetPrinterDriver2(struct torture_context *tctx,
2581                                    struct dcerpc_pipe *p,
2582                                    struct policy_handle *handle,
2583                                    const char *driver_name)
2584 {
2585         struct spoolss_GetPrinterDriver2 r;
2586         uint32_t needed;
2587         uint32_t server_major_version;
2588         uint32_t server_minor_version;
2589
2590         r.in.handle = handle;
2591         r.in.architecture = "W32X86";
2592         r.in.level = 1;
2593         r.in.buffer = NULL;
2594         r.in.offered = 0;
2595         r.in.client_major_version = 0;
2596         r.in.client_minor_version = 0;
2597         r.out.needed = &needed;
2598         r.out.server_major_version = &server_major_version;
2599         r.out.server_minor_version = &server_minor_version;
2600
2601         torture_comment(tctx, "Testing GetPrinterDriver2 level %d\n", r.in.level);
2602
2603         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver2(p, tctx, &r),
2604                 "failed to call GetPrinterDriver2");
2605         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2606                 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
2607                 data_blob_clear(&blob);
2608                 r.in.buffer = &blob;
2609                 r.in.offered = needed;
2610                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver2(p, tctx, &r),
2611                         "failed to call GetPrinterDriver2");
2612         }
2613
2614         torture_assert_werr_ok(tctx, r.out.result,
2615                 "failed to call GetPrinterDriver2");
2616
2617         return true;
2618 }
2619
2620 static bool test_EnumPrinterDrivers_old(struct torture_context *tctx,
2621                                         struct dcerpc_pipe *p)
2622 {
2623         struct spoolss_EnumPrinterDrivers r;
2624         NTSTATUS status;
2625         uint16_t levels[] = {1, 2, 3, 4, 5, 6};
2626         int i;
2627
2628         for (i=0;i<ARRAY_SIZE(levels);i++) {
2629
2630                 uint32_t needed;
2631                 uint32_t count;
2632                 union spoolss_DriverInfo *info;
2633
2634                 r.in.server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2635                 r.in.environment = SPOOLSS_ARCHITECTURE_NT_X86;
2636                 r.in.level = levels[i];
2637                 r.in.buffer = NULL;
2638                 r.in.offered = 0;
2639                 r.out.needed = &needed;
2640                 r.out.count = &count;
2641                 r.out.info = &info;
2642
2643                 torture_comment(tctx, "Testing EnumPrinterDrivers level %u\n", r.in.level);
2644
2645                 status = dcerpc_spoolss_EnumPrinterDrivers(p, tctx, &r);
2646
2647                 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDrivers failed");
2648
2649                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2650                         DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
2651                         data_blob_clear(&blob);
2652                         r.in.buffer = &blob;
2653                         r.in.offered = needed;
2654                         status = dcerpc_spoolss_EnumPrinterDrivers(p, tctx, &r);
2655                 }
2656
2657                 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDrivers failed");
2658
2659                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDrivers failed");
2660
2661                 if (!info) {
2662                         torture_comment(tctx, "No printer drivers returned\n");
2663                         break;
2664                 }
2665         }
2666
2667         return true;
2668 }
2669
2670 static bool test_DeletePrinter(struct torture_context *tctx,
2671                                struct dcerpc_pipe *p,
2672                                struct policy_handle *handle)
2673 {
2674         struct spoolss_DeletePrinter r;
2675
2676         torture_comment(tctx, "Testing DeletePrinter\n");
2677
2678         r.in.handle = handle;
2679
2680         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_DeletePrinter(p, tctx, &r),
2681                 "failed to delete printer");
2682         torture_assert_werr_ok(tctx, r.out.result,
2683                 "failed to delete printer");
2684
2685         return true;
2686 }
2687
2688 static bool test_EnumPrinters_findname(struct torture_context *tctx,
2689                                        struct dcerpc_pipe *p,
2690                                        uint32_t flags,
2691                                        uint32_t level,
2692                                        const char *name,
2693                                        bool *found)
2694 {
2695         struct spoolss_EnumPrinters e;
2696         uint32_t count;
2697         union spoolss_PrinterInfo *info;
2698         uint32_t needed;
2699         int i;
2700
2701         *found = false;
2702
2703         e.in.flags = flags;
2704         e.in.server = NULL;
2705         e.in.level = level;
2706         e.in.buffer = NULL;
2707         e.in.offered = 0;
2708         e.out.count = &count;
2709         e.out.info = &info;
2710         e.out.needed = &needed;
2711
2712         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters(p, tctx, &e),
2713                 "failed to enum printers");
2714
2715         if (W_ERROR_EQUAL(e.out.result, WERR_INSUFFICIENT_BUFFER)) {
2716                 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
2717                 data_blob_clear(&blob);
2718                 e.in.buffer = &blob;
2719                 e.in.offered = needed;
2720
2721                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters(p, tctx, &e),
2722                         "failed to enum printers");
2723         }
2724
2725         torture_assert_werr_ok(tctx, e.out.result,
2726                 "failed to enum printers");
2727
2728         for (i=0; i < count; i++) {
2729
2730                 const char *current = NULL;
2731
2732                 switch (level) {
2733                 case 1:
2734                         current = info[i].info1.name;
2735                         break;
2736                 }
2737
2738                 if (strequal(current, name)) {
2739                         *found = true;
2740                         break;
2741                 }
2742         }
2743
2744         return true;
2745 }
2746
2747 static bool test_AddPrinter_wellknown(struct torture_context *tctx,
2748                                       struct dcerpc_pipe *p,
2749                                       const char *printername,
2750                                       bool ex)
2751 {
2752         WERROR result;
2753         struct spoolss_AddPrinter r;
2754         struct spoolss_AddPrinterEx rex;
2755         struct spoolss_SetPrinterInfoCtr info_ctr;
2756         struct spoolss_SetPrinterInfo1 info1;
2757         struct spoolss_DevmodeContainer devmode_ctr;
2758         struct sec_desc_buf secdesc_ctr;
2759         struct spoolss_UserLevelCtr userlevel_ctr;
2760         struct policy_handle handle;
2761         bool found = false;
2762
2763         ZERO_STRUCT(devmode_ctr);
2764         ZERO_STRUCT(secdesc_ctr);
2765         ZERO_STRUCT(userlevel_ctr);
2766         ZERO_STRUCT(info1);
2767
2768         torture_comment(tctx, "Testing AddPrinter%s level 1\n", ex ? "Ex":"");
2769
2770         /* try to add printer to wellknown printer list (level 1) */
2771
2772         userlevel_ctr.level = 1;
2773
2774         info_ctr.info.info1 = &info1;
2775         info_ctr.level = 1;
2776
2777         rex.in.server = NULL;
2778         rex.in.info_ctr = &info_ctr;
2779         rex.in.devmode_ctr = &devmode_ctr;
2780         rex.in.secdesc_ctr = &secdesc_ctr;
2781         rex.in.userlevel_ctr = &userlevel_ctr;
2782         rex.out.handle = &handle;
2783
2784         r.in.server = NULL;
2785         r.in.info_ctr = &info_ctr;
2786         r.in.devmode_ctr = &devmode_ctr;
2787         r.in.secdesc_ctr = &secdesc_ctr;
2788         r.out.handle = &handle;
2789
2790         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
2791                                               dcerpc_spoolss_AddPrinter(p, tctx, &r),
2792                 "failed to add printer");
2793         result = ex ? rex.out.result : r.out.result;
2794         torture_assert_werr_equal(tctx, result, WERR_INVALID_PRINTER_NAME,
2795                 "unexpected result code");
2796
2797         info1.name = printername;
2798         info1.flags = PRINTER_ATTRIBUTE_SHARED;
2799
2800         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
2801                                               dcerpc_spoolss_AddPrinter(p, tctx, &r),
2802                 "failed to add printer");
2803         result = ex ? rex.out.result : r.out.result;
2804         torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
2805                 "unexpected result code");
2806
2807         /* bizarre protocol, WERR_PRINTER_ALREADY_EXISTS means success here,
2808            better do a real check to see the printer is really there */
2809
2810         torture_assert(tctx, test_EnumPrinters_findname(tctx, p,
2811                                                         PRINTER_ENUM_NETWORK, 1,
2812                                                         printername,
2813                                                         &found),
2814                         "failed to enum printers");
2815
2816         torture_assert(tctx, found, "failed to find newly added printer");
2817
2818         info1.flags = 0;
2819
2820         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
2821                                               dcerpc_spoolss_AddPrinter(p, tctx, &r),
2822                 "failed to add printer");
2823         result = ex ? rex.out.result : r.out.result;
2824         torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
2825                 "unexpected result code");
2826
2827         /* bizarre protocol, WERR_PRINTER_ALREADY_EXISTS means success here,
2828            better do a real check to see the printer has really been removed
2829            from the well known printer list */
2830
2831         found = false;
2832
2833         torture_assert(tctx, test_EnumPrinters_findname(tctx, p,
2834                                                         PRINTER_ENUM_NETWORK, 1,
2835                                                         printername,
2836                                                         &found),
2837                         "failed to enum printers");
2838 #if 0
2839         torture_assert(tctx, !found, "printer still in well known printer list");
2840 #endif
2841         return true;
2842 }
2843
2844 static bool test_AddPrinter_normal(struct torture_context *tctx,
2845                                    struct dcerpc_pipe *p,
2846                                    struct policy_handle *handle_p,
2847                                    const char *printername,
2848                                    const char *drivername,
2849                                    const char *portname,
2850                                    bool ex)
2851 {
2852         WERROR result;
2853         struct spoolss_AddPrinter r;
2854         struct spoolss_AddPrinterEx rex;
2855         struct spoolss_SetPrinterInfoCtr info_ctr;
2856         struct spoolss_SetPrinterInfo2 info2;
2857         struct spoolss_DevmodeContainer devmode_ctr;
2858         struct sec_desc_buf secdesc_ctr;
2859         struct spoolss_UserLevelCtr userlevel_ctr;
2860         struct policy_handle handle;
2861         bool found = false;
2862
2863         ZERO_STRUCT(devmode_ctr);
2864         ZERO_STRUCT(secdesc_ctr);
2865         ZERO_STRUCT(userlevel_ctr);
2866
2867         torture_comment(tctx, "Testing AddPrinter%s level 2\n", ex ? "Ex":"");
2868
2869         userlevel_ctr.level = 1;
2870
2871         rex.in.server = NULL;
2872         rex.in.info_ctr = &info_ctr;
2873         rex.in.devmode_ctr = &devmode_ctr;
2874         rex.in.secdesc_ctr = &secdesc_ctr;
2875         rex.in.userlevel_ctr = &userlevel_ctr;
2876         rex.out.handle = &handle;
2877
2878         r.in.server = NULL;
2879         r.in.info_ctr = &info_ctr;
2880         r.in.devmode_ctr = &devmode_ctr;
2881         r.in.secdesc_ctr = &secdesc_ctr;
2882         r.out.handle = &handle;
2883
2884  again:
2885
2886         /* try to add printer to printer list (level 2) */
2887
2888         ZERO_STRUCT(info2);
2889
2890         info_ctr.info.info2 = &info2;
2891         info_ctr.level = 2;
2892
2893         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
2894                                               dcerpc_spoolss_AddPrinter(p, tctx, &r),
2895                 "failed to add printer");
2896         result = ex ? rex.out.result : r.out.result;
2897         torture_assert_werr_equal(tctx, result, WERR_INVALID_PRINTER_NAME,
2898                 "unexpected result code");
2899
2900         info2.printername = printername;
2901
2902         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
2903                                               dcerpc_spoolss_AddPrinter(p, tctx, &r),
2904                 "failed to add printer");
2905         result = ex ? rex.out.result : r.out.result;
2906
2907         if (W_ERROR_EQUAL(result, WERR_PRINTER_ALREADY_EXISTS)) {
2908                 struct policy_handle printer_handle;
2909
2910                 torture_assert(tctx, call_OpenPrinterEx(tctx, p, printername, &printer_handle),
2911                         "failed to open printer handle");
2912
2913                 torture_assert(tctx, test_DeletePrinter(tctx, p, &printer_handle),
2914                         "failed to delete printer");
2915
2916                 torture_assert(tctx, test_ClosePrinter(tctx, p, &printer_handle),
2917                         "failed to close server handle");
2918
2919                 goto again;
2920         }
2921
2922         torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PORT,
2923                 "unexpected result code");
2924
2925         info2.portname = portname;
2926
2927         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
2928                                               dcerpc_spoolss_AddPrinter(p, tctx, &r),
2929                 "failed to add printer");
2930         result = ex ? rex.out.result : r.out.result;
2931         torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PRINTER_DRIVER,
2932                 "unexpected result code");
2933
2934         info2.drivername = drivername;
2935
2936         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
2937                                               dcerpc_spoolss_AddPrinter(p, tctx, &r),
2938                 "failed to add printer");
2939         result = ex ? rex.out.result : r.out.result;
2940         torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PRINTPROCESSOR,
2941                 "unexpected result code");
2942
2943         info2.printprocessor = "winprint";
2944
2945         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
2946                                               dcerpc_spoolss_AddPrinter(p, tctx, &r),
2947                 "failed to add printer");
2948         result = ex ? rex.out.result : r.out.result;
2949         torture_assert_werr_ok(tctx, result,
2950                 "failed to add printer");
2951
2952         *handle_p = handle;
2953
2954         /* we are paranoid, really check if the printer is there now */
2955
2956         torture_assert(tctx, test_EnumPrinters_findname(tctx, p,
2957                                                         PRINTER_ENUM_LOCAL, 1,
2958                                                         printername,
2959                                                         &found),
2960                         "failed to enum printers");
2961         torture_assert(tctx, found, "failed to find newly added printer");
2962
2963         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
2964                                               dcerpc_spoolss_AddPrinter(p, tctx, &r),
2965                 "failed to add printer");
2966         result = ex ? rex.out.result : r.out.result;
2967         torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
2968                 "unexpected result code");
2969
2970         return true;
2971 }
2972
2973 static bool test_AddPrinterEx(struct torture_context *tctx,
2974                               struct dcerpc_pipe *p,
2975                               struct policy_handle *handle_p,
2976                               const char *printername,
2977                               const char *drivername,
2978                               const char *portname)
2979 {
2980         bool ret = true;
2981
2982         if (!torture_setting_bool(tctx, "samba3", false)) {
2983                 if (!test_AddPrinter_wellknown(tctx, p, TORTURE_WELLKNOWN_PRINTER_EX, true)) {
2984                         torture_comment(tctx, "failed to add printer to well known list\n");
2985                         ret = false;
2986                 }
2987         }
2988
2989         if (!test_AddPrinter_normal(tctx, p, handle_p,
2990                                     printername, drivername, portname,
2991                                     true)) {
2992                 torture_comment(tctx, "failed to add printer to printer list\n");
2993                 ret = false;
2994         }
2995
2996         return ret;
2997 }
2998
2999 static bool test_AddPrinter(struct torture_context *tctx,
3000                             struct dcerpc_pipe *p,
3001                             struct policy_handle *handle_p,
3002                             const char *printername,
3003                             const char *drivername,
3004                             const char *portname)
3005 {
3006         bool ret = true;
3007
3008         if (!torture_setting_bool(tctx, "samba3", false)) {
3009                 if (!test_AddPrinter_wellknown(tctx, p, TORTURE_WELLKNOWN_PRINTER, false)) {
3010                         torture_comment(tctx, "failed to add printer to well known list\n");
3011                         ret = false;
3012                 }
3013         }
3014
3015         if (!test_AddPrinter_normal(tctx, p, handle_p,
3016                                     printername, drivername, portname,
3017                                     false)) {
3018                 torture_comment(tctx, "failed to add printer to printer list\n");
3019                 ret = false;
3020         }
3021
3022         return ret;
3023 }
3024
3025 static bool test_printer_info(struct torture_context *tctx,
3026                               struct dcerpc_pipe *p,
3027                               struct policy_handle *handle)
3028 {
3029         bool ret = true;
3030
3031         if (!test_PrinterInfo(tctx, p, handle)) {
3032                 ret = false;
3033         }
3034
3035         if (!test_SetPrinter_errors(tctx, p, handle)) {
3036                 ret = false;
3037         }
3038
3039         return ret;
3040 }
3041
3042 bool test_printer_keys(struct torture_context *tctx,
3043                        struct dcerpc_pipe *p,
3044                        struct policy_handle *handle)
3045 {
3046         const char **key_array = NULL;
3047         int i;
3048
3049         {
3050                 struct spoolss_EnumPrinterKey r;
3051                 uint32_t needed;
3052                 struct spoolss_StringArray2 key_buffer;
3053
3054                 r.in.handle = handle;
3055                 r.in.key_name = "";
3056                 r.in.offered = 0;
3057                 r.out.key_buffer = &key_buffer;
3058                 r.out.needed = &needed;
3059
3060                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterKey(p, tctx, &r),
3061                         "failed to call EnumPrinterKey");
3062                 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3063                         r.in.offered = needed;
3064                         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterKey(p, tctx, &r),
3065                                 "failed to call EnumPrinterKey");
3066                 }
3067                 torture_assert_werr_ok(tctx, r.out.result,
3068                         "failed to call EnumPrinterKey");
3069
3070                 key_array = key_buffer.string;
3071         }
3072
3073         for (i=0; key_array[i]; i++) {
3074                 struct spoolss_EnumPrinterDataEx r;
3075                 uint32_t count;
3076                 struct spoolss_PrinterEnumValues *info;
3077                 uint32_t needed;
3078
3079                 r.in.handle = handle;
3080                 r.in.key_name = key_array[i];
3081                 r.in.offered = 0;
3082                 r.out.count = &count;
3083                 r.out.info = &info;
3084                 r.out.needed = &needed;
3085
3086                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &r),
3087                         "failed to call EnumPrinterDataEx");
3088                 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3089                         r.in.offered = needed;
3090                         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &r),
3091                                 "failed to call EnumPrinterDataEx");
3092                 }
3093                 torture_assert_werr_ok(tctx, r.out.result,
3094                         "failed to call EnumPrinterDataEx");
3095         }
3096
3097         return true;
3098 }
3099
3100 static bool test_printer(struct torture_context *tctx,
3101                          struct dcerpc_pipe *p)
3102 {
3103         bool ret = true;
3104         struct policy_handle handle[2];
3105         bool found = false;
3106         const char *drivername = "Microsoft XPS Document Writer";
3107         const char *portname = "LPT1:";
3108
3109         /* test printer created via AddPrinter */
3110
3111         if (!test_AddPrinter(tctx, p, &handle[0], TORTURE_PRINTER, drivername, portname)) {
3112                 return false;
3113         }
3114
3115         if (!test_printer_info(tctx, p, &handle[0])) {
3116                 ret = false;
3117         }
3118
3119         if (!test_printer_keys(tctx, p, &handle[0])) {
3120                 ret = false;
3121         }
3122
3123         if (!test_DeletePrinter(tctx, p, &handle[0])) {
3124                 ret = false;
3125         }
3126
3127         if (!test_EnumPrinters_findname(tctx, p, PRINTER_ENUM_LOCAL, 1,
3128                                         TORTURE_PRINTER, &found)) {
3129                 ret = false;
3130         }
3131
3132         torture_assert(tctx, !found, "deleted printer still there");
3133
3134         /* test printer created via AddPrinterEx */
3135
3136         if (!test_AddPrinterEx(tctx, p, &handle[1], TORTURE_PRINTER_EX, drivername, portname)) {
3137                 return false;
3138         }
3139
3140         if (!test_printer_info(tctx, p, &handle[1])) {
3141                 ret = false;
3142         }
3143
3144         if (!test_printer_keys(tctx, p, &handle[1])) {
3145                 ret = false;
3146         }
3147
3148         if (!test_DeletePrinter(tctx, p, &handle[1])) {
3149                 ret = false;
3150         }
3151
3152         if (!test_EnumPrinters_findname(tctx, p, PRINTER_ENUM_LOCAL, 1,
3153                                         TORTURE_PRINTER_EX, &found)) {
3154                 ret = false;
3155         }
3156
3157         torture_assert(tctx, !found, "deleted printer still there");
3158
3159         return ret;
3160 }
3161
3162 bool torture_rpc_spoolss(struct torture_context *torture)
3163 {
3164         NTSTATUS status;
3165         struct dcerpc_pipe *p;
3166         bool ret = true;
3167         struct test_spoolss_context *ctx;
3168
3169         status = torture_rpc_connection(torture, &p, &ndr_table_spoolss);
3170         if (!NT_STATUS_IS_OK(status)) {
3171                 return false;
3172         }
3173
3174         ctx = talloc_zero(torture, struct test_spoolss_context);
3175
3176         ret &= test_OpenPrinter_server(torture, p, &ctx->server_handle);
3177
3178         ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "W3SvcInstalled");
3179         ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "BeepEnabled");
3180         ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "EventLog");
3181         ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "NetPopup");
3182         ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "NetPopupToComputer");
3183         ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "MajorVersion");
3184         ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "MinorVersion");
3185         ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "DefaultSpoolDirectory");
3186         ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "Architecture");
3187         ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "DsPresent");
3188         ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "OSVersion");
3189         ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "OSVersionEx");
3190         ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "DNSMachineName");
3191         ret &= test_EnumForms(torture, p, &ctx->server_handle, true);
3192         ret &= test_AddForm(torture, p, &ctx->server_handle, true);
3193         ret &= test_EnumPorts(torture, p, ctx);
3194         ret &= test_GetPrinterDriverDirectory(torture, p, ctx);
3195         ret &= test_GetPrintProcessorDirectory(torture, p, ctx);
3196         ret &= test_EnumPrinterDrivers(torture, p, ctx);
3197         ret &= test_EnumMonitors(torture, p, ctx);
3198         ret &= test_EnumPrintProcessors(torture, p, ctx);
3199         ret &= test_EnumPrintProcDataTypes(torture, p, ctx);
3200         ret &= test_EnumPrinters(torture, p, ctx);
3201         ret &= test_OpenPrinter_badname(torture, p, "__INVALID_PRINTER__");
3202         ret &= test_OpenPrinter_badname(torture, p, "\\\\__INVALID_HOST__");
3203         ret &= test_OpenPrinter_badname(torture, p, "");
3204         ret &= test_OpenPrinter_badname(torture, p, "\\\\\\");
3205         ret &= test_OpenPrinter_badname(torture, p, "\\\\\\__INVALID_PRINTER__");
3206         ret &= test_OpenPrinter_badname(torture, p, talloc_asprintf(torture, "\\\\%s\\", dcerpc_server_name(p)));
3207         ret &= test_OpenPrinter_badname(torture, p,
3208                                         talloc_asprintf(torture, "\\\\%s\\__INVALID_PRINTER__", dcerpc_server_name(p)));
3209
3210
3211         ret &= test_AddPort(torture, p);
3212         ret &= test_EnumPorts_old(torture, p);
3213         ret &= test_EnumPrinters_old(torture, p);
3214         ret &= test_EnumPrinterDrivers_old(torture, p);
3215
3216         return ret;
3217 }
3218
3219 struct torture_suite *torture_rpc_spoolss_printer(TALLOC_CTX *mem_ctx)
3220 {
3221         struct torture_suite *suite = torture_suite_create(mem_ctx, "SPOOLSS-PRINTER");
3222
3223         struct torture_rpc_tcase *tcase = torture_suite_add_rpc_iface_tcase(suite,
3224                                                         "printer", &ndr_table_spoolss);
3225
3226         torture_rpc_tcase_add_test(tcase, "printer", test_printer);
3227
3228         return suite;
3229 }