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-2010
   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 "librpc/gen_ndr/ndr_misc.h"
  27 #include "librpc/gen_ndr/ndr_spoolss.h"
  28 #include "librpc/gen_ndr/ndr_spoolss_c.h"
  29 #include "librpc/gen_ndr/ndr_winreg_c.h"
  30 #include "librpc/gen_ndr/ndr_security.h"
  31 #include "libcli/security/security.h"
  32 #include "torture/rpc/torture_rpc.h"
  33 #include "param/param.h"
  34 #include "lib/registry/registry.h"
  35 #include "libcli/libcli.h"
  36 #include "libcli/raw/raw_proto.h"
  37 #include "libcli/resolve/resolve.h"
  38 #include "lib/cmdline/popt_common.h"
  39 #include "system/filesys.h"
  40
  41 #define TORTURE_WELLKNOWN_PRINTER       "torture_wkn_printer"
  42 #define TORTURE_PRINTER                 "torture_printer"
  43 #define TORTURE_WELLKNOWN_PRINTER_EX    "torture_wkn_printer_ex"
  44 #define TORTURE_PRINTER_EX              "torture_printer_ex"
  45 #define TORTURE_DRIVER                  "torture_driver"
  46 #define TORTURE_DRIVER_EX               "torture_driver_ex"
  47
  48 #define TOP_LEVEL_PRINT_KEY "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Print"
  49 #define TOP_LEVEL_PRINT_PRINTERS_KEY TOP_LEVEL_PRINT_KEY "\\Printers"
  50 #define TOP_LEVEL_CONTROL_KEY "SYSTEM\\CurrentControlSet\\Control\\Print"
  51 #define TOP_LEVEL_CONTROL_FORMS_KEY TOP_LEVEL_CONTROL_KEY "\\Forms"
  52 #define TOP_LEVEL_CONTROL_PRINTERS_KEY TOP_LEVEL_CONTROL_KEY "\\Printers"
  53 #define TOP_LEVEL_CONTROL_ENVIRONMENTS_KEY TOP_LEVEL_CONTROL_KEY "\\Environments"
  54
  55 struct test_spoolss_context {
  56         struct dcerpc_pipe *spoolss_pipe;
  57
  58         /* server environment */
  59         const char *environment;
  60
  61         /* print server handle */
  62         struct policy_handle server_handle;
  63
  64         /* for EnumPorts */
  65         uint32_t port_count[3];
  66         union spoolss_PortInfo *ports[3];
  67
  68         /* for EnumPrinterDrivers */
  69         uint32_t driver_count[8];
  70         union spoolss_DriverInfo *drivers[8];
  71
  72         /* for EnumMonitors */
  73         uint32_t monitor_count[3];
  74         union spoolss_MonitorInfo *monitors[3];
  75
  76         /* for EnumPrintProcessors */
  77         uint32_t print_processor_count[2];
  78         union spoolss_PrintProcessorInfo *print_processors[2];
  79
  80         /* for EnumPrinters */
  81         uint32_t printer_count[6];
  82         union spoolss_PrinterInfo *printers[6];
  83 };
  84
  85 struct torture_driver_context {
  86         struct {
  87                 const char *driver_directory;
  88                 const char *environment;
  89         } local;
  90         struct {
  91                 const char *driver_directory;
  92                 const char *environment;
  93         } remote;
  94         struct spoolss_AddDriverInfo8 info8;
  95         bool ex;
  96 };
  97
  98 struct torture_printer_context {
  99         struct spoolss_SetPrinterInfo2 info2;
 100         struct torture_driver_context driver;
 101         bool ex;
 102         bool wellknown;
 103         bool added_driver;
 104         bool have_driver;
 105         struct spoolss_DeviceMode *devmode;
 106 };
 107
 108 static bool upload_printer_driver(struct torture_context *tctx,
 109                                   const char *server_name,
 110                                   struct torture_driver_context *d);
 111 static bool remove_printer_driver(struct torture_context *tctx,
 112                                   const char *server_name,
 113                                   struct torture_driver_context *d);
 114 static bool fillup_printserver_info(struct torture_context *tctx,
 115                                     struct dcerpc_pipe *p,
 116                                     struct torture_driver_context *d);
 117 static bool test_AddPrinterDriver_args_level_3(struct torture_context *tctx,
 118                                                struct dcerpc_binding_handle *b,
 119                                                const char *server_name,
 120                                                struct spoolss_AddDriverInfo8 *r,
 121                                                uint32_t flags,
 122                                                bool ex);
 123
 124 #define COMPARE_STRING(tctx, c,r,e) \
 125         torture_assert_str_equal(tctx, c.e, r.e, "invalid value")
 126
 127 /* not every compiler supports __typeof__() */
 128 #if (__GNUC__ >= 3)
 129 #define _CHECK_FIELD_SIZE(c,r,e,type) do {\
 130         if (sizeof(__typeof__(c.e)) != sizeof(type)) { \
 131                 torture_fail(tctx, #c "." #e "field is not " #type "\n"); \
 132         }\
 133         if (sizeof(__typeof__(r.e)) != sizeof(type)) { \
 134                 torture_fail(tctx, #r "." #e "field is not " #type "\n"); \
 135         }\
 136 } while(0)
 137 #else
 138 #define _CHECK_FIELD_SIZE(c,r,e,type) do {} while(0)
 139 #endif
 140
 141 #define COMPARE_UINT32(tctx, c, r, e) do {\
 142         _CHECK_FIELD_SIZE(c, r, e, uint32_t); \
 143         torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
 144 } while(0)
 145
 146 #define COMPARE_UINT64(tctx, c, r, e) do {\
 147         _CHECK_FIELD_SIZE(c, r, e, uint64_t); \
 148         torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
 149 } while(0)
 150
 151
 152 #define COMPARE_NTTIME(tctx, c, r, e) do {\
 153         _CHECK_FIELD_SIZE(c, r, e, NTTIME); \
 154         torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
 155 } while(0)
 156
 157 #define COMPARE_STRING_ARRAY(tctx, c,r,e) do {\
 158         int __i; \
 159         if (!c.e && !r.e) { \
 160                 break; \
 161         } \
 162         if (c.e && !r.e) { \
 163                 torture_fail(tctx, #r "." #e " field is NULL and " #c "." #e " is not\n"); \
 164         } \
 165         if (!c.e && r.e) { \
 166                 torture_fail(tctx, #c "." #e " field is NULL and " #r "." #e " is not\n"); \
 167         } \
 168         for (__i=0;c.e[__i] != NULL; __i++) { \
 169                 torture_assert_str_equal(tctx, c.e[__i], r.e[__i], "invalid value"); \
 170         } \
 171 } while(0)
 172
 173 #define CHECK_ALIGN(size, n) do {\
 174         if (size % n) {\
 175                 torture_warning(tctx, "%d is *NOT* %d byte aligned, should be %d",\
 176                         size, n, size + n - (size % n));\
 177         }\
 178 } while(0)
 179
 180 #define DO_ROUND(size, n) (((size)+((n)-1)) & ~((n)-1))
 181
 182 #define CHECK_NEEDED_SIZE_ENUM_LEVEL(fn, info, level, count, needed, align) do { \
 183         if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
 184         uint32_t size = ndr_size_##fn##_info(tctx, level, count, info);\
 185         uint32_t round_size = DO_ROUND(size, align);\
 186         if (round_size != needed) {\
 187                 torture_warning(tctx, __location__": "#fn" level %d (count: %d) got unexpected needed size: %d, we calculated: %d", level, count, needed, round_size);\
 188                 CHECK_ALIGN(size, align);\
 189         }\
 190         }\
 191 } while(0)
 192
 193 #define CHECK_NEEDED_SIZE_ENUM(fn, info, count, needed, align) do { \
 194         if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
 195         uint32_t size = ndr_size_##fn##_info(tctx, count, info);\
 196         uint32_t round_size = DO_ROUND(size, align);\
 197         if (round_size != needed) {\
 198                 torture_warning(tctx, __location__": "#fn" (count: %d) got unexpected needed size: %d, we calculated: %d", count, needed, round_size);\
 199                 CHECK_ALIGN(size, align);\
 200         }\
 201         }\
 202 } while(0)
 203
 204 #define CHECK_NEEDED_SIZE_LEVEL(fn, info, level, needed, align) do { \
 205         if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
 206         uint32_t size = ndr_size_##fn(info, level, 0);\
 207         uint32_t round_size = DO_ROUND(size, align);\
 208         if (round_size != needed) {\
 209                 torture_warning(tctx, __location__": "#fn" level %d got unexpected needed size: %d, we calculated: %d", level, needed, round_size);\
 210                 CHECK_ALIGN(size, align);\
 211         }\
 212         }\
 213 } while(0)
 214
 215 static bool PrinterInfo_to_SetPrinterInfo(struct torture_context *tctx,
 216                                           const union spoolss_PrinterInfo *i,
 217                                           uint32_t level,
 218                                           union spoolss_SetPrinterInfo *s)
 219 {
 220         switch (level) {
 221         case 0:
 222                 s->info0                        = talloc(tctx, struct spoolss_SetPrinterInfo0);
 223                 break;
 224         case 2:
 225                 s->info2                        = talloc(tctx, struct spoolss_SetPrinterInfo2);
 226                 s->info2->servername            = i->info2.servername;
 227                 s->info2->printername           = i->info2.printername;
 228                 s->info2->sharename             = i->info2.sharename;
 229                 s->info2->portname              = i->info2.portname;
 230                 s->info2->drivername            = i->info2.drivername;
 231                 s->info2->comment               = i->info2.comment;
 232                 s->info2->location              = i->info2.location;
 233                 s->info2->devmode_ptr           = 0;
 234                 s->info2->sepfile               = i->info2.sepfile;
 235                 s->info2->printprocessor        = i->info2.printprocessor;
 236                 s->info2->datatype              = i->info2.datatype;
 237                 s->info2->parameters            = i->info2.parameters;
 238                 s->info2->secdesc_ptr           = 0;
 239                 s->info2->attributes            = i->info2.attributes;
 240                 s->info2->priority              = i->info2.priority;
 241                 s->info2->defaultpriority       = i->info2.defaultpriority;
 242                 s->info2->starttime             = i->info2.starttime;
 243                 s->info2->untiltime             = i->info2.untiltime;
 244                 s->info2->status                = i->info2.status;
 245                 s->info2->cjobs                 = i->info2.cjobs;
 246                 s->info2->averageppm            = i->info2.averageppm;
 247                 break;
 248         case 3:
 249         case 4:
 250         case 5:
 251         case 6:
 252         case 7:
 253         case 8:
 254         case 9:
 255         default:
 256                 return false;
 257         }
 258
 259         return true;
 260 }
 261
 262 static bool test_OpenPrinter_server(struct torture_context *tctx,
 263                                     struct dcerpc_pipe *p,
 264                                     struct policy_handle *server_handle)
 265 {
 266         NTSTATUS status;
 267         struct spoolss_OpenPrinter op;
 268         struct dcerpc_binding_handle *b = p->binding_handle;
 269
 270         op.in.printername       = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 271         op.in.datatype          = NULL;
 272         op.in.devmode_ctr.devmode= NULL;
 273         op.in.access_mask       = 0;
 274         op.out.handle           = server_handle;
 275
 276         torture_comment(tctx, "Testing OpenPrinter(%s)\n", op.in.printername);
 277
 278         status = dcerpc_spoolss_OpenPrinter_r(b, tctx, &op);
 279         torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_OpenPrinter failed");
 280         torture_assert_werr_ok(tctx, op.out.result, "dcerpc_spoolss_OpenPrinter failed");
 281
 282         return true;
 283 }
 284
 285 static bool test_EnumPorts(struct torture_context *tctx,
 286                            void *private_data)
 287 {
 288         struct test_spoolss_context *ctx =
 289                 talloc_get_type_abort(private_data, struct test_spoolss_context);
 290         struct dcerpc_pipe *p = ctx->spoolss_pipe;
 291         struct dcerpc_binding_handle *b = p->binding_handle;
 292         NTSTATUS status;
 293         struct spoolss_EnumPorts r;
 294         uint16_t levels[] = { 1, 2 };
 295         int i, j;
 296
 297         for (i=0;i<ARRAY_SIZE(levels);i++) {
 298                 int level = levels[i];
 299                 DATA_BLOB blob;
 300                 uint32_t needed;
 301                 uint32_t count;
 302                 union spoolss_PortInfo *info;
 303
 304                 r.in.servername = "";
 305                 r.in.level = level;
 306                 r.in.buffer = NULL;
 307                 r.in.offered = 0;
 308                 r.out.needed = &needed;
 309                 r.out.count = &count;
 310                 r.out.info = &info;
 311
 312                 torture_comment(tctx, "Testing EnumPorts level %u\n", r.in.level);
 313
 314                 status = dcerpc_spoolss_EnumPorts_r(b, ctx, &r);
 315                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
 316                 if (W_ERROR_IS_OK(r.out.result)) {
 317                         /* TODO: do some more checks here */
 318                         continue;
 319                 }
 320                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 321                         "EnumPorts unexpected return code");
 322
 323                 blob = data_blob_talloc_zero(ctx, needed);
 324                 r.in.buffer = &blob;
 325                 r.in.offered = needed;
 326
 327                 status = dcerpc_spoolss_EnumPorts_r(b, ctx, &r);
 328                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
 329
 330                 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
 331
 332                 torture_assert(tctx, info, "EnumPorts returned no info");
 333
 334                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPorts, info, r.in.level, count, needed, 4);
 335
 336                 ctx->port_count[level]  = count;
 337                 ctx->ports[level]       = info;
 338         }
 339
 340         for (i=1;i<ARRAY_SIZE(levels);i++) {
 341                 int level = levels[i];
 342                 int old_level = levels[i-1];
 343                 torture_assert_int_equal(tctx, ctx->port_count[level], ctx->port_count[old_level],
 344                         "EnumPorts invalid value");
 345         }
 346         /* if the array sizes are not the same we would maybe segfault in the following code */
 347
 348         for (i=0;i<ARRAY_SIZE(levels);i++) {
 349                 int level = levels[i];
 350                 for (j=0;j<ctx->port_count[level];j++) {
 351                         union spoolss_PortInfo *cur = &ctx->ports[level][j];
 352                         union spoolss_PortInfo *ref = &ctx->ports[2][j];
 353                         switch (level) {
 354                         case 1:
 355                                 COMPARE_STRING(tctx, cur->info1, ref->info2, port_name);
 356                                 break;
 357                         case 2:
 358                                 /* level 2 is our reference, and it makes no sense to compare it to itself */
 359                                 break;
 360                         }
 361                 }
 362         }
 363
 364         return true;
 365 }
 366
 367 static bool test_GetPrintProcessorDirectory(struct torture_context *tctx,
 368                                             void *private_data)
 369 {
 370         struct test_spoolss_context *ctx =
 371                 talloc_get_type_abort(private_data, struct test_spoolss_context);
 372
 373         NTSTATUS status;
 374         struct dcerpc_pipe *p = ctx->spoolss_pipe;
 375         struct dcerpc_binding_handle *b = p->binding_handle;
 376         struct spoolss_GetPrintProcessorDirectory r;
 377         struct {
 378                 uint16_t level;
 379                 const char *server;
 380         } levels[] = {{
 381                         .level  = 1,
 382                         .server = NULL
 383                 },{
 384                         .level  = 1,
 385                         .server = ""
 386                 },{
 387                         .level  = 78,
 388                         .server = ""
 389                 },{
 390                         .level  = 1,
 391                         .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
 392                 },{
 393                         .level  = 1024,
 394                         .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
 395                 }
 396         };
 397         int i;
 398         uint32_t needed;
 399
 400         for (i=0;i<ARRAY_SIZE(levels);i++) {
 401                 int level = levels[i].level;
 402                 DATA_BLOB blob;
 403
 404                 r.in.server             = levels[i].server;
 405                 r.in.environment        = ctx->environment;
 406                 r.in.level              = level;
 407                 r.in.buffer             = NULL;
 408                 r.in.offered            = 0;
 409                 r.out.needed            = &needed;
 410
 411                 torture_comment(tctx, "Testing GetPrintProcessorDirectory level %u\n", r.in.level);
 412
 413                 status = dcerpc_spoolss_GetPrintProcessorDirectory_r(b, tctx, &r);
 414                 torture_assert_ntstatus_ok(tctx, status,
 415                         "dcerpc_spoolss_GetPrintProcessorDirectory failed");
 416                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 417                         "GetPrintProcessorDirectory unexpected return code");
 418
 419                 blob = data_blob_talloc_zero(tctx, needed);
 420                 r.in.buffer = &blob;
 421                 r.in.offered = needed;
 422
 423                 status = dcerpc_spoolss_GetPrintProcessorDirectory_r(b, tctx, &r);
 424                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrintProcessorDirectory failed");
 425
 426                 torture_assert_werr_ok(tctx, r.out.result, "GetPrintProcessorDirectory failed");
 427
 428                 CHECK_NEEDED_SIZE_LEVEL(spoolss_PrintProcessorDirectoryInfo, r.out.info, r.in.level, needed, 2);
 429         }
 430
 431         return true;
 432 }
 433
 434
 435 static bool test_GetPrinterDriverDirectory(struct torture_context *tctx,
 436                                            void *private_data)
 437 {
 438         struct test_spoolss_context *ctx =
 439                 talloc_get_type_abort(private_data, struct test_spoolss_context);
 440
 441         NTSTATUS status;
 442         struct dcerpc_pipe *p = ctx->spoolss_pipe;
 443         struct dcerpc_binding_handle *b = p->binding_handle;
 444         struct spoolss_GetPrinterDriverDirectory r;
 445         struct {
 446                 uint16_t level;
 447                 const char *server;
 448         } levels[] = {{
 449                         .level  = 1,
 450                         .server = NULL
 451                 },{
 452                         .level  = 1,
 453                         .server = ""
 454                 },{
 455                         .level  = 78,
 456                         .server = ""
 457                 },{
 458                         .level  = 1,
 459                         .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
 460                 },{
 461                         .level  = 1024,
 462                         .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
 463                 }
 464         };
 465         int i;
 466         uint32_t needed;
 467
 468         for (i=0;i<ARRAY_SIZE(levels);i++) {
 469                 int level = levels[i].level;
 470                 DATA_BLOB blob;
 471
 472                 r.in.server             = levels[i].server;
 473                 r.in.environment        = ctx->environment;
 474                 r.in.level              = level;
 475                 r.in.buffer             = NULL;
 476                 r.in.offered            = 0;
 477                 r.out.needed            = &needed;
 478
 479                 torture_comment(tctx, "Testing GetPrinterDriverDirectory level %u\n", r.in.level);
 480
 481                 status = dcerpc_spoolss_GetPrinterDriverDirectory_r(b, tctx, &r);
 482                 torture_assert_ntstatus_ok(tctx, status,
 483                         "dcerpc_spoolss_GetPrinterDriverDirectory failed");
 484                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 485                         "GetPrinterDriverDirectory unexpected return code");
 486
 487                 blob = data_blob_talloc_zero(tctx, needed);
 488                 r.in.buffer = &blob;
 489                 r.in.offered = needed;
 490
 491                 status = dcerpc_spoolss_GetPrinterDriverDirectory_r(b, tctx, &r);
 492                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrinterDriverDirectory failed");
 493
 494                 torture_assert_werr_ok(tctx, r.out.result, "GetPrinterDriverDirectory failed");
 495
 496                 CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverDirectoryInfo, r.out.info, r.in.level, needed, 2);
 497         }
 498
 499         return true;
 500 }
 501
 502 static bool test_EnumPrinterDrivers_args(struct torture_context *tctx,
 503                                          struct dcerpc_binding_handle *b,
 504                                          const char *server_name,
 505                                          const char *environment,
 506                                          uint32_t level,
 507                                          uint32_t *count_p,
 508                                          union spoolss_DriverInfo **info_p)
 509 {
 510         struct spoolss_EnumPrinterDrivers r;
 511         uint32_t needed;
 512         uint32_t count;
 513         union spoolss_DriverInfo *info;
 514
 515         r.in.server             = server_name;
 516         r.in.environment        = environment;
 517         r.in.level              = level;
 518         r.in.buffer             = NULL;
 519         r.in.offered            = 0;
 520         r.out.needed            = &needed;
 521         r.out.count             = &count;
 522         r.out.info              = &info;
 523
 524         torture_comment(tctx, "Testing EnumPrinterDrivers(%s) level %u\n",
 525                 r.in.environment, r.in.level);
 526
 527         torture_assert_ntstatus_ok(tctx,
 528                 dcerpc_spoolss_EnumPrinterDrivers_r(b, tctx, &r),
 529                 "EnumPrinterDrivers failed");
 530         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 531                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
 532                 r.in.buffer = &blob;
 533                 r.in.offered = needed;
 534
 535                 torture_assert_ntstatus_ok(tctx,
 536                         dcerpc_spoolss_EnumPrinterDrivers_r(b, tctx, &r),
 537                         "EnumPrinterDrivers failed");
 538         }
 539
 540         torture_assert_werr_ok(tctx, r.out.result,
 541                 "EnumPrinterDrivers failed");
 542
 543         if (count_p) {
 544                 *count_p = count;
 545         }
 546         if (info_p) {
 547                 *info_p = info;
 548         }
 549
 550         CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinterDrivers, info, r.in.level, count, needed, 4);
 551
 552         return true;
 553
 554 }
 555
 556 static bool test_EnumPrinterDrivers_findone(struct torture_context *tctx,
 557                                             struct dcerpc_binding_handle *b,
 558                                             const char *server_name,
 559                                             const char *environment,
 560                                             uint32_t level,
 561                                             const char *driver_name)
 562 {
 563         uint32_t count;
 564         union spoolss_DriverInfo *info;
 565         int i;
 566
 567         torture_assert(tctx,
 568                 test_EnumPrinterDrivers_args(tctx, b, server_name, environment, level, &count, &info),
 569                 "failed to enumerate printer drivers");
 570
 571         for (i=0; i < count; i++) {
 572                 const char *driver_name_ret;
 573                 switch (level) {
 574                 case 1:
 575                         driver_name_ret = info[i].info1.driver_name;
 576                         break;
 577                 case 2:
 578                         driver_name_ret = info[i].info2.driver_name;
 579                         break;
 580                 case 3:
 581                         driver_name_ret = info[i].info3.driver_name;
 582                         break;
 583                 case 4:
 584                         driver_name_ret = info[i].info4.driver_name;
 585                         break;
 586                 case 5:
 587                         driver_name_ret = info[i].info5.driver_name;
 588                         break;
 589                 case 6:
 590                         driver_name_ret = info[i].info6.driver_name;
 591                         break;
 592                 case 7:
 593                         driver_name_ret = info[i].info7.driver_name;
 594                         break;
 595                 case 8:
 596                         driver_name_ret = info[i].info8.driver_name;
 597                         break;
 598                 default:
 599                         break;
 600                 }
 601                 if (strequal(driver_name, driver_name_ret)) {
 602                         return true;
 603                 }
 604         }
 605
 606         return false;
 607 }
 608
 609 static bool test_EnumPrinterDrivers(struct torture_context *tctx,
 610                                     void *private_data)
 611 {
 612         struct test_spoolss_context *ctx =
 613                 talloc_get_type_abort(private_data, struct test_spoolss_context);
 614         struct dcerpc_pipe *p = ctx->spoolss_pipe;
 615         struct dcerpc_binding_handle *b = p->binding_handle;
 616         uint16_t levels[] = { 1, 2, 3, 4, 5, 6, 8 };
 617         int i, j, a;
 618
 619         /* FIXME: gd, come back and fix "" as server, and handle
 620          * priority of returned error codes in torture test and samba 3
 621          * server */
 622         const char *server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 623         const char *environments[2];
 624
 625         environments[0] = SPOOLSS_ARCHITECTURE_ALL;
 626         environments[1] = ctx->environment;
 627
 628         for (a=0;a<ARRAY_SIZE(environments);a++) {
 629
 630         for (i=0;i<ARRAY_SIZE(levels);i++) {
 631                 int level = levels[i];
 632                 uint32_t count;
 633                 union spoolss_DriverInfo *info;
 634
 635                 torture_assert(tctx,
 636                         test_EnumPrinterDrivers_args(tctx, b, server_name, environments[a], level, &count, &info),
 637                         "failed to enumerate drivers");
 638
 639                 ctx->driver_count[level]        = count;
 640                 ctx->drivers[level]             = info;
 641         }
 642
 643         for (i=1;i<ARRAY_SIZE(levels);i++) {
 644                 int level = levels[i];
 645                 int old_level = levels[i-1];
 646
 647                 torture_assert_int_equal(tctx, ctx->driver_count[level], ctx->driver_count[old_level],
 648                         "EnumPrinterDrivers invalid value");
 649         }
 650
 651         for (i=0;i<ARRAY_SIZE(levels);i++) {
 652                 int level = levels[i];
 653
 654                 for (j=0;j<ctx->driver_count[level];j++) {
 655                         union spoolss_DriverInfo *cur = &ctx->drivers[level][j];
 656                         union spoolss_DriverInfo *ref = &ctx->drivers[8][j];
 657
 658                         switch (level) {
 659                         case 1:
 660                                 COMPARE_STRING(tctx, cur->info1, ref->info8, driver_name);
 661                                 break;
 662                         case 2:
 663                                 COMPARE_UINT32(tctx, cur->info2, ref->info8, version);
 664                                 COMPARE_STRING(tctx, cur->info2, ref->info8, driver_name);
 665                                 COMPARE_STRING(tctx, cur->info2, ref->info8, architecture);
 666                                 COMPARE_STRING(tctx, cur->info2, ref->info8, driver_path);
 667                                 COMPARE_STRING(tctx, cur->info2, ref->info8, data_file);
 668                                 COMPARE_STRING(tctx, cur->info2, ref->info8, config_file);
 669                                 break;
 670                         case 3:
 671                                 COMPARE_UINT32(tctx, cur->info3, ref->info8, version);
 672                                 COMPARE_STRING(tctx, cur->info3, ref->info8, driver_name);
 673                                 COMPARE_STRING(tctx, cur->info3, ref->info8, architecture);
 674                                 COMPARE_STRING(tctx, cur->info3, ref->info8, driver_path);
 675                                 COMPARE_STRING(tctx, cur->info3, ref->info8, data_file);
 676                                 COMPARE_STRING(tctx, cur->info3, ref->info8, config_file);
 677                                 COMPARE_STRING(tctx, cur->info3, ref->info8, help_file);
 678                                 COMPARE_STRING_ARRAY(tctx, cur->info3, ref->info8, dependent_files);
 679                                 COMPARE_STRING(tctx, cur->info3, ref->info8, monitor_name);
 680                                 COMPARE_STRING(tctx, cur->info3, ref->info8, default_datatype);
 681                                 break;
 682                         case 4:
 683                                 COMPARE_UINT32(tctx, cur->info4, ref->info8, version);
 684                                 COMPARE_STRING(tctx, cur->info4, ref->info8, driver_name);
 685                                 COMPARE_STRING(tctx, cur->info4, ref->info8, architecture);
 686                                 COMPARE_STRING(tctx, cur->info4, ref->info8, driver_path);
 687                                 COMPARE_STRING(tctx, cur->info4, ref->info8, data_file);
 688                                 COMPARE_STRING(tctx, cur->info4, ref->info8, config_file);
 689                                 COMPARE_STRING(tctx, cur->info4, ref->info8, help_file);
 690                                 COMPARE_STRING_ARRAY(tctx, cur->info4, ref->info8, dependent_files);
 691                                 COMPARE_STRING(tctx, cur->info4, ref->info8, monitor_name);
 692                                 COMPARE_STRING(tctx, cur->info4, ref->info8, default_datatype);
 693                                 COMPARE_STRING_ARRAY(tctx, cur->info4, ref->info8, previous_names);
 694                                 break;
 695                         case 5:
 696                                 COMPARE_UINT32(tctx, cur->info5, ref->info8, version);
 697                                 COMPARE_STRING(tctx, cur->info5, ref->info8, driver_name);
 698                                 COMPARE_STRING(tctx, cur->info5, ref->info8, architecture);
 699                                 COMPARE_STRING(tctx, cur->info5, ref->info8, driver_path);
 700                                 COMPARE_STRING(tctx, cur->info5, ref->info8, data_file);
 701                                 COMPARE_STRING(tctx, cur->info5, ref->info8, config_file);
 702                                 /*COMPARE_UINT32(tctx, cur->info5, ref->info8, driver_attributes);*/
 703                                 /*COMPARE_UINT32(tctx, cur->info5, ref->info8, config_version);*/
 704                                 /*TODO: ! COMPARE_UINT32(tctx, cur->info5, ref->info8, driver_version); */
 705                                 break;
 706                         case 6:
 707                                 COMPARE_UINT32(tctx, cur->info6, ref->info8, version);
 708                                 COMPARE_STRING(tctx, cur->info6, ref->info8, driver_name);
 709                                 COMPARE_STRING(tctx, cur->info6, ref->info8, architecture);
 710                                 COMPARE_STRING(tctx, cur->info6, ref->info8, driver_path);
 711                                 COMPARE_STRING(tctx, cur->info6, ref->info8, data_file);
 712                                 COMPARE_STRING(tctx, cur->info6, ref->info8, config_file);
 713                                 COMPARE_STRING(tctx, cur->info6, ref->info8, help_file);
 714                                 COMPARE_STRING_ARRAY(tctx, cur->info6, ref->info8, dependent_files);
 715                                 COMPARE_STRING(tctx, cur->info6, ref->info8, monitor_name);
 716                                 COMPARE_STRING(tctx, cur->info6, ref->info8, default_datatype);
 717                                 COMPARE_STRING_ARRAY(tctx, cur->info6, ref->info8, previous_names);
 718                                 COMPARE_NTTIME(tctx, cur->info6, ref->info8, driver_date);
 719                                 COMPARE_UINT64(tctx, cur->info6, ref->info8, driver_version);
 720                                 COMPARE_STRING(tctx, cur->info6, ref->info8, manufacturer_name);
 721                                 COMPARE_STRING(tctx, cur->info6, ref->info8, manufacturer_url);
 722                                 COMPARE_STRING(tctx, cur->info6, ref->info8, hardware_id);
 723                                 COMPARE_STRING(tctx, cur->info6, ref->info8, provider);
 724                                 break;
 725                         case 8:
 726                                 /* level 8 is our reference, and it makes no sense to compare it to itself */
 727                                 break;
 728                         }
 729                 }
 730         }
 731         }
 732
 733         return true;
 734 }
 735
 736 static bool test_EnumMonitors(struct torture_context *tctx,
 737                               void *private_data)
 738 {
 739         struct test_spoolss_context *ctx =
 740                 talloc_get_type_abort(private_data, struct test_spoolss_context);
 741         struct dcerpc_pipe *p = ctx->spoolss_pipe;
 742         struct dcerpc_binding_handle *b = p->binding_handle;
 743         NTSTATUS status;
 744         struct spoolss_EnumMonitors r;
 745         uint16_t levels[] = { 1, 2 };
 746         int i, j;
 747
 748         for (i=0;i<ARRAY_SIZE(levels);i++) {
 749                 int level = levels[i];
 750                 DATA_BLOB blob;
 751                 uint32_t needed;
 752                 uint32_t count;
 753                 union spoolss_MonitorInfo *info;
 754
 755                 r.in.servername = "";
 756                 r.in.level = level;
 757                 r.in.buffer = NULL;
 758                 r.in.offered = 0;
 759                 r.out.needed = &needed;
 760                 r.out.count = &count;
 761                 r.out.info = &info;
 762
 763                 torture_comment(tctx, "Testing EnumMonitors level %u\n", r.in.level);
 764
 765                 status = dcerpc_spoolss_EnumMonitors_r(b, ctx, &r);
 766                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
 767                 if (W_ERROR_IS_OK(r.out.result)) {
 768                         /* TODO: do some more checks here */
 769                         continue;
 770                 }
 771                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 772                         "EnumMonitors failed");
 773
 774                 blob = data_blob_talloc_zero(ctx, needed);
 775                 r.in.buffer = &blob;
 776                 r.in.offered = needed;
 777
 778                 status = dcerpc_spoolss_EnumMonitors_r(b, ctx, &r);
 779                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
 780
 781                 torture_assert_werr_ok(tctx, r.out.result, "EnumMonitors failed");
 782
 783                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumMonitors, info, r.in.level, count, needed, 4);
 784
 785                 ctx->monitor_count[level]       = count;
 786                 ctx->monitors[level]            = info;
 787         }
 788
 789         for (i=1;i<ARRAY_SIZE(levels);i++) {
 790                 int level = levels[i];
 791                 int old_level = levels[i-1];
 792                 torture_assert_int_equal(tctx, ctx->monitor_count[level], ctx->monitor_count[old_level],
 793                                          "EnumMonitors invalid value");
 794         }
 795
 796         for (i=0;i<ARRAY_SIZE(levels);i++) {
 797                 int level = levels[i];
 798                 for (j=0;j<ctx->monitor_count[level];j++) {
 799                         union spoolss_MonitorInfo *cur = &ctx->monitors[level][j];
 800                         union spoolss_MonitorInfo *ref = &ctx->monitors[2][j];
 801                         switch (level) {
 802                         case 1:
 803                                 COMPARE_STRING(tctx, cur->info1, ref->info2, monitor_name);
 804                                 break;
 805                         case 2:
 806                                 /* level 2 is our reference, and it makes no sense to compare it to itself */
 807                                 break;
 808                         }
 809                 }
 810         }
 811
 812         return true;
 813 }
 814
 815 static bool test_EnumPrintProcessors_level(struct torture_context *tctx,
 816                                            struct dcerpc_binding_handle *b,
 817                                            const char *environment,
 818                                            uint32_t level,
 819                                            uint32_t *count_p,
 820                                            union spoolss_PrintProcessorInfo **info_p)
 821 {
 822         struct spoolss_EnumPrintProcessors r;
 823         DATA_BLOB blob;
 824         uint32_t needed;
 825         uint32_t count;
 826         union spoolss_PrintProcessorInfo *info;
 827
 828         r.in.servername = "";
 829         r.in.environment = environment;
 830         r.in.level = level;
 831         r.in.buffer = NULL;
 832         r.in.offered = 0;
 833         r.out.needed = &needed;
 834         r.out.count = &count;
 835         r.out.info = &info;
 836
 837         torture_comment(tctx, "Testing EnumPrintProcessors level %u\n", r.in.level);
 838
 839         torture_assert_ntstatus_ok(tctx,
 840                 dcerpc_spoolss_EnumPrintProcessors_r(b, tctx, &r),
 841                 "EnumPrintProcessors failed");
 842         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 843                 blob = data_blob_talloc_zero(tctx, needed);
 844                 r.in.buffer = &blob;
 845                 r.in.offered = needed;
 846                 torture_assert_ntstatus_ok(tctx,
 847                         dcerpc_spoolss_EnumPrintProcessors_r(b, tctx, &r),
 848                         "EnumPrintProcessors failed");
 849         }
 850         torture_assert_werr_ok(tctx, r.out.result,
 851                 "EnumPrintProcessors failed");
 852
 853         CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcessors, info, level, count, needed, 4);
 854
 855         if (count_p) {
 856                 *count_p = count;
 857         }
 858         if (info_p) {
 859                 *info_p = info;
 860         }
 861
 862         return true;
 863 }
 864
 865 static bool test_EnumPrintProcessors(struct torture_context *tctx,
 866                                      void *private_data)
 867 {
 868         struct test_spoolss_context *ctx =
 869                 talloc_get_type_abort(private_data, struct test_spoolss_context);
 870
 871         uint16_t levels[] = { 1 };
 872         int i, j;
 873         struct dcerpc_pipe *p = ctx->spoolss_pipe;
 874         struct dcerpc_binding_handle *b = p->binding_handle;
 875
 876         for (i=0;i<ARRAY_SIZE(levels);i++) {
 877                 int level = levels[i];
 878                 union spoolss_PrintProcessorInfo *info;
 879                 uint32_t count;
 880
 881                 torture_assert(tctx,
 882                         test_EnumPrintProcessors_level(tctx, b, ctx->environment, level, &count, &info),
 883                         "test_EnumPrintProcessors_level failed");
 884
 885                 ctx->print_processor_count[level]       = count;
 886                 ctx->print_processors[level]            = info;
 887         }
 888
 889         for (i=1;i<ARRAY_SIZE(levels);i++) {
 890                 int level = levels[i];
 891                 int old_level = levels[i-1];
 892                 torture_assert_int_equal(tctx, ctx->print_processor_count[level], ctx->print_processor_count[old_level],
 893                         "EnumPrintProcessors failed");
 894         }
 895
 896         for (i=0;i<ARRAY_SIZE(levels);i++) {
 897                 int level = levels[i];
 898                 for (j=0;j<ctx->print_processor_count[level];j++) {
 899 #if 0
 900                         union spoolss_PrintProcessorInfo *cur = &ctx->print_processors[level][j];
 901                         union spoolss_PrintProcessorInfo *ref = &ctx->print_processors[1][j];
 902 #endif
 903                         switch (level) {
 904                         case 1:
 905                                 /* level 1 is our reference, and it makes no sense to compare it to itself */
 906                                 break;
 907                         }
 908                 }
 909         }
 910
 911         return true;
 912 }
 913
 914 static bool test_EnumPrintProcDataTypes(struct torture_context *tctx,
 915                                         void *private_data)
 916 {
 917         struct test_spoolss_context *ctx =
 918                 talloc_get_type_abort(private_data, struct test_spoolss_context);
 919
 920         NTSTATUS status;
 921         struct spoolss_EnumPrintProcDataTypes r;
 922         uint16_t levels[] = { 1 };
 923         int i;
 924         struct dcerpc_pipe *p = ctx->spoolss_pipe;
 925         struct dcerpc_binding_handle *b = p->binding_handle;
 926
 927         for (i=0;i<ARRAY_SIZE(levels);i++) {
 928                 int level = levels[i];
 929                 DATA_BLOB blob;
 930                 uint32_t needed;
 931                 uint32_t count;
 932                 union spoolss_PrintProcDataTypesInfo *info;
 933
 934                 r.in.servername = "";
 935                 r.in.print_processor_name = "winprint";
 936                 r.in.level = level;
 937                 r.in.buffer = NULL;
 938                 r.in.offered = 0;
 939                 r.out.needed = &needed;
 940                 r.out.count = &count;
 941                 r.out.info = &info;
 942
 943                 torture_comment(tctx, "Testing EnumPrintProcDataTypes level %u\n", r.in.level);
 944
 945                 status = dcerpc_spoolss_EnumPrintProcDataTypes_r(b, tctx, &r);
 946                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcDataType failed");
 947                 if (W_ERROR_IS_OK(r.out.result)) {
 948                         /* TODO: do some more checks here */
 949                         continue;
 950                 }
 951                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 952                         "EnumPrintProcDataTypes unexpected return code");
 953
 954                 blob = data_blob_talloc_zero(tctx, needed);
 955                 r.in.buffer = &blob;
 956                 r.in.offered = needed;
 957
 958                 status = dcerpc_spoolss_EnumPrintProcDataTypes_r(b, tctx, &r);
 959                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcDataTypes failed");
 960
 961                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcDataTypes failed");
 962
 963                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcDataTypes, info, r.in.level, count, needed, 4);
 964
 965         }
 966
 967         return true;
 968 }
 969
 970
 971 static bool test_EnumPrinters(struct torture_context *tctx,
 972                               void *private_data)
 973 {
 974         struct test_spoolss_context *ctx =
 975                 talloc_get_type_abort(private_data, struct test_spoolss_context);
 976         struct dcerpc_pipe *p = ctx->spoolss_pipe;
 977         struct dcerpc_binding_handle *b = p->binding_handle;
 978         struct spoolss_EnumPrinters r;
 979         NTSTATUS status;
 980         uint16_t levels[] = { 0, 1, 2, 4, 5 };
 981         int i, j;
 982
 983         for (i=0;i<ARRAY_SIZE(levels);i++) {
 984                 int level = levels[i];
 985                 DATA_BLOB blob;
 986                 uint32_t needed;
 987                 uint32_t count;
 988                 union spoolss_PrinterInfo *info;
 989
 990                 r.in.flags      = PRINTER_ENUM_LOCAL;
 991                 r.in.server     = "";
 992                 r.in.level      = level;
 993                 r.in.buffer     = NULL;
 994                 r.in.offered    = 0;
 995                 r.out.needed    = &needed;
 996                 r.out.count     = &count;
 997                 r.out.info      = &info;
 998
 999                 torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
1000
1001                 status = dcerpc_spoolss_EnumPrinters_r(b, ctx, &r);
1002                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
1003                 if (W_ERROR_IS_OK(r.out.result)) {
1004                         /* TODO: do some more checks here */
1005                         continue;
1006                 }
1007                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
1008                         "EnumPrinters unexpected return code");
1009
1010                 blob = data_blob_talloc_zero(ctx, needed);
1011                 r.in.buffer = &blob;
1012                 r.in.offered = needed;
1013
1014                 status = dcerpc_spoolss_EnumPrinters_r(b, ctx, &r);
1015                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
1016
1017                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
1018
1019                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, needed, 4);
1020
1021                 ctx->printer_count[level]       = count;
1022                 ctx->printers[level]            = info;
1023         }
1024
1025         for (i=1;i<ARRAY_SIZE(levels);i++) {
1026                 int level = levels[i];
1027                 int old_level = levels[i-1];
1028                 torture_assert_int_equal(tctx, ctx->printer_count[level], ctx->printer_count[old_level],
1029                                          "EnumPrinters invalid value");
1030         }
1031
1032         for (i=0;i<ARRAY_SIZE(levels);i++) {
1033                 int level = levels[i];
1034                 for (j=0;j<ctx->printer_count[level];j++) {
1035                         union spoolss_PrinterInfo *cur = &ctx->printers[level][j];
1036                         union spoolss_PrinterInfo *ref = &ctx->printers[2][j];
1037                         switch (level) {
1038                         case 0:
1039                                 COMPARE_STRING(tctx, cur->info0, ref->info2, printername);
1040                                 COMPARE_STRING(tctx, cur->info0, ref->info2, servername);
1041                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, cjobs);
1042                                 /*COMPARE_UINT32(tctx, cur->info0, ref->info2, total_jobs);
1043                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, total_bytes);
1044                                 COMPARE_SPOOLSS_TIME(cur->info0, ref->info2, spoolss_Time time);
1045                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, global_counter);
1046                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, total_pages);
1047                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, version);
1048                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown10);
1049                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown11);
1050                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown12);
1051                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, session_counter);
1052                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown14);
1053                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, printer_errors);
1054                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown16);
1055                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown17);
1056                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown18);
1057                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown19);
1058                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, change_id);
1059                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown21);*/
1060                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, status);
1061                                 /*COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown23);
1062                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, c_setprinter);
1063                                 COMPARE_UINT16(cur->info0, ref->info2, unknown25);
1064                                 COMPARE_UINT16(cur->info0, ref->info2, unknown26);
1065                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown27);
1066                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown28);
1067                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown29);*/
1068                                 break;
1069                         case 1:
1070                                 /*COMPARE_UINT32(tctx, cur->info1, ref->info2, flags);*/
1071                                 /*COMPARE_STRING(tctx, cur->info1, ref->info2, name);*/
1072                                 /*COMPARE_STRING(tctx, cur->info1, ref->info2, description);*/
1073                                 COMPARE_STRING(tctx, cur->info1, ref->info2, comment);
1074                                 break;
1075                         case 2:
1076                                 /* level 2 is our reference, and it makes no sense to compare it to itself */
1077                                 break;
1078                         case 4:
1079                                 COMPARE_STRING(tctx, cur->info4, ref->info2, printername);
1080                                 COMPARE_STRING(tctx, cur->info4, ref->info2, servername);
1081                                 COMPARE_UINT32(tctx, cur->info4, ref->info2, attributes);
1082                                 break;
1083                         case 5:
1084                                 COMPARE_STRING(tctx, cur->info5, ref->info2, printername);
1085                                 COMPARE_STRING(tctx, cur->info5, ref->info2, portname);
1086                                 COMPARE_UINT32(tctx, cur->info5, ref->info2, attributes);
1087                                 /*COMPARE_UINT32(tctx, cur->info5, ref->info2, device_not_selected_timeout);
1088                                 COMPARE_UINT32(tctx, cur->info5, ref->info2, transmission_retry_timeout);*/
1089                                 break;
1090                         }
1091                 }
1092         }
1093
1094         /* TODO:
1095          *      - verify that the port of a printer was in the list returned by EnumPorts
1096          */
1097
1098         return true;
1099 }
1100
1101 static bool test_GetPrinterDriver2(struct torture_context *tctx,
1102                                    struct dcerpc_binding_handle *b,
1103                                    struct policy_handle *handle,
1104                                    const char *driver_name,
1105                                    const char *environment);
1106
1107 bool test_GetPrinter_level(struct torture_context *tctx,
1108                            struct dcerpc_binding_handle *b,
1109                            struct policy_handle *handle,
1110                            uint32_t level,
1111                            union spoolss_PrinterInfo *info)
1112 {
1113         struct spoolss_GetPrinter r;
1114         uint32_t needed;
1115
1116         r.in.handle = handle;
1117         r.in.level = level;
1118         r.in.buffer = NULL;
1119         r.in.offered = 0;
1120         r.out.needed = &needed;
1121
1122         torture_comment(tctx, "Testing GetPrinter level %u\n", r.in.level);
1123
1124         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinter_r(b, tctx, &r),
1125                 "GetPrinter failed");
1126
1127         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
1128                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
1129                 r.in.buffer = &blob;
1130                 r.in.offered = needed;
1131
1132                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinter_r(b, tctx, &r),
1133                         "GetPrinter failed");
1134         }
1135
1136         torture_assert_werr_ok(tctx, r.out.result, "GetPrinter failed");
1137
1138         CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterInfo, r.out.info, r.in.level, needed, 4);
1139
1140         if (info && r.out.info) {
1141                 *info = *r.out.info;
1142         }
1143
1144         return true;
1145 }
1146
1147
1148 static bool test_GetPrinter(struct torture_context *tctx,
1149                             struct dcerpc_binding_handle *b,
1150                             struct policy_handle *handle,
1151                             const char *environment)
1152 {
1153         uint32_t levels[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
1154         int i;
1155
1156         for (i=0;i<ARRAY_SIZE(levels);i++) {
1157
1158                 union spoolss_PrinterInfo info;
1159
1160                 ZERO_STRUCT(info);
1161
1162                 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, levels[i], &info),
1163                         "failed to call GetPrinter");
1164
1165                 if ((levels[i] == 2) && info.info2.drivername && strlen(info.info2.drivername)) {
1166                         torture_assert(tctx,
1167                                 test_GetPrinterDriver2(tctx, b, handle, info.info2.drivername, environment),
1168                                 "failed to call test_GetPrinterDriver2");
1169                 }
1170         }
1171
1172         return true;
1173 }
1174
1175 static bool test_SetPrinter(struct torture_context *tctx,
1176                             struct dcerpc_binding_handle *b,
1177                             struct policy_handle *handle,
1178                             struct spoolss_SetPrinterInfoCtr *info_ctr,
1179                             struct spoolss_DevmodeContainer *devmode_ctr,
1180                             struct sec_desc_buf *secdesc_ctr,
1181                             enum spoolss_PrinterControl command)
1182 {
1183         struct spoolss_SetPrinter r;
1184
1185         r.in.handle = handle;
1186         r.in.info_ctr = info_ctr;
1187         r.in.devmode_ctr = devmode_ctr;
1188         r.in.secdesc_ctr = secdesc_ctr;
1189         r.in.command = command;
1190
1191         torture_comment(tctx, "Testing SetPrinter level %d\n", r.in.info_ctr->level);
1192
1193         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r),
1194                 "failed to call SetPrinter");
1195         torture_assert_werr_ok(tctx, r.out.result,
1196                 "failed to call SetPrinter");
1197
1198         return true;
1199 }
1200
1201 static bool test_SetPrinter_errors(struct torture_context *tctx,
1202                                    struct dcerpc_binding_handle *b,
1203                                    struct policy_handle *handle)
1204 {
1205         struct spoolss_SetPrinter r;
1206         uint16_t levels[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
1207         int i;
1208
1209         struct spoolss_SetPrinterInfoCtr info_ctr;
1210         struct spoolss_DevmodeContainer devmode_ctr;
1211         struct sec_desc_buf secdesc_ctr;
1212
1213         info_ctr.level = 0;
1214         info_ctr.info.info0 = NULL;
1215
1216         ZERO_STRUCT(devmode_ctr);
1217         ZERO_STRUCT(secdesc_ctr);
1218
1219         r.in.handle = handle;
1220         r.in.info_ctr = &info_ctr;
1221         r.in.devmode_ctr = &devmode_ctr;
1222         r.in.secdesc_ctr = &secdesc_ctr;
1223         r.in.command = 0;
1224
1225         torture_comment(tctx, "Testing SetPrinter all zero\n");
1226
1227         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r),
1228                 "failed to call SetPrinter");
1229         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
1230                 "failed to call SetPrinter");
1231
1232  again:
1233         for (i=0; i < ARRAY_SIZE(levels); i++) {
1234
1235                 struct spoolss_SetPrinterInfo0 info0;
1236                 struct spoolss_SetPrinterInfo1 info1;
1237                 struct spoolss_SetPrinterInfo2 info2;
1238                 struct spoolss_SetPrinterInfo3 info3;
1239                 struct spoolss_SetPrinterInfo4 info4;
1240                 struct spoolss_SetPrinterInfo5 info5;
1241                 struct spoolss_SetPrinterInfo6 info6;
1242                 struct spoolss_SetPrinterInfo7 info7;
1243                 struct spoolss_SetPrinterInfo8 info8;
1244                 struct spoolss_SetPrinterInfo9 info9;
1245
1246
1247                 info_ctr.level = levels[i];
1248                 switch (levels[i]) {
1249                 case 0:
1250                         ZERO_STRUCT(info0);
1251                         info_ctr.info.info0 = &info0;
1252                         break;
1253                 case 1:
1254                         ZERO_STRUCT(info1);
1255                         info_ctr.info.info1 = &info1;
1256                         break;
1257                 case 2:
1258                         ZERO_STRUCT(info2);
1259                         info_ctr.info.info2 = &info2;
1260                         break;
1261                 case 3:
1262                         ZERO_STRUCT(info3);
1263                         info_ctr.info.info3 = &info3;
1264                         break;
1265                 case 4:
1266                         ZERO_STRUCT(info4);
1267                         info_ctr.info.info4 = &info4;
1268                         break;
1269                 case 5:
1270                         ZERO_STRUCT(info5);
1271                         info_ctr.info.info5 = &info5;
1272                         break;
1273                 case 6:
1274                         ZERO_STRUCT(info6);
1275                         info_ctr.info.info6 = &info6;
1276                         break;
1277                 case 7:
1278                         ZERO_STRUCT(info7);
1279                         info_ctr.info.info7 = &info7;
1280                         break;
1281                 case 8:
1282                         ZERO_STRUCT(info8);
1283                         info_ctr.info.info8 = &info8;
1284                         break;
1285                 case 9:
1286                         ZERO_STRUCT(info9);
1287                         info_ctr.info.info9 = &info9;
1288                         break;
1289                 }
1290
1291                 torture_comment(tctx, "Testing SetPrinter level %d, command %d\n",
1292                         info_ctr.level, r.in.command);
1293
1294                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r),
1295                         "failed to call SetPrinter");
1296
1297                 switch (r.in.command) {
1298                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: /* 0 */
1299                         /* is ignored for all levels other then 0 */
1300                         if (info_ctr.level > 0) {
1301                                 /* ignored then */
1302                                 break;
1303                         }
1304                 case SPOOLSS_PRINTER_CONTROL_PAUSE: /* 1 */
1305                 case SPOOLSS_PRINTER_CONTROL_RESUME: /* 2 */
1306                 case SPOOLSS_PRINTER_CONTROL_PURGE: /* 3 */
1307                         if (info_ctr.level > 0) {
1308                                 /* is invalid for all levels other then 0 */
1309                                 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PRINTER_COMMAND,
1310                                         "unexpected error code returned");
1311                                 continue;
1312                         } else {
1313                                 torture_assert_werr_ok(tctx, r.out.result,
1314                                         "failed to call SetPrinter with non 0 command");
1315                                 continue;
1316                         }
1317                         break;
1318
1319                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: /* 4 */
1320                         /* FIXME: gd needs further investigation */
1321                 default:
1322                         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PRINTER_COMMAND,
1323                                 "unexpected error code returned");
1324                         continue;
1325                 }
1326
1327                 switch (info_ctr.level) {
1328                 case 1:
1329                         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
1330                                 "unexpected error code returned");
1331                         break;
1332                 case 2:
1333                         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_PRINTER_DRIVER,
1334                                 "unexpected error code returned");
1335                         break;
1336                 case 3:
1337                 case 4:
1338                 case 5:
1339                 case 7:
1340                         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
1341                                 "unexpected error code returned");
1342                         break;
1343                 case 9:
1344                         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1345                                 "unexpected error code returned");
1346                         break;
1347                 default:
1348                         torture_assert_werr_ok(tctx, r.out.result,
1349                                 "failed to call SetPrinter");
1350                         break;
1351                 }
1352         }
1353
1354         if (r.in.command < 5) {
1355                 r.in.command++;
1356                 goto again;
1357         }
1358
1359         return true;
1360 }
1361
1362 static void clear_info2(struct spoolss_SetPrinterInfoCtr *r)
1363 {
1364         if ((r->level == 2) && (r->info.info2)) {
1365                 r->info.info2->secdesc_ptr = 0;
1366                 r->info.info2->devmode_ptr = 0;
1367         }
1368 }
1369
1370 static bool test_PrinterInfo(struct torture_context *tctx,
1371                              struct dcerpc_binding_handle *b,
1372                              struct policy_handle *handle)
1373 {
1374         NTSTATUS status;
1375         struct spoolss_SetPrinter s;
1376         struct spoolss_GetPrinter q;
1377         struct spoolss_GetPrinter q0;
1378         struct spoolss_SetPrinterInfoCtr info_ctr;
1379         union spoolss_PrinterInfo info;
1380         struct spoolss_DevmodeContainer devmode_ctr;
1381         struct sec_desc_buf secdesc_ctr;
1382         uint32_t needed;
1383         bool ret = true;
1384         int i;
1385
1386         uint32_t status_list[] = {
1387                 /* these do not stick
1388                 PRINTER_STATUS_PAUSED,
1389                 PRINTER_STATUS_ERROR,
1390                 PRINTER_STATUS_PENDING_DELETION, */
1391                 PRINTER_STATUS_PAPER_JAM,
1392                 PRINTER_STATUS_PAPER_OUT,
1393                 PRINTER_STATUS_MANUAL_FEED,
1394                 PRINTER_STATUS_PAPER_PROBLEM,
1395                 PRINTER_STATUS_OFFLINE,
1396                 PRINTER_STATUS_IO_ACTIVE,
1397                 PRINTER_STATUS_BUSY,
1398                 PRINTER_STATUS_PRINTING,
1399                 PRINTER_STATUS_OUTPUT_BIN_FULL,
1400                 PRINTER_STATUS_NOT_AVAILABLE,
1401                 PRINTER_STATUS_WAITING,
1402                 PRINTER_STATUS_PROCESSING,
1403                 PRINTER_STATUS_INITIALIZING,
1404                 PRINTER_STATUS_WARMING_UP,
1405                 PRINTER_STATUS_TONER_LOW,
1406                 PRINTER_STATUS_NO_TONER,
1407                 PRINTER_STATUS_PAGE_PUNT,
1408                 PRINTER_STATUS_USER_INTERVENTION,
1409                 PRINTER_STATUS_OUT_OF_MEMORY,
1410                 PRINTER_STATUS_DOOR_OPEN,
1411                 PRINTER_STATUS_SERVER_UNKNOWN,
1412                 PRINTER_STATUS_POWER_SAVE,
1413                 /* these do not stick
1414                 0x02000000,
1415                 0x04000000,
1416                 0x08000000,
1417                 0x10000000,
1418                 0x20000000,
1419                 0x40000000,
1420                 0x80000000 */
1421         };
1422         uint32_t default_attribute = PRINTER_ATTRIBUTE_LOCAL;
1423         uint32_t attribute_list[] = {
1424                 PRINTER_ATTRIBUTE_QUEUED,
1425                 /* fails with WERR_INVALID_DATATYPE:
1426                 PRINTER_ATTRIBUTE_DIRECT, */
1427                 /* does not stick
1428                 PRINTER_ATTRIBUTE_DEFAULT, */
1429                 PRINTER_ATTRIBUTE_SHARED,
1430                 /* does not stick
1431                 PRINTER_ATTRIBUTE_NETWORK, */
1432                 PRINTER_ATTRIBUTE_HIDDEN,
1433                 PRINTER_ATTRIBUTE_LOCAL,
1434                 PRINTER_ATTRIBUTE_ENABLE_DEVQ,
1435                 PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS,
1436                 PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST,
1437                 PRINTER_ATTRIBUTE_WORK_OFFLINE,
1438                 /* does not stick
1439                 PRINTER_ATTRIBUTE_ENABLE_BIDI, */
1440                 /* fails with WERR_INVALID_DATATYPE:
1441                 PRINTER_ATTRIBUTE_RAW_ONLY, */
1442                 /* these do not stick
1443                 PRINTER_ATTRIBUTE_PUBLISHED,
1444                 PRINTER_ATTRIBUTE_FAX,
1445                 PRINTER_ATTRIBUTE_TS,
1446                 0x00010000,
1447                 0x00020000,
1448                 0x00040000,
1449                 0x00080000,
1450                 0x00100000,
1451                 0x00200000,
1452                 0x00400000,
1453                 0x00800000,
1454                 0x01000000,
1455                 0x02000000,
1456                 0x04000000,
1457                 0x08000000,
1458                 0x10000000,
1459                 0x20000000,
1460                 0x40000000,
1461                 0x80000000 */
1462         };
1463
1464         ZERO_STRUCT(devmode_ctr);
1465         ZERO_STRUCT(secdesc_ctr);
1466
1467         s.in.handle = handle;
1468         s.in.command = 0;
1469         s.in.info_ctr = &info_ctr;
1470         s.in.devmode_ctr = &devmode_ctr;
1471         s.in.secdesc_ctr = &secdesc_ctr;
1472
1473         q.in.handle = handle;
1474         q.out.info = &info;
1475         q0 = q;
1476
1477 #define TESTGETCALL(call, r) \
1478                 r.in.buffer = NULL; \
1479                 r.in.offered = 0;\
1480                 r.out.needed = &needed; \
1481                 status = dcerpc_spoolss_ ##call## _r(b, tctx, &r); \
1482                 if (!NT_STATUS_IS_OK(status)) { \
1483                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1484                                r.in.level, nt_errstr(status), __location__); \
1485                         ret = false; \
1486                         break; \
1487                 }\
1488                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {\
1489                         DATA_BLOB blob = data_blob_talloc_zero(tctx, needed); \
1490                         r.in.buffer = &blob; \
1491                         r.in.offered = needed; \
1492                 }\
1493                 status = dcerpc_spoolss_ ##call## _r(b, tctx, &r); \
1494                 if (!NT_STATUS_IS_OK(status)) { \
1495                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1496                                r.in.level, nt_errstr(status), __location__); \
1497                         ret = false; \
1498                         break; \
1499                 } \
1500                 if (!W_ERROR_IS_OK(r.out.result)) { \
1501                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1502                                r.in.level, win_errstr(r.out.result), __location__); \
1503                         ret = false; \
1504                         break; \
1505                 }
1506
1507
1508 #define TESTSETCALL_EXP(call, r, err) \
1509                 clear_info2(&info_ctr);\
1510                 status = dcerpc_spoolss_ ##call## _r(b, tctx, &r); \
1511                 if (!NT_STATUS_IS_OK(status)) { \
1512                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1513                                r.in.info_ctr->level, nt_errstr(status), __location__); \
1514                         ret = false; \
1515                         break; \
1516                 } \
1517                 if (!W_ERROR_IS_OK(err)) { \
1518                         if (!W_ERROR_EQUAL(err, r.out.result)) { \
1519                                 torture_comment(tctx, #call " level %u failed - %s, expected %s (%s)\n", \
1520                                        r.in.info_ctr->level, win_errstr(r.out.result), win_errstr(err), __location__); \
1521                                 ret = false; \
1522                         } \
1523                         break; \
1524                 } \
1525                 if (!W_ERROR_IS_OK(r.out.result)) { \
1526                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1527                                r.in.info_ctr->level, win_errstr(r.out.result), __location__); \
1528                         ret = false; \
1529                         break; \
1530                 }
1531
1532 #define TESTSETCALL(call, r) \
1533         TESTSETCALL_EXP(call, r, WERR_OK)
1534
1535 #define STRING_EQUAL(s1, s2, field) \
1536                 if ((s1 && !s2) || (s2 && !s1) || strcmp(s1, s2)) { \
1537                         torture_comment(tctx, "Failed to set %s to '%s' (%s)\n", \
1538                                #field, s2, __location__); \
1539                         ret = false; \
1540                         break; \
1541                 }
1542
1543 #define MEM_EQUAL(s1, s2, length, field) \
1544                 if ((s1 && !s2) || (s2 && !s1) || memcmp(s1, s2, length)) { \
1545                         torture_comment(tctx, "Failed to set %s to '%s' (%s)\n", \
1546                                #field, (const char *)s2, __location__); \
1547                         ret = false; \
1548                         break; \
1549                 }
1550
1551 #define INT_EQUAL(i1, i2, field) \
1552                 if (i1 != i2) { \
1553                         torture_comment(tctx, "Failed to set %s to 0x%llx - got 0x%llx (%s)\n", \
1554                                #field, (unsigned long long)i2, (unsigned long long)i1, __location__); \
1555                         ret = false; \
1556                         break; \
1557                 }
1558
1559 #define SD_EQUAL(sd1, sd2, field) \
1560                 if (!security_descriptor_equal(sd1, sd2)) { \
1561                         torture_comment(tctx, "Failed to set %s (%s)\n", \
1562                                #field, __location__); \
1563                         ret = false; \
1564                         break; \
1565                 }
1566
1567 #define TEST_PRINTERINFO_STRING_EXP_ERR(lvl1, field1, lvl2, field2, value, err) do { \
1568                 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
1569                 q.in.level = lvl1; \
1570                 TESTGETCALL(GetPrinter, q) \
1571                 info_ctr.level = lvl1; \
1572                 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
1573                 info_ctr.info.info ## lvl1->field1 = value;\
1574                 TESTSETCALL_EXP(SetPrinter, s, err) \
1575                 info_ctr.info.info ## lvl1->field1 = ""; \
1576                 TESTGETCALL(GetPrinter, q) \
1577                 info_ctr.info.info ## lvl1->field1 = value; \
1578                 STRING_EQUAL(info_ctr.info.info ## lvl1->field1, value, field1); \
1579                 q.in.level = lvl2; \
1580                 TESTGETCALL(GetPrinter, q) \
1581                 info_ctr.info.info ## lvl2 = (struct spoolss_SetPrinterInfo ## lvl2 *)(void *)&q.out.info->info ## lvl2; \
1582                 STRING_EQUAL(info_ctr.info.info ## lvl2->field2, value, field2); \
1583         } while (0)
1584
1585 #define TEST_PRINTERINFO_STRING(lvl1, field1, lvl2, field2, value) do { \
1586         TEST_PRINTERINFO_STRING_EXP_ERR(lvl1, field1, lvl2, field2, value, WERR_OK); \
1587         } while (0);
1588
1589 #define TEST_PRINTERINFO_INT_EXP(lvl1, field1, lvl2, field2, value, exp_value) do { \
1590                 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
1591                 q.in.level = lvl1; \
1592                 TESTGETCALL(GetPrinter, q) \
1593                 info_ctr.level = lvl1; \
1594                 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
1595                 info_ctr.info.info ## lvl1->field1 = value; \
1596                 TESTSETCALL(SetPrinter, s) \
1597                 info_ctr.info.info ## lvl1->field1 = 0; \
1598                 TESTGETCALL(GetPrinter, q) \
1599                 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
1600                 INT_EQUAL(info_ctr.info.info ## lvl1->field1, exp_value, field1); \
1601                 q.in.level = lvl2; \
1602                 TESTGETCALL(GetPrinter, q) \
1603                 info_ctr.info.info ## lvl2 = (struct spoolss_SetPrinterInfo ## lvl2 *)(void *)&q.out.info->info ## lvl2; \
1604                 INT_EQUAL(info_ctr.info.info ## lvl2->field2, exp_value, field1); \
1605         } while (0)
1606
1607 #define TEST_PRINTERINFO_INT(lvl1, field1, lvl2, field2, value) do { \
1608         TEST_PRINTERINFO_INT_EXP(lvl1, field1, lvl2, field2, value, value); \
1609         } while (0)
1610
1611         q0.in.level = 0;
1612         do { TESTGETCALL(GetPrinter, q0) } while (0);
1613
1614         TEST_PRINTERINFO_STRING(2, comment,  1, comment, "xx2-1 comment");
1615         TEST_PRINTERINFO_STRING(2, comment,  2, comment, "xx2-2 comment");
1616
1617         /* level 0 printername does not stick */
1618 /*      TEST_PRINTERINFO_STRING(2, printername,  0, printername, "xx2-0 printer"); */
1619         TEST_PRINTERINFO_STRING(2, printername,  1, name,        "xx2-1 printer");
1620         TEST_PRINTERINFO_STRING(2, printername,  2, printername, "xx2-2 printer");
1621         TEST_PRINTERINFO_STRING(2, printername,  4, printername, "xx2-4 printer");
1622         TEST_PRINTERINFO_STRING(2, printername,  5, printername, "xx2-5 printer");
1623 /*      TEST_PRINTERINFO_STRING(4, printername,  0, printername, "xx4-0 printer"); */
1624         TEST_PRINTERINFO_STRING(4, printername,  1, name,        "xx4-1 printer");
1625         TEST_PRINTERINFO_STRING(4, printername,  2, printername, "xx4-2 printer");
1626         TEST_PRINTERINFO_STRING(4, printername,  4, printername, "xx4-4 printer");
1627         TEST_PRINTERINFO_STRING(4, printername,  5, printername, "xx4-5 printer");
1628 /*      TEST_PRINTERINFO_STRING(5, printername,  0, printername, "xx5-0 printer"); */
1629         TEST_PRINTERINFO_STRING(5, printername,  1, name,        "xx5-1 printer");
1630         TEST_PRINTERINFO_STRING(5, printername,  2, printername, "xx5-2 printer");
1631         TEST_PRINTERINFO_STRING(5, printername,  4, printername, "xx5-4 printer");
1632         TEST_PRINTERINFO_STRING(5, printername,  5, printername, "xx5-5 printer");
1633
1634         /* servername can be set but does not stick
1635         TEST_PRINTERINFO_STRING(2, servername,  0, servername, "xx2-0 servername");
1636         TEST_PRINTERINFO_STRING(2, servername,  2, servername, "xx2-2 servername");
1637         TEST_PRINTERINFO_STRING(2, servername,  4, servername, "xx2-4 servername");
1638         */
1639
1640         /* passing an invalid port will result in WERR_UNKNOWN_PORT */
1641         TEST_PRINTERINFO_STRING_EXP_ERR(2, portname,  2, portname, "xx2-2 portname", WERR_UNKNOWN_PORT);
1642         TEST_PRINTERINFO_STRING_EXP_ERR(2, portname,  5, portname, "xx2-5 portname", WERR_UNKNOWN_PORT);
1643         TEST_PRINTERINFO_STRING_EXP_ERR(5, portname,  2, portname, "xx5-2 portname", WERR_UNKNOWN_PORT);
1644         TEST_PRINTERINFO_STRING_EXP_ERR(5, portname,  5, portname, "xx5-5 portname", WERR_UNKNOWN_PORT);
1645
1646         TEST_PRINTERINFO_STRING(2, sharename,   2, sharename,   "xx2-2 sharename");
1647         /* passing an invalid driver will result in WERR_UNKNOWN_PRINTER_DRIVER */
1648         TEST_PRINTERINFO_STRING_EXP_ERR(2, drivername,  2, drivername,  "xx2-2 drivername", WERR_UNKNOWN_PRINTER_DRIVER);
1649         TEST_PRINTERINFO_STRING(2, location,    2, location,    "xx2-2 location");
1650         /* passing an invalid sepfile will result in WERR_INVALID_SEPARATOR_FILE */
1651         TEST_PRINTERINFO_STRING_EXP_ERR(2, sepfile,     2, sepfile,     "xx2-2 sepfile", WERR_INVALID_SEPARATOR_FILE);
1652         /* passing an invalid printprocessor will result in WERR_UNKNOWN_PRINTPROCESSOR */
1653         TEST_PRINTERINFO_STRING_EXP_ERR(2, printprocessor, 2, printprocessor, "xx2-2 printprocessor", WERR_UNKNOWN_PRINTPROCESSOR);
1654         TEST_PRINTERINFO_STRING(2, datatype,    2, datatype,    "xx2-2 datatype");
1655         TEST_PRINTERINFO_STRING(2, parameters,  2, parameters,  "xx2-2 parameters");
1656
1657         for (i=0; i < ARRAY_SIZE(attribute_list); i++) {
1658 /*              TEST_PRINTERINFO_INT_EXP(2, attributes, 1, flags,
1659                         attribute_list[i],
1660                         (attribute_list[i] | default_attribute)
1661                         ); */
1662                 TEST_PRINTERINFO_INT_EXP(2, attributes, 2, attributes,
1663                         attribute_list[i],
1664                         (attribute_list[i] | default_attribute)
1665                         );
1666                 TEST_PRINTERINFO_INT_EXP(2, attributes, 4, attributes,
1667                         attribute_list[i],
1668                         (attribute_list[i] | default_attribute)
1669                         );
1670                 TEST_PRINTERINFO_INT_EXP(2, attributes, 5, attributes,
1671                         attribute_list[i],
1672                         (attribute_list[i] | default_attribute)
1673                         );
1674 /*              TEST_PRINTERINFO_INT_EXP(4, attributes, 1, flags,
1675                         attribute_list[i],
1676                         (attribute_list[i] | default_attribute)
1677                         ); */
1678                 TEST_PRINTERINFO_INT_EXP(4, attributes, 2, attributes,
1679                         attribute_list[i],
1680                         (attribute_list[i] | default_attribute)
1681                         );
1682                 TEST_PRINTERINFO_INT_EXP(4, attributes, 4, attributes,
1683                         attribute_list[i],
1684                         (attribute_list[i] | default_attribute)
1685                         );
1686                 TEST_PRINTERINFO_INT_EXP(4, attributes, 5, attributes,
1687                         attribute_list[i],
1688                         (attribute_list[i] | default_attribute)
1689                         );
1690 /*              TEST_PRINTERINFO_INT_EXP(5, attributes, 1, flags,
1691                         attribute_list[i],
1692                         (attribute_list[i] | default_attribute)
1693                         ); */
1694                 TEST_PRINTERINFO_INT_EXP(5, attributes, 2, attributes,
1695                         attribute_list[i],
1696                         (attribute_list[i] | default_attribute)
1697                         );
1698                 TEST_PRINTERINFO_INT_EXP(5, attributes, 4, attributes,
1699                         attribute_list[i],
1700                         (attribute_list[i] | default_attribute)
1701                         );
1702                 TEST_PRINTERINFO_INT_EXP(5, attributes, 5, attributes,
1703                         attribute_list[i],
1704                         (attribute_list[i] | default_attribute)
1705                         );
1706         }
1707
1708         for (i=0; i < ARRAY_SIZE(status_list); i++) {
1709                 /* level 2 sets do not stick
1710                 TEST_PRINTERINFO_INT(2, status, 0, status, status_list[i]);
1711                 TEST_PRINTERINFO_INT(2, status, 2, status, status_list[i]);
1712                 TEST_PRINTERINFO_INT(2, status, 6, status, status_list[i]); */
1713                 TEST_PRINTERINFO_INT(6, status, 0, status, status_list[i]);
1714                 TEST_PRINTERINFO_INT(6, status, 2, status, status_list[i]);
1715                 TEST_PRINTERINFO_INT(6, status, 6, status, status_list[i]);
1716         }
1717
1718         /* priorities need to be between 0 and 99
1719            passing an invalid priority will result in WERR_INVALID_PRIORITY */
1720         TEST_PRINTERINFO_INT(2, priority,       2, priority, 0);
1721         TEST_PRINTERINFO_INT(2, priority,       2, priority, 1);
1722         TEST_PRINTERINFO_INT(2, priority,       2, priority, 99);
1723         /* TEST_PRINTERINFO_INT(2, priority,    2, priority, 100); */
1724         TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 0);
1725         TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 1);
1726         TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 99);
1727         /* TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 100); */
1728
1729         TEST_PRINTERINFO_INT(2, starttime,      2, starttime, __LINE__);
1730         TEST_PRINTERINFO_INT(2, untiltime,      2, untiltime, __LINE__);
1731
1732         /* does not stick
1733         TEST_PRINTERINFO_INT(2, cjobs,          2, cjobs, __LINE__);
1734         TEST_PRINTERINFO_INT(2, averageppm,     2, averageppm, __LINE__); */
1735
1736         /* does not stick
1737         TEST_PRINTERINFO_INT(5, device_not_selected_timeout, 5, device_not_selected_timeout, __LINE__);
1738         TEST_PRINTERINFO_INT(5, transmission_retry_timeout, 5, transmission_retry_timeout, __LINE__); */
1739
1740         /* FIXME: gd also test devmode and secdesc behavior */
1741
1742         {
1743                 /* verify composition of level 1 description field */
1744                 const char *description;
1745                 const char *tmp;
1746
1747                 q0.in.level = 1;
1748                 do { TESTGETCALL(GetPrinter, q0) } while (0);
1749
1750                 description = talloc_strdup(tctx, q0.out.info->info1.description);
1751
1752                 q0.in.level = 2;
1753                 do { TESTGETCALL(GetPrinter, q0) } while (0);
1754
1755                 tmp = talloc_asprintf(tctx, "%s,%s,%s",
1756                         q0.out.info->info2.printername,
1757                         q0.out.info->info2.drivername,
1758                         q0.out.info->info2.location);
1759
1760                 do { STRING_EQUAL(description, tmp, "description")} while (0);
1761         }
1762
1763         return ret;
1764 }
1765
1766 #define torture_assert_sid_equal(torture_ctx,got,expected,cmt)\
1767         do { struct dom_sid *__got = (got), *__expected = (expected); \
1768         if (!dom_sid_equal(__got, __expected)) { \
1769                 torture_result(torture_ctx, TORTURE_FAIL, \
1770                                            __location__": "#got" was %s, expected %s: %s", \
1771                                            dom_sid_string(torture_ctx, __got), dom_sid_string(torture_ctx, __expected), cmt); \
1772                 return false; \
1773         } \
1774         } while(0)
1775
1776 static bool test_security_descriptor_equal(struct torture_context *tctx,
1777                                            const struct security_descriptor *sd1,
1778                                            const struct security_descriptor *sd2)
1779 {
1780         if (sd1 == sd2) {
1781                 return true;
1782         }
1783
1784         if (!sd1 || !sd2) {
1785                 torture_comment(tctx, "%s\n", __location__);
1786                 return false;
1787         }
1788
1789         torture_assert_int_equal(tctx, sd1->revision, sd2->revision, "revision mismatch");
1790         torture_assert_int_equal(tctx, sd1->type, sd2->type, "type mismatch");
1791
1792         torture_assert_sid_equal(tctx, sd1->owner_sid, sd2->owner_sid, "owner mismatch");
1793         torture_assert_sid_equal(tctx, sd1->group_sid, sd2->group_sid, "group mismatch");
1794
1795         if (!security_acl_equal(sd1->sacl, sd2->sacl)) {
1796                 torture_comment(tctx, "%s: sacl mismatch\n", __location__);
1797                 NDR_PRINT_DEBUG(security_acl, sd1->sacl);
1798                 NDR_PRINT_DEBUG(security_acl, sd2->sacl);
1799                 return false;
1800         }
1801         if (!security_acl_equal(sd1->dacl, sd2->dacl)) {
1802                 torture_comment(tctx, "%s: dacl mismatch\n", __location__);
1803                 NDR_PRINT_DEBUG(security_acl, sd1->dacl);
1804                 NDR_PRINT_DEBUG(security_acl, sd2->dacl);
1805                 return false;
1806         }
1807
1808         return true;
1809 }
1810
1811 static bool test_sd_set_level(struct torture_context *tctx,
1812                               struct dcerpc_binding_handle *b,
1813                               struct policy_handle *handle,
1814                               uint32_t level,
1815                               struct security_descriptor *sd)
1816 {
1817         struct spoolss_SetPrinterInfoCtr info_ctr;
1818         struct spoolss_DevmodeContainer devmode_ctr;
1819         struct sec_desc_buf secdesc_ctr;
1820         union spoolss_SetPrinterInfo sinfo;
1821
1822         ZERO_STRUCT(devmode_ctr);
1823         ZERO_STRUCT(secdesc_ctr);
1824
1825         switch (level) {
1826         case 2: {
1827                 union spoolss_PrinterInfo info;
1828                 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1829                 torture_assert(tctx, PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
1830
1831                 info_ctr.level = 2;
1832                 info_ctr.info = sinfo;
1833
1834                 break;
1835         }
1836         case 3: {
1837                 struct spoolss_SetPrinterInfo3 info3;
1838
1839                 info3.sec_desc_ptr = 0;
1840
1841                 info_ctr.level = 3;
1842                 info_ctr.info.info3 = &info3;
1843
1844                 break;
1845         }
1846         default:
1847                 return false;
1848         }
1849
1850         secdesc_ctr.sd = sd;
1851
1852         torture_assert(tctx,
1853                 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0), "");
1854
1855         return true;
1856 }
1857
1858 static bool test_PrinterInfo_SDs(struct torture_context *tctx,
1859                                  struct dcerpc_binding_handle *b,
1860                                  struct policy_handle *handle)
1861 {
1862         union spoolss_PrinterInfo info;
1863         struct security_descriptor *sd1, *sd2;
1864         int i;
1865
1866         /* just compare level 2 and level 3 */
1867
1868         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1869
1870         sd1 = info.info2.secdesc;
1871
1872         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 3, &info), "");
1873
1874         sd2 = info.info3.secdesc;
1875
1876         torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1877                 "SD level 2 != SD level 3");
1878
1879
1880         /* query level 2, set level 2, query level 2 */
1881
1882         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1883
1884         sd1 = info.info2.secdesc;
1885
1886         torture_assert(tctx, test_sd_set_level(tctx, b, handle, 2, sd1), "");
1887
1888         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1889
1890         sd2 = info.info2.secdesc;
1891         if (sd1->type & SEC_DESC_DACL_DEFAULTED) {
1892                 torture_comment(tctx, "removing SEC_DESC_DACL_DEFAULTED\n");
1893                 sd1->type &= ~SEC_DESC_DACL_DEFAULTED;
1894         }
1895
1896         torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1897                 "SD level 2 != SD level 2 after SD has been set via level 2");
1898
1899
1900         /* query level 2, set level 3, query level 2 */
1901
1902         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1903
1904         sd1 = info.info2.secdesc;
1905
1906         torture_assert(tctx, test_sd_set_level(tctx, b, handle, 3, sd1), "");
1907
1908         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1909
1910         sd2 = info.info2.secdesc;
1911
1912         torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1913                 "SD level 2 != SD level 2 after SD has been set via level 3");
1914
1915         /* set modified sd level 3, query level 2 */
1916
1917         for (i=0; i < 93; i++) {
1918                 struct security_ace a;
1919                 const char *sid_string = talloc_asprintf(tctx, "S-1-5-32-9999%i", i);
1920                 a.type = SEC_ACE_TYPE_ACCESS_ALLOWED;
1921                 a.flags = 0;
1922                 a.size = 0; /* autogenerated */
1923                 a.access_mask = 0;
1924                 a.trustee = *dom_sid_parse_talloc(tctx, sid_string);
1925                 torture_assert_ntstatus_ok(tctx, security_descriptor_dacl_add(sd1, &a), "");
1926         }
1927
1928         torture_assert(tctx, test_sd_set_level(tctx, b, handle, 3, sd1), "");
1929
1930         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1931         sd2 = info.info2.secdesc;
1932
1933         if (sd1->type & SEC_DESC_DACL_DEFAULTED) {
1934                 torture_comment(tctx, "removing SEC_DESC_DACL_DEFAULTED\n");
1935                 sd1->type &= ~SEC_DESC_DACL_DEFAULTED;
1936         }
1937
1938         torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1939                 "modified SD level 2 != SD level 2 after SD has been set via level 3");
1940
1941
1942         return true;
1943 }
1944
1945 /*
1946  * wrapper call that saves original sd, runs tests, and restores sd
1947  */
1948
1949 static bool test_PrinterInfo_SD(struct torture_context *tctx,
1950                                 struct dcerpc_binding_handle *b,
1951                                 struct policy_handle *handle)
1952 {
1953         union spoolss_PrinterInfo info;
1954         struct security_descriptor *sd;
1955         bool ret = true;
1956
1957         torture_comment(tctx, "Testing Printer Security Descriptors\n");
1958
1959         /* save original sd */
1960
1961         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info),
1962                 "failed to get initial security descriptor");
1963
1964         sd = security_descriptor_copy(tctx, info.info2.secdesc);
1965
1966         /* run tests */
1967
1968         ret = test_PrinterInfo_SDs(tctx, b, handle);
1969
1970         /* restore original sd */
1971
1972         torture_assert(tctx, test_sd_set_level(tctx, b, handle, 3, sd),
1973                 "failed to restore initial security descriptor");
1974
1975         torture_comment(tctx, "Printer Security Descriptors test %s\n\n",
1976                 ret ? "succeeded" : "failed");
1977
1978
1979         return ret;
1980 }
1981
1982 static bool test_devmode_set_level(struct torture_context *tctx,
1983                                    struct dcerpc_binding_handle *b,
1984                                    struct policy_handle *handle,
1985                                    uint32_t level,
1986                                    struct spoolss_DeviceMode *devmode)
1987 {
1988         struct spoolss_SetPrinterInfoCtr info_ctr;
1989         struct spoolss_DevmodeContainer devmode_ctr;
1990         struct sec_desc_buf secdesc_ctr;
1991         union spoolss_SetPrinterInfo sinfo;
1992
1993         ZERO_STRUCT(devmode_ctr);
1994         ZERO_STRUCT(secdesc_ctr);
1995
1996         switch (level) {
1997         case 2: {
1998                 union spoolss_PrinterInfo info;
1999                 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
2000                 torture_assert(tctx, PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
2001
2002                 info_ctr.level = 2;
2003                 info_ctr.info = sinfo;
2004
2005                 break;
2006         }
2007         case 8: {
2008                 struct spoolss_SetPrinterInfo8 info8;
2009
2010                 info8.devmode_ptr = 0;
2011
2012                 info_ctr.level = 8;
2013                 info_ctr.info.info8 = &info8;
2014
2015                 break;
2016         }
2017         default:
2018                 return false;
2019         }
2020
2021         devmode_ctr.devmode = devmode;
2022
2023         torture_assert(tctx,
2024                 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0), "");
2025
2026         return true;
2027 }
2028
2029
2030 static bool test_devicemode_equal(struct torture_context *tctx,
2031                                   const struct spoolss_DeviceMode *d1,
2032                                   const struct spoolss_DeviceMode *d2)
2033 {
2034         if (d1 == d2) {
2035                 return true;
2036         }
2037
2038         if (!d1 || !d2) {
2039                 torture_comment(tctx, "%s\n", __location__);
2040                 return false;
2041         }
2042         torture_assert_str_equal(tctx, d1->devicename, d2->devicename, "devicename mismatch");
2043         torture_assert_int_equal(tctx, d1->specversion, d2->specversion, "specversion mismatch");
2044         torture_assert_int_equal(tctx, d1->driverversion, d2->driverversion, "driverversion mismatch");
2045         torture_assert_int_equal(tctx, d1->size, d2->size, "size mismatch");
2046         torture_assert_int_equal(tctx, d1->__driverextra_length, d2->__driverextra_length, "__driverextra_length mismatch");
2047         torture_assert_int_equal(tctx, d1->fields, d2->fields, "fields mismatch");
2048         torture_assert_int_equal(tctx, d1->orientation, d2->orientation, "orientation mismatch");
2049         torture_assert_int_equal(tctx, d1->papersize, d2->papersize, "papersize mismatch");
2050         torture_assert_int_equal(tctx, d1->paperlength, d2->paperlength, "paperlength mismatch");
2051         torture_assert_int_equal(tctx, d1->paperwidth, d2->paperwidth, "paperwidth mismatch");
2052         torture_assert_int_equal(tctx, d1->scale, d2->scale, "scale mismatch");
2053         torture_assert_int_equal(tctx, d1->copies, d2->copies, "copies mismatch");
2054         torture_assert_int_equal(tctx, d1->defaultsource, d2->defaultsource, "defaultsource mismatch");
2055         torture_assert_int_equal(tctx, d1->printquality, d2->printquality, "printquality mismatch");
2056         torture_assert_int_equal(tctx, d1->color, d2->color, "color mismatch");
2057         torture_assert_int_equal(tctx, d1->duplex, d2->duplex, "duplex mismatch");
2058         torture_assert_int_equal(tctx, d1->yresolution, d2->yresolution, "yresolution mismatch");
2059         torture_assert_int_equal(tctx, d1->ttoption, d2->ttoption, "ttoption mismatch");
2060         torture_assert_int_equal(tctx, d1->collate, d2->collate, "collate mismatch");
2061         torture_assert_str_equal(tctx, d1->formname, d2->formname, "formname mismatch");
2062         torture_assert_int_equal(tctx, d1->logpixels, d2->logpixels, "logpixels mismatch");
2063         torture_assert_int_equal(tctx, d1->bitsperpel, d2->bitsperpel, "bitsperpel mismatch");
2064         torture_assert_int_equal(tctx, d1->pelswidth, d2->pelswidth, "pelswidth mismatch");
2065         torture_assert_int_equal(tctx, d1->pelsheight, d2->pelsheight, "pelsheight mismatch");
2066         torture_assert_int_equal(tctx, d1->displayflags, d2->displayflags, "displayflags mismatch");
2067         torture_assert_int_equal(tctx, d1->displayfrequency, d2->displayfrequency, "displayfrequency mismatch");
2068         torture_assert_int_equal(tctx, d1->icmmethod, d2->icmmethod, "icmmethod mismatch");
2069         torture_assert_int_equal(tctx, d1->icmintent, d2->icmintent, "icmintent mismatch");
2070         torture_assert_int_equal(tctx, d1->mediatype, d2->mediatype, "mediatype mismatch");
2071         torture_assert_int_equal(tctx, d1->dithertype, d2->dithertype, "dithertype mismatch");
2072         torture_assert_int_equal(tctx, d1->reserved1, d2->reserved1, "reserved1 mismatch");
2073         torture_assert_int_equal(tctx, d1->reserved2, d2->reserved2, "reserved2 mismatch");
2074         torture_assert_int_equal(tctx, d1->panningwidth, d2->panningwidth, "panningwidth mismatch");
2075         torture_assert_int_equal(tctx, d1->panningheight, d2->panningheight, "panningheight mismatch");
2076         torture_assert_data_blob_equal(tctx, d1->driverextra_data, d2->driverextra_data, "driverextra_data mismatch");
2077
2078         return true;
2079 }
2080
2081 static bool test_devicemode_full(struct torture_context *tctx,
2082                                  struct dcerpc_binding_handle *b,
2083                                  struct policy_handle *handle)
2084 {
2085         struct spoolss_SetPrinter s;
2086         struct spoolss_GetPrinter q;
2087         struct spoolss_GetPrinter q0;
2088         struct spoolss_SetPrinterInfoCtr info_ctr;
2089         struct spoolss_SetPrinterInfo8 info8;
2090         union spoolss_PrinterInfo info;
2091         struct spoolss_DevmodeContainer devmode_ctr;
2092         struct sec_desc_buf secdesc_ctr;
2093         uint32_t needed;
2094         bool ret = true;
2095         NTSTATUS status;
2096
2097 #define TEST_DEVMODE_INT_EXP(lvl1, field1, lvl2, field2, value, exp_value) do { \
2098                 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
2099                 q.in.level = lvl1; \
2100                 TESTGETCALL(GetPrinter, q) \
2101                 info_ctr.level = lvl1; \
2102                 if (lvl1 == 2) {\
2103                         info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
2104                 } else if (lvl1 == 8) {\
2105                         info_ctr.info.info ## lvl1 = &info8; \
2106                 }\
2107                 devmode_ctr.devmode = q.out.info->info ## lvl1.devmode; \
2108                 devmode_ctr.devmode->field1 = value; \
2109                 TESTSETCALL(SetPrinter, s) \
2110                 TESTGETCALL(GetPrinter, q) \
2111                 INT_EQUAL(q.out.info->info ## lvl1.devmode->field1, exp_value, field1); \
2112                 q.in.level = lvl2; \
2113                 TESTGETCALL(GetPrinter, q) \
2114                 INT_EQUAL(q.out.info->info ## lvl2.devmode->field2, exp_value, field1); \
2115         } while (0)
2116
2117 #define TEST_DEVMODE_INT(lvl1, field1, lvl2, field2, value) do { \
2118         TEST_DEVMODE_INT_EXP(lvl1, field1, lvl2, field2, value, value); \
2119         } while (0)
2120
2121         ZERO_STRUCT(devmode_ctr);
2122         ZERO_STRUCT(secdesc_ctr);
2123         ZERO_STRUCT(info8);
2124
2125         s.in.handle = handle;
2126         s.in.command = 0;
2127         s.in.info_ctr = &info_ctr;
2128         s.in.devmode_ctr = &devmode_ctr;
2129         s.in.secdesc_ctr = &secdesc_ctr;
2130
2131         q.in.handle = handle;
2132         q.out.info = &info;
2133         q0 = q;
2134
2135 #if 0
2136         const char *devicename;/* [charset(UTF16)] */
2137         enum spoolss_DeviceModeSpecVersion specversion;
2138         uint16_t driverversion;
2139         uint16_t size;
2140         uint16_t __driverextra_length;/* [value(r->driverextra_data.length)] */
2141         uint32_t fields;
2142 #endif
2143
2144         TEST_DEVMODE_INT(8, orientation,        8, orientation, __LINE__);
2145         TEST_DEVMODE_INT(8, papersize,          8, papersize, __LINE__);
2146         TEST_DEVMODE_INT(8, paperlength,        8, paperlength, __LINE__);
2147         TEST_DEVMODE_INT(8, paperwidth,         8, paperwidth, __LINE__);
2148         TEST_DEVMODE_INT(8, scale,              8, scale, __LINE__);
2149         TEST_DEVMODE_INT(8, copies,             8, copies, __LINE__);
2150         TEST_DEVMODE_INT(8, defaultsource,      8, defaultsource, __LINE__);
2151         TEST_DEVMODE_INT(8, printquality,       8, printquality, __LINE__);
2152         TEST_DEVMODE_INT(8, color,              8, color, __LINE__);
2153         TEST_DEVMODE_INT(8, duplex,             8, duplex, __LINE__);
2154         TEST_DEVMODE_INT(8, yresolution,        8, yresolution, __LINE__);
2155         TEST_DEVMODE_INT(8, ttoption,           8, ttoption, __LINE__);
2156         TEST_DEVMODE_INT(8, collate,            8, collate, __LINE__);
2157 #if 0
2158         const char *formname;/* [charset(UTF16)] */
2159 #endif
2160         TEST_DEVMODE_INT(8, logpixels,          8, logpixels, __LINE__);
2161         TEST_DEVMODE_INT(8, bitsperpel,         8, bitsperpel, __LINE__);
2162         TEST_DEVMODE_INT(8, pelswidth,          8, pelswidth, __LINE__);
2163         TEST_DEVMODE_INT(8, pelsheight,         8, pelsheight, __LINE__);
2164         TEST_DEVMODE_INT(8, displayflags,       8, displayflags, __LINE__);
2165         TEST_DEVMODE_INT(8, displayfrequency,   8, displayfrequency, __LINE__);
2166         TEST_DEVMODE_INT(8, icmmethod,          8, icmmethod, __LINE__);
2167         TEST_DEVMODE_INT(8, icmintent,          8, icmintent, __LINE__);
2168         TEST_DEVMODE_INT(8, mediatype,          8, mediatype, __LINE__);
2169         TEST_DEVMODE_INT(8, dithertype,         8, dithertype, __LINE__);
2170         TEST_DEVMODE_INT(8, reserved1,          8, reserved1, __LINE__);
2171         TEST_DEVMODE_INT(8, reserved2,          8, reserved2, __LINE__);
2172         TEST_DEVMODE_INT(8, panningwidth,       8, panningwidth, __LINE__);
2173         TEST_DEVMODE_INT(8, panningheight,      8, panningheight, __LINE__);
2174
2175         return ret;
2176 }
2177
2178 static bool call_OpenPrinterEx(struct torture_context *tctx,
2179                                struct dcerpc_pipe *p,
2180                                const char *name,
2181                                struct spoolss_DeviceMode *devmode,
2182                                struct policy_handle *handle);
2183
2184 static bool test_ClosePrinter(struct torture_context *tctx,
2185                               struct dcerpc_binding_handle *b,
2186                               struct policy_handle *handle);
2187
2188 static bool test_PrinterInfo_DevModes(struct torture_context *tctx,
2189                                       struct dcerpc_pipe *p,
2190                                       struct policy_handle *handle,
2191                                       const char *name)
2192 {
2193         union spoolss_PrinterInfo info;
2194         struct spoolss_DeviceMode *devmode;
2195         struct spoolss_DeviceMode *devmode2;
2196         struct policy_handle handle_devmode;
2197         struct dcerpc_binding_handle *b = p->binding_handle;
2198
2199         /* simply compare level8 and level2 devmode */
2200
2201         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info), "");
2202
2203         devmode = info.info8.devmode;
2204
2205         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
2206
2207         devmode2 = info.info2.devmode;
2208
2209         torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2210                 "DM level 8 != DM level 2");
2211
2212
2213         /* set devicemode level 8 and see if it persists */
2214
2215         devmode->copies = 93;
2216         devmode->formname = talloc_strdup(tctx, "Legal");
2217
2218         torture_assert(tctx, test_devmode_set_level(tctx, b, handle, 8, devmode), "");
2219
2220         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info), "");
2221
2222         devmode2 = info.info8.devmode;
2223
2224         torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2225                 "modified DM level 8 != DM level 8 after DM has been set via level 8");
2226
2227         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
2228
2229         devmode2 = info.info2.devmode;
2230
2231         torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2232                 "modified DM level 8 != DM level 2");
2233
2234
2235         /* set devicemode level 2 and see if it persists */
2236
2237         devmode->copies = 39;
2238         devmode->formname = talloc_strdup(tctx, "Executive");
2239
2240         torture_assert(tctx, test_devmode_set_level(tctx, b, handle, 2, devmode), "");
2241
2242         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info), "");
2243
2244         devmode2 = info.info8.devmode;
2245
2246         torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2247                 "modified DM level 8 != DM level 8 after DM has been set via level 2");
2248
2249         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
2250
2251         devmode2 = info.info2.devmode;
2252
2253         torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2254                 "modified DM level 8 != DM level 2");
2255
2256
2257         /* check every single bit in public part of devicemode */
2258
2259         torture_assert(tctx, test_devicemode_full(tctx, b, handle),
2260                 "failed to set every single devicemode component");
2261
2262
2263         /* change formname upon open and see if it persists in getprinter calls */
2264
2265         devmode->formname = talloc_strdup(tctx, "A4");
2266         devmode->copies = 42;
2267
2268         torture_assert(tctx, call_OpenPrinterEx(tctx, p, name, devmode, &handle_devmode),
2269                 "failed to open printer handle");
2270
2271         torture_assert(tctx, test_GetPrinter_level(tctx, b, &handle_devmode, 8, &info), "");
2272
2273         devmode2 = info.info8.devmode;
2274
2275         if (strequal(devmode->devicename, devmode2->devicename)) {
2276                 torture_warning(tctx, "devicenames are the same\n");
2277         } else {
2278                 torture_comment(tctx, "devicename passed in for open: %s\n", devmode->devicename);
2279                 torture_comment(tctx, "devicename after level 8 get: %s\n", devmode2->devicename);
2280         }
2281
2282         if (strequal(devmode->formname, devmode2->formname)) {
2283                 torture_warning(tctx, "formname are the same\n");
2284         } else {
2285                 torture_comment(tctx, "formname passed in for open: %s\n", devmode->formname);
2286                 torture_comment(tctx, "formname after level 8 get: %s\n", devmode2->formname);
2287         }
2288
2289         if (devmode->copies == devmode2->copies) {
2290                 torture_warning(tctx, "copies are the same\n");
2291         } else {
2292                 torture_comment(tctx, "copies passed in for open: %d\n", devmode->copies);
2293                 torture_comment(tctx, "copies after level 8 get: %d\n", devmode2->copies);
2294         }
2295
2296         torture_assert(tctx, test_GetPrinter_level(tctx, b, &handle_devmode, 2, &info), "");
2297
2298         devmode2 = info.info2.devmode;
2299
2300         if (strequal(devmode->devicename, devmode2->devicename)) {
2301                 torture_warning(tctx, "devicenames are the same\n");
2302         } else {
2303                 torture_comment(tctx, "devicename passed in for open: %s\n", devmode->devicename);
2304                 torture_comment(tctx, "devicename after level 2 get: %s\n", devmode2->devicename);
2305         }
2306
2307         if (strequal(devmode->formname, devmode2->formname)) {
2308                 torture_warning(tctx, "formname is the same\n");
2309         } else {
2310                 torture_comment(tctx, "formname passed in for open: %s\n", devmode->formname);
2311                 torture_comment(tctx, "formname after level 2 get: %s\n", devmode2->formname);
2312         }
2313
2314         if (devmode->copies == devmode2->copies) {
2315                 torture_warning(tctx, "copies are the same\n");
2316         } else {
2317                 torture_comment(tctx, "copies passed in for open: %d\n", devmode->copies);
2318                 torture_comment(tctx, "copies after level 2 get: %d\n", devmode2->copies);
2319         }
2320
2321         test_ClosePrinter(tctx, b, &handle_devmode);
2322
2323         return true;
2324 }
2325
2326 /*
2327  * wrapper call that saves original devmode, runs tests, and restores devmode
2328  */
2329
2330 static bool test_PrinterInfo_DevMode(struct torture_context *tctx,
2331                                      struct dcerpc_pipe *p,
2332                                      struct policy_handle *handle,
2333                                      const char *name,
2334                                      struct spoolss_DeviceMode *addprinter_devmode)
2335 {
2336         union spoolss_PrinterInfo info;
2337         struct spoolss_DeviceMode *devmode;
2338         bool ret = true;
2339         struct dcerpc_binding_handle *b = p->binding_handle;
2340
2341         torture_comment(tctx, "Testing Printer Devicemodes\n");
2342
2343         /* save original devmode */
2344
2345         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info),
2346                 "failed to get initial global devicemode");
2347
2348         devmode = info.info8.devmode;
2349
2350         if (addprinter_devmode) {
2351                 if (!test_devicemode_equal(tctx, devmode, addprinter_devmode)) {
2352                         torture_warning(tctx, "current global DM is != DM provided in addprinter");
2353                 }
2354         }
2355
2356         /* run tests */
2357
2358         ret = test_PrinterInfo_DevModes(tctx, p, handle, name);
2359
2360         /* restore original devmode */
2361
2362         torture_assert(tctx, test_devmode_set_level(tctx, b, handle, 8, devmode),
2363                 "failed to restore initial global device mode");
2364
2365         torture_comment(tctx, "Printer Devicemodes test %s\n\n",
2366                 ret ? "succeeded" : "failed");
2367
2368
2369         return ret;
2370 }
2371
2372 static bool test_ClosePrinter(struct torture_context *tctx,
2373                               struct dcerpc_binding_handle *b,
2374                               struct policy_handle *handle)
2375 {
2376         NTSTATUS status;
2377         struct spoolss_ClosePrinter r;
2378
2379         r.in.handle = handle;
2380         r.out.handle = handle;
2381
2382         torture_comment(tctx, "Testing ClosePrinter\n");
2383
2384         status = dcerpc_spoolss_ClosePrinter_r(b, tctx, &r);
2385         torture_assert_ntstatus_ok(tctx, status, "ClosePrinter failed");
2386         torture_assert_werr_ok(tctx, r.out.result, "ClosePrinter failed");
2387
2388         return true;
2389 }
2390
2391 static bool test_GetForm_args(struct torture_context *tctx,
2392                               struct dcerpc_binding_handle *b,
2393                               struct policy_handle *handle,
2394                               const char *form_name,
2395                               uint32_t level,
2396                               union spoolss_FormInfo *info_p)
2397 {
2398         NTSTATUS status;
2399         struct spoolss_GetForm r;
2400         uint32_t needed;
2401
2402         r.in.handle = handle;
2403         r.in.form_name = form_name;
2404         r.in.level = level;
2405         r.in.buffer = NULL;
2406         r.in.offered = 0;
2407         r.out.needed = &needed;
2408
2409         torture_comment(tctx, "Testing GetForm(%s) level %d\n", form_name, r.in.level);
2410
2411         status = dcerpc_spoolss_GetForm_r(b, tctx, &r);
2412         torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
2413
2414         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2415                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2416                 r.in.buffer = &blob;
2417                 r.in.offered = needed;
2418                 status = dcerpc_spoolss_GetForm_r(b, tctx, &r);
2419                 torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
2420
2421                 torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
2422
2423                 torture_assert(tctx, r.out.info, "No form info returned");
2424         }
2425
2426         torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
2427
2428         CHECK_NEEDED_SIZE_LEVEL(spoolss_FormInfo, r.out.info, r.in.level, needed, 4);
2429
2430         if (info_p) {
2431                 *info_p = *r.out.info;
2432         }
2433
2434         return true;
2435 }
2436
2437 static bool test_GetForm(struct torture_context *tctx,
2438                          struct dcerpc_binding_handle *b,
2439                          struct policy_handle *handle,
2440                          const char *form_name,
2441                          uint32_t level)
2442 {
2443         return test_GetForm_args(tctx, b, handle, form_name, level, NULL);
2444 }
2445
2446 static bool test_EnumForms(struct torture_context *tctx,
2447                            struct dcerpc_binding_handle *b,
2448                            struct policy_handle *handle,
2449                            bool print_server,
2450                            uint32_t level,
2451                            uint32_t *count_p,
2452                            union spoolss_FormInfo **info_p)
2453 {
2454         struct spoolss_EnumForms r;
2455         uint32_t needed;
2456         uint32_t count;
2457         union spoolss_FormInfo *info;
2458
2459         r.in.handle = handle;
2460         r.in.level = level;
2461         r.in.buffer = NULL;
2462         r.in.offered = 0;
2463         r.out.needed = &needed;
2464         r.out.count = &count;
2465         r.out.info = &info;
2466
2467         torture_comment(tctx, "Testing EnumForms level %d\n", r.in.level);
2468
2469         torture_assert_ntstatus_ok(tctx,
2470                 dcerpc_spoolss_EnumForms_r(b, tctx, &r),
2471                 "EnumForms failed");
2472
2473         if ((r.in.level == 2) && (W_ERROR_EQUAL(r.out.result, WERR_UNKNOWN_LEVEL))) {
2474                 torture_skip(tctx, "EnumForms level 2 not supported");
2475         }
2476
2477         if (print_server && W_ERROR_EQUAL(r.out.result, WERR_BADFID)) {
2478                 torture_fail(tctx, "EnumForms on the PrintServer isn't supported by test server (NT4)");
2479         }
2480
2481         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2482                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2483                 r.in.buffer = &blob;
2484                 r.in.offered = needed;
2485
2486                 torture_assert_ntstatus_ok(tctx,
2487                         dcerpc_spoolss_EnumForms_r(b, tctx, &r),
2488                         "EnumForms failed");
2489
2490                 torture_assert(tctx, info, "No forms returned");
2491         }
2492
2493         torture_assert_werr_ok(tctx, r.out.result, "EnumForms failed");
2494
2495         CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumForms, info, r.in.level, count, needed, 4);
2496
2497         if (info_p) {
2498                 *info_p = info;
2499         }
2500         if (count_p) {
2501                 *count_p = count;
2502         }
2503
2504         return true;
2505 }
2506
2507 static bool test_EnumForms_all(struct torture_context *tctx,
2508                                struct dcerpc_binding_handle *b,
2509                                struct policy_handle *handle,
2510                                bool print_server)
2511 {
2512         uint32_t levels[] = { 1, 2 };
2513         int i, j;
2514
2515         for (i=0; i<ARRAY_SIZE(levels); i++) {
2516
2517                 uint32_t count = 0;
2518                 union spoolss_FormInfo *info = NULL;
2519
2520                 torture_assert(tctx,
2521                         test_EnumForms(tctx, b, handle, print_server, levels[i], &count, &info),
2522                         "failed to enum forms");
2523
2524                 for (j = 0; j < count; j++) {
2525                         if (!print_server) {
2526                                 torture_assert(tctx,
2527                                         test_GetForm(tctx, b, handle, info[j].info1.form_name, levels[i]),
2528                                         "failed to get form");
2529                         }
2530                 }
2531         }
2532
2533         return true;
2534 }
2535
2536 static bool test_EnumForms_find_one(struct torture_context *tctx,
2537                                     struct dcerpc_binding_handle *b,
2538                                     struct policy_handle *handle,
2539                                     bool print_server,
2540                                     const char *form_name)
2541 {
2542         union spoolss_FormInfo *info;
2543         uint32_t count;
2544         bool found = false;
2545         int i;
2546
2547         torture_assert(tctx,
2548                 test_EnumForms(tctx, b, handle, print_server, 1, &count, &info),
2549                 "failed to enumerate forms");
2550
2551         for (i=0; i<count; i++) {
2552                 if (strequal(form_name, info[i].info1.form_name)) {
2553                         found = true;
2554                         break;
2555                 }
2556         }
2557
2558         return found;
2559 }
2560
2561 static bool test_DeleteForm(struct torture_context *tctx,
2562                             struct dcerpc_binding_handle *b,
2563                             struct policy_handle *handle,
2564                             const char *form_name,
2565                             WERROR expected_result)
2566 {
2567         struct spoolss_DeleteForm r;
2568
2569         r.in.handle = handle;
2570         r.in.form_name = form_name;
2571
2572         torture_comment(tctx, "Testing DeleteForm(%s)\n", form_name);
2573
2574         torture_assert_ntstatus_ok(tctx,
2575                 dcerpc_spoolss_DeleteForm_r(b, tctx, &r),
2576                 "DeleteForm failed");
2577         torture_assert_werr_equal(tctx, r.out.result, expected_result,
2578                 "DeleteForm gave unexpected result");
2579         if (W_ERROR_IS_OK(r.out.result)) {
2580                 torture_assert_ntstatus_ok(tctx,
2581                         dcerpc_spoolss_DeleteForm_r(b, tctx, &r),
2582                         "2nd DeleteForm failed");
2583                 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_FORM_NAME,
2584                         "2nd DeleteForm failed");
2585         }
2586
2587         return true;
2588 }
2589
2590 static bool test_AddForm(struct torture_context *tctx,
2591                          struct dcerpc_binding_handle *b,
2592                          struct policy_handle *handle,
2593                          uint32_t level,
2594                          union spoolss_AddFormInfo *info,
2595                          WERROR expected_result)
2596 {
2597         struct spoolss_AddForm r;
2598
2599         if (level != 1) {
2600                 torture_skip(tctx, "only level 1 supported");
2601         }
2602
2603         r.in.handle     = handle;
2604         r.in.level      = level;
2605         r.in.info       = *info;
2606
2607         torture_comment(tctx, "Testing AddForm(%s) level %d, type %d\n",
2608                 r.in.info.info1->form_name, r.in.level,
2609                 r.in.info.info1->flags);
2610
2611         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_AddForm_r(b, tctx, &r),
2612                 "AddForm failed");
2613         torture_assert_werr_equal(tctx, r.out.result, expected_result,
2614                 "AddForm gave unexpected result");
2615
2616         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_AddForm_r(b, tctx, &r),
2617                 "2nd AddForm failed");
2618         if (W_ERROR_EQUAL(expected_result, WERR_INVALID_PARAM)) {
2619                 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
2620                         "2nd AddForm gave unexpected result");
2621         } else {
2622                 torture_assert_werr_equal(tctx, r.out.result, WERR_FILE_EXISTS,
2623                         "2nd AddForm gave unexpected result");
2624         }
2625
2626         return true;
2627 }
2628
2629 static bool test_SetForm(struct torture_context *tctx,
2630                          struct dcerpc_binding_handle *b,
2631                          struct policy_handle *handle,
2632                          const char *form_name,
2633                          uint32_t level,
2634                          union spoolss_AddFormInfo *info)
2635 {
2636         struct spoolss_SetForm r;
2637
2638         r.in.handle     = handle;
2639         r.in.form_name  = form_name;
2640         r.in.level      = level;
2641         r.in.info       = *info;
2642
2643         torture_comment(tctx, "Testing SetForm(%s) level %d\n",
2644                 form_name, r.in.level);
2645
2646         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetForm_r(b, tctx, &r),
2647                 "SetForm failed");
2648
2649         torture_assert_werr_ok(tctx, r.out.result,
2650                 "SetForm failed");
2651
2652         return true;
2653 }
2654
2655 static bool test_GetForm_winreg(struct torture_context *tctx,
2656                                 struct dcerpc_binding_handle *b,
2657                                 struct policy_handle *handle,
2658                                 const char *key_name,
2659                                 const char *form_name,
2660                                 enum winreg_Type *w_type,
2661                                 uint32_t *w_size,
2662                                 uint32_t *w_length,
2663                                 uint8_t **w_data);
2664
2665 static bool test_Forms_args(struct torture_context *tctx,
2666                             struct dcerpc_binding_handle *b,
2667                             struct policy_handle *handle,
2668                             bool print_server,
2669                             const char *printer_name,
2670                             struct dcerpc_binding_handle *winreg_handle,
2671                             struct policy_handle *hive_handle,
2672                             const char *form_name,
2673                             struct spoolss_AddFormInfo1 *info1,
2674                             WERROR expected_add_result,
2675                             WERROR expected_delete_result)
2676 {
2677         union spoolss_FormInfo info;
2678         union spoolss_AddFormInfo add_info;
2679
2680         enum winreg_Type w_type;
2681         uint32_t w_size;
2682         uint32_t w_length;
2683         uint8_t *w_data;
2684
2685         add_info.info1 = info1;
2686
2687         torture_assert(tctx,
2688                 test_AddForm(tctx, b, handle, 1, &add_info, expected_add_result),
2689                 "failed to add form");
2690
2691         if (winreg_handle && hive_handle && W_ERROR_IS_OK(expected_add_result)) {
2692
2693                 torture_assert(tctx,
2694                         test_GetForm_winreg(tctx, winreg_handle, hive_handle, TOP_LEVEL_CONTROL_FORMS_KEY, form_name, &w_type, &w_size, &w_length, &w_data),
2695                         "failed to get form via winreg");
2696
2697                 torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");
2698                 torture_assert_int_equal(tctx, w_size, 0x20, "unexpected size");
2699                 torture_assert_int_equal(tctx, w_length, 0x20, "unexpected length");
2700                 torture_assert_mem_equal(tctx, &w_data[0], &add_info.info1->size.width, 4, "width mismatch");
2701                 torture_assert_mem_equal(tctx, &w_data[4], &add_info.info1->size.height, 4, "height mismatch");
2702                 torture_assert_mem_equal(tctx, &w_data[8], &add_info.info1->area.left, 4, "left mismatch");
2703                 torture_assert_mem_equal(tctx, &w_data[12], &add_info.info1->area.top, 4, "top mismatch");
2704                 torture_assert_mem_equal(tctx, &w_data[16], &add_info.info1->area.right, 4, "right mismatch");
2705                 torture_assert_mem_equal(tctx, &w_data[20], &add_info.info1->area.bottom, 4, "bottom mismatch");
2706                 /* skip index here */
2707                 torture_assert_mem_equal(tctx, &w_data[28], &add_info.info1->flags, 4, "flags mismatch");
2708         }
2709
2710         if (!print_server && W_ERROR_IS_OK(expected_add_result)) {
2711                 torture_assert(tctx,
2712                         test_GetForm_args(tctx, b, handle, form_name, 1, &info),
2713                         "failed to get added form");
2714
2715                 torture_assert_int_equal(tctx, info.info1.size.width, add_info.info1->size.width, "width mismatch");
2716                 torture_assert_int_equal(tctx, info.info1.size.height, add_info.info1->size.height, "height mismatch");
2717                 torture_assert_int_equal(tctx, info.info1.area.left, add_info.info1->area.left, "left mismatch");
2718                 torture_assert_int_equal(tctx, info.info1.area.top, add_info.info1->area.top, "top mismatch");
2719                 torture_assert_int_equal(tctx, info.info1.area.right, add_info.info1->area.right, "right mismatch");
2720                 torture_assert_int_equal(tctx, info.info1.area.bottom, add_info.info1->area.bottom, "bottom mismatch");
2721                 torture_assert_int_equal(tctx, info.info1.flags, add_info.info1->flags, "flags mismatch");
2722
2723                 if (winreg_handle && hive_handle) {
2724                         torture_assert_mem_equal(tctx, &w_data[0], &info.info1.size.width, 4, "width mismatch");
2725                         torture_assert_mem_equal(tctx, &w_data[4], &info.info1.size.height, 4, "height mismatch");
2726                         torture_assert_mem_equal(tctx, &w_data[8], &info.info1.area.left, 4, "left mismatch");
2727                         torture_assert_mem_equal(tctx, &w_data[12], &info.info1.area.top, 4, "top mismatch");
2728                         torture_assert_mem_equal(tctx, &w_data[16], &info.info1.area.right, 4, "right mismatch");
2729                         torture_assert_mem_equal(tctx, &w_data[20], &info.info1.area.bottom, 4, "bottom mismatch");
2730                         /* skip index here */
2731                         torture_assert_mem_equal(tctx, &w_data[28], &info.info1.flags, 4, "flags mismatch");
2732                 }
2733
2734                 add_info.info1->size.width = 1234;
2735
2736                 torture_assert(tctx,
2737                         test_SetForm(tctx, b, handle, form_name, 1, &add_info),
2738                         "failed to set form");
2739                 torture_assert(tctx,
2740                         test_GetForm_args(tctx, b, handle, form_name, 1, &info),
2741                         "failed to get setted form");
2742
2743                 torture_assert_int_equal(tctx, info.info1.size.width, add_info.info1->size.width, "width mismatch");
2744         }
2745
2746         if (!W_ERROR_EQUAL(expected_add_result, WERR_INVALID_PARAM)) {
2747                 torture_assert(tctx,
2748                         test_EnumForms_find_one(tctx, b, handle, print_server, form_name),
2749                         "Newly added form not found in enum call");
2750         }
2751
2752         torture_assert(tctx,
2753                 test_DeleteForm(tctx, b, handle, form_name, expected_delete_result),
2754                 "failed to delete form");
2755
2756         return true;
2757 }
2758
2759 static bool test_Forms(struct torture_context *tctx,
2760                        struct dcerpc_binding_handle *b,
2761                        struct policy_handle *handle,
2762                        bool print_server,
2763                        const char *printer_name,
2764                        struct dcerpc_binding_handle *winreg_handle,
2765                        struct policy_handle *hive_handle)
2766 {
2767         const struct spoolss_FormSize size = {
2768                 .width  = 50,
2769                 .height = 25
2770         };
2771         const struct spoolss_FormArea area = {
2772                 .left   = 5,
2773                 .top    = 10,
2774                 .right  = 45,
2775                 .bottom = 15
2776         };
2777         int i;
2778
2779         struct {
2780                 struct spoolss_AddFormInfo1 info1;
2781                 WERROR expected_add_result;
2782                 WERROR expected_delete_result;
2783         } forms[] = {
2784                 {
2785                         .info1 = {
2786                                 .flags          = SPOOLSS_FORM_USER,
2787                                 .form_name      = "testform_user",
2788                                 .size           = size,
2789                                 .area           = area,
2790                         },
2791                         .expected_add_result    = WERR_OK,
2792                         .expected_delete_result = WERR_OK
2793                 },
2794 /*
2795                 weird, we can add a builtin form but we can never remove it
2796                 again - gd
2797
2798                 {
2799                         .info1 = {
2800                                 .flags          = SPOOLSS_FORM_BUILTIN,
2801                                 .form_name      = "testform_builtin",
2802                                 .size           = size,
2803                                 .area           = area,
2804                         },
2805                         .expected_add_result    = WERR_OK,
2806                         .expected_delete_result = WERR_INVALID_PARAM,
2807                 },
2808 */
2809                 {
2810                         .info1 = {
2811                                 .flags          = SPOOLSS_FORM_PRINTER,
2812                                 .form_name      = "testform_printer",
2813                                 .size           = size,
2814                                 .area           = area,
2815                         },
2816                         .expected_add_result    = WERR_OK,
2817                         .expected_delete_result = WERR_OK
2818                 },
2819                 {
2820                         .info1 = {
2821                                 .flags          = SPOOLSS_FORM_USER,
2822                                 .form_name      = "Letter",
2823                                 .size           = size,
2824                                 .area           = area,
2825                         },
2826                         .expected_add_result    = WERR_FILE_EXISTS,
2827                         .expected_delete_result = WERR_INVALID_PARAM
2828                 },
2829                 {
2830                         .info1 = {
2831                                 .flags          = SPOOLSS_FORM_BUILTIN,
2832                                 .form_name      = "Letter",
2833                                 .size           = size,
2834                                 .area           = area,
2835                         },
2836                         .expected_add_result    = WERR_FILE_EXISTS,
2837                         .expected_delete_result = WERR_INVALID_PARAM
2838                 },
2839                 {
2840                         .info1 = {
2841                                 .flags          = SPOOLSS_FORM_PRINTER,
2842                                 .form_name      = "Letter",
2843                                 .size           = size,
2844                                 .area           = area,
2845                         },
2846                         .expected_add_result    = WERR_FILE_EXISTS,
2847                         .expected_delete_result = WERR_INVALID_PARAM
2848                 },
2849                 {
2850                         .info1 = {
2851                                 .flags          = 12345,
2852                                 .form_name      = "invalid_flags",
2853                                 .size           = size,
2854                                 .area           = area,
2855                         },
2856                         .expected_add_result    = WERR_INVALID_PARAM,
2857                         .expected_delete_result = WERR_INVALID_FORM_NAME
2858                 }
2859
2860         };
2861
2862         for (i=0; i < ARRAY_SIZE(forms); i++) {
2863                 torture_assert(tctx,
2864                         test_Forms_args(tctx, b, handle, print_server, printer_name,
2865                                         winreg_handle, hive_handle,
2866                                         forms[i].info1.form_name,
2867                                         &forms[i].info1,
2868                                         forms[i].expected_add_result,
2869                                         forms[i].expected_delete_result),
2870                         talloc_asprintf(tctx, "failed to test form '%s'", forms[i].info1.form_name));
2871         }
2872
2873         return true;
2874 }
2875
2876 static bool test_EnumPorts_old(struct torture_context *tctx,
2877                                void *private_data)
2878 {
2879         struct test_spoolss_context *ctx =
2880                 talloc_get_type_abort(private_data, struct test_spoolss_context);
2881
2882         NTSTATUS status;
2883         struct spoolss_EnumPorts r;
2884         uint32_t needed;
2885         uint32_t count;
2886         union spoolss_PortInfo *info;
2887         struct dcerpc_pipe *p = ctx->spoolss_pipe;
2888         struct dcerpc_binding_handle *b = p->binding_handle;
2889
2890         r.in.servername = talloc_asprintf(tctx, "\\\\%s",
2891                                           dcerpc_server_name(p));
2892         r.in.level = 2;
2893         r.in.buffer = NULL;
2894         r.in.offered = 0;
2895         r.out.needed = &needed;
2896         r.out.count = &count;
2897         r.out.info = &info;
2898
2899         torture_comment(tctx, "Testing EnumPorts\n");
2900
2901         status = dcerpc_spoolss_EnumPorts_r(b, tctx, &r);
2902
2903         torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
2904
2905         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2906                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2907                 r.in.buffer = &blob;
2908                 r.in.offered = needed;
2909
2910                 status = dcerpc_spoolss_EnumPorts_r(b, tctx, &r);
2911                 torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
2912                 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
2913
2914                 torture_assert(tctx, info, "No ports returned");
2915         }
2916
2917         torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
2918
2919         CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPorts, info, 2, count, needed, 4);
2920
2921         return true;
2922 }
2923
2924 static bool test_AddPort(struct torture_context *tctx,
2925                          void *private_data)
2926 {
2927         struct test_spoolss_context *ctx =
2928                 talloc_get_type_abort(private_data, struct test_spoolss_context);
2929
2930         NTSTATUS status;
2931         struct spoolss_AddPort r;
2932         struct dcerpc_pipe *p = ctx->spoolss_pipe;
2933         struct dcerpc_binding_handle *b = p->binding_handle;
2934
2935         r.in.server_name = talloc_asprintf(tctx, "\\\\%s",
2936                                            dcerpc_server_name(p));
2937         r.in.unknown = 0;
2938         r.in.monitor_name = "foo";
2939
2940         torture_comment(tctx, "Testing AddPort\n");
2941
2942         status = dcerpc_spoolss_AddPort_r(b, tctx, &r);
2943
2944         torture_assert_ntstatus_ok(tctx, status, "AddPort failed");
2945
2946         /* win2k3 returns WERR_NOT_SUPPORTED */
2947
2948 #if 0
2949
2950         if (!W_ERROR_IS_OK(r.out.result)) {
2951                 printf("AddPort failed - %s\n", win_errstr(r.out.result));
2952                 return false;
2953         }
2954
2955 #endif
2956
2957         return true;
2958 }
2959
2960 static bool test_GetJob_args(struct torture_context *tctx,
2961                              struct dcerpc_binding_handle *b,
2962                              struct policy_handle *handle,
2963                              uint32_t job_id,
2964                              uint32_t level,
2965                              union spoolss_JobInfo *info_p)
2966 {
2967         NTSTATUS status;
2968         struct spoolss_GetJob r;
2969         union spoolss_JobInfo info;
2970         uint32_t needed;
2971
2972         r.in.handle = handle;
2973         r.in.job_id = job_id;
2974         r.in.level = level;
2975         r.in.buffer = NULL;
2976         r.in.offered = 0;
2977         r.out.needed = &needed;
2978         r.out.info = &info;
2979
2980         torture_comment(tctx, "Testing GetJob(%d), level %d\n", job_id, r.in.level);
2981
2982         status = dcerpc_spoolss_GetJob_r(b, tctx, &r);
2983         torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
2984         if (level == 0) {
2985                 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "Unexpected return code");
2986         }
2987
2988         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2989                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2990                 r.in.buffer = &blob;
2991                 r.in.offered = needed;
2992
2993                 status = dcerpc_spoolss_GetJob_r(b, tctx, &r);
2994                 torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
2995         }
2996
2997         torture_assert_werr_ok(tctx, r.out.result, "GetJob failed");
2998         torture_assert(tctx, r.out.info, "No job info returned");
2999
3000         CHECK_NEEDED_SIZE_LEVEL(spoolss_JobInfo, r.out.info, r.in.level, needed, 4);
3001
3002         if (info_p) {
3003                 *info_p = *r.out.info;
3004         }
3005
3006         return true;
3007 }
3008
3009 static bool test_GetJob(struct torture_context *tctx,
3010                         struct dcerpc_binding_handle *b,
3011                         struct policy_handle *handle,
3012                         uint32_t job_id)
3013 {
3014         uint32_t levels[] = {0, 1, 2 /* 3, 4 */};
3015         uint32_t i;
3016
3017         for (i=0; i < ARRAY_SIZE(levels); i++) {
3018                 torture_assert(tctx,
3019                         test_GetJob_args(tctx, b, handle, job_id, levels[i], NULL),
3020                         "GetJob failed");
3021         }
3022
3023         return true;
3024 }
3025
3026 static bool test_SetJob(struct torture_context *tctx,
3027                         struct dcerpc_binding_handle *b,
3028                         struct policy_handle *handle,
3029                         uint32_t job_id,
3030                         struct spoolss_JobInfoContainer *ctr,
3031                         enum spoolss_JobControl command)
3032 {
3033         NTSTATUS status;
3034         struct spoolss_SetJob r;
3035
3036         r.in.handle     = handle;
3037         r.in.job_id     = job_id;
3038         r.in.ctr        = ctr;
3039         r.in.command    = command;
3040
3041         switch (command) {
3042         case SPOOLSS_JOB_CONTROL_PAUSE:
3043                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_PAUSE\n", job_id);
3044                 break;
3045         case SPOOLSS_JOB_CONTROL_RESUME:
3046                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RESUME\n", job_id);
3047                 break;
3048         case SPOOLSS_JOB_CONTROL_CANCEL:
3049                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_CANCEL\n", job_id);
3050                 break;
3051         case SPOOLSS_JOB_CONTROL_RESTART:
3052                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RESTART\n", job_id);
3053                 break;
3054         case SPOOLSS_JOB_CONTROL_DELETE:
3055                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_DELETE\n", job_id);
3056                 break;
3057         case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER:
3058                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER\n", job_id);
3059                 break;
3060         case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED:
3061                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED\n", job_id);
3062                 break;
3063         case SPOOLSS_JOB_CONTROL_RETAIN:
3064                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RETAIN\n", job_id);
3065                 break;
3066         case SPOOLSS_JOB_CONTROL_RELEASE:
3067                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RELEASE\n", job_id);
3068                 break;
3069         default:
3070                 torture_comment(tctx, "Testing SetJob(%d)\n", job_id);
3071                 break;
3072         }
3073
3074         status = dcerpc_spoolss_SetJob_r(b, tctx, &r);
3075         torture_assert_ntstatus_ok(tctx, status, "SetJob failed");
3076         torture_assert_werr_ok(tctx, r.out.result, "SetJob failed");
3077
3078         return true;
3079 }
3080
3081 static bool test_AddJob(struct torture_context *tctx,
3082                         struct dcerpc_binding_handle *b,
3083                         struct policy_handle *handle)
3084 {
3085         NTSTATUS status;
3086         struct spoolss_AddJob r;
3087         uint32_t needed;
3088
3089         r.in.level = 0;
3090         r.in.handle = handle;
3091         r.in.offered = 0;
3092         r.out.needed = &needed;
3093         r.in.buffer = r.out.buffer = NULL;
3094
3095         torture_comment(tctx, "Testing AddJob\n");
3096
3097         status = dcerpc_spoolss_AddJob_r(b, tctx, &r);
3098         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "AddJob failed");
3099
3100         r.in.level = 1;
3101
3102         status = dcerpc_spoolss_AddJob_r(b, tctx, &r);
3103         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM, "AddJob failed");
3104
3105         return true;
3106 }
3107
3108
3109 static bool test_EnumJobs_args(struct torture_context *tctx,
3110                                struct dcerpc_binding_handle *b,
3111                                struct policy_handle *handle,
3112                                uint32_t level,
3113                                uint32_t *count_p,
3114                                union spoolss_JobInfo **info_p)
3115 {
3116         NTSTATUS status;
3117         struct spoolss_EnumJobs r;
3118         uint32_t needed;
3119         uint32_t count;
3120         union spoolss_JobInfo *info;
3121
3122         r.in.handle = handle;
3123         r.in.firstjob = 0;
3124         r.in.numjobs = 0xffffffff;
3125         r.in.level = level;
3126         r.in.buffer = NULL;
3127         r.in.offered = 0;
3128         r.out.needed = &needed;
3129         r.out.count = &count;
3130         r.out.info = &info;
3131
3132         torture_comment(tctx, "Testing EnumJobs level %d\n", level);
3133
3134         status = dcerpc_spoolss_EnumJobs_r(b, tctx, &r);
3135
3136         torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
3137
3138         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
3139                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
3140                 r.in.buffer = &blob;
3141                 r.in.offered = needed;
3142
3143                 status = dcerpc_spoolss_EnumJobs_r(b, tctx, &r);
3144
3145                 torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
3146                 torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
3147                 torture_assert(tctx, info, "No jobs returned");
3148
3149                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumJobs, *r.out.info, r.in.level, count, needed, 4);
3150
3151         } else {
3152                 torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
3153         }
3154
3155         if (count_p) {
3156                 *count_p = count;
3157         }
3158         if (info_p) {
3159                 *info_p = info;
3160         }
3161
3162         return true;
3163 }
3164
3165 static bool test_DoPrintTest_add_one_job(struct torture_context *tctx,
3166                                          struct dcerpc_binding_handle *b,
3167                                          struct policy_handle *handle,
3168                                          uint32_t *job_id)
3169 {
3170         NTSTATUS status;
3171         struct spoolss_StartDocPrinter s;
3172         struct spoolss_DocumentInfo1 info1;
3173         struct spoolss_StartPagePrinter sp;
3174         struct spoolss_WritePrinter w;
3175         struct spoolss_EndPagePrinter ep;
3176         struct spoolss_EndDocPrinter e;
3177         int i;
3178         uint32_t num_written;
3179
3180         torture_comment(tctx, "Testing StartDocPrinter\n");
3181
3182         s.in.handle             = handle;
3183         s.in.level              = 1;
3184         s.in.info.info1         = &info1;
3185         s.out.job_id            = job_id;
3186         info1.document_name     = "TorturePrintJob";
3187         info1.output_file       = NULL;
3188         info1.datatype          = "RAW";
3189
3190         status = dcerpc_spoolss_StartDocPrinter_r(b, tctx, &s);
3191         torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_StartDocPrinter failed");
3192         torture_assert_werr_ok(tctx, s.out.result, "StartDocPrinter failed");
3193
3194         for (i=1; i < 4; i++) {
3195                 torture_comment(tctx, "Testing StartPagePrinter: Page[%d], JobId[%d]\n", i, *job_id);
3196
3197                 sp.in.handle            = handle;
3198
3199                 status = dcerpc_spoolss_StartPagePrinter_r(b, tctx, &sp);
3200                 torture_assert_ntstatus_ok(tctx, status,
3201                                            "dcerpc_spoolss_StartPagePrinter failed");
3202                 torture_assert_werr_ok(tctx, sp.out.result, "StartPagePrinter failed");
3203
3204                 torture_comment(tctx, "Testing WritePrinter: Page[%d], JobId[%d]\n", i, *job_id);
3205
3206                 w.in.handle             = handle;
3207                 w.in.data               = data_blob_string_const(talloc_asprintf(tctx,"TortureTestPage: %d\nData\n",i));
3208                 w.out.num_written       = &num_written;
3209
3210                 status = dcerpc_spoolss_WritePrinter_r(b, tctx, &w);
3211                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_WritePrinter failed");
3212                 torture_assert_werr_ok(tctx, w.out.result, "WritePrinter failed");
3213
3214                 torture_comment(tctx, "Testing EndPagePrinter: Page[%d], JobId[%d]\n", i, *job_id);
3215
3216                 ep.in.handle            = handle;
3217
3218                 status = dcerpc_spoolss_EndPagePrinter_r(b, tctx, &ep);
3219                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndPagePrinter failed");
3220                 torture_assert_werr_ok(tctx, ep.out.result, "EndPagePrinter failed");
3221         }
3222
3223         torture_comment(tctx, "Testing EndDocPrinter: JobId[%d]\n", *job_id);
3224
3225         e.in.handle = handle;
3226
3227         status = dcerpc_spoolss_EndDocPrinter_r(b, tctx, &e);
3228         torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndDocPrinter failed");
3229         torture_assert_werr_ok(tctx, e.out.result, "EndDocPrinter failed");
3230
3231         return true;
3232 }
3233
3234 static bool test_DoPrintTest_check_jobs(struct torture_context *tctx,
3235                                         struct dcerpc_binding_handle *b,
3236                                         struct policy_handle *handle,
3237                                         uint32_t num_jobs,
3238                                         uint32_t *job_ids)
3239 {
3240         uint32_t count;
3241         union spoolss_JobInfo *info = NULL;
3242         int i;
3243
3244         torture_assert(tctx,
3245                 test_AddJob(tctx, b, handle),
3246                 "AddJob failed");
3247
3248         torture_assert(tctx,
3249                 test_EnumJobs_args(tctx, b, handle, 1, &count, &info),
3250                 "EnumJobs level 1 failed");
3251
3252         torture_assert_int_equal(tctx, count, num_jobs, "unexpected number of jobs in queue");
3253
3254         for (i=0; i < num_jobs; i++) {
3255                 union spoolss_JobInfo ginfo;
3256                 const char *document_name;
3257                 const char *new_document_name = "any_other_docname";
3258                 struct spoolss_JobInfoContainer ctr;
3259                 struct spoolss_SetJobInfo1 info1;
3260
3261                 torture_assert_int_equal(tctx, info[i].info1.job_id, job_ids[i], "job id mismatch");
3262
3263                 torture_assert(tctx,
3264                         test_GetJob_args(tctx, b, handle, info[i].info1.job_id, 1, &ginfo),
3265                         "failed to call test_GetJob");
3266
3267                 torture_assert_int_equal(tctx, ginfo.info1.job_id, info[i].info1.job_id, "job id mismatch");
3268
3269                 document_name = ginfo.info1.document_name;
3270
3271                 info1.job_id            = ginfo.info1.job_id;
3272                 info1.printer_name      = ginfo.info1.printer_name;
3273                 info1.server_name       = ginfo.info1.server_name;
3274                 info1.user_name         = ginfo.info1.user_name;
3275                 info1.document_name     = new_document_name;
3276                 info1.data_type         = ginfo.info1.data_type;
3277                 info1.text_status       = ginfo.info1.text_status;
3278                 info1.status            = ginfo.info1.status;
3279                 info1.priority          = ginfo.info1.priority;
3280                 info1.position          = ginfo.info1.position;
3281                 info1.total_pages       = ginfo.info1.total_pages;
3282                 info1.pages_printed     = ginfo.info1.pages_printed;
3283                 info1.submitted         = ginfo.info1.submitted;
3284
3285                 ctr.level = 1;
3286                 ctr.info.info1 = &info1;
3287
3288                 torture_assert(tctx,
3289                         test_SetJob(tctx, b, handle, info[i].info1.job_id, &ctr, 0),
3290                         "failed to call test_SetJob level 1");
3291
3292                 torture_assert(tctx,
3293                         test_GetJob_args(tctx, b, handle, info[i].info1.job_id, 1, &ginfo),
3294                         "failed to call test_GetJob");
3295
3296                 if (strequal(ginfo.info1.document_name, document_name)) {
3297                         torture_warning(tctx,
3298                                 talloc_asprintf(tctx, "document_name did *NOT* change from '%s' to '%s'\n",
3299                                         document_name, new_document_name));
3300                 }
3301         }
3302
3303         for (i=0; i < num_jobs; i++) {
3304                 if (!test_SetJob(tctx, b, handle, info[i].info1.job_id, NULL, SPOOLSS_JOB_CONTROL_PAUSE)) {
3305                         torture_warning(tctx, "failed to pause printjob\n");
3306                 }
3307                 if (!test_SetJob(tctx, b, handle, info[i].info1.job_id, NULL, SPOOLSS_JOB_CONTROL_RESUME)) {
3308                         torture_warning(tctx, "failed to resume printjob\n");
3309                 }
3310         }
3311
3312         return true;
3313 }
3314
3315 static bool test_DoPrintTest(struct torture_context *tctx,
3316                              struct dcerpc_binding_handle *b,
3317                              struct policy_handle *handle)
3318 {
3319         bool ret = true;
3320         uint32_t num_jobs = 8;
3321         uint32_t *job_ids;
3322         int i;
3323
3324         torture_comment(tctx, "Testing real print operations\n");
3325
3326         job_ids = talloc_zero_array(tctx, uint32_t, num_jobs);
3327
3328         for (i=0; i < num_jobs; i++) {
3329                 ret &= test_DoPrintTest_add_one_job(tctx, b, handle, &job_ids[i]);
3330         }
3331
3332         for (i=0; i < num_jobs; i++) {
3333                 ret &= test_SetJob(tctx, b, handle, job_ids[i], NULL, SPOOLSS_JOB_CONTROL_DELETE);
3334         }
3335
3336         if (ret == true) {
3337                 torture_comment(tctx, "real print operations test succeeded\n\n");
3338         }
3339
3340         return ret;
3341 }
3342
3343 static bool test_DoPrintTest_extended(struct torture_context *tctx,
3344                                       struct dcerpc_binding_handle *b,
3345                                       struct policy_handle *handle)
3346 {
3347         bool ret = true;
3348         uint32_t num_jobs = 8;
3349         uint32_t *job_ids;
3350         int i;
3351         torture_comment(tctx, "Testing real print operations (extended)\n");
3352
3353         job_ids = talloc_zero_array(tctx, uint32_t, num_jobs);
3354
3355         for (i=0; i < num_jobs; i++) {
3356                 ret &= test_DoPrintTest_add_one_job(tctx, b, handle, &job_ids[i]);
3357         }
3358
3359         ret &= test_DoPrintTest_check_jobs(tctx, b, handle, num_jobs, job_ids);
3360
3361         for (i=0; i < num_jobs; i++) {
3362                 ret &= test_SetJob(tctx, b, handle, job_ids[i], NULL, SPOOLSS_JOB_CONTROL_DELETE);
3363         }
3364
3365         if (ret == true) {
3366                 torture_comment(tctx, "real print operations (extended) test succeeded\n\n");
3367         }
3368
3369         return ret;
3370 }
3371
3372 static bool test_PausePrinter(struct torture_context *tctx,
3373                               struct dcerpc_binding_handle *b,
3374                               struct policy_handle *handle)
3375 {
3376         NTSTATUS status;
3377         struct spoolss_SetPrinter r;
3378         struct spoolss_SetPrinterInfoCtr info_ctr;
3379         struct spoolss_DevmodeContainer devmode_ctr;
3380         struct sec_desc_buf secdesc_ctr;
3381
3382         info_ctr.level = 0;
3383         info_ctr.info.info0 = NULL;
3384
3385         ZERO_STRUCT(devmode_ctr);
3386         ZERO_STRUCT(secdesc_ctr);
3387
3388         r.in.handle             = handle;
3389         r.in.info_ctr           = &info_ctr;
3390         r.in.devmode_ctr        = &devmode_ctr;
3391         r.in.secdesc_ctr        = &secdesc_ctr;
3392         r.in.command            = SPOOLSS_PRINTER_CONTROL_PAUSE;
3393
3394         torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_PAUSE\n");
3395
3396         status = dcerpc_spoolss_SetPrinter_r(b, tctx, &r);
3397
3398         torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
3399
3400         torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
3401
3402         return true;
3403 }
3404
3405 static bool test_ResumePrinter(struct torture_context *tctx,
3406                                struct dcerpc_binding_handle *b,
3407                                struct policy_handle *handle)
3408 {
3409         NTSTATUS status;
3410         struct spoolss_SetPrinter r;
3411         struct spoolss_SetPrinterInfoCtr info_ctr;
3412         struct spoolss_DevmodeContainer devmode_ctr;
3413         struct sec_desc_buf secdesc_ctr;
3414
3415         info_ctr.level = 0;
3416         info_ctr.info.info0 = NULL;
3417
3418         ZERO_STRUCT(devmode_ctr);
3419         ZERO_STRUCT(secdesc_ctr);
3420
3421         r.in.handle             = handle;
3422         r.in.info_ctr           = &info_ctr;
3423         r.in.devmode_ctr        = &devmode_ctr;
3424         r.in.secdesc_ctr        = &secdesc_ctr;
3425         r.in.command            = SPOOLSS_PRINTER_CONTROL_RESUME;
3426
3427         torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_RESUME\n");
3428
3429         status = dcerpc_spoolss_SetPrinter_r(b, tctx, &r);
3430
3431         torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
3432
3433         torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
3434
3435         return true;
3436 }
3437
3438 static bool test_GetPrinterData(struct torture_context *tctx,
3439                                 struct dcerpc_binding_handle *b,
3440                                 struct policy_handle *handle,
3441                                 const char *value_name,
3442                                 enum winreg_Type *type_p,
3443                                 uint8_t **data_p,
3444                                 uint32_t *needed_p)
3445 {
3446         NTSTATUS status;
3447         struct spoolss_GetPrinterData r;
3448         uint32_t needed;
3449         enum winreg_Type type;
3450         union spoolss_PrinterData data;
3451
3452         r.in.handle = handle;
3453         r.in.value_name = value_name;
3454         r.in.offered = 0;
3455         r.out.needed = &needed;
3456         r.out.type = &type;
3457         r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3458
3459         torture_comment(tctx, "Testing GetPrinterData(%s)\n", r.in.value_name);
3460
3461         status = dcerpc_spoolss_GetPrinterData_r(b, tctx, &r);
3462         torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
3463
3464         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3465                 r.in.offered = needed;
3466                 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3467                 status = dcerpc_spoolss_GetPrinterData_r(b, tctx, &r);
3468                 torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
3469         }
3470
3471         torture_assert_werr_ok(tctx, r.out.result,
3472                 talloc_asprintf(tctx, "GetPrinterData(%s) failed", r.in.value_name));
3473
3474         CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterData, &data, type, needed, 1);
3475
3476         if (type_p) {
3477                 *type_p = type;
3478         }
3479
3480         if (data_p) {
3481                 *data_p = r.out.data;
3482         }
3483
3484         if (needed_p) {
3485                 *needed_p = needed;
3486         }
3487
3488         return true;
3489 }
3490
3491 static bool test_GetPrinterDataEx(struct torture_context *tctx,
3492                                   struct dcerpc_pipe *p,
3493                                   struct policy_handle *handle,
3494                                   const char *key_name,
3495                                   const char *value_name,
3496                                   enum winreg_Type *type_p,
3497                                   uint8_t **data_p,
3498                                   uint32_t *needed_p)
3499 {
3500         NTSTATUS status;
3501         struct spoolss_GetPrinterDataEx r;
3502         enum winreg_Type type;
3503         uint32_t needed;
3504         union spoolss_PrinterData data;
3505         struct dcerpc_binding_handle *b = p->binding_handle;
3506
3507         r.in.handle = handle;
3508         r.in.key_name = key_name;
3509         r.in.value_name = value_name;
3510         r.in.offered = 0;
3511         r.out.type = &type;
3512         r.out.needed = &needed;
3513         r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3514
3515         torture_comment(tctx, "Testing GetPrinterDataEx(%s - %s)\n",
3516                 r.in.key_name, r.in.value_name);
3517
3518         status = dcerpc_spoolss_GetPrinterDataEx_r(b, tctx, &r);
3519         if (!NT_STATUS_IS_OK(status)) {
3520                 if (NT_STATUS_EQUAL(status, NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE)) {
3521                         torture_skip(tctx, "GetPrinterDataEx not supported by server\n");
3522                 }
3523                 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
3524         }
3525
3526         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3527                 r.in.offered = needed;
3528                 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3529                 status = dcerpc_spoolss_GetPrinterDataEx_r(b, tctx, &r);
3530                 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
3531         }
3532
3533         torture_assert_werr_ok(tctx, r.out.result,
3534                 talloc_asprintf(tctx, "GetPrinterDataEx(%s - %s) failed", r.in.key_name, r.in.value_name));
3535
3536         CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterData, &data, type, needed, 1);
3537
3538         if (type_p) {
3539                 *type_p = type;
3540         }
3541
3542         if (data_p) {
3543                 *data_p = r.out.data;
3544         }
3545
3546         if (needed_p) {
3547                 *needed_p = needed;
3548         }
3549
3550         return true;
3551 }
3552
3553 static bool test_get_environment(struct torture_context *tctx,
3554                                  struct dcerpc_binding_handle *b,
3555                                  struct policy_handle *handle,
3556                                  const char **architecture)
3557 {
3558         DATA_BLOB blob;
3559         enum winreg_Type type;
3560         uint8_t *data;
3561         uint32_t needed;
3562
3563         torture_assert(tctx,
3564                 test_GetPrinterData(tctx, b, handle, "Architecture", &type, &data, &needed),
3565                 "failed to get Architecture");
3566
3567         torture_assert_int_equal(tctx, type, REG_SZ, "unexpected type");
3568
3569         blob = data_blob_const(data, needed);
3570         *architecture = reg_val_data_string(tctx, REG_SZ, blob);
3571
3572         return true;
3573 }
3574
3575 static bool test_GetPrinterData_list(struct torture_context *tctx,
3576                                      void *private_data)
3577 {
3578         struct test_spoolss_context *ctx =
3579                 talloc_get_type_abort(private_data, struct test_spoolss_context);
3580         struct dcerpc_pipe *p = ctx->spoolss_pipe;
3581         struct dcerpc_binding_handle *b = p->binding_handle;
3582         const char *list[] = {
3583                 "W3SvcInstalled",
3584                 "BeepEnabled",
3585                 "EventLog",
3586                 /* "NetPopup", not on w2k8 */
3587                 /* "NetPopupToComputer", not on w2k8 */
3588                 "MajorVersion",
3589                 "MinorVersion",
3590                 "DefaultSpoolDirectory",
3591                 "Architecture",
3592                 "DsPresent",
3593                 "OSVersion",
3594                 /* "OSVersionEx", not on s3 */
3595                 "DNSMachineName"
3596         };
3597         int i;
3598
3599         for (i=0; i < ARRAY_SIZE(list); i++) {
3600                 enum winreg_Type type, type_ex;
3601                 uint8_t *data, *data_ex;
3602                 uint32_t needed, needed_ex;
3603
3604                 torture_assert(tctx, test_GetPrinterData(tctx, b, &ctx->server_handle, list[i], &type, &data, &needed),
3605                         talloc_asprintf(tctx, "GetPrinterData failed on %s\n", list[i]));
3606                 torture_assert(tctx, test_GetPrinterDataEx(tctx, p, &ctx->server_handle, "random_string", list[i], &type_ex, &data_ex, &needed_ex),
3607                         talloc_asprintf(tctx, "GetPrinterDataEx failed on %s\n", list[i]));
3608                 torture_assert_int_equal(tctx, type, type_ex, "type mismatch");
3609                 torture_assert_int_equal(tctx, needed, needed_ex, "needed mismatch");
3610                 torture_assert_mem_equal(tctx, data, data_ex, needed, "data mismatch");
3611         }
3612
3613         return true;
3614 }
3615
3616 static bool test_EnumPrinterData(struct torture_context *tctx,
3617                                  struct dcerpc_pipe *p,
3618                                  struct policy_handle *handle,
3619                                  uint32_t enum_index,
3620                                  uint32_t value_offered,
3621                                  uint32_t data_offered,
3622                                  enum winreg_Type *type_p,
3623                                  uint32_t *value_needed_p,
3624                                  uint32_t *data_needed_p,
3625                                  const char **value_name_p,
3626                                  uint8_t **data_p,
3627                                  WERROR *result_p)
3628 {
3629         struct spoolss_EnumPrinterData r;
3630         uint32_t data_needed;
3631         uint32_t value_needed;
3632         enum winreg_Type type;
3633         struct dcerpc_binding_handle *b = p->binding_handle;
3634
3635         r.in.handle = handle;
3636         r.in.enum_index = enum_index;
3637         r.in.value_offered = value_offered;
3638         r.in.data_offered = data_offered;
3639         r.out.data_needed = &data_needed;
3640         r.out.value_needed = &value_needed;
3641         r.out.type = &type;
3642         r.out.data = talloc_zero_array(tctx, uint8_t, r.in.data_offered);
3643         r.out.value_name = talloc_zero_array(tctx, const char, r.in.value_offered);
3644
3645         torture_comment(tctx, "Testing EnumPrinterData(%d)\n", enum_index);
3646
3647         torture_assert_ntstatus_ok(tctx,
3648                 dcerpc_spoolss_EnumPrinterData_r(b, tctx, &r),
3649                 "EnumPrinterData failed");
3650
3651         if (type_p) {
3652                 *type_p = type;
3653         }
3654         if (value_needed_p) {
3655                 *value_needed_p = value_needed;
3656         }
3657         if (data_needed_p) {
3658                 *data_needed_p = data_needed;
3659         }
3660         if (value_name_p) {
3661                 *value_name_p = r.out.value_name;
3662         }
3663         if (data_p) {
3664                 *data_p = r.out.data;
3665         }
3666         if (result_p) {
3667                 *result_p = r.out.result;
3668         }
3669
3670         return true;
3671 }
3672
3673
3674 static bool test_EnumPrinterData_all(struct torture_context *tctx,
3675                                      struct dcerpc_pipe *p,
3676                                      struct policy_handle *handle)
3677 {
3678         uint32_t enum_index = 0;
3679         enum winreg_Type type;
3680         uint32_t value_needed;
3681         uint32_t data_needed;
3682         uint8_t *data;
3683         const char *value_name;
3684         WERROR result;
3685
3686         torture_comment(tctx, "Testing EnumPrinterData\n");
3687
3688         do {
3689                 torture_assert(tctx,
3690                         test_EnumPrinterData(tctx, p, handle, enum_index, 0, 0,
3691                                              &type, &value_needed, &data_needed,
3692                                              &value_name, &data, &result),
3693                         "EnumPrinterData failed");
3694
3695                 if (W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS)) {
3696                         break;
3697                 }
3698
3699                 torture_assert(tctx,
3700                         test_EnumPrinterData(tctx, p, handle, enum_index, value_needed, data_needed,
3701                                              &type, &value_needed, &data_needed,
3702                                              &value_name, &data, &result),
3703                         "EnumPrinterData failed");
3704
3705                 if (W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS)) {
3706                         break;
3707                 }
3708
3709                 enum_index++;
3710
3711         } while (W_ERROR_IS_OK(result));
3712
3713         torture_comment(tctx, "EnumPrinterData test succeeded\n");
3714
3715         return true;
3716 }
3717
3718 static bool test_EnumPrinterDataEx(struct torture_context *tctx,
3719                                    struct dcerpc_binding_handle *b,
3720                                    struct policy_handle *handle,
3721                                    const char *key_name,
3722                                    uint32_t *count_p,
3723                                    struct spoolss_PrinterEnumValues **info_p)
3724 {
3725         struct spoolss_EnumPrinterDataEx r;
3726         struct spoolss_PrinterEnumValues *info;
3727         uint32_t needed;
3728         uint32_t count;
3729
3730         r.in.handle = handle;
3731         r.in.key_name = key_name;
3732         r.in.offered = 0;
3733         r.out.needed = &needed;
3734         r.out.count = &count;
3735         r.out.info = &info;
3736
3737         torture_comment(tctx, "Testing EnumPrinterDataEx(%s)\n", key_name);
3738
3739         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterDataEx_r(b, tctx, &r),
3740                 "EnumPrinterDataEx failed");
3741         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3742                 r.in.offered = needed;
3743                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterDataEx_r(b, tctx, &r),
3744                         "EnumPrinterDataEx failed");
3745         }
3746
3747         torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDataEx failed");
3748
3749         CHECK_NEEDED_SIZE_ENUM(spoolss_EnumPrinterDataEx, info, count, needed, 1);
3750
3751         if (count_p) {
3752                 *count_p = count;
3753         }
3754         if (info_p) {
3755                 *info_p = info;
3756         }
3757
3758         return true;
3759 }
3760
3761 static bool test_SetPrinterData(struct torture_context *tctx,
3762                                 struct dcerpc_binding_handle *b,
3763                                 struct policy_handle *handle,
3764                                 const char *value_name,
3765                                 enum winreg_Type type,
3766                                 uint8_t *data,
3767                                 uint32_t offered);
3768 static bool test_DeletePrinterData(struct torture_context *tctx,
3769                                    struct dcerpc_binding_handle *b,
3770                                    struct policy_handle *handle,
3771                                    const char *value_name);
3772
3773 static bool test_EnumPrinterData_consistency(struct torture_context *tctx,
3774                                              struct dcerpc_pipe *p,
3775                                              struct policy_handle *handle)
3776 {
3777         uint32_t count;
3778         struct spoolss_PrinterEnumValues *info;
3779         int i;
3780         uint32_t value_needed, data_needed;
3781         uint32_t value_offered, data_offered;
3782         WERROR result;
3783         struct dcerpc_binding_handle *b = p->binding_handle;
3784
3785         enum winreg_Type type;
3786         DATA_BLOB blob;
3787
3788         torture_comment(tctx, "Testing EnumPrinterData vs EnumPrinterDataEx consistency\n");
3789
3790         torture_assert(tctx, push_reg_sz(tctx, &blob, "torture_data1"), "");
3791         type = REG_SZ;
3792
3793         torture_assert(tctx,
3794                 test_SetPrinterData(tctx, b, handle, "torture_value1", type, blob.data, blob.length),
3795                 "SetPrinterData failed");
3796
3797         blob = data_blob_string_const("torture_data2");
3798
3799         torture_assert(tctx,
3800                 test_SetPrinterData(tctx, b, handle, "torture_value2", REG_BINARY, blob.data, blob.length),
3801                 "SetPrinterData failed");
3802
3803         blob = data_blob_talloc(tctx, NULL, 4);
3804         SIVAL(blob.data, 0, 0x11223344);
3805
3806         torture_assert(tctx,
3807                 test_SetPrinterData(tctx, b, handle, "torture_value3", type, blob.data, blob.length),
3808                 "SetPrinterData failed");
3809
3810         torture_assert(tctx,
3811                 test_EnumPrinterDataEx(tctx, b, handle, "PrinterDriverData", &count, &info),
3812                 "failed to call EnumPrinterDataEx");
3813
3814         /* get the max sizes for value and data */
3815
3816         torture_assert(tctx,
3817                 test_EnumPrinterData(tctx, p, handle, 0, 0, 0,
3818                                      NULL, &value_needed, &data_needed,
3819                                      NULL, NULL, &result),
3820                 "EnumPrinterData failed");
3821         torture_assert_werr_ok(tctx, result, "unexpected result");
3822
3823         /* check if the reply from the EnumPrinterData really matches max values */
3824
3825         for (i=0; i < count; i++) {
3826                 if (info[i].value_name_len > value_needed) {
3827                         torture_fail(tctx,
3828                                 talloc_asprintf(tctx,
3829                                 "EnumPrinterDataEx gave a reply with value length %d which is larger then expected max value length %d from EnumPrinterData",
3830                                 info[i].value_name_len, value_needed));
3831                 }
3832                 if (info[i].data_length > data_needed) {
3833                         torture_fail(tctx,
3834                                 talloc_asprintf(tctx,
3835                                 "EnumPrinterDataEx gave a reply with data length %d which is larger then expected max data length %d from EnumPrinterData",
3836                                 info[i].data_length, data_needed));
3837                 }
3838         }
3839
3840         /* assuming that both EnumPrinterData and EnumPrinterDataEx do either
3841          * sort or not sort the replies by value name, we should be able to do
3842          * the following entry comparison */
3843
3844         data_offered = data_needed;
3845         value_offered = value_needed;
3846
3847         for (i=0; i < count; i++) {
3848
3849                 const char *value_name;
3850                 uint8_t *data;
3851
3852                 torture_assert(tctx,
3853                         test_EnumPrinterData(tctx, p, handle, i, value_offered, data_offered,
3854                                              &type, &value_needed, &data_needed,
3855                                              &value_name, &data, &result),
3856                         "EnumPrinterData failed");
3857
3858                 if (i -1 == count) {
3859                         torture_assert_werr_equal(tctx, result, WERR_NO_MORE_ITEMS,
3860                                 "unexpected result");
3861                         break;
3862                 } else {
3863                         torture_assert_werr_ok(tctx, result, "unexpected result");
3864                 }
3865
3866                 torture_assert_int_equal(tctx, type, info[i].type, "type mismatch");
3867                 torture_assert_int_equal(tctx, value_needed, info[i].value_name_len, "value name length mismatch");
3868                 torture_assert_str_equal(tctx, value_name, info[i].value_name, "value name mismatch");
3869                 torture_assert_int_equal(tctx, data_needed, info[i].data_length, "data length mismatch");
3870                 torture_assert_mem_equal(tctx, data, info[i].data->data, info[i].data_length, "data mismatch");
3871         }
3872
3873         torture_assert(tctx,
3874                 test_DeletePrinterData(tctx, b, handle, "torture_value1"),
3875                 "DeletePrinterData failed");
3876         torture_assert(tctx,
3877                 test_DeletePrinterData(tctx, b, handle, "torture_value2"),
3878                 "DeletePrinterData failed");
3879         torture_assert(tctx,
3880                 test_DeletePrinterData(tctx, b, handle, "torture_value3"),
3881                 "DeletePrinterData failed");
3882
3883         torture_comment(tctx, "EnumPrinterData vs EnumPrinterDataEx consistency test succeeded\n\n");
3884
3885         return true;
3886 }
3887
3888 static bool test_DeletePrinterData(struct torture_context *tctx,
3889                                    struct dcerpc_binding_handle *b,
3890                                    struct policy_handle *handle,
3891                                    const char *value_name)
3892 {
3893         NTSTATUS status;
3894         struct spoolss_DeletePrinterData r;
3895
3896         r.in.handle = handle;
3897         r.in.value_name = value_name;
3898
3899         torture_comment(tctx, "Testing DeletePrinterData(%s)\n",
3900                 r.in.value_name);
3901
3902         status = dcerpc_spoolss_DeletePrinterData_r(b, tctx, &r);
3903
3904         torture_assert_ntstatus_ok(tctx, status, "DeletePrinterData failed");
3905         torture_assert_werr_ok(tctx, r.out.result, "DeletePrinterData failed");
3906
3907         return true;
3908 }
3909
3910 static bool test_DeletePrinterDataEx(struct torture_context *tctx,
3911                                      struct dcerpc_binding_handle *b,
3912                                      struct policy_handle *handle,
3913                                      const char *key_name,
3914                                      const char *value_name)
3915 {
3916         struct spoolss_DeletePrinterDataEx r;
3917
3918         r.in.handle = handle;
3919         r.in.key_name = key_name;
3920         r.in.value_name = value_name;
3921
3922         torture_comment(tctx, "Testing DeletePrinterDataEx(%s - %s)\n",
3923                 r.in.key_name, r.in.value_name);
3924
3925         torture_assert_ntstatus_ok(tctx,
3926                 dcerpc_spoolss_DeletePrinterDataEx_r(b, tctx, &r),
3927                 "DeletePrinterDataEx failed");
3928         torture_assert_werr_ok(tctx, r.out.result,
3929                 "DeletePrinterDataEx failed");
3930
3931         return true;
3932 }
3933
3934 static bool test_DeletePrinterKey(struct torture_context *tctx,
3935                                   struct dcerpc_binding_handle *b,
3936                                   struct policy_handle *handle,
3937                                   const char *key_name)
3938 {
3939         struct spoolss_DeletePrinterKey r;
3940
3941         r.in.handle = handle;
3942         r.in.key_name = key_name;
3943
3944         torture_comment(tctx, "Testing DeletePrinterKey(%s)\n", r.in.key_name);
3945
3946         if (strequal(key_name, "") && !torture_setting_bool(tctx, "dangerous", false)) {
3947                 torture_skip(tctx, "not wiping out printer registry - enable dangerous tests to use\n");
3948                 return true;
3949         }
3950
3951         torture_assert_ntstatus_ok(tctx,
3952                 dcerpc_spoolss_DeletePrinterKey_r(b, tctx, &r),
3953                 "DeletePrinterKey failed");
3954         torture_assert_werr_ok(tctx, r.out.result,
3955                 "DeletePrinterKey failed");
3956
3957         return true;
3958 }
3959
3960 static bool test_winreg_OpenHKLM(struct torture_context *tctx,
3961                                  struct dcerpc_binding_handle *b,
3962                                  struct policy_handle *handle)
3963 {
3964         struct winreg_OpenHKLM r;
3965
3966         r.in.system_name = NULL;
3967         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
3968         r.out.handle = handle;
3969
3970         torture_comment(tctx, "Testing winreg_OpenHKLM\n");
3971
3972         torture_assert_ntstatus_ok(tctx, dcerpc_winreg_OpenHKLM_r(b, tctx, &r), "OpenHKLM failed");
3973         torture_assert_werr_ok(tctx, r.out.result, "OpenHKLM failed");
3974
3975         return true;
3976 }
3977
3978 static void init_winreg_String(struct winreg_String *name, const char *s)
3979 {
3980         name->name = s;
3981         if (s) {
3982                 name->name_len = 2 * (strlen_m(s) + 1);
3983                 name->name_size = name->name_len;
3984         } else {
3985                 name->name_len = 0;
3986                 name->name_size = 0;
3987         }
3988 }
3989
3990 static bool test_winreg_OpenKey_opts(struct torture_context *tctx,
3991                                      struct dcerpc_binding_handle *b,
3992                                      struct policy_handle *hive_handle,
3993                                      const char *keyname,
3994                                      uint32_t options,
3995                                      struct policy_handle *key_handle)
3996 {
3997         struct winreg_OpenKey r;
3998
3999         r.in.parent_handle = hive_handle;
4000         init_winreg_String(&r.in.keyname, keyname);
4001         r.in.options = options;
4002         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
4003         r.out.handle = key_handle;
4004
4005         torture_comment(tctx, "Testing winreg_OpenKey(%s)\n", keyname);
4006
4007         torture_assert_ntstatus_ok(tctx, dcerpc_winreg_OpenKey_r(b, tctx, &r), "OpenKey failed");
4008         torture_assert_werr_ok(tctx, r.out.result, "OpenKey failed");
4009
4010         return true;
4011 }
4012
4013 static bool test_winreg_OpenKey(struct torture_context *tctx,
4014                                 struct dcerpc_binding_handle *b,
4015                                 struct policy_handle *hive_handle,
4016                                 const char *keyname,
4017                                 struct policy_handle *key_handle)
4018 {
4019         return test_winreg_OpenKey_opts(tctx, b, hive_handle, keyname,
4020                                         REG_OPTION_NON_VOLATILE, key_handle);
4021 }
4022
4023 static bool test_winreg_CloseKey(struct torture_context *tctx,
4024                                  struct dcerpc_binding_handle *b,
4025                                  struct policy_handle *handle)
4026 {
4027         struct winreg_CloseKey r;
4028
4029         r.in.handle = handle;
4030         r.out.handle = handle;
4031
4032         torture_comment(tctx, "Testing winreg_CloseKey\n");
4033
4034         torture_assert_ntstatus_ok(tctx, dcerpc_winreg_CloseKey_r(b, tctx, &r), "CloseKey failed");
4035         torture_assert_werr_ok(tctx, r.out.result, "CloseKey failed");
4036
4037         return true;
4038 }
4039
4040 bool test_winreg_QueryValue(struct torture_context *tctx,
4041                             struct dcerpc_binding_handle *b,
4042                             struct policy_handle *handle,
4043                             const char *value_name,
4044                             enum winreg_Type *type_p,
4045                             uint32_t *data_size_p,
4046                             uint32_t *data_length_p,
4047                             uint8_t **data_p)
4048 {
4049         struct winreg_QueryValue r;
4050         enum winreg_Type type = REG_NONE;
4051         uint32_t data_size = 0;
4052         uint32_t data_length = 0;
4053         struct winreg_String valuename;
4054         uint8_t *data = NULL;
4055
4056         init_winreg_String(&valuename, value_name);
4057
4058         data = talloc_zero_array(tctx, uint8_t, 0);
4059
4060         r.in.handle = handle;
4061         r.in.value_name = &valuename;
4062         r.in.type = &type;
4063         r.in.data_size = &data_size;
4064         r.in.data_length = &data_length;
4065         r.in.data = data;
4066         r.out.type = &type;
4067         r.out.data = data;
4068         r.out.data_size = &data_size;
4069         r.out.data_length = &data_length;
4070
4071         torture_comment(tctx, "Testing winreg_QueryValue(%s)\n", value_name);
4072
4073         torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue_r(b, tctx, &r), "QueryValue failed");
4074         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
4075                 *r.in.data_size = *r.out.data_size;
4076                 data = talloc_zero_array(tctx, uint8_t, *r.in.data_size);
4077                 r.in.data = data;
4078                 r.out.data = data;
4079                 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue_r(b, tctx, &r), "QueryValue failed");
4080         }
4081         torture_assert_werr_ok(tctx, r.out.result, "QueryValue failed");
4082
4083         if (type_p) {
4084                 *type_p = *r.out.type;
4085         }
4086         if (data_size_p) {
4087                 *data_size_p = *r.out.data_size;
4088         }
4089         if (data_length_p) {
4090                 *data_length_p = *r.out.data_length;
4091         }
4092         if (data_p) {
4093                 *data_p = r.out.data;
4094         }
4095
4096         return true;
4097 }
4098
4099 static bool test_winreg_query_printerdata(struct torture_context *tctx,
4100                                           struct dcerpc_binding_handle *b,
4101                                           struct policy_handle *handle,
4102                                           const char *printer_name,
4103                                           const char *key_name,
4104                                           const char *value_name,
4105                                           enum winreg_Type *w_type,
4106                                           uint32_t *w_size,
4107                                           uint32_t *w_length,
4108                                           uint8_t **w_data)
4109 {
4110         const char *printer_key;
4111         struct policy_handle key_handle;
4112
4113         printer_key = talloc_asprintf(tctx, "%s\\%s\\%s",
4114                 TOP_LEVEL_PRINT_PRINTERS_KEY, printer_name, key_name);
4115
4116         torture_assert(tctx,
4117                 test_winreg_OpenKey(tctx, b, handle, printer_key, &key_handle), "");
4118
4119         torture_assert(tctx,
4120                 test_winreg_QueryValue(tctx, b, &key_handle, value_name, w_type, w_size, w_length, w_data), "");
4121
4122         torture_assert(tctx,
4123                 test_winreg_CloseKey(tctx, b, &key_handle), "");
4124
4125         return true;
4126 }
4127
4128 static bool test_GetForm_winreg(struct torture_context *tctx,
4129                                 struct dcerpc_binding_handle *b,
4130                                 struct policy_handle *handle,
4131                                 const char *key_name,
4132                                 const char *form_name,
4133                                 enum winreg_Type *w_type,
4134                                 uint32_t *w_size,
4135                                 uint32_t *w_length,
4136                                 uint8_t **w_data)
4137 {
4138         struct policy_handle key_handle;
4139
4140         torture_assert(tctx,
4141                 test_winreg_OpenKey(tctx, b, handle, key_name, &key_handle), "");
4142
4143         torture_assert(tctx,
4144                 test_winreg_QueryValue(tctx, b, &key_handle, form_name, w_type, w_size, w_length, w_data), "");
4145
4146         torture_assert(tctx,
4147                 test_winreg_CloseKey(tctx, b, &key_handle), "");
4148
4149         return true;
4150 }
4151
4152 static bool test_winreg_symbolic_link(struct torture_context *tctx,
4153                                       struct dcerpc_binding_handle *b,
4154                                       struct policy_handle *handle,
4155                                       const char *symlink_keyname,
4156                                       const char *symlink_destination)
4157 {
4158         /* check if the first key is a symlink to the second key */
4159
4160         enum winreg_Type w_type;
4161         uint32_t w_size;
4162         uint32_t w_length;
4163         uint8_t *w_data;
4164         struct policy_handle key_handle;
4165         DATA_BLOB blob;
4166         const char *str;
4167
4168         if (torture_setting_bool(tctx, "samba3", false)) {
4169                 torture_skip(tctx, "skip winreg symlink test against samba");
4170         }
4171
4172         torture_assert(tctx,
4173                 test_winreg_OpenKey_opts(tctx, b, handle, symlink_keyname, REG_OPTION_OPEN_LINK, &key_handle),
4174                         "failed to open key link");
4175
4176         torture_assert(tctx,
4177                 test_winreg_QueryValue(tctx, b, &key_handle,
4178                                        "SymbolicLinkValue",
4179                                        &w_type, &w_size, &w_length, &w_data),
4180                 "failed to query for 'SymbolicLinkValue' attribute");
4181
4182         torture_assert_int_equal(tctx, w_type, REG_LINK, "unexpected type");
4183
4184         blob = data_blob(w_data, w_size);
4185         str = reg_val_data_string(tctx, REG_SZ, blob);
4186
4187         torture_assert_str_equal(tctx, str, symlink_destination, "unexpected symlink target string");
4188
4189         torture_assert(tctx,
4190                 test_winreg_CloseKey(tctx, b, &key_handle),
4191                 "failed to close key link");
4192
4193         return true;
4194 }
4195
4196 static const char *strip_unc(const char *unc)
4197 {
4198         char *name;
4199
4200         if (!unc) {
4201                 return NULL;
4202         }
4203
4204         if (unc[0] == '\\' && unc[1] == '\\') {
4205                 unc +=2;
4206         }
4207
4208         name = strchr(unc, '\\');
4209         if (name) {
4210                 return name+1;
4211         }
4212
4213         return unc;
4214 }
4215
4216 static bool test_GetPrinterInfo_winreg(struct torture_context *tctx,
4217                                        struct dcerpc_binding_handle *b,
4218                                        struct policy_handle *handle,
4219                                        const char *printer_name,
4220                                        struct dcerpc_binding_handle *winreg_handle,
4221                                        struct policy_handle *hive_handle)
4222 {
4223         union spoolss_PrinterInfo info;
4224         const char *keys[] = {
4225                 TOP_LEVEL_CONTROL_PRINTERS_KEY,
4226                 TOP_LEVEL_PRINT_PRINTERS_KEY
4227         };
4228         int i;
4229         const char *printername, *sharename;
4230
4231         torture_comment(tctx, "Testing Printer Info and winreg consistency\n");
4232
4233         torture_assert(tctx,
4234                 test_GetPrinter_level(tctx, b, handle, 2, &info),
4235                 "failed to get printer info level 2");
4236
4237         printername = strip_unc(info.info2.printername);
4238         sharename = strip_unc(info.info2.sharename);
4239
4240 #define test_sz(wname, iname) \
4241 do {\
4242         DATA_BLOB blob;\
4243         const char *str;\
4244         enum winreg_Type w_type;\
4245         uint32_t w_size;\
4246         uint32_t w_length;\
4247         uint8_t *w_data;\
4248         torture_assert(tctx,\
4249                 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4250                                        &w_type, &w_size, &w_length, &w_data),\
4251                 "failed to query winreg");\
4252         torture_assert_int_equal(tctx, w_type, REG_SZ, "unexpected type");\
4253         blob = data_blob(w_data, w_size);\
4254         str = reg_val_data_string(tctx, REG_SZ, blob);\
4255         if (w_size == 2 && iname == NULL) {\
4256                 /*torture_comment(tctx, "%s: \"\", %s: (null)\n", #wname, #iname);\ */\
4257         } else {\
4258                 torture_assert_str_equal(tctx, str, iname,\
4259                         talloc_asprintf(tctx, "%s - %s mismatch", #wname, #iname));\
4260         }\
4261 } while(0);
4262
4263 #define test_dword(wname, iname) \
4264 do {\
4265         uint32_t value;\
4266         enum winreg_Type w_type;\
4267         uint32_t w_size;\
4268         uint32_t w_length;\
4269         uint8_t *w_data;\
4270         torture_assert(tctx,\
4271                 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4272                                        &w_type, &w_size, &w_length, &w_data),\
4273                 "failed to query winreg");\
4274         torture_assert_int_equal(tctx, w_type, REG_DWORD, "unexpected type");\
4275         torture_assert_int_equal(tctx, w_size, 4, "unexpected size");\
4276         torture_assert_int_equal(tctx, w_length, 4, "unexpected length");\
4277         value = IVAL(w_data, 0);\
4278         torture_assert_int_equal(tctx, value, iname,\
4279                 talloc_asprintf(tctx, "%s - %s mismatch", #wname, #iname));\
4280 } while(0);
4281
4282 #define test_dm(wname, iname) \
4283 do {\
4284         DATA_BLOB blob;\
4285         struct spoolss_DeviceMode dm;\
4286         enum ndr_err_code ndr_err;\
4287         enum winreg_Type w_type;\
4288         uint32_t w_size;\
4289         uint32_t w_length;\
4290         uint8_t *w_data;\
4291         torture_assert(tctx,\
4292                 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4293                                        &w_type, &w_size, &w_length, &w_data),\
4294                 "failed to query winreg");\
4295         torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");\
4296         blob = data_blob(w_data, w_size);\
4297         ndr_err = ndr_pull_struct_blob(&blob, tctx, &dm,\
4298                 (ndr_pull_flags_fn_t)ndr_pull_spoolss_DeviceMode);\
4299         torture_assert_ndr_success(tctx, ndr_err, "failed to unmarshall dm");\
4300         torture_assert(tctx, test_devicemode_equal(tctx, &dm, iname),\
4301                 "dm unequal");\
4302 } while(0);
4303
4304 #define test_sd(wname, iname) \
4305 do {\
4306         DATA_BLOB blob;\
4307         struct security_descriptor sd;\
4308         enum ndr_err_code ndr_err;\
4309         enum winreg_Type w_type;\
4310         uint32_t w_size;\
4311         uint32_t w_length;\
4312         uint8_t *w_data;\
4313         torture_assert(tctx,\
4314                 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4315                                        &w_type, &w_size, &w_length, &w_data),\
4316                 "failed to query winreg");\
4317         torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");\
4318         blob = data_blob(w_data, w_size);\
4319         ndr_err = ndr_pull_struct_blob(&blob, tctx, &sd,\
4320                 (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);\
4321         torture_assert_ndr_success(tctx, ndr_err, "failed to unmarshall sd");\
4322         torture_assert(tctx, test_security_descriptor_equal(tctx, &sd, iname),\
4323                 "sd unequal");\
4324 } while(0);
4325
4326 #define test_multi_sz(wname, iname) \
4327 do {\
4328         DATA_BLOB blob;\
4329         const char **array;\
4330         enum winreg_Type w_type;\
4331         uint32_t w_size;\
4332         uint32_t w_length;\
4333         uint8_t *w_data;\
4334         int i;\
4335         torture_assert(tctx,\
4336                 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4337                                        &w_type, &w_size, &w_length, &w_data),\
4338                 "failed to query winreg");\
4339         torture_assert_int_equal(tctx, w_type, REG_MULTI_SZ, "unexpected type");\
4340         blob = data_blob(w_data, w_size);\
4341         torture_assert(tctx, \
4342                 pull_reg_multi_sz(tctx, &blob, &array),\
4343                 "failed to pull multi sz");\
4344         for (i=0; array[i] != NULL; i++) {\
4345                 torture_assert_str_equal(tctx, array[i], iname[i],\
4346                         talloc_asprintf(tctx, "%s - %s mismatch", #wname, iname[i]));\
4347         }\
4348 } while(0);
4349
4350
4351         if (!test_winreg_symbolic_link(tctx, winreg_handle, hive_handle,
4352                                        TOP_LEVEL_CONTROL_PRINTERS_KEY,
4353                                        "\\Registry\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Print\\Printers"))
4354         {
4355                 torture_warning(tctx, "failed to check for winreg symlink");
4356         }
4357
4358
4359         for (i=0; i < ARRAY_SIZE(keys); i++) {
4360
4361                 const char *printer_key;
4362                 struct policy_handle key_handle;
4363
4364                 printer_key = talloc_asprintf(tctx, "%s\\%s",
4365                         keys[i], printer_name);
4366
4367                 torture_assert(tctx,
4368                         test_winreg_OpenKey(tctx, winreg_handle, hive_handle, printer_key, &key_handle), "");
4369
4370                 test_sz("Name", printername);
4371                 test_sz("Share Name", sharename);
4372                 test_sz("Port", info.info2.portname);
4373                 test_sz("Printer Driver", info.info2.drivername);
4374                 test_sz("Description", info.info2.comment);
4375                 test_sz("Location", info.info2.location);
4376                 test_sz("Separator File", info.info2.sepfile);
4377                 test_sz("Print Processor", info.info2.printprocessor);
4378                 test_sz("Datatype", info.info2.datatype);
4379                 test_sz("Parameters", info.info2.parameters);
4380                 /* winreg: 0, spoolss not */
4381 /*              test_dword("Attributes", info.info2.attributes); */
4382                 test_dword("Priority", info.info2.priority);
4383                 test_dword("Default Priority", info.info2.defaultpriority);
4384                 /* winreg: 60, spoolss: 0 */
4385 /*              test_dword("StartTime", info.info2.starttime); */
4386 /*              test_dword("UntilTime", info.info2.untiltime); */
4387                 /* winreg != spoolss */
4388 /*              test_dword("Status", info.info2.status); */
4389                 test_dm("Default DevMode", info.info2.devmode);
4390                 test_sd("Security", info.info2.secdesc);
4391
4392                 torture_assert(tctx,
4393                         test_winreg_CloseKey(tctx, winreg_handle, &key_handle), "");
4394         }
4395
4396 #undef test_dm
4397 #undef test_sd
4398
4399         torture_comment(tctx, "Printer Info and winreg consistency test succeeded\n\n");
4400
4401         return true;
4402 }
4403
4404 static bool test_PrintProcessors(struct torture_context *tctx,
4405                                  struct dcerpc_binding_handle *b,
4406                                  const char *environment,
4407                                  struct dcerpc_binding_handle *winreg_handle,
4408                                  struct policy_handle *hive_handle)
4409 {
4410         union spoolss_PrintProcessorInfo *info;
4411         uint32_t count;
4412         int i;
4413
4414         torture_comment(tctx, "Testing Print Processor Info and winreg consistency\n");
4415
4416         torture_assert(tctx,
4417                 test_EnumPrintProcessors_level(tctx, b, environment, 1, &count, &info),
4418                 "failed to enum print processors level 1");
4419
4420         for (i=0; i < count; i++) {
4421
4422                 const char *processor_key;
4423                 struct policy_handle key_handle;
4424
4425                 processor_key = talloc_asprintf(tctx, "%s\\%s\\Print Processors\\%s",
4426                                                 TOP_LEVEL_CONTROL_ENVIRONMENTS_KEY,
4427                                                 environment,
4428                                                 info[i].info1.print_processor_name);
4429
4430                 torture_assert(tctx,
4431                         test_winreg_OpenKey(tctx, winreg_handle, hive_handle, processor_key, &key_handle), "");
4432
4433                 /* nothing to check in there so far */
4434
4435                 torture_assert(tctx,
4436                         test_winreg_CloseKey(tctx, winreg_handle, &key_handle), "");
4437         }
4438
4439         torture_comment(tctx, "Print Processor Info and winreg consistency test succeeded\n\n");
4440
4441         return true;
4442 }
4443
4444 static bool test_GetPrinterDriver2_level(struct torture_context *tctx,
4445                                          struct dcerpc_binding_handle *b,
4446                                          struct policy_handle *handle,
4447                                          const char *driver_name,
4448                                          const char *architecture,
4449                                          uint32_t level,
4450                                          uint32_t client_major_version,
4451                                          uint32_t client_minor_version,
4452                                          union spoolss_DriverInfo *info_p,
4453                                          WERROR *result);
4454
4455 static const char *strip_path(const char *path)
4456 {
4457         char *p;
4458
4459         if (path == NULL) {
4460                 return NULL;
4461         }
4462
4463         p = strrchr(path, '\\');
4464         if (p) {
4465                 return p+1;
4466         }
4467
4468         return path;
4469 }
4470
4471 static const char **strip_paths(const char **path_array)
4472 {
4473         int i;
4474
4475         if (path_array == NULL) {
4476                 return NULL;
4477         }
4478
4479         for (i=0; path_array[i] != NULL; i++) {
4480                 path_array[i] = strip_path(path_array[i]);
4481         }
4482
4483         return path_array;
4484 }
4485
4486 static const char *driver_winreg_date(TALLOC_CTX *mem_ctx, NTTIME nt)
4487 {
4488         time_t t;
4489         struct tm *tm;
4490         t = nt_time_to_unix(nt);
4491         tm = localtime(&t);
4492
4493         return talloc_asprintf(mem_ctx, "%02d/%02d/%04d",
4494                 tm->tm_mon + 1, tm->tm_mday, tm->tm_year + 1900);
4495 }
4496
4497 static const char *driver_winreg_version(TALLOC_CTX *mem_ctx, uint64_t v)
4498 {
4499         return talloc_asprintf(mem_ctx, "%u.%u.%u.%u",
4500                 (unsigned)((v >> 48) & 0xFFFF),
4501                 (unsigned)((v >> 32) & 0xFFFF),
4502                 (unsigned)((v >> 16) & 0xFFFF),
4503                 (unsigned)(v & 0xFFFF));
4504 }
4505
4506 static bool test_GetDriverInfo_winreg(struct torture_context *tctx,
4507                                       struct dcerpc_binding_handle *b,
4508                                       struct policy_handle *handle,
4509                                       const char *printer_name,
4510                                       const char *driver_name,
4511                                       const char *environment,
4512                                       struct dcerpc_binding_handle *winreg_handle,
4513                                       struct policy_handle *hive_handle)
4514 {
4515         WERROR result;
4516         union spoolss_DriverInfo info;
4517         const char *driver_key;
4518         struct policy_handle key_handle;
4519
4520         const char *driver_path;
4521         const char *data_file;
4522         const char *config_file;
4523         const char *help_file;
4524         const char **dependent_files;
4525
4526         const char *driver_date;
4527         const char *inbox_driver_date;
4528
4529         const char *driver_version;
4530         const char *inbox_driver_version;
4531
4532         torture_comment(tctx, "Testing Driver Info and winreg consistency\n");
4533
4534         driver_key = talloc_asprintf(tctx, "%s\\%s\\Drivers\\Version-%d\\%s",
4535                                      TOP_LEVEL_CONTROL_ENVIRONMENTS_KEY,
4536                                      environment,
4537                                      3,
4538                                      driver_name);
4539
4540         torture_assert(tctx,
4541                 test_winreg_OpenKey(tctx, winreg_handle, hive_handle, driver_key, &key_handle),
4542                 "failed to open driver key");
4543
4544         if (torture_setting_bool(tctx, "samba3", false)) {
4545                 goto try_level3;
4546         }
4547
4548         torture_assert(tctx,
4549                 test_GetPrinterDriver2_level(tctx, b, handle, driver_name, environment, 8, 3, 0, &info, &result),
4550                 "failed to get driver info level 8");
4551
4552         if (W_ERROR_EQUAL(result, WERR_INVALID_LEVEL)) {
4553                 goto try_level6;
4554         }
4555
4556         driver_path     = strip_path(info.info8.driver_path);
4557         data_file       = strip_path(info.info8.data_file);
4558         config_file     = strip_path(info.info8.config_file);
4559         help_file       = strip_path(info.info8.help_file);
4560         dependent_files = strip_paths(info.info8.dependent_files);
4561
4562         driver_date             = driver_winreg_date(tctx, info.info8.driver_date);
4563         inbox_driver_date       = driver_winreg_date(tctx, info.info8.min_inbox_driver_ver_date);
4564
4565         driver_version          = driver_winreg_version(tctx, info.info8.driver_version);
4566         inbox_driver_version    = driver_winreg_version(tctx, info.info8.min_inbox_driver_ver_version);
4567
4568         test_sz("Configuration File",           config_file);
4569         test_sz("Data File",                    data_file);
4570         test_sz("Datatype",                     info.info8.default_datatype);
4571         test_sz("Driver",                       driver_path);
4572         test_sz("DriverDate",                   driver_date);
4573         test_sz("DriverVersion",                driver_version);
4574         test_sz("HardwareID",                   info.info8.hardware_id);
4575         test_sz("Help File",                    help_file);
4576         test_sz("InfPath",                      info.info8.inf_path);
4577         test_sz("Manufacturer",                 info.info8.manufacturer_name);
4578         test_sz("MinInboxDriverVerDate",        inbox_driver_date);
4579         test_sz("MinInboxDriverVerVersion",     inbox_driver_version);
4580         test_sz("Monitor",                      info.info8.monitor_name);
4581         test_sz("OEM URL",                      info.info8.manufacturer_url);
4582         test_sz("Print Processor",              info.info8.print_processor);
4583         test_sz("Provider",                     info.info8.provider);
4584         test_sz("VendorSetup",                  info.info8.vendor_setup);
4585         test_multi_sz("ColorProfiles",          info.info8.color_profiles);
4586         test_multi_sz("Dependent Files",        dependent_files);
4587         test_multi_sz("CoreDependencies",       info.info8.core_driver_dependencies);
4588         test_multi_sz("Previous Names",         info.info8.previous_names);
4589 /*      test_dword("Attributes",                ?); */
4590         test_dword("PrinterDriverAttributes",   info.info8.printer_driver_attributes);
4591         test_dword("Version",                   info.info8.version);
4592 /*      test_dword("TempDir",                   ?); */
4593
4594  try_level6:
4595
4596         torture_assert(tctx,
4597                 test_GetPrinterDriver2_level(tctx, b, handle, driver_name, environment, 6, 3, 0, &info, &result),
4598                 "failed to get driver info level 6");
4599
4600         driver_path     = strip_path(info.info6.driver_path);
4601         data_file       = strip_path(info.info6.data_file);
4602         config_file     = strip_path(info.info6.config_file);
4603         help_file       = strip_path(info.info6.help_file);
4604         dependent_files = strip_paths(info.info6.dependent_files);
4605
4606         driver_date             = driver_winreg_date(tctx, info.info6.driver_date);
4607
4608         driver_version          = driver_winreg_version(tctx, info.info6.driver_version);
4609
4610         test_sz("Configuration File",           config_file);
4611         test_sz("Data File",                    data_file);
4612         test_sz("Datatype",                     info.info6.default_datatype);
4613         test_sz("Driver",                       driver_path);
4614         test_sz("DriverDate",                   driver_date);
4615         test_sz("DriverVersion",                driver_version);
4616         test_sz("HardwareID",                   info.info6.hardware_id);
4617         test_sz("Help File",                    help_file);
4618         test_sz("Manufacturer",                 info.info6.manufacturer_name);
4619         test_sz("Monitor",                      info.info6.monitor_name);
4620         test_sz("OEM URL",                      info.info6.manufacturer_url);
4621         test_sz("Provider",                     info.info6.provider);
4622         test_multi_sz("Dependent Files",        dependent_files);
4623         test_multi_sz("Previous Names",         info.info6.previous_names);
4624 /*      test_dword("Attributes",                ?); */
4625         test_dword("Version",                   info.info6.version);
4626 /*      test_dword("TempDir",                   ?); */
4627
4628  try_level3:
4629
4630         torture_assert(tctx,
4631                 test_GetPrinterDriver2_level(tctx, b, handle, driver_name, environment, 3, 3, 0, &info, &result),
4632                 "failed to get driver info level 3");
4633
4634         driver_path     = strip_path(info.info3.driver_path);
4635         data_file       = strip_path(info.info3.data_file);
4636         config_file     = strip_path(info.info3.config_file);
4637         help_file       = strip_path(info.info3.help_file);
4638         dependent_files = strip_paths(info.info3.dependent_files);
4639
4640         test_sz("Configuration File",           config_file);
4641         test_sz("Data File",                    data_file);
4642         test_sz("Datatype",                     info.info3.default_datatype);
4643         test_sz("Driver",                       driver_path);
4644         test_sz("Help File",                    help_file);
4645         test_sz("Monitor",                      info.info3.monitor_name);
4646         test_multi_sz("Dependent Files",        dependent_files);
4647 /*      test_dword("Attributes",                ?); */
4648         test_dword("Version",                   info.info3.version);
4649 /*      test_dword("TempDir",                   ?); */
4650
4651
4652         torture_assert(tctx,
4653                 test_winreg_CloseKey(tctx, winreg_handle, &key_handle), "");
4654
4655         torture_comment(tctx, "Driver Info and winreg consistency test succeeded\n\n");
4656
4657         return true;
4658 }
4659
4660 #undef test_sz
4661 #undef test_dword
4662
4663 static bool test_SetPrinterData(struct torture_context *tctx,
4664                                 struct dcerpc_binding_handle *b,
4665                                 struct policy_handle *handle,
4666                                 const char *value_name,
4667                                 enum winreg_Type type,
4668                                 uint8_t *data,
4669                                 uint32_t offered)
4670 {
4671         struct spoolss_SetPrinterData r;
4672
4673         r.in.handle = handle;
4674         r.in.value_name = value_name;
4675         r.in.type = type;
4676         r.in.data = data;
4677         r.in.offered = offered;
4678
4679         torture_comment(tctx, "Testing SetPrinterData(%s)\n",
4680                 r.in.value_name);
4681
4682         torture_assert_ntstatus_ok(tctx,
4683                 dcerpc_spoolss_SetPrinterData_r(b, tctx, &r),
4684                 "SetPrinterData failed");
4685         torture_assert_werr_ok(tctx, r.out.result,
4686                 "SetPrinterData failed");
4687
4688         return true;
4689 }
4690
4691 static bool test_SetPrinterData_matrix(struct torture_context *tctx,
4692                                        struct dcerpc_binding_handle *b,
4693                                        struct policy_handle *handle,
4694                                        const char *printer_name,
4695                                        struct dcerpc_binding_handle *winreg_handle,
4696                                        struct policy_handle *hive_handle)
4697 {
4698         const char *values[] = {
4699                 "spootyfoot",
4700                 "spooty\\foot",
4701 #if 0
4702         /* FIXME: not working with s3 atm. */
4703                 "spooty,foot",
4704                 "spooty,fo,ot",
4705 #endif
4706                 "spooty foot",
4707 #if 0
4708         /* FIXME: not working with s3 atm. */
4709                 "spooty\\fo,ot",
4710                 "spooty,fo\\ot"
4711 #endif
4712         };
4713         int i;
4714
4715         for (i=0; i < ARRAY_SIZE(values); i++) {
4716
4717                 enum winreg_Type type;
4718                 DATA_BLOB blob;
4719                 uint8_t *data;
4720                 uint32_t needed;
4721
4722                 torture_assert(tctx, push_reg_sz(tctx, &blob, "dog"), "");
4723                 type = REG_SZ;
4724
4725                 torture_assert(tctx,
4726                         test_SetPrinterData(tctx, b, handle, values[i], REG_SZ, blob.data, blob.length),
4727                         "SetPrinterData failed");
4728
4729                 torture_assert(tctx,
4730                         test_GetPrinterData(tctx, b, handle, values[i], &type, &data, &needed),
4731                         "GetPrinterData failed");
4732
4733                 torture_assert_int_equal(tctx, type, REG_SZ, "type mismatch");
4734                 torture_assert_int_equal(tctx, needed, blob.length, "size mismatch");
4735                 torture_assert_mem_equal(tctx, data, blob.data, blob.length, "buffer mismatch");
4736
4737                 if (winreg_handle && hive_handle) {
4738
4739                         enum winreg_Type w_type;
4740                         uint32_t w_size;
4741                         uint32_t w_length;
4742                         uint8_t *w_data;
4743
4744                         torture_assert(tctx,
4745                                 test_winreg_query_printerdata(tctx, winreg_handle, hive_handle,
4746                                         printer_name, "PrinterDriverData", values[i],
4747                                         &w_type, &w_size, &w_length, &w_data), "");
4748
4749                         torture_assert_int_equal(tctx, w_type, REG_SZ, "winreg type mismatch");
4750                         torture_assert_int_equal(tctx, w_size, blob.length, "winreg size mismatch");
4751                         torture_assert_int_equal(tctx, w_length, blob.length, "winreg length mismatch");
4752                         torture_assert_mem_equal(tctx, w_data, blob.data, blob.length, "winreg buffer mismatch");
4753                 }
4754
4755                 torture_assert(tctx,
4756                         test_DeletePrinterData(tctx, b, handle, values[i]),
4757                         "DeletePrinterData failed");
4758         }
4759
4760         return true;
4761 }
4762
4763
4764 static bool test_EnumPrinterKey(struct torture_context *tctx,
4765                                 struct dcerpc_binding_handle *b,
4766                                 struct policy_handle *handle,
4767                                 const char *key_name,
4768                                 const char ***array);
4769
4770 static bool test_SetPrinterDataEx(struct torture_context *tctx,
4771                                   struct dcerpc_binding_handle *b,
4772                                   struct policy_handle *handle,
4773                                   const char *key_name,
4774                                   const char *value_name,
4775                                   enum winreg_Type type,
4776                                   uint8_t *data,
4777                                   uint32_t offered)
4778 {
4779         NTSTATUS status;
4780         struct spoolss_SetPrinterDataEx r;
4781
4782         r.in.handle = handle;
4783         r.in.key_name = key_name;
4784         r.in.value_name = value_name;
4785         r.in.type = type;
4786         r.in.data = data;
4787         r.in.offered = offered;
4788
4789         torture_comment(tctx, "Testing SetPrinterDataEx(%s - %s) type: %s, offered: 0x%08x\n",
4790                 r.in.key_name, r.in.value_name, str_regtype(r.in.type), r.in.offered);
4791
4792         status = dcerpc_spoolss_SetPrinterDataEx_r(b, tctx, &r);
4793
4794         torture_assert_ntstatus_ok(tctx, status, "SetPrinterDataEx failed");
4795         torture_assert_werr_ok(tctx, r.out.result, "SetPrinterDataEx failed");
4796
4797         return true;
4798 }
4799
4800 static bool test_SetPrinterDataEx_matrix(struct torture_context *tctx,
4801                                          struct dcerpc_pipe *p,
4802                                          struct policy_handle *handle,
4803                                          const char *printername,
4804                                          struct dcerpc_binding_handle *winreg_handle,
4805                                          struct policy_handle *hive_handle)
4806 {
4807         struct dcerpc_binding_handle *b = p->binding_handle;
4808         const char *value_name = "dog";
4809         const char *keys[] = {
4810                 "torturedataex",
4811                 "torture data ex",
4812 #if 0
4813         /* FIXME: not working with s3 atm. */
4814                 "torturedataex_with_subkey\\subkey",
4815                 "torturedataex_with_subkey\\subkey:0",
4816                 "torturedataex_with_subkey\\subkey:1",
4817                 "torturedataex_with_subkey\\subkey\\subsubkey",
4818                 "torturedataex_with_subkey\\subkey\\subsubkey:0",
4819                 "torturedataex_with_subkey\\subkey\\subsubkey:1",
4820 #endif
4821                 "torture,data",
4822 #if 0
4823         /* FIXME: not working with s3 atm. */
4824
4825                 "torture,data,ex",
4826                 "torture,data\\ex",
4827                 "torture\\data,ex"
4828 #endif
4829         };
4830         enum winreg_Type types[] = {
4831                 REG_SZ,
4832                 REG_MULTI_SZ,
4833                 REG_DWORD,
4834                 REG_BINARY
4835         };
4836         const char *str = "abcdefghi";
4837         int i, t, s;
4838
4839
4840         for (i=0; i < ARRAY_SIZE(keys); i++) {
4841         for (t=0; t < ARRAY_SIZE(types); t++) {
4842         for (s=0; s < strlen(str); s++) {
4843
4844                 char *c;
4845                 const char *key;
4846                 enum winreg_Type type;
4847                 const char *string = talloc_strndup(tctx, str, s);
4848                 const char *array[2];
4849                 DATA_BLOB blob = data_blob_string_const(string);
4850                 const char **subkeys;
4851                 DATA_BLOB data;
4852                 uint8_t *data_out;
4853                 uint32_t needed, offered = 0;
4854                 uint32_t ecount;
4855                 struct spoolss_PrinterEnumValues *einfo;
4856
4857                 array[0] = talloc_strdup(tctx, string);
4858                 array[1] = NULL;
4859
4860                 if (types[t] == REG_DWORD) {
4861                         s = 0xffff;
4862                 }
4863
4864                 if (torture_setting_bool(tctx, "samba3", false)) {
4865                         if ((types[t] == REG_MULTI_SZ) && s == 0) {
4866                                 torture_warning(tctx, "samba3 does not handle 4 byte emtpy REG_MULTI_SZ buffers");
4867                                 continue;
4868                         }
4869                 }
4870
4871                 switch (types[t]) {
4872                 case REG_BINARY:
4873                         data = blob;
4874                         offered = blob.length;
4875                         break;
4876                 case REG_DWORD:
4877                         data = data_blob_talloc(tctx, NULL, 4);
4878                         SIVAL(data.data, 0, 0x12345678);
4879                         offered = 4;
4880                         break;
4881                 case REG_SZ:
4882                         torture_assert(tctx, push_reg_sz(tctx, &data, string), "");
4883                         type = REG_SZ;
4884                         offered = data.length;
4885                         /*strlen_m_term(data.string)*2;*/
4886                         break;
4887                 case REG_MULTI_SZ:
4888                         torture_assert(tctx, push_reg_multi_sz(tctx, &data, array), "");
4889                         type = REG_MULTI_SZ;
4890                         offered = data.length;
4891                         break;
4892                 default:
4893                         torture_fail(tctx, talloc_asprintf(tctx, "type %d untested\n", types[t]));
4894                 }
4895
4896                 torture_assert(tctx,
4897                         test_SetPrinterDataEx(tctx, b, handle, keys[i], value_name, types[t], data.data, offered),
4898                         "failed to call SetPrinterDataEx");
4899
4900                 torture_assert(tctx,
4901                         test_GetPrinterDataEx(tctx, p, handle, keys[i], value_name, &type, &data_out, &needed),
4902                         "failed to call GetPrinterDataEx");
4903
4904                 torture_assert(tctx,
4905                         test_EnumPrinterDataEx(tctx, b, handle, keys[i], &ecount, &einfo),
4906                         "failed to call EnumPrinterDataEx");
4907
4908                 torture_assert_int_equal(tctx, types[t], type, "type mismatch");
4909                 torture_assert_int_equal(tctx, needed, offered, "size mismatch");
4910                 torture_assert_mem_equal(tctx, data_out, data.data, offered, "buffer mismatch");
4911
4912                 torture_assert_int_equal(tctx, ecount, 1, "unexpected enum count");
4913                 torture_assert_str_equal(tctx, einfo[0].value_name, value_name, "value_name mismatch");
4914                 torture_assert_int_equal(tctx, einfo[0].value_name_len, strlen_m_term(value_name)*2, "unexpected value_name_len");
4915                 torture_assert_int_equal(tctx, einfo[0].type, types[t], "type mismatch");
4916                 torture_assert_int_equal(tctx, einfo[0].data_length, offered, "size mismatch");
4917                 if (einfo[0].data_length > 0) {
4918                         torture_assert_mem_equal(tctx, einfo[0].data->data, data.data, offered, "buffer mismatch");
4919                 }
4920
4921                 if (winreg_handle && hive_handle) {
4922                         enum winreg_Type w_type;
4923                         uint32_t w_size;
4924                         uint32_t w_length;
4925                         uint8_t *w_data;
4926
4927                         torture_assert(tctx,
4928                                 test_winreg_query_printerdata(tctx, winreg_handle, hive_handle,
4929                                         printername, keys[i], value_name,
4930                                         &w_type, &w_size, &w_length, &w_data), "");
4931
4932                         torture_assert_int_equal(tctx, w_type, types[t], "winreg type mismatch");
4933                         torture_assert_int_equal(tctx, w_size, offered, "winreg size mismatch");
4934                         torture_assert_int_equal(tctx, w_length, offered, "winreg length mismatch");
4935                         torture_assert_mem_equal(tctx, w_data, data.data, offered, "winreg buffer mismatch");
4936                 }
4937
4938                 key = talloc_strdup(tctx, keys[i]);
4939
4940                 if (!test_DeletePrinterDataEx(tctx, b, handle, keys[i], value_name)) {
4941                         return false;
4942                 }
4943
4944                 c = strchr(key, '\\');
4945                 if (c) {
4946                         int k;
4947
4948                         /* we have subkeys */
4949
4950                         *c = 0;
4951
4952                         if (!test_EnumPrinterKey(tctx, b, handle, key, &subkeys)) {
4953                                 return false;
4954                         }
4955
4956                         for (k=0; subkeys && subkeys[k]; k++) {
4957
4958                                 const char *current_key = talloc_asprintf(tctx, "%s\\%s", key, subkeys[k]);
4959
4960                                 if (!test_DeletePrinterKey(tctx, b, handle, current_key)) {
4961                                         return false;
4962                                 }
4963                         }
4964
4965                         if (!test_DeletePrinterKey(tctx, b, handle, key)) {
4966                                 return false;
4967                         }
4968
4969                 } else {
4970                         if (!test_DeletePrinterKey(tctx, b, handle, key)) {
4971                                 return false;
4972                         }
4973                 }
4974         }
4975         }
4976         }
4977
4978         return true;
4979 }
4980
4981 static bool test_PrinterData_winreg(struct torture_context *tctx,
4982                                     struct dcerpc_pipe *p,
4983                                     struct policy_handle *handle,
4984                                     const char *printer_name)
4985 {
4986         struct dcerpc_binding_handle *b = p->binding_handle;
4987         struct dcerpc_pipe *p2;
4988         bool ret = true;
4989         struct policy_handle hive_handle;
4990         struct dcerpc_binding_handle *b2;
4991
4992         torture_assert_ntstatus_ok(tctx,
4993                 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
4994                 "could not open winreg pipe");
4995         b2 = p2->binding_handle;
4996
4997         torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
4998
4999         ret &= test_SetPrinterData_matrix(tctx, b, handle, printer_name, b2, &hive_handle);
5000         ret &= test_SetPrinterDataEx_matrix(tctx, p, handle, printer_name, b2, &hive_handle);
5001
5002         test_winreg_CloseKey(tctx, b2, &hive_handle);
5003
5004         talloc_free(p2);
5005
5006         return ret;
5007 }
5008
5009 static bool test_Forms_winreg(struct torture_context *tctx,
5010                               struct dcerpc_binding_handle *b,
5011                               struct policy_handle *handle,
5012                               bool print_server,
5013                               const char *printer_name)
5014 {
5015         struct dcerpc_pipe *p2;
5016         bool ret = true;
5017         struct policy_handle hive_handle;
5018         struct dcerpc_binding_handle *b2;
5019
5020         torture_assert_ntstatus_ok(tctx,
5021                 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
5022                 "could not open winreg pipe");
5023         b2 = p2->binding_handle;
5024
5025         torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
5026
5027         ret = test_Forms(tctx, b, handle, print_server, printer_name, b2, &hive_handle);
5028
5029         test_winreg_CloseKey(tctx, b2, &hive_handle);
5030
5031         talloc_free(p2);
5032
5033         return ret;
5034 }
5035
5036 static bool test_PrinterInfo_winreg(struct torture_context *tctx,
5037                                     struct dcerpc_pipe *p,
5038                                     struct policy_handle *handle,
5039                                     const char *printer_name)
5040 {
5041         struct dcerpc_binding_handle *b = p->binding_handle;
5042         struct dcerpc_pipe *p2;
5043         bool ret = true;
5044         struct policy_handle hive_handle;
5045         struct dcerpc_binding_handle *b2;
5046
5047         torture_assert_ntstatus_ok(tctx,
5048                 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
5049                 "could not open winreg pipe");
5050         b2 = p2->binding_handle;
5051
5052         torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
5053
5054         ret = test_GetPrinterInfo_winreg(tctx, b, handle, printer_name, b2, &hive_handle);
5055
5056         test_winreg_CloseKey(tctx, b2, &hive_handle);
5057
5058         talloc_free(p2);
5059
5060         return ret;
5061 }
5062
5063 static bool test_DriverInfo_winreg(struct torture_context *tctx,
5064                                    struct dcerpc_pipe *p,
5065                                    struct policy_handle *handle,
5066                                    const char *printer_name,
5067                                    const char *driver_name,
5068                                    const char *environment)
5069 {
5070         struct dcerpc_binding_handle *b = p->binding_handle;
5071         struct dcerpc_pipe *p2;
5072         bool ret = true;
5073         struct policy_handle hive_handle;
5074         struct dcerpc_binding_handle *b2;
5075
5076         torture_assert_ntstatus_ok(tctx,
5077                 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
5078                 "could not open winreg pipe");
5079         b2 = p2->binding_handle;
5080
5081         torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
5082
5083         ret = test_GetDriverInfo_winreg(tctx, b, handle, printer_name, driver_name, environment, b2, &hive_handle);
5084
5085         test_winreg_CloseKey(tctx, b2, &hive_handle);
5086
5087         talloc_free(p2);
5088
5089         return ret;
5090 }
5091
5092 static bool test_PrintProcessors_winreg(struct torture_context *tctx,
5093                                         struct dcerpc_binding_handle *b,
5094                                         const char *environment)
5095 {
5096         struct dcerpc_pipe *p2;
5097         bool ret = true;
5098         struct policy_handle hive_handle;
5099         struct dcerpc_binding_handle *b2;
5100
5101         torture_assert_ntstatus_ok(tctx,
5102                 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
5103                 "could not open winreg pipe");
5104         b2 = p2->binding_handle;
5105
5106         torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
5107
5108         ret = test_PrintProcessors(tctx, b, environment, b2, &hive_handle);
5109
5110         test_winreg_CloseKey(tctx, b2, &hive_handle);
5111
5112         talloc_free(p2);
5113
5114         return ret;
5115 }
5116
5117 static bool test_PrinterData_DsSpooler(struct torture_context *tctx,
5118                                        struct dcerpc_pipe *p,
5119                                        struct policy_handle *handle,
5120                                        const char *printer_name)
5121 {
5122         struct spoolss_SetPrinterInfoCtr info_ctr;
5123         struct spoolss_DevmodeContainer devmode_ctr;
5124         struct sec_desc_buf secdesc_ctr;
5125         union spoolss_SetPrinterInfo sinfo;
5126         union spoolss_PrinterInfo info;
5127         struct dcerpc_binding_handle *b = p->binding_handle;
5128         const char *pname;
5129
5130         ZERO_STRUCT(info_ctr);
5131         ZERO_STRUCT(devmode_ctr);
5132         ZERO_STRUCT(secdesc_ctr);
5133
5134         torture_comment(tctx, "Testing DsSpooler <-> SetPrinter relations\n");
5135
5136         torture_assert(tctx,
5137                 test_GetPrinter_level(tctx, b, handle, 2, &info),
5138                 "failed to query Printer level 2");
5139
5140         torture_assert(tctx,
5141                 PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo),
5142                 "failed to convert");
5143
5144         info_ctr.level = 2;
5145         info_ctr.info = sinfo;
5146
5147 #define TEST_SZ(wname, iname) \
5148 do {\
5149         enum winreg_Type type;\
5150         uint8_t *data;\
5151         uint32_t needed;\
5152         DATA_BLOB blob;\
5153         const char *str;\
5154         torture_assert(tctx,\
5155                 test_GetPrinterDataEx(tctx, p, handle, "DsSpooler", wname, &type, &data, &needed),\
5156                 "failed to query");\
5157         torture_assert_int_equal(tctx, type, REG_SZ, "unexpected type");\
5158         blob = data_blob_const(data, needed);\
5159         torture_assert(tctx,\
5160                 pull_reg_sz(tctx, &blob, &str),\
5161                 "failed to pull REG_SZ");\
5162         torture_assert_str_equal(tctx, str, iname, "unexpected result");\
5163 } while(0);
5164
5165
5166 #define TEST_SET_SZ(wname, iname, val) \
5167 do {\
5168         enum winreg_Type type;\
5169         uint8_t *data;\
5170         uint32_t needed;\
5171         DATA_BLOB blob;\
5172         const char *str;\
5173         sinfo.info2->iname = val;\
5174         torture_assert(tctx,\
5175                 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),\
5176                 "failed to call SetPrinter");\
5177         torture_assert(tctx,\
5178                 test_GetPrinterDataEx(tctx, p, handle, "DsSpooler", wname, &type, &data, &needed),\
5179                 "failed to query");\
5180         torture_assert_int_equal(tctx, type, REG_SZ, "unexpected type");\
5181         blob = data_blob_const(data, needed);\
5182         torture_assert(tctx,\
5183                 pull_reg_sz(tctx, &blob, &str),\
5184                 "failed to pull REG_SZ");\
5185         torture_assert_str_equal(tctx, str, val, "unexpected result");\
5186 } while(0);
5187
5188 #define TEST_SET_DWORD(wname, iname, val) \
5189 do {\
5190         enum winreg_Type type;\
5191         uint8_t *data;\
5192         uint32_t needed;\
5193         uint32_t value;\
5194         sinfo.info2->iname = val;\
5195         torture_assert(tctx,\
5196                 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),\
5197                 "failed to call SetPrinter");\
5198         torture_assert(tctx,\
5199                 test_GetPrinterDataEx(tctx, p, handle, "DsSpooler", wname, &type, &data, &needed),\
5200                 "failed to query");\
5201         torture_assert_int_equal(tctx, type, REG_DWORD, "unexpected type");\
5202         torture_assert_int_equal(tctx, needed, 4, "unexpected length");\
5203         value = IVAL(data, 0); \
5204         torture_assert_int_equal(tctx, value, val, "unexpected result");\
5205 } while(0);
5206
5207         TEST_SET_SZ("description", comment, "newval");
5208         TEST_SET_SZ("location", location, "newval");
5209 /*      TEST_SET_DWORD("priority", priority, 25); */
5210
5211         torture_assert(tctx,
5212                 test_GetPrinter_level(tctx, b, handle, 2, &info),
5213                 "failed to query Printer level 2");
5214
5215         TEST_SZ("description", info.info2.comment);
5216 /*      TEST_SZ("driverName", info.info2.drivername); */
5217         TEST_SZ("location", info.info2.location);
5218
5219         pname = strrchr(info.info2.printername, '\\');
5220         if (pname == NULL) {
5221                 pname = info.info2.printername;
5222         } else {
5223                 pname++;
5224         }
5225 /*      TEST_SZ("printerName", pname); */
5226         /* TEST_SZ("printSeparatorFile", info.info2.sepfile); */
5227         /* TEST_SZ("printShareName", info.info2.sharename); */
5228
5229         /* FIXME gd: complete the list */
5230
5231 #undef TEST_SZ
5232 #undef TEST_SET_SZ
5233 #undef TEST_DWORD
5234
5235         torture_comment(tctx, "DsSpooler <-> SetPrinter relations test succeeded\n\n");
5236
5237         return true;
5238 }
5239
5240 static bool test_print_processors_winreg(struct torture_context *tctx,
5241                                          void *private_data)
5242 {
5243         struct test_spoolss_context *ctx =
5244                 talloc_get_type_abort(private_data, struct test_spoolss_context);
5245         struct dcerpc_pipe *p = ctx->spoolss_pipe;
5246         struct dcerpc_binding_handle *b = p->binding_handle;
5247
5248         return test_PrintProcessors_winreg(tctx, b, ctx->environment);
5249 }
5250
5251 static bool test_GetChangeID_PrinterData(struct torture_context *tctx,
5252                                          struct dcerpc_binding_handle *b,
5253                                          struct policy_handle *handle,
5254                                          uint32_t *change_id)
5255 {
5256         enum winreg_Type type;
5257         uint8_t *data;
5258         uint32_t needed;
5259
5260         torture_assert(tctx,
5261                 test_GetPrinterData(tctx, b, handle, "ChangeID", &type, &data, &needed),
5262                 "failed to call GetPrinterData");
5263
5264         torture_assert(tctx, type == REG_DWORD, "unexpected type");
5265         torture_assert_int_equal(tctx, needed, 4, "unexpected size");
5266
5267         *change_id = IVAL(data, 0);
5268
5269         return true;
5270 }
5271
5272 static bool test_GetChangeID_PrinterDataEx(struct torture_context *tctx,
5273                                            struct dcerpc_pipe *p,
5274                                            struct policy_handle *handle,
5275                                            uint32_t *change_id)
5276 {
5277         enum winreg_Type type;
5278         uint8_t *data;
5279         uint32_t needed;
5280
5281         torture_assert(tctx,
5282                 test_GetPrinterDataEx(tctx, p, handle, "PrinterDriverData", "ChangeID", &type, &data, &needed),
5283                 "failed to call GetPrinterData");
5284
5285         torture_assert(tctx, type == REG_DWORD, "unexpected type");
5286         torture_assert_int_equal(tctx, needed, 4, "unexpected size");
5287
5288         *change_id = IVAL(data, 0);
5289
5290         return true;
5291 }
5292
5293 static bool test_GetChangeID_PrinterInfo(struct torture_context *tctx,
5294                                          struct dcerpc_binding_handle *b,
5295                                          struct policy_handle *handle,
5296                                          uint32_t *change_id)
5297 {
5298         union spoolss_PrinterInfo info;
5299
5300         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 0, &info),
5301                 "failed to query Printer level 0");
5302
5303         *change_id = info.info0.change_id;
5304
5305         return true;
5306 }
5307
5308 static bool test_ChangeID(struct torture_context *tctx,
5309                           struct dcerpc_pipe *p,
5310                           struct policy_handle *handle)
5311 {
5312         uint32_t change_id, change_id_ex, change_id_info;
5313         uint32_t change_id2, change_id_ex2, change_id_info2;
5314         union spoolss_PrinterInfo info;
5315         const char *comment;
5316         struct dcerpc_binding_handle *b = p->binding_handle;
5317
5318         torture_comment(tctx, "Testing ChangeID: id change test #1\n");
5319
5320         torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id),
5321                 "failed to query for ChangeID");
5322         torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
5323                 "failed to query for ChangeID");
5324         torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info),
5325                 "failed to query for ChangeID");
5326
5327         torture_assert_int_equal(tctx, change_id, change_id_ex,
5328                 "change_ids should all be equal");
5329         torture_assert_int_equal(tctx, change_id_ex, change_id_info,
5330                 "change_ids should all be equal");
5331
5332
5333         torture_comment(tctx, "Testing ChangeID: id change test #2\n");
5334
5335         torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id),
5336                 "failed to query for ChangeID");
5337         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info),
5338                 "failed to query Printer level 2");
5339         torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
5340                 "failed to query for ChangeID");
5341         torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info),
5342                 "failed to query for ChangeID");
5343         torture_assert_int_equal(tctx, change_id, change_id_ex,
5344                 "change_id should not have changed");
5345         torture_assert_int_equal(tctx, change_id_ex, change_id_info,
5346                 "change_id should not have changed");
5347
5348
5349         torture_comment(tctx, "Testing ChangeID: id change test #3\n");
5350
5351         torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id),
5352                 "failed to query for ChangeID");
5353         torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
5354                 "failed to query for ChangeID");
5355         torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info),
5356                 "failed to query for ChangeID");
5357         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info),
5358                 "failed to query Printer level 2");
5359         comment = talloc_strdup(tctx, info.info2.comment);
5360
5361         {
5362                 struct spoolss_SetPrinterInfoCtr info_ctr;
5363                 struct spoolss_DevmodeContainer devmode_ctr;
5364                 struct sec_desc_buf secdesc_ctr;
5365                 union spoolss_SetPrinterInfo sinfo;
5366
5367                 ZERO_STRUCT(info_ctr);
5368                 ZERO_STRUCT(devmode_ctr);
5369                 ZERO_STRUCT(secdesc_ctr);
5370
5371
5372                 torture_assert(tctx, PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
5373                 sinfo.info2->comment    = "torture_comment";
5374
5375                 info_ctr.level = 2;
5376                 info_ctr.info = sinfo;
5377
5378                 torture_assert(tctx, test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
5379                         "failed to call SetPrinter");
5380
5381                 sinfo.info2->comment    = comment;
5382
5383                 torture_assert(tctx, test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
5384                         "failed to call SetPrinter");
5385
5386         }
5387
5388         torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id2),
5389                 "failed to query for ChangeID");
5390         torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex2),
5391                 "failed to query for ChangeID");
5392         torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info2),
5393                 "failed to query for ChangeID");
5394
5395         torture_assert_int_equal(tctx, change_id2, change_id_ex2,
5396                 "change_ids should all be equal");
5397         torture_assert_int_equal(tctx, change_id_ex2, change_id_info2,
5398                 "change_ids should all be equal");
5399
5400         torture_assert(tctx, (change_id < change_id2),
5401                 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
5402                 change_id2, change_id));
5403         torture_assert(tctx, (change_id_ex < change_id_ex2),
5404                 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
5405                 change_id_ex2, change_id_ex));
5406         torture_assert(tctx, (change_id_info < change_id_info2),
5407                 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
5408                 change_id_info2, change_id_info));
5409
5410         torture_comment(tctx, "ChangeID tests succeeded\n\n");
5411
5412         return true;
5413 }
5414
5415 static bool test_SecondaryClosePrinter(struct torture_context *tctx,
5416                                        struct dcerpc_pipe *p,
5417                                        struct policy_handle *handle)
5418 {
5419         NTSTATUS status;
5420         struct dcerpc_binding *b;
5421         struct dcerpc_pipe *p2;
5422         struct spoolss_ClosePrinter cp;
5423
5424         /* only makes sense on SMB */
5425         if (p->conn->transport.transport != NCACN_NP) {
5426                 return true;
5427         }
5428
5429         torture_comment(tctx, "Testing close on secondary pipe\n");
5430
5431         status = dcerpc_parse_binding(tctx, p->conn->binding_string, &b);
5432         torture_assert_ntstatus_ok(tctx, status, "Failed to parse dcerpc binding");
5433
5434         status = dcerpc_secondary_connection(p, &p2, b);
5435         torture_assert_ntstatus_ok(tctx, status, "Failed to create secondary connection");
5436
5437         status = dcerpc_bind_auth_none(p2, &ndr_table_spoolss);
5438         torture_assert_ntstatus_ok(tctx, status, "Failed to create bind on secondary connection");
5439
5440         cp.in.handle = handle;
5441         cp.out.handle = handle;
5442
5443         status = dcerpc_spoolss_ClosePrinter_r(p2->binding_handle, tctx, &cp);
5444         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_RPC_SS_CONTEXT_MISMATCH,
5445                         "ERROR: Allowed close on secondary connection");
5446
5447         talloc_free(p2);
5448
5449         return true;
5450 }
5451
5452 static bool test_OpenPrinter_badname(struct torture_context *tctx,
5453                                      struct dcerpc_binding_handle *b, const char *name)
5454 {
5455         NTSTATUS status;
5456         struct spoolss_OpenPrinter op;
5457         struct spoolss_OpenPrinterEx opEx;
5458         struct policy_handle handle;
5459         bool ret = true;
5460
5461         op.in.printername       = name;
5462         op.in.datatype          = NULL;
5463         op.in.devmode_ctr.devmode= NULL;
5464         op.in.access_mask       = 0;
5465         op.out.handle           = &handle;
5466
5467         torture_comment(tctx, "Testing OpenPrinter(%s) with bad name\n", op.in.printername);
5468
5469         status = dcerpc_spoolss_OpenPrinter_r(b, tctx, &op);
5470         torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
5471         torture_assert_werr_equal(tctx, op.out.result, WERR_INVALID_PRINTER_NAME,
5472                 "unexpected result");
5473
5474         if (W_ERROR_IS_OK(op.out.result)) {
5475                 ret &=test_ClosePrinter(tctx, b, &handle);
5476         }
5477
5478         opEx.in.printername             = name;
5479         opEx.in.datatype                = NULL;
5480         opEx.in.devmode_ctr.devmode     = NULL;
5481         opEx.in.access_mask             = 0;
5482         opEx.in.level                   = 1;
5483         opEx.in.userlevel.level1        = NULL;
5484         opEx.out.handle                 = &handle;
5485
5486         torture_comment(tctx, "Testing OpenPrinterEx(%s) with bad name\n", opEx.in.printername);
5487
5488         status = dcerpc_spoolss_OpenPrinterEx_r(b, tctx, &opEx);
5489         torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
5490         torture_assert_werr_equal(tctx, opEx.out.result, WERR_INVALID_PARAM,
5491                 "unexpected result");
5492
5493         if (W_ERROR_IS_OK(opEx.out.result)) {
5494                 ret &=test_ClosePrinter(tctx, b, &handle);
5495         }
5496
5497         return ret;
5498 }
5499
5500 static bool test_OpenPrinter_badname_list(struct torture_context *tctx,
5501                                           void *private_data)
5502 {
5503         struct test_spoolss_context *ctx =
5504                 talloc_get_type_abort(private_data, struct test_spoolss_context);
5505
5506         const char *badnames[] = {
5507                 "__INVALID_PRINTER__",
5508                 "\\\\__INVALID_HOST__",
5509                 "",
5510                 "\\\\\\",
5511                 "\\\\\\__INVALID_PRINTER__"
5512         };
5513         const char *badname;
5514         struct dcerpc_pipe *p = ctx->spoolss_pipe;
5515         const char *server_name = dcerpc_server_name(p);
5516         struct dcerpc_binding_handle *b = p->binding_handle;
5517         int i;
5518
5519         for (i=0; i < ARRAY_SIZE(badnames); i++) {
5520                 torture_assert(tctx,
5521                         test_OpenPrinter_badname(tctx, b, badnames[i]),
5522                         "");
5523         }
5524
5525         badname = talloc_asprintf(tctx, "\\\\%s\\", server_name);
5526         torture_assert(tctx,
5527                 test_OpenPrinter_badname(tctx, b, badname),
5528                 "");
5529
5530         badname = talloc_asprintf(tctx, "\\\\%s\\__INVALID_PRINTER__", server_name);
5531         torture_assert(tctx,
5532                 test_OpenPrinter_badname(tctx, b, badname),
5533                 "");
5534
5535         return true;
5536 }
5537
5538 static bool test_OpenPrinter(struct torture_context *tctx,
5539                              struct dcerpc_pipe *p,
5540                              const char *name,
5541                              const char *environment)
5542 {
5543         NTSTATUS status;
5544         struct spoolss_OpenPrinter r;
5545         struct policy_handle handle;
5546         bool ret = true;
5547         struct dcerpc_binding_handle *b = p->binding_handle;
5548
5549         r.in.printername        = talloc_asprintf(tctx, "\\\\%s\\%s", dcerpc_server_name(p), name);
5550         r.in.datatype           = NULL;
5551         r.in.devmode_ctr.devmode= NULL;
5552         r.in.access_mask        = SEC_FLAG_MAXIMUM_ALLOWED;
5553         r.out.handle            = &handle;
5554
5555         torture_comment(tctx, "Testing OpenPrinter(%s)\n", r.in.printername);
5556
5557         status = dcerpc_spoolss_OpenPrinter_r(b, tctx, &r);
5558
5559         torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
5560
5561         torture_assert_werr_ok(tctx, r.out.result, "OpenPrinter failed");
5562
5563         if (!test_GetPrinter(tctx, b, &handle, environment)) {
5564                 ret = false;
5565         }
5566
5567         if (!torture_setting_bool(tctx, "samba3", false)) {
5568                 if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
5569                         ret = false;
5570                 }
5571         }
5572
5573         if (!test_ClosePrinter(tctx, b, &handle)) {
5574                 ret = false;
5575         }
5576
5577         return ret;
5578 }
5579
5580 static bool call_OpenPrinterEx(struct torture_context *tctx,
5581                                struct dcerpc_pipe *p,
5582                                const char *name,
5583                                struct spoolss_DeviceMode *devmode,
5584                                struct policy_handle *handle)
5585 {
5586         struct spoolss_OpenPrinterEx r;
5587         struct spoolss_UserLevel1 userlevel1;
5588         NTSTATUS status;
5589         struct dcerpc_binding_handle *b = p->binding_handle;
5590
5591         if (name && name[0]) {
5592                 r.in.printername = talloc_asprintf(tctx, "\\\\%s\\%s",
5593                                                    dcerpc_server_name(p), name);
5594         } else {
5595                 r.in.printername = talloc_asprintf(tctx, "\\\\%s",
5596                                                    dcerpc_server_name(p));
5597         }
5598
5599         r.in.datatype           = NULL;
5600         r.in.devmode_ctr.devmode= devmode;
5601         r.in.access_mask        = SEC_FLAG_MAXIMUM_ALLOWED;
5602         r.in.level              = 1;
5603         r.in.userlevel.level1   = &userlevel1;
5604         r.out.handle = handle;
5605
5606         userlevel1.size = 1234;
5607         userlevel1.client = "hello";
5608         userlevel1.user = "spottyfoot!";
5609         userlevel1.build = 1;
5610         userlevel1.major = 2;
5611         userlevel1.minor = 3;
5612         userlevel1.processor = 4;
5613
5614         torture_comment(tctx, "Testing OpenPrinterEx(%s)\n", r.in.printername);
5615
5616         status = dcerpc_spoolss_OpenPrinterEx_r(b, tctx, &r);
5617
5618         torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
5619
5620         torture_assert_werr_ok(tctx, r.out.result, "OpenPrinterEx failed");
5621
5622         return true;
5623 }
5624
5625 static bool test_printer_rename(struct torture_context *tctx,
5626                                 struct dcerpc_pipe *p,
5627                                 struct policy_handle *handle,
5628                                 const char *name)
5629 {
5630         bool ret = true;
5631         union spoolss_PrinterInfo info;
5632         union spoolss_SetPrinterInfo sinfo;
5633         struct spoolss_SetPrinterInfoCtr info_ctr;
5634         struct spoolss_DevmodeContainer devmode_ctr;
5635         struct sec_desc_buf secdesc_ctr;
5636         const char *printer_name;
5637         const char *printer_name_orig;
5638         const char *printer_name_new = "SAMBA smbtorture Test Printer (Copy 2)";
5639         struct policy_handle new_handle;
5640         const char *q;
5641         struct dcerpc_binding_handle *b = p->binding_handle;
5642
5643         ZERO_STRUCT(devmode_ctr);
5644         ZERO_STRUCT(secdesc_ctr);
5645
5646         torture_comment(tctx, "Testing Printer rename operations\n");
5647
5648         torture_assert(tctx,
5649                 test_GetPrinter_level(tctx, b, handle, 2, &info),
5650                 "failed to call GetPrinter level 2");
5651
5652         printer_name_orig = talloc_strdup(tctx, info.info2.printername);
5653
5654         q = strrchr(info.info2.printername, '\\');
5655         if (q) {
5656                 torture_warning(tctx,
5657                         "server returns printername %s incl. servername although we did not set servername", info.info2.printername);
5658         }
5659
5660         torture_assert(tctx,
5661                 PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
5662
5663         sinfo.info2->printername = printer_name_new;
5664
5665         info_ctr.level = 2;
5666         info_ctr.info = sinfo;
5667
5668         torture_assert(tctx,
5669                 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
5670                 "failed to call SetPrinter level 2");
5671
5672         torture_assert(tctx,
5673                 test_GetPrinter_level(tctx, b, handle, 2, &info),
5674                 "failed to call GetPrinter level 2");
5675
5676         printer_name = talloc_strdup(tctx, info.info2.printername);
5677
5678         q = strrchr(info.info2.printername, '\\');
5679         if (q) {
5680                 torture_warning(tctx,
5681                         "server returns printername %s incl. servername although we did not set servername", info.info2.printername);
5682                 q++;
5683                 printer_name = q;
5684         }
5685
5686         torture_assert_str_equal(tctx, printer_name, printer_name_new,
5687                 "new printer name was not set");
5688
5689         /* samba currently cannot fully rename printers */
5690         if (!torture_setting_bool(tctx, "samba3", false)) {
5691                 torture_assert(tctx,
5692                         test_OpenPrinter_badname(tctx, b, printer_name_orig),
5693                         "still can open printer with oldname after rename");
5694         } else {
5695                 torture_warning(tctx, "*not* checking for open with oldname after rename for samba3");
5696         }
5697
5698         torture_assert(tctx,
5699                 call_OpenPrinterEx(tctx, p, printer_name_new, NULL, &new_handle),
5700                 "failed to open printer with new name");
5701
5702         torture_assert(tctx,
5703                 test_GetPrinter_level(tctx, b, &new_handle, 2, &info),
5704                 "failed to call GetPrinter level 2");
5705
5706         /* FIXME: we openend with servername! */
5707         printer_name = talloc_asprintf(tctx, "\\\\%s\\%s",
5708                 dcerpc_server_name(p), printer_name_new);
5709
5710         torture_assert_str_equal(tctx, info.info2.printername, printer_name,
5711                 "new printer name was not set");
5712
5713         torture_assert(tctx,
5714                 test_ClosePrinter(tctx, b, &new_handle),
5715                 "failed to close printer");
5716
5717         torture_comment(tctx, "Printer rename operations test succeeded\n\n");
5718
5719         return ret;
5720 }
5721
5722
5723 static bool test_OpenPrinterEx(struct torture_context *tctx,
5724                                struct dcerpc_pipe *p,
5725                                const char *name,
5726                                const char *environment)
5727 {
5728         struct policy_handle handle;
5729         bool ret = true;
5730         struct dcerpc_binding_handle *b = p->binding_handle;
5731
5732         if (!call_OpenPrinterEx(tctx, p, name, NULL, &handle)) {
5733                 return false;
5734         }
5735
5736         if (!test_PrinterInfo_SD(tctx, b, &handle)) {
5737                 ret = false;
5738         }
5739
5740         if (!test_GetPrinter(tctx, b, &handle, environment)) {
5741                 ret = false;
5742         }
5743
5744         if (!test_EnumForms_all(tctx, b, &handle, false)) {
5745                 ret = false;
5746         }
5747
5748         if (!test_Forms(tctx, b, &handle, false, name, NULL, NULL)) {
5749                 ret = false;
5750         }
5751
5752         if (!test_Forms_winreg(tctx, b, &handle, false, name)) {
5753                 ret = false;
5754         }
5755
5756         if (!test_EnumPrinterData_all(tctx, p, &handle)) {
5757                 ret = false;
5758         }
5759
5760         if (!test_EnumPrinterDataEx(tctx, b, &handle, "PrinterDriverData", NULL, NULL)) {
5761                 ret = false;
5762         }
5763
5764         if (!test_EnumPrinterData_consistency(tctx, p, &handle)) {
5765                 ret = false;
5766         }
5767
5768         if (!test_printer_keys(tctx, b, &handle)) {
5769                 ret = false;
5770         }
5771
5772         if (!test_PausePrinter(tctx, b, &handle)) {
5773                 ret = false;
5774         }
5775
5776         if (!test_DoPrintTest(tctx, b, &handle)) {
5777                 ret = false;
5778         }
5779
5780         if (!test_ResumePrinter(tctx, b, &handle)) {
5781                 ret = false;
5782         }
5783
5784         if (!test_SetPrinterData_matrix(tctx, b, &handle, name, NULL, NULL)) {
5785                 ret = false;
5786         }
5787
5788         if (!test_SetPrinterDataEx_matrix(tctx, p, &handle, name, NULL, NULL)) {
5789                 ret = false;
5790         }
5791
5792         if (!torture_setting_bool(tctx, "samba3", false)) {
5793                 if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
5794                         ret = false;
5795                 }
5796         }
5797
5798         if (!test_ClosePrinter(tctx, b, &handle)) {
5799                 ret = false;
5800         }
5801
5802         return ret;
5803 }
5804
5805 static bool test_EnumPrinters_old(struct torture_context *tctx,
5806                                   void *private_data)
5807 {
5808         struct test_spoolss_context *ctx =
5809                 talloc_get_type_abort(private_data, struct test_spoolss_context);
5810         struct spoolss_EnumPrinters r;
5811         NTSTATUS status;
5812         uint16_t levels[] = {1, 2, 4, 5};
5813         int i;
5814         bool ret = true;
5815         struct dcerpc_pipe *p = ctx->spoolss_pipe;
5816         struct dcerpc_binding_handle *b = p->binding_handle;
5817
5818         for (i=0;i<ARRAY_SIZE(levels);i++) {
5819                 union spoolss_PrinterInfo *info;
5820                 int j;
5821                 uint32_t needed;
5822                 uint32_t count;
5823
5824                 r.in.flags      = PRINTER_ENUM_LOCAL;
5825                 r.in.server     = "";
5826                 r.in.level      = levels[i];
5827                 r.in.buffer     = NULL;
5828                 r.in.offered    = 0;
5829                 r.out.needed    = &needed;
5830                 r.out.count     = &count;
5831                 r.out.info      = &info;
5832
5833                 torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
5834
5835                 status = dcerpc_spoolss_EnumPrinters_r(b, tctx, &r);
5836                 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
5837
5838                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
5839                         DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
5840                         r.in.buffer = &blob;
5841                         r.in.offered = needed;
5842                         status = dcerpc_spoolss_EnumPrinters_r(b, tctx, &r);
5843                 }
5844
5845                 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
5846
5847                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
5848
5849                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, needed, 4);
5850
5851                 if (!info) {
5852                         torture_comment(tctx, "No printers returned\n");
5853                         return true;
5854                 }
5855
5856                 for (j=0;j<count;j++) {
5857                         if (r.in.level == 1) {
5858                                 char *unc = talloc_strdup(tctx, info[j].info1.name);
5859                                 char *slash, *name;
5860                                 name = unc;
5861                                 if (unc[0] == '\\' && unc[1] == '\\') {
5862                                         unc +=2;
5863                                 }
5864                                 slash = strchr(unc, '\\');
5865                                 if (slash) {
5866                                         slash++;
5867                                         name = slash;
5868                                 }
5869                                 if (!test_OpenPrinter(tctx, p, name, ctx->environment)) {
5870                                         ret = false;
5871                                 }
5872                                 if (!test_OpenPrinterEx(tctx, p, name, ctx->environment)) {
5873                                         ret = false;
5874                                 }
5875                         }
5876                 }
5877         }
5878
5879         return ret;
5880 }
5881
5882 static bool test_GetPrinterDriver(struct torture_context *tctx,
5883                                   struct dcerpc_binding_handle *b,
5884                                   struct policy_handle *handle,
5885                                   const char *driver_name)
5886 {
5887         struct spoolss_GetPrinterDriver r;
5888         uint32_t needed;
5889
5890         r.in.handle = handle;
5891         r.in.architecture = "W32X86";
5892         r.in.level = 1;
5893         r.in.buffer = NULL;
5894         r.in.offered = 0;
5895         r.out.needed = &needed;
5896
5897         torture_comment(tctx, "Testing GetPrinterDriver level %d\n", r.in.level);
5898
5899         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver_r(b, tctx, &r),
5900                 "failed to call GetPrinterDriver");
5901         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
5902                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
5903                 r.in.buffer = &blob;
5904                 r.in.offered = needed;
5905                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver_r(b, tctx, &r),
5906                         "failed to call GetPrinterDriver");
5907         }
5908
5909         torture_assert_werr_ok(tctx, r.out.result,
5910                 "failed to call GetPrinterDriver");
5911
5912         CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverInfo, r.out.info, r.in.level, needed, 4);
5913
5914         return true;
5915 }
5916
5917 static bool test_GetPrinterDriver2_level(struct torture_context *tctx,
5918                                          struct dcerpc_binding_handle *b,
5919                                          struct policy_handle *handle,
5920                                          const char *driver_name,
5921                                          const char *architecture,
5922                                          uint32_t level,
5923                                          uint32_t client_major_version,
5924                                          uint32_t client_minor_version,
5925                                          union spoolss_DriverInfo *info_p,
5926                                          WERROR *result_p)
5927
5928 {
5929         struct spoolss_GetPrinterDriver2 r;
5930         uint32_t needed;
5931         uint32_t server_major_version;
5932         uint32_t server_minor_version;
5933
5934         r.in.handle = handle;
5935         r.in.architecture = architecture;
5936         r.in.client_major_version = client_major_version;
5937         r.in.client_minor_version = client_minor_version;
5938         r.in.buffer = NULL;
5939         r.in.offered = 0;
5940         r.in.level = level;
5941         r.out.needed = &needed;
5942         r.out.server_major_version = &server_major_version;
5943         r.out.server_minor_version = &server_minor_version;
5944
5945         torture_comment(tctx, "Testing GetPrinterDriver2(%s) level %d\n",
5946                 driver_name, r.in.level);
5947
5948         torture_assert_ntstatus_ok(tctx,
5949                 dcerpc_spoolss_GetPrinterDriver2_r(b, tctx, &r),
5950                 "failed to call GetPrinterDriver2");
5951         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
5952                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
5953                 r.in.buffer = &blob;
5954                 r.in.offered = needed;
5955                 torture_assert_ntstatus_ok(tctx,
5956                         dcerpc_spoolss_GetPrinterDriver2_r(b, tctx, &r),
5957                         "failed to call GetPrinterDriver2");
5958         }
5959
5960         if (result_p) {
5961                 *result_p = r.out.result;
5962         }
5963
5964         if (W_ERROR_EQUAL(r.out.result, WERR_INVALID_LEVEL)) {
5965                 switch (r.in.level) {
5966                 case 101:
5967                 case 8:
5968                         torture_comment(tctx,
5969                                 "level %d not implemented, not considering as an error\n",
5970                                 r.in.level);
5971                         return true;
5972                 default:
5973                         break;
5974                 }
5975         }
5976
5977         torture_assert_werr_ok(tctx, r.out.result,
5978                 "failed to call GetPrinterDriver2");
5979
5980         CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverInfo, r.out.info, r.in.level, needed, 4);
5981
5982         if (info_p) {
5983                 *info_p = *r.out.info;
5984         }
5985
5986         return true;
5987 }
5988
5989 static bool test_GetPrinterDriver2(struct torture_context *tctx,
5990                                    struct dcerpc_binding_handle *b,
5991                                    struct policy_handle *handle,
5992                                    const char *driver_name,
5993                                    const char *architecture)
5994 {
5995         uint16_t levels[] = {1, 2, 3, 4, 5, 6, 8, 101 };
5996         int i;
5997
5998
5999         for (i=0;i<ARRAY_SIZE(levels);i++) {
6000
6001                 torture_assert(tctx,
6002                         test_GetPrinterDriver2_level(tctx, b, handle, driver_name, architecture, levels[i], 3, 0, NULL, NULL),
6003                         "");
6004         }
6005
6006         return true;
6007 }
6008
6009 static bool test_EnumPrinterDrivers_old(struct torture_context *tctx,
6010                                         void *private_data)
6011 {
6012         struct test_spoolss_context *ctx =
6013                 talloc_get_type_abort(private_data, struct test_spoolss_context);
6014         uint16_t levels[] = {1, 2, 3, 4, 5, 6};
6015         int i;
6016         struct dcerpc_pipe *p = ctx->spoolss_pipe;
6017         struct dcerpc_binding_handle *b = p->binding_handle;
6018         const char *server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
6019
6020         for (i=0;i<ARRAY_SIZE(levels);i++) {
6021
6022                 uint32_t count;
6023                 union spoolss_DriverInfo *info;
6024
6025                 torture_assert(tctx,
6026                         test_EnumPrinterDrivers_args(tctx, b, server_name, ctx->environment, levels[i], &count, &info),
6027                         "failed to enumerate drivers");
6028
6029                 if (!info) {
6030                         torture_comment(tctx, "No printer drivers returned\n");
6031                         break;
6032                 }
6033         }
6034
6035         return true;
6036 }
6037
6038 static bool test_DeletePrinter(struct torture_context *tctx,
6039                                struct dcerpc_binding_handle *b,
6040                                struct policy_handle *handle)
6041 {
6042         struct spoolss_DeletePrinter r;
6043
6044         torture_comment(tctx, "Testing DeletePrinter\n");
6045
6046         r.in.handle = handle;
6047
6048         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_DeletePrinter_r(b, tctx, &r),
6049                 "failed to delete printer");
6050         torture_assert_werr_ok(tctx, r.out.result,
6051                 "failed to delete printer");
6052
6053         return true;
6054 }
6055
6056 static bool test_EnumPrinters_findname(struct torture_context *tctx,
6057                                        struct dcerpc_binding_handle *b,
6058                                        uint32_t flags,
6059                                        uint32_t level,
6060                                        const char *name,
6061                                        bool *found)
6062 {
6063         struct spoolss_EnumPrinters e;
6064         uint32_t count;
6065         union spoolss_PrinterInfo *info;
6066         uint32_t needed;
6067         int i;
6068
6069         *found = false;
6070
6071         e.in.flags = flags;
6072         e.in.server = NULL;
6073         e.in.level = level;
6074         e.in.buffer = NULL;
6075         e.in.offered = 0;
6076         e.out.count = &count;
6077         e.out.info = &info;
6078         e.out.needed = &needed;
6079
6080         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters_r(b, tctx, &e),
6081                 "failed to enum printers");
6082
6083         if (W_ERROR_EQUAL(e.out.result, WERR_INSUFFICIENT_BUFFER)) {
6084                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
6085                 e.in.buffer = &blob;
6086                 e.in.offered = needed;
6087
6088                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters_r(b, tctx, &e),
6089                         "failed to enum printers");
6090         }
6091
6092         torture_assert_werr_ok(tctx, e.out.result,
6093                 "failed to enum printers");
6094
6095         for (i=0; i < count; i++) {
6096
6097                 const char *current = NULL;
6098                 const char *q;
6099
6100                 switch (level) {
6101                 case 1:
6102                         current = info[i].info1.name;
6103                         break;
6104                 }
6105
6106                 if (strequal(current, name)) {
6107                         *found = true;
6108                         break;
6109                 }
6110
6111                 q = strrchr(current, '\\');
6112                 if (q) {
6113                         if (!e.in.server) {
6114                                 torture_warning(tctx,
6115                                         "server returns printername %s incl. servername although we did not set servername", current);
6116                         }
6117                         q++;
6118                         if (strequal(q, name)) {
6119                                 *found = true;
6120                                 break;
6121                         }
6122                 }
6123         }
6124
6125         return true;
6126 }
6127
6128 static bool test_AddPrinter_wellknown(struct torture_context *tctx,
6129                                       struct dcerpc_pipe *p,
6130                                       const char *printername,
6131                                       bool ex)
6132 {
6133         WERROR result;
6134         struct spoolss_AddPrinter r;
6135         struct spoolss_AddPrinterEx rex;
6136         struct spoolss_SetPrinterInfoCtr info_ctr;
6137         struct spoolss_SetPrinterInfo1 info1;
6138         struct spoolss_DevmodeContainer devmode_ctr;
6139         struct sec_desc_buf secdesc_ctr;
6140         struct spoolss_UserLevelCtr userlevel_ctr;
6141         struct policy_handle handle;
6142         bool found = false;
6143         struct dcerpc_binding_handle *b = p->binding_handle;
6144
6145         ZERO_STRUCT(devmode_ctr);
6146         ZERO_STRUCT(secdesc_ctr);
6147         ZERO_STRUCT(userlevel_ctr);
6148         ZERO_STRUCT(info1);
6149
6150         torture_comment(tctx, "Testing AddPrinter%s(%s) level 1\n",
6151                         ex ? "Ex":"", printername);
6152
6153         /* try to add printer to wellknown printer list (level 1) */
6154
6155         userlevel_ctr.level = 1;
6156
6157         info_ctr.info.info1 = &info1;
6158         info_ctr.level = 1;
6159
6160         rex.in.server = NULL;
6161         rex.in.info_ctr = &info_ctr;
6162         rex.in.devmode_ctr = &devmode_ctr;
6163         rex.in.secdesc_ctr = &secdesc_ctr;
6164         rex.in.userlevel_ctr = &userlevel_ctr;
6165         rex.out.handle = &handle;
6166
6167         r.in.server = NULL;
6168         r.in.info_ctr = &info_ctr;
6169         r.in.devmode_ctr = &devmode_ctr;
6170         r.in.secdesc_ctr = &secdesc_ctr;
6171         r.out.handle = &handle;
6172
6173         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6174                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6175                 "failed to add printer");
6176         result = ex ? rex.out.result : r.out.result;
6177         torture_assert_werr_equal(tctx, result, WERR_INVALID_PRINTER_NAME,
6178                 "unexpected result code");
6179
6180         info1.name = printername;
6181         info1.flags = PRINTER_ATTRIBUTE_SHARED;
6182
6183         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6184                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6185                 "failed to add printer");
6186         result = ex ? rex.out.result : r.out.result;
6187         torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
6188                 "unexpected result code");
6189
6190         /* bizarre protocol, WERR_PRINTER_ALREADY_EXISTS means success here,
6191            better do a real check to see the printer is really there */
6192
6193         torture_assert(tctx, test_EnumPrinters_findname(tctx, b,
6194                                                         PRINTER_ENUM_NETWORK, 1,
6195                                                         printername,
6196                                                         &found),
6197                         "failed to enum printers");
6198
6199         torture_assert(tctx, found, "failed to find newly added printer");
6200
6201         info1.flags = 0;
6202
6203         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6204                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6205                 "failed to add printer");
6206         result = ex ? rex.out.result : r.out.result;
6207         torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
6208                 "unexpected result code");
6209
6210         /* bizarre protocol, WERR_PRINTER_ALREADY_EXISTS means success here,
6211            better do a real check to see the printer has really been removed
6212            from the well known printer list */
6213
6214         found = false;
6215
6216         torture_assert(tctx, test_EnumPrinters_findname(tctx, b,
6217                                                         PRINTER_ENUM_NETWORK, 1,
6218                                                         printername,
6219                                                         &found),
6220                         "failed to enum printers");
6221 #if 0
6222         torture_assert(tctx, !found, "printer still in well known printer list");
6223 #endif
6224         return true;
6225 }
6226
6227 static bool test_AddPrinter_normal(struct torture_context *tctx,
6228                                    struct dcerpc_pipe *p,
6229                                    struct policy_handle *handle_p,
6230                                    const char *printername,
6231                                    const char *drivername,
6232                                    const char *portname,
6233                                    struct spoolss_DeviceMode *devmode,
6234                                    bool ex)
6235 {
6236         WERROR result;
6237         struct spoolss_AddPrinter r;
6238         struct spoolss_AddPrinterEx rex;
6239         struct spoolss_SetPrinterInfoCtr info_ctr;
6240         struct spoolss_SetPrinterInfo2 info2;
6241         struct spoolss_DevmodeContainer devmode_ctr;
6242         struct sec_desc_buf secdesc_ctr;
6243         struct spoolss_UserLevelCtr userlevel_ctr;
6244         struct policy_handle handle;
6245         bool found = false;
6246         bool existing_printer_deleted = false;
6247         struct dcerpc_binding_handle *b = p->binding_handle;
6248
6249         ZERO_STRUCT(devmode_ctr);
6250         ZERO_STRUCT(secdesc_ctr);
6251         ZERO_STRUCT(userlevel_ctr);
6252
6253         torture_comment(tctx, "Testing AddPrinter%s(%s) level 2\n",
6254                         ex ? "Ex":"", printername);
6255
6256         devmode_ctr.devmode = devmode;
6257
6258         userlevel_ctr.level = 1;
6259
6260         rex.in.server = NULL;
6261         rex.in.info_ctr = &info_ctr;
6262         rex.in.devmode_ctr = &devmode_ctr;
6263         rex.in.secdesc_ctr = &secdesc_ctr;
6264         rex.in.userlevel_ctr = &userlevel_ctr;
6265         rex.out.handle = &handle;
6266
6267         r.in.server = NULL;
6268         r.in.info_ctr = &info_ctr;
6269         r.in.devmode_ctr = &devmode_ctr;
6270         r.in.secdesc_ctr = &secdesc_ctr;
6271         r.out.handle = &handle;
6272
6273  again:
6274
6275         /* try to add printer to printer list (level 2) */
6276
6277         ZERO_STRUCT(info2);
6278
6279         info_ctr.info.info2 = &info2;
6280         info_ctr.level = 2;
6281
6282         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6283                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6284                 "failed to add printer");
6285         result = ex ? rex.out.result : r.out.result;
6286         torture_assert_werr_equal(tctx, result, WERR_INVALID_PRINTER_NAME,
6287                 "unexpected result code");
6288
6289         info2.printername = printername;
6290
6291         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6292                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6293                 "failed to add printer");
6294         result = ex ? rex.out.result : r.out.result;
6295
6296         if (W_ERROR_EQUAL(result, WERR_PRINTER_ALREADY_EXISTS)) {
6297                 struct policy_handle printer_handle;
6298
6299                 if (existing_printer_deleted) {
6300                         torture_fail(tctx, "already deleted printer still existing?");
6301                 }
6302
6303                 torture_assert(tctx, call_OpenPrinterEx(tctx, p, printername, NULL, &printer_handle),
6304                         "failed to open printer handle");
6305
6306                 torture_assert(tctx, test_DeletePrinter(tctx, b, &printer_handle),
6307                         "failed to delete printer");
6308
6309                 torture_assert(tctx, test_ClosePrinter(tctx, b, &printer_handle),
6310                         "failed to close server handle");
6311
6312                 existing_printer_deleted = true;
6313
6314                 goto again;
6315         }
6316
6317         torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PORT,
6318                 "unexpected result code");
6319
6320         info2.portname = portname;
6321
6322         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6323                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6324                 "failed to add printer");
6325         result = ex ? rex.out.result : r.out.result;
6326         torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PRINTER_DRIVER,
6327                 "unexpected result code");
6328
6329         info2.drivername = drivername;
6330
6331         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6332                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6333                 "failed to add printer");
6334         result = ex ? rex.out.result : r.out.result;
6335
6336         /* w2k8r2 allows to add printer w/o defining printprocessor */
6337
6338         if (!W_ERROR_IS_OK(result)) {
6339                 torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PRINTPROCESSOR,
6340                         "unexpected result code");
6341
6342                 info2.printprocessor = "winprint";
6343
6344                 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6345                                                       dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6346                         "failed to add printer");
6347                 result = ex ? rex.out.result : r.out.result;
6348                 torture_assert_werr_ok(tctx, result,
6349                         "failed to add printer");
6350         }
6351
6352         *handle_p = handle;
6353
6354         /* we are paranoid, really check if the printer is there now */
6355
6356         torture_assert(tctx, test_EnumPrinters_findname(tctx, b,
6357                                                         PRINTER_ENUM_LOCAL, 1,
6358                                                         printername,
6359                                                         &found),
6360                         "failed to enum printers");
6361         torture_assert(tctx, found, "failed to find newly added printer");
6362
6363         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6364                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6365                 "failed to add printer");
6366         result = ex ? rex.out.result : r.out.result;
6367         torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
6368                 "unexpected result code");
6369
6370         return true;
6371 }
6372
6373 static bool test_printer_info(struct torture_context *tctx,
6374                               struct dcerpc_binding_handle *b,
6375                               struct policy_handle *handle)
6376 {
6377         bool ret = true;
6378
6379         if (torture_setting_bool(tctx, "samba3", false)) {
6380                 torture_skip(tctx, "skipping printer info cross tests against samba 3");
6381         }
6382
6383         if (!test_PrinterInfo(tctx, b, handle)) {
6384                 ret = false;
6385         }
6386
6387         if (!test_SetPrinter_errors(tctx, b, handle)) {
6388                 ret = false;
6389         }
6390
6391         return ret;
6392 }
6393
6394 static bool test_EnumPrinterKey(struct torture_context *tctx,
6395                                 struct dcerpc_binding_handle *b,
6396                                 struct policy_handle *handle,
6397                                 const char *key_name,
6398                                 const char ***array)
6399 {
6400         struct spoolss_EnumPrinterKey r;
6401         uint32_t needed = 0;
6402         union spoolss_KeyNames key_buffer;
6403         int32_t offered[] = { 0, 1, 2, 3, 4, 5, -1, -2, -3, -4, -5, 256, 512, 1024, 2048 };
6404         uint32_t _ndr_size;
6405         int i;
6406
6407         r.in.handle = handle;
6408         r.in.key_name = key_name;
6409         r.out.key_buffer = &key_buffer;
6410         r.out.needed = &needed;
6411         r.out._ndr_size = &_ndr_size;
6412
6413         for (i=0; i < ARRAY_SIZE(offered); i++) {
6414
6415                 if (offered[i] < 0 && needed) {
6416                         if (needed <= 4) {
6417                                 continue;
6418                         }
6419                         r.in.offered = needed + offered[i];
6420                 } else {
6421                         r.in.offered = offered[i];
6422                 }
6423
6424                 ZERO_STRUCT(key_buffer);
6425
6426                 torture_comment(tctx, "Testing EnumPrinterKey(%s) with %d offered\n", r.in.key_name, r.in.offered);
6427
6428                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterKey_r(b, tctx, &r),
6429                         "failed to call EnumPrinterKey");
6430                 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
6431
6432                         torture_assert(tctx, (_ndr_size == r.in.offered/2),
6433                                 talloc_asprintf(tctx, "EnumPrinterKey size mismatch, _ndr_size %d (expected %d)",
6434                                         _ndr_size, r.in.offered/2));
6435
6436                         r.in.offered = needed;
6437                         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterKey_r(b, tctx, &r),
6438                                 "failed to call EnumPrinterKey");
6439                 }
6440
6441                 if (offered[i] > 0) {
6442                         torture_assert_werr_ok(tctx, r.out.result,
6443                                 "failed to call EnumPrinterKey");
6444                 }
6445
6446                 torture_assert(tctx, (_ndr_size == r.in.offered/2),
6447                         talloc_asprintf(tctx, "EnumPrinterKey size mismatch, _ndr_size %d (expected %d)",
6448                                 _ndr_size, r.in.offered/2));
6449
6450                 torture_assert(tctx, (*r.out.needed <= r.in.offered),
6451                         talloc_asprintf(tctx, "EnumPrinterKey size mismatch: needed %d is not <= offered %d", *r.out.needed, r.in.offered));
6452
6453                 torture_assert(tctx, (*r.out.needed <= _ndr_size * 2),
6454                         talloc_asprintf(tctx, "EnumPrinterKey size mismatch: needed %d is not <= _ndr_size %d * 2", *r.out.needed, _ndr_size));
6455
6456                 if (key_buffer.string_array) {
6457                         uint32_t calc_needed = 0;
6458                         int s;
6459                         for (s=0; key_buffer.string_array[s]; s++) {
6460                                 calc_needed += strlen_m_term(key_buffer.string_array[s])*2;
6461                         }
6462                         if (!key_buffer.string_array[0]) {
6463                                 calc_needed += 2;
6464                         }
6465                         calc_needed += 2;
6466
6467                         torture_assert_int_equal(tctx, *r.out.needed, calc_needed,
6468                                 "EnumPrinterKey unexpected size");
6469                 }
6470         }
6471
6472         if (array) {
6473                 *array = key_buffer.string_array;
6474         }
6475
6476         return true;
6477 }
6478
6479 bool test_printer_keys(struct torture_context *tctx,
6480                        struct dcerpc_binding_handle *b,
6481                        struct policy_handle *handle)
6482 {
6483         const char **key_array = NULL;
6484         int i;
6485
6486         torture_comment(tctx, "Testing Printer Keys\n");
6487
6488         torture_assert(tctx, test_EnumPrinterKey(tctx, b, handle, "", &key_array),
6489                 "failed to call test_EnumPrinterKey");
6490
6491         for (i=0; key_array && key_array[i]; i++) {
6492                 torture_assert(tctx, test_EnumPrinterKey(tctx, b, handle, key_array[i], NULL),
6493                         "failed to call test_EnumPrinterKey");
6494         }
6495         for (i=0; key_array && key_array[i]; i++) {
6496                 torture_assert(tctx, test_EnumPrinterDataEx(tctx, b, handle, key_array[i], NULL, NULL),
6497                         "failed to call test_EnumPrinterDataEx");
6498         }
6499
6500         torture_comment(tctx, "Printer Keys test succeeded\n\n");
6501
6502         return true;
6503 }
6504
6505 static bool test_one_printer(struct torture_context *tctx,
6506                              struct dcerpc_pipe *p,
6507                              struct policy_handle *handle,
6508                              const char *name,
6509                              const char *drivername,
6510                              const char *environment,
6511                              bool have_driver,
6512                              struct spoolss_DeviceMode *devmode)
6513 {
6514         bool ret = true;
6515         struct dcerpc_binding_handle *b = p->binding_handle;
6516
6517         if (!test_PausePrinter(tctx, b, handle)) {
6518                 ret = false;
6519         }
6520
6521         if (!test_DoPrintTest(tctx, b, handle)) {
6522                 ret = false;
6523         }
6524
6525         if (!test_DoPrintTest_extended(tctx, b, handle)) {
6526                 torture_comment(tctx, "extended printing test failed!\n");
6527         }
6528
6529         if (!test_ResumePrinter(tctx, b, handle)) {
6530                 ret = false;
6531         }
6532
6533         if (!test_printer_info(tctx, b, handle)) {
6534                 ret = false;
6535         }
6536
6537         if (!test_PrinterInfo_SD(tctx, b, handle)) {
6538                 ret = false;
6539         }
6540
6541         if (!test_PrinterInfo_DevMode(tctx, p, handle, name, devmode)) {
6542                 ret = false;
6543         }
6544
6545         if (!test_PrinterInfo_winreg(tctx, p, handle, name)) {
6546                 ret = false;
6547         }
6548
6549         if (!test_ChangeID(tctx, p, handle)) {
6550                 ret = false;
6551         }
6552
6553         if (!test_printer_keys(tctx, b, handle)) {
6554                 ret = false;
6555         }
6556
6557         if (!test_EnumPrinterData_consistency(tctx, p, handle)) {
6558                 ret = false;
6559         }
6560
6561         if (!test_SetPrinterDataEx_matrix(tctx, p, handle, name, NULL, NULL)) {
6562                 ret = false;
6563         }
6564
6565         if (!test_PrinterData_winreg(tctx, p, handle, name)) {
6566                 ret = false;
6567         }
6568
6569         if (!test_PrinterData_DsSpooler(tctx, p, handle, name)) {
6570                 ret = false;
6571         }
6572
6573         if (have_driver) {
6574                 if (!test_DriverInfo_winreg(tctx, p, handle, name, drivername, environment)) {
6575                         ret = false;
6576                 }
6577         }
6578
6579         if (!test_printer_rename(tctx, p, handle, name)) {
6580                 ret = false;
6581         }
6582
6583         return ret;
6584 }
6585
6586 static bool test_csetprinter(struct torture_context *tctx,
6587                              struct dcerpc_pipe *p,
6588                              struct policy_handle *handle,
6589                              const char *printername,
6590                              const char *drivername,
6591                              const char *portname)
6592 {
6593         union spoolss_PrinterInfo info;
6594         struct policy_handle new_handle, new_handle2;
6595         struct dcerpc_binding_handle *b = p->binding_handle;
6596
6597         torture_comment(tctx, "Testing c_setprinter\n");
6598
6599         torture_assert(tctx,
6600                 test_GetPrinter_level(tctx, b, handle, 0, &info),
6601                 "failed to get level 0 printer info");
6602         torture_comment(tctx, "csetprinter on initial printer handle: %d\n",
6603                 info.info0.c_setprinter);
6604
6605         /* check if c_setprinter on 1st handle increases after a printer has
6606          * been added */
6607
6608         torture_assert(tctx,
6609                 test_AddPrinter_normal(tctx, p, &new_handle, printername, drivername, portname, NULL, false),
6610                 "failed to add new printer");
6611         torture_assert(tctx,
6612                 test_GetPrinter_level(tctx, b, handle, 0, &info),
6613                 "failed to get level 0 printer info");
6614         torture_comment(tctx, "csetprinter on initial printer handle (after add): %d\n",
6615                 info.info0.c_setprinter);
6616
6617         /* check if c_setprinter on new handle increases after a printer has
6618          * been added */
6619
6620         torture_assert(tctx,
6621                 test_GetPrinter_level(tctx, b, &new_handle, 0, &info),
6622                 "failed to get level 0 printer info");
6623         torture_comment(tctx, "csetprinter on created handle: %d\n",
6624                 info.info0.c_setprinter);
6625
6626         /* open the new printer and check if c_setprinter increases */
6627
6628         torture_assert(tctx,
6629                 call_OpenPrinterEx(tctx, p, printername, NULL, &new_handle2),
6630                 "failed to open created printer");
6631         torture_assert(tctx,
6632                 test_GetPrinter_level(tctx, b, &new_handle2, 0, &info),
6633                 "failed to get level 0 printer info");
6634         torture_comment(tctx, "csetprinter on new handle (after openprinter): %d\n",
6635                 info.info0.c_setprinter);
6636
6637         /* cleanup */
6638
6639         torture_assert(tctx,
6640                 test_ClosePrinter(tctx, b, &new_handle2),
6641                 "failed to close printer");
6642         torture_assert(tctx,
6643                 test_DeletePrinter(tctx, b, &new_handle),
6644                 "failed to delete new printer");
6645
6646         return true;
6647 }
6648
6649 static bool test_add_printer_args_with_driver(struct torture_context *tctx,
6650                                               struct dcerpc_pipe *p,
6651                                               struct torture_printer_context *t)
6652 {
6653         bool ret = true;
6654         struct policy_handle handle;
6655         bool found = false;
6656         struct dcerpc_binding_handle *b = p->binding_handle;
6657         const char *printer_name = t->info2.printername;
6658         const char *driver_name = t->added_driver ? t->driver.info8.driver_name : t->info2.drivername;
6659         const char *port_name = t->info2.portname;
6660         const char *printer_name2 = talloc_asprintf(tctx, "%s2", printer_name);
6661
6662         if (t->wellknown) {
6663                 torture_assert(tctx,
6664                         test_AddPrinter_wellknown(tctx, p, printer_name, t->ex),
6665                         "failed to add wellknown printer");
6666         } else {
6667                 torture_assert(tctx,
6668                         test_AddPrinter_normal(tctx, p, &handle, printer_name, driver_name, port_name, t->devmode, t->ex),
6669                         "failed to add printer");
6670         }
6671
6672         if (!test_csetprinter(tctx, p, &handle, printer_name2, driver_name, port_name)) {
6673                 ret = false;
6674         }
6675
6676         if (!test_one_printer(tctx, p, &handle, printer_name, driver_name, t->driver.remote.environment, t->have_driver, t->devmode)) {
6677                 ret = false;
6678         }
6679
6680         if (!test_DeletePrinter(tctx, b, &handle)) {
6681                 ret = false;
6682         }
6683
6684         if (!test_EnumPrinters_findname(tctx, b, PRINTER_ENUM_LOCAL, 1,
6685                                         printer_name, &found)) {
6686                 ret = false;
6687         }
6688
6689         torture_assert(tctx, !found, "deleted printer still there");
6690
6691         return ret;
6692 }
6693
6694 static bool compose_local_driver_directory(struct torture_context *tctx,
6695                                            const char *environment,
6696                                            const char *local_dir,
6697                                            const char **path)
6698 {
6699         char *p;
6700
6701         p = strrchr(local_dir, '/');
6702         if (!p) {
6703                 return NULL;
6704         }
6705         p++;
6706
6707         if (strequal(environment, "Windows x64")) {
6708                 if (!strequal(p, "x64")) {
6709                         *path = talloc_asprintf(tctx, "%s/x64", local_dir);
6710                 }
6711         } else if (strequal(environment, "Windows NT x86")) {
6712                 if (!strequal(p, "i386")) {
6713                         *path = talloc_asprintf(tctx, "%s/i386", local_dir);
6714                 }
6715         } else {
6716                 torture_assert(tctx, "unknown environment: '%s'\n", environment);
6717         }
6718
6719         return true;
6720 }
6721
6722 static bool test_add_printer_args(struct torture_context *tctx,
6723                                   struct dcerpc_pipe *p,
6724                                   struct torture_printer_context *t)
6725 {
6726         bool ret = true;
6727         struct dcerpc_binding_handle *b = p->binding_handle;
6728         const char *server_name_slash = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
6729
6730         if (t->wellknown && torture_setting_bool(tctx, "samba3", false)) {
6731                 torture_skip(tctx, "skipping AddPrinter level 1 against samba");
6732         }
6733
6734         torture_assert(tctx,
6735                 fillup_printserver_info(tctx, p, &t->driver),
6736                 "failed to fillup printserver info");
6737
6738         t->driver.info8.architecture = talloc_strdup(t, t->driver.remote.environment);
6739
6740         torture_assert(tctx,
6741                 compose_local_driver_directory(tctx, t->driver.remote.environment,
6742                                                t->driver.local.driver_directory,
6743                                                &t->driver.local.driver_directory),
6744                 "failed to compose local driver directory");
6745
6746         if (test_EnumPrinterDrivers_findone(tctx, b, server_name_slash, t->driver.remote.environment, 3, t->info2.drivername)) {
6747                 t->have_driver = true;
6748                 goto try_run;
6749         }
6750
6751         torture_comment(tctx, "driver '%s' (architecture: %s, version: 3) does not exist on the server\n",
6752                 t->info2.drivername, t->driver.remote.environment);
6753         torture_comment(tctx, "trying to upload own driver\n");
6754
6755         if (!directory_exist(t->driver.local.driver_directory)) {
6756                 torture_warning(tctx, "no local driver is available!");
6757                 t->have_driver = false;
6758                 goto try_run;
6759         }
6760
6761         torture_assert(tctx,
6762                 upload_printer_driver(tctx, dcerpc_server_name(p), &t->driver),
6763                 "failed to upload printer driver");
6764
6765         torture_assert(tctx,
6766                 test_AddPrinterDriver_args_level_3(tctx, b, server_name_slash, &t->driver.info8, 0, false),
6767                 "failed to add driver");
6768
6769         t->added_driver = true;
6770         t->have_driver = true;
6771
6772  try_run:
6773         ret = test_add_printer_args_with_driver(tctx, p, t);
6774
6775         if (t->added_driver) {
6776                 torture_assert(tctx,
6777                         remove_printer_driver(tctx, dcerpc_server_name(p), &t->driver),
6778                         "failed to remove printer driver");
6779         }
6780
6781         return ret;
6782 }
6783
6784 static bool test_add_printer(struct torture_context *tctx,
6785                              struct dcerpc_pipe *p,
6786                              void *private_data)
6787 {
6788         struct torture_printer_context *t =
6789                 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
6790
6791         t->ex                   = false;
6792         t->wellknown            = false;
6793         t->info2.printername    = TORTURE_PRINTER;
6794
6795         return test_add_printer_args(tctx, p, t);
6796 }
6797
6798 static bool test_add_printer_wellknown(struct torture_context *tctx,
6799                                        struct dcerpc_pipe *p,
6800                                        void *private_data)
6801 {
6802         struct torture_printer_context *t =
6803                 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
6804
6805         t->ex                   = false;
6806         t->wellknown            = true;
6807         t->info2.printername    = TORTURE_WELLKNOWN_PRINTER;
6808         t->devmode              = NULL;
6809
6810         return test_add_printer_args(tctx, p, t);
6811 }
6812
6813 static bool test_add_printer_ex(struct torture_context *tctx,
6814                                 struct dcerpc_pipe *p,
6815                                 void *private_data)
6816 {
6817         struct torture_printer_context *t =
6818                 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
6819
6820         t->ex                   = true;
6821         t->wellknown            = false;
6822         t->info2.printername    = TORTURE_PRINTER_EX;
6823         t->devmode              = NULL;
6824
6825         return test_add_printer_args(tctx, p, t);
6826 }
6827
6828 static bool test_add_printer_ex_wellknown(struct torture_context *tctx,
6829                                           struct dcerpc_pipe *p,
6830                                           void *private_data)
6831 {
6832         struct torture_printer_context *t =
6833                 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
6834
6835         t->ex                   = true;
6836         t->wellknown            = true;
6837         t->info2.printername    = TORTURE_WELLKNOWN_PRINTER_EX;
6838         t->devmode              = NULL;
6839
6840         return test_add_printer_args(tctx, p, t);
6841 }
6842
6843 static struct spoolss_DeviceMode *torture_devicemode(TALLOC_CTX *mem_ctx,
6844                                                      const char *devicename)
6845 {
6846         struct spoolss_DeviceMode *r;
6847
6848         r = talloc_zero(mem_ctx, struct spoolss_DeviceMode);
6849         if (r == NULL) {
6850                 return NULL;
6851         }
6852
6853         r->devicename           = talloc_strdup(r, devicename);
6854         r->specversion          = DMSPEC_NT4_AND_ABOVE;
6855         r->driverversion        = 0x0600;
6856         r->size                 = 0x00dc;
6857         r->__driverextra_length = 0;
6858         r->fields               = DEVMODE_FORMNAME |
6859                                   DEVMODE_TTOPTION |
6860                                   DEVMODE_PRINTQUALITY |
6861                                   DEVMODE_DEFAULTSOURCE |
6862                                   DEVMODE_COPIES |
6863                                   DEVMODE_SCALE |
6864                                   DEVMODE_PAPERSIZE |
6865                                   DEVMODE_ORIENTATION;
6866         r->orientation          = DMORIENT_PORTRAIT;
6867         r->papersize            = DMPAPER_LETTER;
6868         r->paperlength          = 0;
6869         r->paperwidth           = 0;
6870         r->scale                = 100;
6871         r->copies               = 55;
6872         r->defaultsource        = DMBIN_FORMSOURCE;
6873         r->printquality         = DMRES_HIGH;
6874         r->color                = DMRES_MONOCHROME;
6875         r->duplex               = DMDUP_SIMPLEX;
6876         r->yresolution          = 0;
6877         r->ttoption             = DMTT_SUBDEV;
6878         r->collate              = DMCOLLATE_FALSE;
6879         r->formname             = talloc_strdup(r, "Letter");
6880
6881         return r;
6882 }
6883
6884 static bool test_add_printer_with_devmode(struct torture_context *tctx,
6885                                           struct dcerpc_pipe *p,
6886                                           void *private_data)
6887 {
6888         struct torture_printer_context *t =
6889                 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
6890
6891         t->ex                   = true;
6892         t->wellknown            = false;
6893         t->info2.printername    = TORTURE_PRINTER_EX;
6894         t->devmode              = torture_devicemode(t, TORTURE_PRINTER_EX);
6895
6896         return test_add_printer_args(tctx, p, t);
6897 }
6898
6899 static bool test_architecture_buffer(struct torture_context *tctx,
6900                                      void *private_data)
6901 {
6902         struct test_spoolss_context *ctx =
6903                 talloc_get_type_abort(private_data, struct test_spoolss_context);
6904
6905         struct spoolss_OpenPrinterEx r;
6906         struct spoolss_UserLevel1 u1;
6907         struct policy_handle handle;
6908         uint32_t architectures[] = {
6909                 PROCESSOR_ARCHITECTURE_INTEL,
6910                 PROCESSOR_ARCHITECTURE_IA64,
6911                 PROCESSOR_ARCHITECTURE_AMD64
6912         };
6913         uint32_t needed[3];
6914         int i;
6915         struct dcerpc_pipe *p = ctx->spoolss_pipe;
6916         struct dcerpc_binding_handle *b = p->binding_handle;
6917
6918         for (i=0; i < ARRAY_SIZE(architectures); i++) {
6919
6920                 torture_comment(tctx, "Testing OpenPrinterEx with architecture %d\n", architectures[i]);
6921
6922                 u1.size = 0;
6923                 u1.client = NULL;
6924                 u1.user = NULL;
6925                 u1.build = 0;
6926                 u1.major = 3;
6927                 u1.minor = 0;
6928                 u1.processor = architectures[i];
6929
6930                 r.in.printername        = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
6931                 r.in.datatype           = NULL;
6932                 r.in.devmode_ctr.devmode= NULL;
6933                 r.in.access_mask        = SEC_FLAG_MAXIMUM_ALLOWED;
6934                 r.in.level               = 1;
6935                 r.in.userlevel.level1   = &u1;
6936                 r.out.handle            = &handle;
6937
6938                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_OpenPrinterEx_r(b, tctx, &r), "");
6939                 torture_assert_werr_ok(tctx, r.out.result, "");
6940
6941                 {
6942                         struct spoolss_EnumPrinters e;
6943                         uint32_t count;
6944                         union spoolss_PrinterInfo *info;
6945
6946                         e.in.flags = PRINTER_ENUM_LOCAL;
6947                         e.in.server = NULL;
6948                         e.in.level = 2;
6949                         e.in.buffer = NULL;
6950                         e.in.offered = 0;
6951                         e.out.count = &count;
6952                         e.out.info = &info;
6953                         e.out.needed = &needed[i];
6954
6955                         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters_r(b, tctx, &e), "");
6956 #if 0
6957                         torture_comment(tctx, "needed was %d\n", needed[i]);
6958 #endif
6959                 }
6960
6961                 torture_assert(tctx, test_ClosePrinter(tctx, b, &handle), "");
6962         }
6963
6964         for (i=1; i < ARRAY_SIZE(architectures); i++) {
6965                 if (needed[i-1] != needed[i]) {
6966                         torture_fail(tctx,
6967                                 talloc_asprintf(tctx, "needed size %d for architecture %d != needed size %d for architecture %d\n",
6968                                                 needed[i-1], architectures[i-1], needed[i], architectures[i]));
6969                 }
6970         }
6971
6972         return true;
6973 }
6974
6975 static bool test_PrintServer_Forms_Winreg(struct torture_context *tctx,
6976                                           void *private_data)
6977 {
6978         struct test_spoolss_context *ctx =
6979                 talloc_get_type_abort(private_data, struct test_spoolss_context);
6980         struct dcerpc_pipe *p = ctx->spoolss_pipe;
6981         struct dcerpc_binding_handle *b = p->binding_handle;
6982
6983         return test_Forms_winreg(tctx, b, &ctx->server_handle, true, NULL);
6984 }
6985
6986 static bool test_PrintServer_Forms(struct torture_context *tctx,
6987                                    void *private_data)
6988 {
6989         struct test_spoolss_context *ctx =
6990                 talloc_get_type_abort(private_data, struct test_spoolss_context);
6991         struct dcerpc_pipe *p = ctx->spoolss_pipe;
6992         struct dcerpc_binding_handle *b = p->binding_handle;
6993
6994         return test_Forms(tctx, b, &ctx->server_handle, true, NULL, NULL, NULL);
6995 }
6996
6997 static bool test_PrintServer_EnumForms(struct torture_context *tctx,
6998                                        void *private_data)
6999 {
7000         struct test_spoolss_context *ctx =
7001                 talloc_get_type_abort(private_data, struct test_spoolss_context);
7002         struct dcerpc_pipe *p = ctx->spoolss_pipe;
7003         struct dcerpc_binding_handle *b = p->binding_handle;
7004
7005         return test_EnumForms_all(tctx, b, &ctx->server_handle, true);
7006 }
7007
7008 static bool torture_rpc_spoolss_setup_common(struct torture_context *tctx, struct test_spoolss_context *t)
7009 {
7010         NTSTATUS status;
7011
7012         status = torture_rpc_connection(tctx, &t->spoolss_pipe, &ndr_table_spoolss);
7013
7014         torture_assert_ntstatus_ok(tctx, status, "Error connecting to server");
7015
7016         torture_assert(tctx,
7017                 test_OpenPrinter_server(tctx, t->spoolss_pipe, &t->server_handle),
7018                 "failed to open printserver");
7019         torture_assert(tctx,
7020                 test_get_environment(tctx, t->spoolss_pipe->binding_handle, &t->server_handle, &t->environment),
7021                 "failed to get environment");
7022
7023         return true;
7024 }
7025
7026 static bool torture_rpc_spoolss_setup(struct torture_context *tctx, void **data)
7027 {
7028         struct test_spoolss_context *t;
7029
7030         *data = t = talloc_zero(tctx, struct test_spoolss_context);
7031
7032         return torture_rpc_spoolss_setup_common(tctx, t);
7033 }
7034
7035 static bool torture_rpc_spoolss_teardown_common(struct torture_context *tctx, struct test_spoolss_context *t)
7036 {
7037         test_ClosePrinter(tctx, t->spoolss_pipe->binding_handle, &t->server_handle);
7038
7039         return true;
7040 }
7041
7042 static bool torture_rpc_spoolss_teardown(struct torture_context *tctx, void *data)
7043 {
7044         struct test_spoolss_context *t = talloc_get_type(data, struct test_spoolss_context);
7045         bool ret;
7046
7047         ret = torture_rpc_spoolss_teardown_common(tctx, t);
7048         talloc_free(t);
7049
7050         return ret;
7051 }
7052
7053 struct torture_suite *torture_rpc_spoolss(TALLOC_CTX *mem_ctx)
7054 {
7055         struct torture_suite *suite = torture_suite_create(mem_ctx, "SPOOLSS");
7056         struct torture_tcase *tcase = torture_suite_add_tcase(suite, "PRINTSERVER");
7057
7058         torture_tcase_set_fixture(tcase,
7059                                   torture_rpc_spoolss_setup,
7060                                   torture_rpc_spoolss_teardown);
7061
7062         torture_tcase_add_simple_test(tcase, "openprinter_badnamelist", test_OpenPrinter_badname_list);
7063         torture_tcase_add_simple_test(tcase, "printer_data_list", test_GetPrinterData_list);
7064         torture_tcase_add_simple_test(tcase, "enum_forms", test_PrintServer_EnumForms);
7065         torture_tcase_add_simple_test(tcase, "forms", test_PrintServer_Forms);
7066         torture_tcase_add_simple_test(tcase, "forms_winreg", test_PrintServer_Forms_Winreg);
7067         torture_tcase_add_simple_test(tcase, "enum_ports", test_EnumPorts);
7068         torture_tcase_add_simple_test(tcase, "add_port", test_AddPort);
7069         torture_tcase_add_simple_test(tcase, "get_printer_driver_directory", test_GetPrinterDriverDirectory);
7070         torture_tcase_add_simple_test(tcase, "get_print_processor_directory", test_GetPrintProcessorDirectory);
7071         torture_tcase_add_simple_test(tcase, "enum_printer_drivers", test_EnumPrinterDrivers);
7072         torture_tcase_add_simple_test(tcase, "enum_monitors", test_EnumMonitors);
7073         torture_tcase_add_simple_test(tcase, "enum_print_processors", test_EnumPrintProcessors);
7074         torture_tcase_add_simple_test(tcase, "print_processors_winreg", test_print_processors_winreg);
7075         torture_tcase_add_simple_test(tcase, "enum_printprocdata", test_EnumPrintProcDataTypes);
7076         torture_tcase_add_simple_test(tcase, "enum_printers", test_EnumPrinters);
7077         torture_tcase_add_simple_test(tcase, "enum_ports_old", test_EnumPorts_old);
7078         torture_tcase_add_simple_test(tcase, "enum_printers_old", test_EnumPrinters_old);
7079         torture_tcase_add_simple_test(tcase, "enum_printer_drivers_old", test_EnumPrinterDrivers_old);
7080         torture_tcase_add_simple_test(tcase, "architecture_buffer", test_architecture_buffer);
7081
7082         return suite;
7083 }
7084
7085 struct torture_suite *torture_rpc_spoolss_printer(TALLOC_CTX *mem_ctx)
7086 {
7087         struct torture_suite *suite = torture_suite_create(mem_ctx, "SPOOLSS-PRINTER");
7088
7089         struct torture_rpc_tcase *tcase = torture_suite_add_rpc_iface_tcase(suite,
7090                                                         "printer", &ndr_table_spoolss);
7091
7092         struct torture_printer_context *t;
7093
7094         t = talloc_zero(mem_ctx, struct torture_printer_context);
7095
7096         t->driver.info8.version                 = SPOOLSS_DRIVER_VERSION_200X;
7097         t->driver.info8.driver_name             = TORTURE_DRIVER;
7098         t->driver.info8.driver_path             = "pscript5.dll";
7099         t->driver.info8.data_file               = "cups6.ppd";
7100         t->driver.info8.config_file             = "ps5ui.dll";
7101         t->driver.info8.help_file               = "pscript.hlp";
7102         t->driver.info8.default_datatype        = "RAW";
7103         t->driver.info8.dependent_files         = talloc_zero(t, struct spoolss_StringArray);
7104         t->driver.info8.dependent_files->string = talloc_zero_array(t, const char *, 8 + 1);
7105         t->driver.info8.dependent_files->string[0] = "pscript5.dll";
7106         t->driver.info8.dependent_files->string[1] = "cups6.ppd";
7107         t->driver.info8.dependent_files->string[2] = "ps5ui.dll";
7108         t->driver.info8.dependent_files->string[3] = "pscript.hlp";
7109         t->driver.info8.dependent_files->string[4] = "pscript.ntf";
7110         t->driver.info8.dependent_files->string[5] = "cups6.ini";
7111         t->driver.info8.dependent_files->string[6] = "cupsps6.dll";
7112         t->driver.info8.dependent_files->string[7] = "cupsui6.dll";
7113
7114         t->driver.local.driver_directory= "/usr/share/cups/drivers";
7115
7116         t->info2.drivername             = "Microsoft XPS Document Writer";
7117         t->info2.portname               = "LPT1:";
7118
7119         torture_rpc_tcase_add_test_ex(tcase, "add_printer", test_add_printer, t);
7120         torture_rpc_tcase_add_test_ex(tcase, "add_printer_wellknown", test_add_printer_wellknown, t);
7121         torture_rpc_tcase_add_test_ex(tcase, "add_printer_ex", test_add_printer_ex, t);
7122         torture_rpc_tcase_add_test_ex(tcase, "add_printer_ex_wellknown", test_add_printer_ex_wellknown, t);
7123
7124         torture_rpc_tcase_add_test_ex(tcase, "add_printer_with_devmode", test_add_printer_with_devmode, t);
7125
7126         return suite;
7127 }
7128
7129 static bool test_GetPrinterDriverDirectory_getdir(struct torture_context *tctx,
7130                                                   struct dcerpc_binding_handle *b,
7131                                                   const char *server,
7132                                                   const char *environment,
7133                                                   const char **dir_p)
7134 {
7135         struct spoolss_GetPrinterDriverDirectory r;
7136         uint32_t needed;
7137
7138         r.in.server             = server;
7139         r.in.environment        = environment;
7140         r.in.level              = 1;
7141         r.in.buffer             = NULL;
7142         r.in.offered            = 0;
7143         r.out.needed            = &needed;
7144
7145         torture_assert_ntstatus_ok(tctx,
7146                 dcerpc_spoolss_GetPrinterDriverDirectory_r(b, tctx, &r),
7147                 "failed to query driver directory");
7148
7149         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
7150                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
7151                 r.in.buffer = &blob;
7152                 r.in.offered = needed;
7153
7154                 torture_assert_ntstatus_ok(tctx,
7155                         dcerpc_spoolss_GetPrinterDriverDirectory_r(b, tctx, &r),
7156                         "failed to query driver directory");
7157         }
7158
7159         torture_assert_werr_ok(tctx, r.out.result,
7160                 "failed to query driver directory");
7161
7162         if (dir_p) {
7163                 *dir_p = r.out.info->info1.directory_name;
7164         }
7165
7166         return true;
7167 }
7168
7169 static const char *get_driver_from_info(struct spoolss_AddDriverInfoCtr *info_ctr)
7170 {
7171         if (info_ctr == NULL) {
7172                 return NULL;
7173         }
7174
7175         switch (info_ctr->level) {
7176         case 1:
7177                 return info_ctr->info.info1->driver_name;
7178         case 2:
7179                 return info_ctr->info.info2->driver_name;
7180         case 3:
7181                 return info_ctr->info.info3->driver_name;
7182         case 4:
7183                 return info_ctr->info.info4->driver_name;
7184         case 6:
7185                 return info_ctr->info.info6->driver_name;
7186         case 8:
7187                 return info_ctr->info.info8->driver_name;
7188         default:
7189                 return NULL;
7190         }
7191 }
7192
7193 static const char *get_environment_from_info(struct spoolss_AddDriverInfoCtr *info_ctr)
7194 {
7195         if (info_ctr == NULL) {
7196                 return NULL;
7197         }
7198
7199         switch (info_ctr->level) {
7200         case 2:
7201                 return info_ctr->info.info2->architecture;
7202         case 3:
7203                 return info_ctr->info.info3->architecture;
7204         case 4:
7205                 return info_ctr->info.info4->architecture;
7206         case 6:
7207                 return info_ctr->info.info6->architecture;
7208         case 8:
7209                 return info_ctr->info.info8->architecture;
7210         default:
7211                 return NULL;
7212         }
7213 }
7214
7215
7216 static bool test_AddPrinterDriver_exp(struct torture_context *tctx,
7217                                       struct dcerpc_binding_handle *b,
7218                                       const char *servername,
7219                                       struct spoolss_AddDriverInfoCtr *info_ctr,
7220                                       WERROR expected_result)
7221 {
7222         struct spoolss_AddPrinterDriver r;
7223         const char *drivername = get_driver_from_info(info_ctr);
7224         const char *environment = get_environment_from_info(info_ctr);
7225
7226         r.in.servername = servername;
7227         r.in.info_ctr = info_ctr;
7228
7229         torture_comment(tctx, "Testing AddPrinterDriver(%s) level: %d, environment: '%s'\n",
7230                 drivername, info_ctr->level, environment);
7231
7232         torture_assert_ntstatus_ok(tctx,
7233                 dcerpc_spoolss_AddPrinterDriver_r(b, tctx, &r),
7234                 "spoolss_AddPrinterDriver failed");
7235         torture_assert_werr_equal(tctx, r.out.result, expected_result,
7236                 "spoolss_AddPrinterDriver failed with unexpected result");
7237
7238         return true;
7239
7240 }
7241
7242 static bool test_AddPrinterDriverEx_exp(struct torture_context *tctx,
7243                                         struct dcerpc_binding_handle *b,
7244                                         const char *servername,
7245                                         struct spoolss_AddDriverInfoCtr *info_ctr,
7246                                         uint32_t flags,
7247                                         WERROR expected_result)
7248 {
7249         struct spoolss_AddPrinterDriverEx r;
7250         const char *drivername = get_driver_from_info(info_ctr);
7251         const char *environment = get_environment_from_info(info_ctr);
7252
7253         r.in.servername = servername;
7254         r.in.info_ctr = info_ctr;
7255         r.in.flags = flags;
7256
7257         torture_comment(tctx, "Testing AddPrinterDriverEx(%s) level: %d, environment: '%s'\n",
7258                 drivername, info_ctr->level, environment);
7259
7260         torture_assert_ntstatus_ok(tctx,
7261                 dcerpc_spoolss_AddPrinterDriverEx_r(b, tctx, &r),
7262                 "AddPrinterDriverEx failed");
7263         torture_assert_werr_equal(tctx, r.out.result, expected_result,
7264                 "AddPrinterDriverEx failed with unexpected result");
7265
7266         return true;
7267 }
7268
7269 static bool test_AddPrinterDriver_args_level_1(struct torture_context *tctx,
7270                                                struct dcerpc_binding_handle *b,
7271                                                const char *server_name,
7272                                                struct spoolss_AddDriverInfo8 *r,
7273                                                uint32_t flags,
7274                                                bool ex)
7275 {
7276         struct spoolss_AddDriverInfoCtr info_ctr;
7277         struct spoolss_AddDriverInfo1 info1;
7278
7279         ZERO_STRUCT(info1);
7280
7281         info_ctr.level = 1;
7282         info_ctr.info.info1 = &info1;
7283
7284         if (ex) {
7285                 torture_assert(tctx,
7286                         test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_UNKNOWN_LEVEL),
7287                         "failed to test AddPrinterDriverEx level 1");
7288         } else {
7289                 torture_assert(tctx,
7290                         test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_UNKNOWN_LEVEL),
7291                         "failed to test AddPrinterDriver level 1");
7292         }
7293
7294         info1.driver_name = r->driver_name;
7295
7296         if (ex) {
7297                 torture_assert(tctx,
7298                         test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_UNKNOWN_LEVEL),
7299                         "failed to test AddPrinterDriverEx level 1");
7300         } else {
7301                 torture_assert(tctx,
7302                         test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_UNKNOWN_LEVEL),
7303                         "failed to test AddPrinterDriver level 1");
7304         }
7305
7306         return true;
7307 }
7308
7309 static bool test_AddPrinterDriver_args_level_2(struct torture_context *tctx,
7310                                                struct dcerpc_binding_handle *b,
7311                                                const char *server_name,
7312                                                struct spoolss_AddDriverInfo8 *r,
7313                                                uint32_t flags,
7314                                                bool ex)
7315 {
7316         struct spoolss_AddDriverInfoCtr info_ctr;
7317         struct spoolss_AddDriverInfo2 info2;
7318
7319         ZERO_STRUCT(info2);
7320
7321         info_ctr.level = 2;
7322         info_ctr.info.info2 = &info2;
7323
7324         if (ex) {
7325                 torture_assert(tctx,
7326                         test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
7327                         "failed to test AddPrinterDriverEx level 2");
7328         } else {
7329                 torture_assert(tctx,
7330                         test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
7331                         "failed to test AddPrinterDriver level 2");
7332         }
7333
7334         info2.driver_name = r->driver_name;
7335
7336         if (ex) {
7337                 torture_assert(tctx,
7338                         test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
7339                         "failed to test AddPrinterDriverEx level 2");
7340         } else {
7341                 torture_assert(tctx,
7342                         test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
7343                         "failed to test AddPrinterDriver level 2");
7344         }
7345
7346         info2.version = r->version;
7347
7348         if (ex) {
7349                 torture_assert(tctx,
7350                         test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
7351                         "failed to test AddPrinterDriverEx level 2");
7352         } else {
7353                 torture_assert(tctx,
7354                         test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
7355                         "failed to test AddPrinterDriver level 2");
7356         }
7357
7358         info2.architecture = r->architecture;
7359
7360         if (ex) {
7361                 torture_assert(tctx,
7362                         test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
7363                         "failed to test AddPrinterDriverEx level 2");
7364         } else {
7365                 torture_assert(tctx,
7366                         test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
7367                         "failed to test AddPrinterDriver level 2");
7368         }
7369
7370         info2.driver_path = r->driver_path;
7371
7372         if (ex) {
7373                 torture_assert(tctx,
7374                         test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
7375                         "failed to test AddPrinterDriverEx level 2");
7376         } else {
7377                 torture_assert(tctx,
7378                         test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
7379                         "failed to test AddPrinterDriver level 2");
7380         }
7381
7382         info2.data_file = r->data_file;
7383
7384         if (ex) {
7385                 torture_assert(tctx,
7386                         test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
7387                         "failed to test AddPrinterDriverEx level 2");
7388         } else {
7389                 torture_assert(tctx,
7390                         test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
7391                         "failed to test AddPrinterDriver level 2");
7392         }
7393
7394         info2.config_file = r->config_file;
7395
7396         if (ex) {
7397                 torture_assert(tctx,
7398                         test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, 0, WERR_INVALID_PARAM),
7399                         "failed to test AddPrinterDriverEx");
7400         }
7401
7402         if (ex) {
7403                 torture_assert(tctx,
7404                         test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
7405                         "failed to test AddPrinterDriverEx level 2");
7406         } else {
7407                 torture_assert(tctx,
7408                         test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_OK),
7409                         "failed to test AddPrinterDriver level 2");
7410         }
7411
7412         torture_assert(tctx,
7413                 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 2, r->driver_name),
7414                 "failed to find added printer driver");
7415
7416         return true;
7417 }
7418
7419 static bool test_AddPrinterDriver_args_level_3(struct torture_context *tctx,
7420                                                struct dcerpc_binding_handle *b,
7421                                                const char *server_name,
7422                                                struct spoolss_AddDriverInfo8 *r,
7423                                                uint32_t flags,
7424                                                bool ex)
7425 {
7426         struct spoolss_AddDriverInfoCtr info_ctr;
7427         struct spoolss_AddDriverInfo3 info3;
7428
7429         info3.driver_name       = r->driver_name;
7430         info3.version           = r->version;
7431         info3.architecture      = r->architecture;
7432         info3.driver_path       = r->driver_path;
7433         info3.data_file         = r->data_file;
7434         info3.config_file       = r->config_file;
7435         info3.help_file         = r->help_file;
7436         info3.monitor_name      = r->monitor_name;
7437         info3.default_datatype  = r->default_datatype;
7438         info3._ndr_size_dependent_files = r->_ndr_size_dependent_files;
7439         info3.dependent_files   = r->dependent_files;
7440
7441         info_ctr.level = 3;
7442         info_ctr.info.info3 = &info3;
7443
7444         if (ex) {
7445                 torture_assert(tctx,
7446                         test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
7447                         "failed to test AddPrinterDriverEx level 3");
7448         } else {
7449                 torture_assert(tctx,
7450                         test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_OK),
7451                         "failed to test AddPrinterDriver level 3");
7452         }
7453
7454         torture_assert(tctx,
7455                 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 3, r->driver_name),
7456                 "failed to find added printer driver");
7457
7458         return true;
7459 }
7460
7461 static bool test_AddPrinterDriver_args_level_4(struct torture_context *tctx,
7462                                                struct dcerpc_binding_handle *b,
7463                                                const char *server_name,
7464                                                struct spoolss_AddDriverInfo8 *r,
7465                                                uint32_t flags,
7466                                                bool ex)
7467 {
7468         struct spoolss_AddDriverInfoCtr info_ctr;
7469         struct spoolss_AddDriverInfo4 info4;
7470
7471         info4.version           = r->version;
7472         info4.driver_name       = r->driver_name;
7473         info4.architecture      = r->architecture;
7474         info4.driver_path       = r->driver_path;
7475         info4.data_file         = r->data_file;
7476         info4.config_file       = r->config_file;
7477         info4.help_file         = r->help_file;
7478         info4.monitor_name      = r->monitor_name;
7479         info4.default_datatype  = r->default_datatype;
7480         info4._ndr_size_dependent_files = r->_ndr_size_dependent_files;
7481         info4.dependent_files   = r->dependent_files;
7482         info4._ndr_size_previous_names = r->_ndr_size_previous_names;
7483         info4.previous_names = r->previous_names;
7484
7485         info_ctr.level = 4;
7486         info_ctr.info.info4 = &info4;
7487
7488         if (ex) {
7489                 torture_assert(tctx,
7490                         test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
7491                         "failed to test AddPrinterDriverEx level 4");
7492         } else {
7493                 torture_assert(tctx,
7494                         test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_OK),
7495                         "failed to test AddPrinterDriver level 4");
7496         }
7497
7498         torture_assert(tctx,
7499                 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 4, r->driver_name),
7500                 "failed to find added printer driver");
7501
7502         return true;
7503 }
7504
7505 static bool test_AddPrinterDriver_args_level_6(struct torture_context *tctx,
7506                                                struct dcerpc_binding_handle *b,
7507                                                const char *server_name,
7508                                                struct spoolss_AddDriverInfo8 *r,
7509                                                uint32_t flags,
7510                                                bool ex)
7511 {
7512         struct spoolss_AddDriverInfoCtr info_ctr;
7513         struct spoolss_AddDriverInfo6 info6;
7514
7515         info6.version           = r->version;
7516         info6.driver_name       = r->driver_name;
7517         info6.architecture      = r->architecture;
7518         info6.driver_path       = r->driver_path;
7519         info6.data_file         = r->data_file;
7520         info6.config_file       = r->config_file;
7521         info6.help_file         = r->help_file;
7522         info6.monitor_name      = r->monitor_name;
7523         info6.default_datatype  = r->default_datatype;
7524         info6._ndr_size_dependent_files = r->_ndr_size_dependent_files;
7525         info6.dependent_files   = r->dependent_files;
7526         info6._ndr_size_previous_names = r->_ndr_size_previous_names;
7527         info6.previous_names    = r->previous_names;
7528         info6.driver_date       = r->driver_date;
7529         info6.driver_version    = r->driver_version;
7530         info6.manufacturer_name = r->manufacturer_name;
7531         info6.manufacturer_url  = r->manufacturer_url;
7532         info6.hardware_id       = r->hardware_id;
7533         info6.provider          = r->provider;
7534
7535         info_ctr.level = 6;
7536         info_ctr.info.info6 = &info6;
7537
7538         if (ex) {
7539                 torture_assert(tctx,
7540                         test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
7541                         "failed to test AddPrinterDriverEx level 6");
7542         } else {
7543                 torture_assert(tctx,
7544                         test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_UNKNOWN_LEVEL),
7545                         "failed to test AddPrinterDriver level 6");
7546         }
7547
7548         /* spoolss_AddPrinterDriver does not deal with level 6 or 8 - gd */
7549
7550         if (!ex) {
7551                 return true;
7552         }
7553
7554         torture_assert(tctx,
7555                 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 6, r->driver_name),
7556                 "failed to find added printer driver");
7557
7558         return true;
7559 }
7560
7561 static bool test_AddPrinterDriver_args_level_8(struct torture_context *tctx,
7562                                                struct dcerpc_binding_handle *b,
7563                                                const char *server_name,
7564                                                struct spoolss_AddDriverInfo8 *r,
7565                                                uint32_t flags,
7566                                                bool ex)
7567 {
7568         struct spoolss_AddDriverInfoCtr info_ctr;
7569
7570         info_ctr.level = 8;
7571         info_ctr.info.info8 = r;
7572
7573         if (ex) {
7574                 torture_assert(tctx,
7575                         test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
7576                         "failed to test AddPrinterDriverEx level 8");
7577         } else {
7578                 torture_assert(tctx,
7579                         test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_UNKNOWN_LEVEL),
7580                         "failed to test AddPrinterDriver level 8");
7581         }
7582
7583         /* spoolss_AddPrinterDriver does not deal with level 6 or 8 - gd */
7584
7585         if (!ex) {
7586                 return true;
7587         }
7588
7589         torture_assert(tctx,
7590                 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 8, r->driver_name),
7591                 "failed to find added printer driver");
7592
7593         return true;
7594 }
7595
7596 static bool test_DeletePrinterDriver_exp(struct torture_context *tctx,
7597                                          struct dcerpc_binding_handle *b,
7598                                          const char *server,
7599                                          const char *driver,
7600                                          const char *environment,
7601                                          WERROR expected_result)
7602 {
7603         struct spoolss_DeletePrinterDriver r;
7604
7605         r.in.server = server;
7606         r.in.architecture = environment;
7607         r.in.driver = driver;
7608
7609         torture_comment(tctx, "Testing DeletePrinterDriver(%s)\n", driver);
7610
7611         torture_assert_ntstatus_ok(tctx,
7612                 dcerpc_spoolss_DeletePrinterDriver_r(b, tctx, &r),
7613                 "DeletePrinterDriver failed");
7614         torture_assert_werr_equal(tctx, r.out.result, expected_result,
7615                 "DeletePrinterDriver failed with unexpected result");
7616
7617         return true;
7618 }
7619
7620 static bool test_DeletePrinterDriverEx_exp(struct torture_context *tctx,
7621                                            struct dcerpc_binding_handle *b,
7622                                            const char *server,
7623                                            const char *driver,
7624                                            const char *environment,
7625                                            uint32_t delete_flags,
7626                                            uint32_t version,
7627                                            WERROR expected_result)
7628 {
7629         struct spoolss_DeletePrinterDriverEx r;
7630
7631         r.in.server = server;
7632         r.in.architecture = environment;
7633         r.in.driver = driver;
7634         r.in.delete_flags = delete_flags;
7635         r.in.version = version;
7636
7637         torture_comment(tctx, "Testing DeletePrinterDriverEx(%s)\n", driver);
7638
7639         torture_assert_ntstatus_ok(tctx,
7640                 dcerpc_spoolss_DeletePrinterDriverEx_r(b, tctx, &r),
7641                 "DeletePrinterDriverEx failed");
7642         torture_assert_werr_equal(tctx, r.out.result, expected_result,
7643                 "DeletePrinterDriverEx failed with unexpected result");
7644
7645         return true;
7646 }
7647
7648 static bool test_DeletePrinterDriver(struct torture_context *tctx,
7649                                      struct dcerpc_binding_handle *b,
7650                                      const char *server_name,
7651                                      const char *driver,
7652                                      const char *environment)
7653 {
7654         torture_assert(tctx,
7655                 test_DeletePrinterDriver_exp(tctx, b, server_name, driver, "FOOBAR", WERR_INVALID_ENVIRONMENT),
7656                 "failed to delete driver");
7657
7658         torture_assert(tctx,
7659                 test_DeletePrinterDriver_exp(tctx, b, server_name, driver, environment, WERR_OK),
7660                 "failed to delete driver");
7661
7662         if (test_EnumPrinterDrivers_findone(tctx, b, server_name, environment, 1, driver)) {
7663                 torture_fail(tctx, "deleted driver still enumerated");
7664         }
7665
7666         torture_assert(tctx,
7667                 test_DeletePrinterDriver_exp(tctx, b, server_name, driver, environment, WERR_UNKNOWN_PRINTER_DRIVER),
7668                 "2nd delete failed");
7669
7670         return true;
7671 }
7672
7673 static bool test_DeletePrinterDriverEx(struct torture_context *tctx,
7674                                        struct dcerpc_binding_handle *b,
7675                                        const char *server_name,
7676                                        const char *driver,
7677                                        const char *environment,
7678                                        uint32_t delete_flags,
7679                                        uint32_t version)
7680 {
7681         torture_assert(tctx,
7682                 test_DeletePrinterDriverEx_exp(tctx, b, server_name, driver, "FOOBAR", delete_flags, version, WERR_INVALID_ENVIRONMENT),
7683                 "failed to delete driver");
7684
7685         torture_assert(tctx,
7686                 test_DeletePrinterDriverEx_exp(tctx, b, server_name, driver, environment, delete_flags, version, WERR_OK),
7687                 "failed to delete driver");
7688
7689         if (test_EnumPrinterDrivers_findone(tctx, b, server_name, environment, 1, driver)) {
7690                 torture_fail(tctx, "deleted driver still enumerated");
7691         }
7692
7693         torture_assert(tctx,
7694                 test_DeletePrinterDriverEx_exp(tctx, b, server_name, driver, environment, delete_flags, version, WERR_UNKNOWN_PRINTER_DRIVER),
7695                 "2nd delete failed");
7696
7697         return true;
7698 }
7699
7700 static bool test_PrinterDriver_args(struct torture_context *tctx,
7701                                     struct dcerpc_binding_handle *b,
7702                                     const char *server_name,
7703                                     uint32_t level,
7704                                     struct spoolss_AddDriverInfo8 *r,
7705                                     uint32_t add_flags,
7706                                     uint32_t delete_flags,
7707                                     uint32_t delete_version,
7708                                     bool ex)
7709 {
7710         bool ret = true;
7711
7712         switch (level) {
7713         case 1:
7714                 ret = test_AddPrinterDriver_args_level_1(tctx, b, server_name, r, add_flags, ex);
7715                 break;
7716         case 2:
7717                 ret = test_AddPrinterDriver_args_level_2(tctx, b, server_name, r, add_flags, ex);
7718                 break;
7719         case 3:
7720                 ret = test_AddPrinterDriver_args_level_3(tctx, b, server_name, r, add_flags, ex);
7721                 break;
7722         case 4:
7723                 ret = test_AddPrinterDriver_args_level_4(tctx, b, server_name, r, add_flags, ex);
7724                 break;
7725         case 6:
7726                 ret = test_AddPrinterDriver_args_level_6(tctx, b, server_name, r, add_flags, ex);
7727                 break;
7728         case 8:
7729                 ret = test_AddPrinterDriver_args_level_8(tctx, b, server_name, r, add_flags, ex);
7730                 break;
7731         default:
7732                 return false;
7733         }
7734
7735         if (ret == false) {
7736                 return ret;
7737         }
7738
7739         if (level == 1) {
7740                 return ret;
7741         }
7742
7743         /* spoolss_AddPrinterDriver does not deal with level 6 or 8 - gd */
7744
7745         if (!ex && (level == 6 || level == 8)) {
7746                 return ret;
7747         }
7748
7749         if (ex) {
7750                 return test_DeletePrinterDriverEx(tctx, b, server_name, r->driver_name, r->architecture, delete_flags, r->version);
7751         } else {
7752                 return test_DeletePrinterDriver(tctx, b, server_name, r->driver_name, r->architecture);
7753         }
7754 }
7755
7756 static bool fillup_printserver_info(struct torture_context *tctx,
7757                                     struct dcerpc_pipe *p,
7758                                     struct torture_driver_context *d)
7759 {
7760         struct policy_handle server_handle;
7761         struct dcerpc_binding_handle *b = p->binding_handle;
7762         const char *server_name_slash = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
7763
7764         torture_assert(tctx,
7765                 test_OpenPrinter_server(tctx, p, &server_handle),
7766                 "failed to open printserver");
7767         torture_assert(tctx,
7768                 test_get_environment(tctx, b, &server_handle, &d->remote.environment),
7769                 "failed to get environment");
7770         torture_assert(tctx,
7771                 test_ClosePrinter(tctx, b, &server_handle),
7772                 "failed to close printserver");
7773
7774         torture_assert(tctx,
7775                 test_GetPrinterDriverDirectory_getdir(tctx, b, server_name_slash,
7776                         d->local.environment ? d->local.environment : d->remote.environment,
7777                         &d->remote.driver_directory),
7778                 "failed to get driver directory");
7779
7780         return true;
7781 }
7782
7783 static const char *driver_directory_dir(const char *driver_directory)
7784 {
7785         char *p;
7786
7787         p = strrchr(driver_directory, '\\');
7788         if (p) {
7789                 return p+1;
7790         }
7791
7792         return NULL;
7793 }
7794
7795 static const char *driver_directory_share(struct torture_context *tctx,
7796                                           const char *driver_directory)
7797 {
7798         const char *p;
7799         char *tok;
7800
7801         if (driver_directory[0] == '\\' && driver_directory[1] == '\\') {
7802                 driver_directory += 2;
7803         }
7804
7805         p = talloc_strdup(tctx, driver_directory);
7806
7807         torture_assert(tctx,
7808                 next_token_talloc(tctx, &p, &tok, "\\"),
7809                 "cannot explode uri");
7810         torture_assert(tctx,
7811                 next_token_talloc(tctx, &p, &tok, "\\"),
7812                 "cannot explode uri");
7813
7814         return tok;
7815 }
7816
7817 static bool upload_printer_driver_file(struct torture_context *tctx,
7818                                        struct smbcli_state *cli,
7819                                        struct torture_driver_context *d,
7820                                        const char *file_name)
7821 {
7822         XFILE *f;
7823         int fnum;
7824         uint8_t *buf;
7825         int maxwrite = 64512;
7826         off_t nread = 0;
7827         size_t start = 0;
7828         const char *remote_dir = driver_directory_dir(d->remote.driver_directory);
7829         const char *local_name = talloc_asprintf(tctx, "%s/%s", d->local.driver_directory, file_name);
7830         const char *remote_name = talloc_asprintf(tctx, "%s\\%s", remote_dir, file_name);
7831
7832         if (!file_name) {
7833                 return true;
7834         }
7835
7836         torture_comment(tctx, "Uploading %s to %s\n", local_name, remote_name);
7837
7838         fnum = smbcli_open(cli->tree, remote_name, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE);
7839         if (fnum == -1) {
7840                 torture_fail(tctx, talloc_asprintf(tctx, "failed to open remote file: %s\n", remote_name));
7841         }
7842
7843         f = x_fopen(local_name, O_RDONLY, 0);
7844         if (f == NULL) {
7845                 torture_fail(tctx, talloc_asprintf(tctx, "failed to open local file: %s\n", local_name));
7846         }
7847
7848         buf = talloc_array(tctx, uint8_t, maxwrite);
7849         if (!buf) {
7850                 return false;
7851         }
7852
7853         while (!x_feof(f)) {
7854                 int n = maxwrite;
7855                 int ret;
7856
7857                 if ((n = x_fread(buf, 1, n, f)) < 1) {
7858                         if((n == 0) && x_feof(f))
7859                                 break; /* Empty local file. */
7860
7861                         torture_warning(tctx,
7862                                 "failed to read file: %s\n", strerror(errno));
7863                         break;
7864                 }
7865
7866                 ret = smbcli_write(cli->tree, fnum, 0, buf, nread + start, n);
7867
7868                 if (n != ret) {
7869                         torture_warning(tctx,
7870                                 "failed to write file: %s\n", smbcli_errstr(cli->tree));
7871                         break;
7872                 }
7873
7874                 nread += n;
7875         }
7876
7877         x_fclose(f);
7878
7879         torture_assert_ntstatus_ok(tctx,
7880                 smbcli_close(cli->tree, fnum),
7881                 "failed to close file");
7882
7883         return true;
7884 }
7885
7886 static bool connect_printer_driver_share(struct torture_context *tctx,
7887                                          const char *server_name,
7888                                          const char *share_name,
7889                                          struct smbcli_state **cli)
7890 {
7891         struct smbcli_options smb_options;
7892         struct smbcli_session_options smb_session_options;
7893
7894         torture_comment(tctx, "Connecting printer driver share '%s' on '%s'\n",
7895                 share_name, server_name);
7896
7897         lp_smbcli_options(tctx->lp_ctx, &smb_options);
7898         lp_smbcli_session_options(tctx->lp_ctx, &smb_session_options);
7899
7900         torture_assert_ntstatus_ok(tctx,
7901                 smbcli_full_connection(tctx, cli, server_name,
7902                                         lp_smb_ports(tctx->lp_ctx),
7903                                         share_name, NULL,
7904                                         lp_socket_options(tctx->lp_ctx),
7905                                         cmdline_credentials,
7906                                         lp_resolve_context(tctx->lp_ctx),
7907                                         tctx->ev,
7908                                         &smb_options,
7909                                         &smb_session_options,
7910                                         lp_gensec_settings(tctx, tctx->lp_ctx)),
7911                 "failed to open driver share");
7912
7913         return true;
7914 }
7915
7916 static bool upload_printer_driver(struct torture_context *tctx,
7917                                   const char *server_name,
7918                                   struct torture_driver_context *d)
7919 {
7920         struct smbcli_state *cli;
7921         const char *share_name = driver_directory_share(tctx, d->remote.driver_directory);
7922         int i;
7923
7924         torture_assert(tctx,
7925                 connect_printer_driver_share(tctx, server_name, share_name, &cli),
7926                 "failed to connect to driver share");
7927
7928         torture_comment(tctx, "Uploading printer driver files to \\\\%s\\%s\n",
7929                 server_name, share_name);
7930
7931         torture_assert(tctx,
7932                 upload_printer_driver_file(tctx, cli, d, d->info8.driver_path),
7933                 "failed to upload driver_path");
7934         torture_assert(tctx,
7935                 upload_printer_driver_file(tctx, cli, d, d->info8.data_file),
7936                 "failed to upload data_file");
7937         torture_assert(tctx,
7938                 upload_printer_driver_file(tctx, cli, d, d->info8.config_file),
7939                 "failed to upload config_file");
7940         torture_assert(tctx,
7941                 upload_printer_driver_file(tctx, cli, d, d->info8.help_file),
7942                 "failed to upload help_file");
7943         if (d->info8.dependent_files) {
7944                 for (i=0; d->info8.dependent_files->string && d->info8.dependent_files->string[i] != NULL; i++) {
7945                         torture_assert(tctx,
7946                                 upload_printer_driver_file(tctx, cli, d, d->info8.dependent_files->string[i]),
7947                                 "failed to upload dependent_files");
7948                 }
7949         }
7950
7951         talloc_free(cli);
7952
7953         return true;
7954 }
7955
7956 static bool remove_printer_driver_file(struct torture_context *tctx,
7957                                        struct smbcli_state *cli,
7958                                        struct torture_driver_context *d,
7959                                        const char *file_name)
7960 {
7961         const char *remote_name;
7962         const char *remote_dir =  driver_directory_dir(d->remote.driver_directory);
7963
7964         if (!file_name) {
7965                 return true;
7966         }
7967
7968         remote_name = talloc_asprintf(tctx, "%s\\%s", remote_dir, file_name);
7969
7970         torture_comment(tctx, "Removing %s\n", remote_name);
7971
7972         torture_assert_ntstatus_ok(tctx,
7973                 smbcli_unlink(cli->tree, remote_name),
7974                 "failed to unlink");
7975
7976         return true;
7977 }
7978
7979 static bool remove_printer_driver(struct torture_context *tctx,
7980                                   const char *server_name,
7981                                   struct torture_driver_context *d)
7982 {
7983         struct smbcli_state *cli;
7984         const char *share_name = driver_directory_share(tctx, d->remote.driver_directory);
7985         int i;
7986
7987         torture_assert(tctx,
7988                 connect_printer_driver_share(tctx, server_name, share_name, &cli),
7989                 "failed to connect to driver share");
7990
7991         torture_comment(tctx, "Removing printer driver files from \\\\%s\\%s\n",
7992                 server_name, share_name);
7993
7994         torture_assert(tctx,
7995                 remove_printer_driver_file(tctx, cli, d, d->info8.driver_path),
7996                 "failed to remove driver_path");
7997         torture_assert(tctx,
7998                 remove_printer_driver_file(tctx, cli, d, d->info8.data_file),
7999                 "failed to remove data_file");
8000         torture_assert(tctx,
8001                 remove_printer_driver_file(tctx, cli, d, d->info8.config_file),
8002                 "failed to remove config_file");
8003         torture_assert(tctx,
8004                 remove_printer_driver_file(tctx, cli, d, d->info8.help_file),
8005                 "failed to remove help_file");
8006         if (d->info8.dependent_files) {
8007                 for (i=0; d->info8.dependent_files->string && d->info8.dependent_files->string[i] != NULL; i++) {
8008                         if (strequal(d->info8.dependent_files->string[i], d->info8.driver_path) ||
8009                             strequal(d->info8.dependent_files->string[i], d->info8.data_file) ||
8010                             strequal(d->info8.dependent_files->string[i], d->info8.config_file) ||
8011                             strequal(d->info8.dependent_files->string[i], d->info8.help_file)) {
8012                                 continue;
8013                         }
8014                         torture_assert(tctx,
8015                                 remove_printer_driver_file(tctx, cli, d, d->info8.dependent_files->string[i]),
8016                                 "failed to remove dependent_files");
8017                 }
8018         }
8019
8020         talloc_free(cli);
8021
8022         return true;
8023
8024 }
8025
8026 static bool test_add_driver_arg(struct torture_context *tctx,
8027                                 struct dcerpc_pipe *p,
8028                                 struct torture_driver_context *d)
8029 {
8030         bool ret = true;
8031         struct dcerpc_binding_handle *b = p->binding_handle;
8032         const char *server_name_slash = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
8033         uint32_t levels[] = { 1, 2, 3, 4, 6, 8 };
8034         int i;
8035         struct spoolss_AddDriverInfo8 info8;
8036         uint32_t add_flags = APD_COPY_NEW_FILES;
8037         uint32_t delete_flags = 0;
8038
8039         ZERO_STRUCT(info8);
8040
8041         torture_comment(tctx, "Testing PrinterDriver%s '%s' for environment '%s'\n",
8042                 d->ex ? "Ex" : "", d->info8.driver_name, d->local.environment);
8043
8044         torture_assert(tctx,
8045                 fillup_printserver_info(tctx, p, d),
8046                 "failed to fillup printserver info");
8047
8048         if (!directory_exist(d->local.driver_directory)) {
8049                 torture_skip(tctx, "Skipping Printer Driver test as no local driver is available");
8050         }
8051
8052         torture_assert(tctx,
8053                 upload_printer_driver(tctx, dcerpc_server_name(p), d),
8054                 "failed to upload printer driver");
8055
8056         info8.version           = d->info8.version;
8057         info8.driver_name       = d->info8.driver_name;
8058         info8.architecture      = d->local.environment;
8059         info8.driver_path       = d->info8.driver_path;
8060         info8.data_file         = d->info8.data_file;
8061         info8.config_file       = d->info8.config_file;
8062
8063         for (i=0; i < ARRAY_SIZE(levels); i++) {
8064
8065                 if (torture_setting_bool(tctx, "samba3", false)) {
8066                         switch (levels[i]) {
8067                         case 2:
8068                         case 4:
8069                         case 8:
8070                                 torture_comment(tctx, "skipping level %d against samba\n", levels[i]);
8071                                 continue;
8072                         default:
8073                                 break;
8074                         }
8075                 }
8076
8077                 torture_comment(tctx,
8078                         "Testing PrinterDriver%s '%s' add & delete level %d\n",
8079                                 d->ex ? "Ex" : "", info8.driver_name, levels[i]);
8080
8081                 ret &= test_PrinterDriver_args(tctx, b, server_name_slash, levels[i], &info8, add_flags, delete_flags, d->info8.version, d->ex);
8082         }
8083
8084         info8.driver_path       = talloc_asprintf(tctx, "%s\\%s", d->remote.driver_directory, d->info8.driver_path);
8085         info8.data_file         = talloc_asprintf(tctx, "%s\\%s", d->remote.driver_directory, d->info8.data_file);
8086         info8.config_file       = talloc_asprintf(tctx, "%s\\%s", d->remote.driver_directory, d->info8.config_file);
8087
8088         for (i=0; i < ARRAY_SIZE(levels); i++) {
8089
8090                 if (torture_setting_bool(tctx, "samba3", false)) {
8091                         switch (levels[i]) {
8092                         case 2:
8093                         case 4:
8094                         case 8:
8095                                 torture_comment(tctx, "skipping level %d against samba\n", levels[i]);
8096                                 continue;
8097                         default:
8098                                 break;
8099                         }
8100                 }
8101
8102
8103                 torture_comment(tctx,
8104                         "Testing PrinterDriver%s '%s' add & delete level %d (full unc paths)\n",
8105                                 d->ex ? "Ex" : "", info8.driver_name, levels[i]);
8106
8107                 ret &= test_PrinterDriver_args(tctx, b, server_name_slash, levels[i], &info8, add_flags, delete_flags, d->info8.version, d->ex);
8108         }
8109
8110         torture_assert(tctx,
8111                 remove_printer_driver(tctx, dcerpc_server_name(p), d),
8112                 "failed to remove printer driver");
8113
8114         torture_comment(tctx, "\n");
8115
8116         return ret;
8117 }
8118
8119 static bool test_add_driver_ex_64(struct torture_context *tctx,
8120                                   struct dcerpc_pipe *p,
8121                                   void *private_data)
8122 {
8123         struct torture_driver_context *d =
8124                 (struct torture_driver_context *)talloc_get_type_abort(private_data, struct torture_driver_context);
8125
8126         d->local.environment            = talloc_strdup(d, "Windows x64");
8127         d->local.driver_directory       = talloc_strdup(d, "/usr/share/cups/drivers/x64");
8128         d->info8.driver_name            = TORTURE_DRIVER_EX;
8129         d->ex                           = true;
8130
8131         return test_add_driver_arg(tctx, p, d);
8132 }
8133
8134 static bool test_add_driver_ex_32(struct torture_context *tctx,
8135                                   struct dcerpc_pipe *p,
8136                                   void *private_data)
8137 {
8138         struct torture_driver_context *d =
8139                 (struct torture_driver_context *)talloc_get_type_abort(private_data, struct torture_driver_context);
8140
8141         d->local.environment            = talloc_strdup(d, "Windows NT x86");
8142         d->local.driver_directory       = talloc_strdup(d, "/usr/share/cups/drivers/i386");
8143         d->info8.driver_name            = TORTURE_DRIVER_EX;
8144         d->ex                           = true;
8145
8146         return test_add_driver_arg(tctx, p, d);
8147 }
8148
8149 static bool test_add_driver_64(struct torture_context *tctx,
8150                                struct dcerpc_pipe *p,
8151                                void *private_data)
8152 {
8153         struct torture_driver_context *d =
8154                 (struct torture_driver_context *)talloc_get_type_abort(private_data, struct torture_driver_context);
8155
8156         d->local.environment            = talloc_strdup(d, "Windows x64");
8157         d->local.driver_directory       = talloc_strdup(d, "/usr/share/cups/drivers/x64");
8158         d->info8.driver_name            = TORTURE_DRIVER;
8159         d->ex                           = false;
8160
8161         return test_add_driver_arg(tctx, p, d);
8162 }
8163
8164 static bool test_add_driver_32(struct torture_context *tctx,
8165                                struct dcerpc_pipe *p,
8166                                void *private_data)
8167 {
8168         struct torture_driver_context *d =
8169                 (struct torture_driver_context *)talloc_get_type_abort(private_data, struct torture_driver_context);
8170
8171         d->local.environment            = talloc_strdup(d, "Windows NT x86");
8172         d->local.driver_directory       = talloc_strdup(d, "/usr/share/cups/drivers/i386");
8173         d->info8.driver_name            = TORTURE_DRIVER;
8174         d->ex                           = false;
8175
8176         return test_add_driver_arg(tctx, p, d);
8177 }
8178
8179 struct torture_suite *torture_rpc_spoolss_driver(TALLOC_CTX *mem_ctx)
8180 {
8181         struct torture_suite *suite = torture_suite_create(mem_ctx, "SPOOLSS-DRIVER");
8182
8183         struct torture_rpc_tcase *tcase = torture_suite_add_rpc_iface_tcase(suite,
8184                                                         "driver", &ndr_table_spoolss);
8185         struct torture_driver_context *t;
8186
8187         t = talloc_zero(mem_ctx, struct torture_driver_context);
8188
8189         t->info8.version        = SPOOLSS_DRIVER_VERSION_200X;
8190         t->info8.driver_name    = NULL;
8191         t->info8.architecture   = NULL;
8192         t->info8.driver_path    = talloc_strdup(t, "pscript5.dll");
8193         t->info8.data_file      = talloc_strdup(t, "cups6.ppd");
8194         t->info8.config_file    = talloc_strdup(t, "cupsui6.dll");
8195
8196         torture_rpc_tcase_add_test_ex(tcase, "add_driver_64", test_add_driver_64, t);
8197         torture_rpc_tcase_add_test_ex(tcase, "add_driver_ex_64", test_add_driver_ex_64, t);
8198
8199         torture_rpc_tcase_add_test_ex(tcase, "add_driver_32", test_add_driver_32, t);
8200         torture_rpc_tcase_add_test_ex(tcase, "add_driver_ex_32", test_add_driver_ex_32, t);
8201
8202         return suite;
8203 }