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