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