source4/torture/rpc/spoolss.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    test suite for spoolss rpc operations
   4
   5    Copyright (C) Tim Potter 2003
   6    Copyright (C) Stefan Metzmacher 2005
   7    Copyright (C) Jelmer Vernooij 2007
   8    Copyright (C) Guenther Deschner 2009-2010
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25 #include "torture/torture.h"
  26 #include "librpc/gen_ndr/ndr_misc.h"
  27 #include "librpc/gen_ndr/ndr_spoolss.h"
  28 #include "librpc/gen_ndr/ndr_spoolss_c.h"
  29 #include "librpc/gen_ndr/ndr_winreg_c.h"
  30 #include "librpc/gen_ndr/ndr_security.h"
  31 #include "libcli/security/security.h"
  32 #include "torture/rpc/torture_rpc.h"
  33 #include "param/param.h"
  34 #include "lib/registry/registry.h"
  35
  36 #define TORTURE_WELLKNOWN_PRINTER       "torture_wkn_printer"
  37 #define TORTURE_PRINTER                 "torture_printer"
  38 #define TORTURE_WELLKNOWN_PRINTER_EX    "torture_wkn_printer_ex"
  39 #define TORTURE_PRINTER_EX              "torture_printer_ex"
  40
  41 #define TOP_LEVEL_PRINT_KEY "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Print"
  42 #define TOP_LEVEL_PRINT_PRINTERS_KEY TOP_LEVEL_PRINT_KEY "\\Printers"
  43 #define TOP_LEVEL_CONTROL_KEY "SYSTEM\\CurrentControlSet\\Control\\Print"
  44 #define TOP_LEVEL_CONTROL_FORMS_KEY TOP_LEVEL_CONTROL_KEY "\\Forms"
  45 #define TOP_LEVEL_CONTROL_PRINTERS_KEY TOP_LEVEL_CONTROL_KEY "\\Printers"
  46
  47 struct test_spoolss_context {
  48         /* print server handle */
  49         struct policy_handle server_handle;
  50
  51         /* for EnumPorts */
  52         uint32_t port_count[3];
  53         union spoolss_PortInfo *ports[3];
  54
  55         /* for EnumPrinterDrivers */
  56         uint32_t driver_count[8];
  57         union spoolss_DriverInfo *drivers[8];
  58
  59         /* for EnumMonitors */
  60         uint32_t monitor_count[3];
  61         union spoolss_MonitorInfo *monitors[3];
  62
  63         /* for EnumPrintProcessors */
  64         uint32_t print_processor_count[2];
  65         union spoolss_PrintProcessorInfo *print_processors[2];
  66
  67         /* for EnumPrinters */
  68         uint32_t printer_count[6];
  69         union spoolss_PrinterInfo *printers[6];
  70 };
  71
  72 #define COMPARE_STRING(tctx, c,r,e) \
  73         torture_assert_str_equal(tctx, c.e, r.e, "invalid value")
  74
  75 /* not every compiler supports __typeof__() */
  76 #if (__GNUC__ >= 3)
  77 #define _CHECK_FIELD_SIZE(c,r,e,type) do {\
  78         if (sizeof(__typeof__(c.e)) != sizeof(type)) { \
  79                 torture_fail(tctx, #c "." #e "field is not " #type "\n"); \
  80         }\
  81         if (sizeof(__typeof__(r.e)) != sizeof(type)) { \
  82                 torture_fail(tctx, #r "." #e "field is not " #type "\n"); \
  83         }\
  84 } while(0)
  85 #else
  86 #define _CHECK_FIELD_SIZE(c,r,e,type) do {} while(0)
  87 #endif
  88
  89 #define COMPARE_UINT32(tctx, c, r, e) do {\
  90         _CHECK_FIELD_SIZE(c, r, e, uint32_t); \
  91         torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
  92 } while(0)
  93
  94 #define COMPARE_UINT64(tctx, c, r, e) do {\
  95         _CHECK_FIELD_SIZE(c, r, e, uint64_t); \
  96         torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
  97 } while(0)
  98
  99
 100 #define COMPARE_NTTIME(tctx, c, r, e) do {\
 101         _CHECK_FIELD_SIZE(c, r, e, NTTIME); \
 102         torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
 103 } while(0)
 104
 105 #define COMPARE_STRING_ARRAY(tctx, c,r,e) do {\
 106         int __i; \
 107         if (!c.e && !r.e) { \
 108                 break; \
 109         } \
 110         if (c.e && !r.e) { \
 111                 torture_fail(tctx, #r "." #e " field is NULL and " #c "." #e " is not\n"); \
 112         } \
 113         if (!c.e && r.e) { \
 114                 torture_fail(tctx, #c "." #e " field is NULL and " #r "." #e " is not\n"); \
 115         } \
 116         for (__i=0;c.e[__i] != NULL; __i++) { \
 117                 torture_assert_str_equal(tctx, c.e[__i], r.e[__i], "invalid value"); \
 118         } \
 119 } while(0)
 120
 121 #define CHECK_ALIGN(size, n) do {\
 122         if (size % n) {\
 123                 torture_warning(tctx, "%d is *NOT* %d byte aligned, should be %d",\
 124                         size, n, size + n - (size % n));\
 125         }\
 126 } while(0)
 127
 128 #define DO_ROUND(size, n) (((size)+((n)-1)) & ~((n)-1))
 129
 130 #define CHECK_NEEDED_SIZE_ENUM_LEVEL(fn, info, level, count, ic, needed, align) do { \
 131         if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
 132         uint32_t size = ndr_size_##fn##_info(tctx, ic, level, count, info);\
 133         uint32_t round_size = DO_ROUND(size, align);\
 134         if (round_size != needed) {\
 135                 torture_warning(tctx, __location__": "#fn" level %d (count: %d) got unexpected needed size: %d, we calculated: %d", level, count, needed, round_size);\
 136                 CHECK_ALIGN(size, align);\
 137         }\
 138         }\
 139 } while(0)
 140
 141 #define CHECK_NEEDED_SIZE_ENUM(fn, info, count, ic, needed, align) do { \
 142         if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
 143         uint32_t size = ndr_size_##fn##_info(tctx, ic, count, info);\
 144         uint32_t round_size = DO_ROUND(size, align);\
 145         if (round_size != needed) {\
 146                 torture_warning(tctx, __location__": "#fn" (count: %d) got unexpected needed size: %d, we calculated: %d", count, needed, round_size);\
 147                 CHECK_ALIGN(size, align);\
 148         }\
 149         }\
 150 } while(0)
 151
 152 #define CHECK_NEEDED_SIZE_LEVEL(fn, info, level, ic, needed, align) do { \
 153         if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
 154         uint32_t size = ndr_size_##fn(info, level, ic, 0);\
 155         uint32_t round_size = DO_ROUND(size, align);\
 156         if (round_size != needed) {\
 157                 torture_warning(tctx, __location__": "#fn" level %d got unexpected needed size: %d, we calculated: %d", level, needed, round_size);\
 158                 CHECK_ALIGN(size, align);\
 159         }\
 160         }\
 161 } while(0)
 162
 163 static bool PrinterInfo_to_SetPrinterInfo(struct torture_context *tctx,
 164                                           const union spoolss_PrinterInfo *i,
 165                                           uint32_t level,
 166                                           union spoolss_SetPrinterInfo *s)
 167 {
 168         switch (level) {
 169         case 0:
 170                 s->info0                        = talloc(tctx, struct spoolss_SetPrinterInfo0);
 171                 break;
 172         case 2:
 173                 s->info2                        = talloc(tctx, struct spoolss_SetPrinterInfo2);
 174                 s->info2->servername            = i->info2.servername;
 175                 s->info2->printername           = i->info2.printername;
 176                 s->info2->sharename             = i->info2.sharename;
 177                 s->info2->portname              = i->info2.portname;
 178                 s->info2->drivername            = i->info2.drivername;
 179                 s->info2->comment               = i->info2.comment;
 180                 s->info2->location              = i->info2.location;
 181                 s->info2->devmode_ptr           = 0;
 182                 s->info2->sepfile               = i->info2.sepfile;
 183                 s->info2->printprocessor        = i->info2.printprocessor;
 184                 s->info2->datatype              = i->info2.datatype;
 185                 s->info2->parameters            = i->info2.parameters;
 186                 s->info2->secdesc_ptr           = 0;
 187                 s->info2->attributes            = i->info2.attributes;
 188                 s->info2->priority              = i->info2.priority;
 189                 s->info2->defaultpriority       = i->info2.defaultpriority;
 190                 s->info2->starttime             = i->info2.starttime;
 191                 s->info2->untiltime             = i->info2.untiltime;
 192                 s->info2->status                = i->info2.status;
 193                 s->info2->cjobs                 = i->info2.cjobs;
 194                 s->info2->averageppm            = i->info2.averageppm;
 195                 break;
 196         case 3:
 197         case 4:
 198         case 5:
 199         case 6:
 200         case 7:
 201         case 8:
 202         case 9:
 203         default:
 204                 return false;
 205         }
 206
 207         return true;
 208 }
 209
 210 static bool test_OpenPrinter_server(struct torture_context *tctx,
 211                                     struct dcerpc_pipe *p,
 212                                     struct policy_handle *server_handle)
 213 {
 214         NTSTATUS status;
 215         struct spoolss_OpenPrinter op;
 216         struct dcerpc_binding_handle *b = p->binding_handle;
 217
 218         op.in.printername       = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 219         op.in.datatype          = NULL;
 220         op.in.devmode_ctr.devmode= NULL;
 221         op.in.access_mask       = 0;
 222         op.out.handle           = server_handle;
 223
 224         torture_comment(tctx, "Testing OpenPrinter(%s)\n", op.in.printername);
 225
 226         status = dcerpc_spoolss_OpenPrinter_r(b, tctx, &op);
 227         torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_OpenPrinter failed");
 228         torture_assert_werr_ok(tctx, op.out.result, "dcerpc_spoolss_OpenPrinter failed");
 229
 230         return true;
 231 }
 232
 233 static bool test_EnumPorts(struct torture_context *tctx,
 234                            struct dcerpc_binding_handle *b,
 235                            struct test_spoolss_context *ctx)
 236 {
 237         NTSTATUS status;
 238         struct spoolss_EnumPorts r;
 239         uint16_t levels[] = { 1, 2 };
 240         int i, j;
 241
 242         for (i=0;i<ARRAY_SIZE(levels);i++) {
 243                 int level = levels[i];
 244                 DATA_BLOB blob;
 245                 uint32_t needed;
 246                 uint32_t count;
 247                 union spoolss_PortInfo *info;
 248
 249                 r.in.servername = "";
 250                 r.in.level = level;
 251                 r.in.buffer = NULL;
 252                 r.in.offered = 0;
 253                 r.out.needed = &needed;
 254                 r.out.count = &count;
 255                 r.out.info = &info;
 256
 257                 torture_comment(tctx, "Testing EnumPorts level %u\n", r.in.level);
 258
 259                 status = dcerpc_spoolss_EnumPorts_r(b, ctx, &r);
 260                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
 261                 if (W_ERROR_IS_OK(r.out.result)) {
 262                         /* TODO: do some more checks here */
 263                         continue;
 264                 }
 265                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 266                         "EnumPorts unexpected return code");
 267
 268                 blob = data_blob_talloc_zero(ctx, needed);
 269                 r.in.buffer = &blob;
 270                 r.in.offered = needed;
 271
 272                 status = dcerpc_spoolss_EnumPorts_r(b, ctx, &r);
 273                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
 274
 275                 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
 276
 277                 torture_assert(tctx, info, "EnumPorts returned no info");
 278
 279                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPorts, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
 280
 281                 ctx->port_count[level]  = count;
 282                 ctx->ports[level]       = info;
 283         }
 284
 285         for (i=1;i<ARRAY_SIZE(levels);i++) {
 286                 int level = levels[i];
 287                 int old_level = levels[i-1];
 288                 torture_assert_int_equal(tctx, ctx->port_count[level], ctx->port_count[old_level],
 289                         "EnumPorts invalid value");
 290         }
 291         /* if the array sizes are not the same we would maybe segfault in the following code */
 292
 293         for (i=0;i<ARRAY_SIZE(levels);i++) {
 294                 int level = levels[i];
 295                 for (j=0;j<ctx->port_count[level];j++) {
 296                         union spoolss_PortInfo *cur = &ctx->ports[level][j];
 297                         union spoolss_PortInfo *ref = &ctx->ports[2][j];
 298                         switch (level) {
 299                         case 1:
 300                                 COMPARE_STRING(tctx, cur->info1, ref->info2, port_name);
 301                                 break;
 302                         case 2:
 303                                 /* level 2 is our reference, and it makes no sense to compare it to itself */
 304                                 break;
 305                         }
 306                 }
 307         }
 308
 309         return true;
 310 }
 311
 312 static bool test_GetPrintProcessorDirectory(struct torture_context *tctx,
 313                                             struct dcerpc_pipe *p,
 314                                             const char *environment)
 315 {
 316         NTSTATUS status;
 317         struct dcerpc_binding_handle *b = p->binding_handle;
 318         struct spoolss_GetPrintProcessorDirectory r;
 319         struct {
 320                 uint16_t level;
 321                 const char *server;
 322         } levels[] = {{
 323                         .level  = 1,
 324                         .server = NULL
 325                 },{
 326                         .level  = 1,
 327                         .server = ""
 328                 },{
 329                         .level  = 78,
 330                         .server = ""
 331                 },{
 332                         .level  = 1,
 333                         .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
 334                 },{
 335                         .level  = 1024,
 336                         .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
 337                 }
 338         };
 339         int i;
 340         uint32_t needed;
 341
 342         for (i=0;i<ARRAY_SIZE(levels);i++) {
 343                 int level = levels[i].level;
 344                 DATA_BLOB blob;
 345
 346                 r.in.server             = levels[i].server;
 347                 r.in.environment        = environment;
 348                 r.in.level              = level;
 349                 r.in.buffer             = NULL;
 350                 r.in.offered            = 0;
 351                 r.out.needed            = &needed;
 352
 353                 torture_comment(tctx, "Testing GetPrintProcessorDirectory level %u\n", r.in.level);
 354
 355                 status = dcerpc_spoolss_GetPrintProcessorDirectory_r(b, tctx, &r);
 356                 torture_assert_ntstatus_ok(tctx, status,
 357                         "dcerpc_spoolss_GetPrintProcessorDirectory failed");
 358                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 359                         "GetPrintProcessorDirectory unexpected return code");
 360
 361                 blob = data_blob_talloc_zero(tctx, needed);
 362                 r.in.buffer = &blob;
 363                 r.in.offered = needed;
 364
 365                 status = dcerpc_spoolss_GetPrintProcessorDirectory_r(b, tctx, &r);
 366                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrintProcessorDirectory failed");
 367
 368                 torture_assert_werr_ok(tctx, r.out.result, "GetPrintProcessorDirectory failed");
 369
 370                 CHECK_NEEDED_SIZE_LEVEL(spoolss_PrintProcessorDirectoryInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 2);
 371         }
 372
 373         return true;
 374 }
 375
 376
 377 static bool test_GetPrinterDriverDirectory(struct torture_context *tctx,
 378                                            struct dcerpc_pipe *p,
 379                                            const char *environment)
 380 {
 381         NTSTATUS status;
 382         struct dcerpc_binding_handle *b = p->binding_handle;
 383         struct spoolss_GetPrinterDriverDirectory r;
 384         struct {
 385                 uint16_t level;
 386                 const char *server;
 387         } levels[] = {{
 388                         .level  = 1,
 389                         .server = NULL
 390                 },{
 391                         .level  = 1,
 392                         .server = ""
 393                 },{
 394                         .level  = 78,
 395                         .server = ""
 396                 },{
 397                         .level  = 1,
 398                         .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
 399                 },{
 400                         .level  = 1024,
 401                         .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
 402                 }
 403         };
 404         int i;
 405         uint32_t needed;
 406
 407         for (i=0;i<ARRAY_SIZE(levels);i++) {
 408                 int level = levels[i].level;
 409                 DATA_BLOB blob;
 410
 411                 r.in.server             = levels[i].server;
 412                 r.in.environment        = environment;
 413                 r.in.level              = level;
 414                 r.in.buffer             = NULL;
 415                 r.in.offered            = 0;
 416                 r.out.needed            = &needed;
 417
 418                 torture_comment(tctx, "Testing GetPrinterDriverDirectory level %u\n", r.in.level);
 419
 420                 status = dcerpc_spoolss_GetPrinterDriverDirectory_r(b, tctx, &r);
 421                 torture_assert_ntstatus_ok(tctx, status,
 422                         "dcerpc_spoolss_GetPrinterDriverDirectory failed");
 423                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 424                         "GetPrinterDriverDirectory unexpected return code");
 425
 426                 blob = data_blob_talloc_zero(tctx, needed);
 427                 r.in.buffer = &blob;
 428                 r.in.offered = needed;
 429
 430                 status = dcerpc_spoolss_GetPrinterDriverDirectory_r(b, tctx, &r);
 431                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrinterDriverDirectory failed");
 432
 433                 torture_assert_werr_ok(tctx, r.out.result, "GetPrinterDriverDirectory failed");
 434
 435                 CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverDirectoryInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 2);
 436         }
 437
 438         return true;
 439 }
 440
 441 static bool test_EnumPrinterDrivers(struct torture_context *tctx,
 442                                     struct dcerpc_pipe *p,
 443                                     struct test_spoolss_context *ctx,
 444                                     const char *architecture)
 445 {
 446         NTSTATUS status;
 447         struct dcerpc_binding_handle *b = p->binding_handle;
 448         struct spoolss_EnumPrinterDrivers r;
 449         uint16_t levels[] = { 1, 2, 3, 4, 5, 6, 8 };
 450         int i, j;
 451
 452         for (i=0;i<ARRAY_SIZE(levels);i++) {
 453                 int level = levels[i];
 454                 DATA_BLOB blob;
 455                 uint32_t needed;
 456                 uint32_t count;
 457                 union spoolss_DriverInfo *info;
 458
 459                 /* FIXME: gd, come back and fix "" as server, and handle
 460                  * priority of returned error codes in torture test and samba 3
 461                  * server */
 462
 463                 r.in.server             = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 464                 r.in.environment        = architecture;
 465                 r.in.level              = level;
 466                 r.in.buffer             = NULL;
 467                 r.in.offered            = 0;
 468                 r.out.needed            = &needed;
 469                 r.out.count             = &count;
 470                 r.out.info              = &info;
 471
 472                 torture_comment(tctx, "Testing EnumPrinterDrivers level %u (%s)\n", r.in.level, r.in.environment);
 473
 474                 status = dcerpc_spoolss_EnumPrinterDrivers_r(b, ctx, &r);
 475                 torture_assert_ntstatus_ok(tctx, status,
 476                                            "dcerpc_spoolss_EnumPrinterDrivers failed");
 477                 if (W_ERROR_IS_OK(r.out.result)) {
 478                         /* TODO: do some more checks here */
 479                         continue;
 480                 }
 481                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 482                         blob = data_blob_talloc_zero(ctx, needed);
 483                         r.in.buffer = &blob;
 484                         r.in.offered = needed;
 485
 486                         status = dcerpc_spoolss_EnumPrinterDrivers_r(b, ctx, &r);
 487                         torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinterDrivers failed");
 488                 }
 489
 490                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDrivers failed");
 491
 492                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinterDrivers, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
 493
 494                 ctx->driver_count[level]        = count;
 495                 ctx->drivers[level]             = info;
 496         }
 497
 498         for (i=1;i<ARRAY_SIZE(levels);i++) {
 499                 int level = levels[i];
 500                 int old_level = levels[i-1];
 501
 502                 torture_assert_int_equal(tctx, ctx->driver_count[level], ctx->driver_count[old_level],
 503                         "EnumPrinterDrivers invalid value");
 504         }
 505
 506         for (i=0;i<ARRAY_SIZE(levels);i++) {
 507                 int level = levels[i];
 508
 509                 for (j=0;j<ctx->driver_count[level];j++) {
 510                         union spoolss_DriverInfo *cur = &ctx->drivers[level][j];
 511                         union spoolss_DriverInfo *ref = &ctx->drivers[8][j];
 512
 513                         switch (level) {
 514                         case 1:
 515                                 COMPARE_STRING(tctx, cur->info1, ref->info8, driver_name);
 516                                 break;
 517                         case 2:
 518                                 COMPARE_UINT32(tctx, cur->info2, ref->info8, version);
 519                                 COMPARE_STRING(tctx, cur->info2, ref->info8, driver_name);
 520                                 COMPARE_STRING(tctx, cur->info2, ref->info8, architecture);
 521                                 COMPARE_STRING(tctx, cur->info2, ref->info8, driver_path);
 522                                 COMPARE_STRING(tctx, cur->info2, ref->info8, data_file);
 523                                 COMPARE_STRING(tctx, cur->info2, ref->info8, config_file);
 524                                 break;
 525                         case 3:
 526                                 COMPARE_UINT32(tctx, cur->info3, ref->info8, version);
 527                                 COMPARE_STRING(tctx, cur->info3, ref->info8, driver_name);
 528                                 COMPARE_STRING(tctx, cur->info3, ref->info8, architecture);
 529                                 COMPARE_STRING(tctx, cur->info3, ref->info8, driver_path);
 530                                 COMPARE_STRING(tctx, cur->info3, ref->info8, data_file);
 531                                 COMPARE_STRING(tctx, cur->info3, ref->info8, config_file);
 532                                 COMPARE_STRING(tctx, cur->info3, ref->info8, help_file);
 533                                 COMPARE_STRING_ARRAY(tctx, cur->info3, ref->info8, dependent_files);
 534                                 COMPARE_STRING(tctx, cur->info3, ref->info8, monitor_name);
 535                                 COMPARE_STRING(tctx, cur->info3, ref->info8, default_datatype);
 536                                 break;
 537                         case 4:
 538                                 COMPARE_UINT32(tctx, cur->info4, ref->info8, version);
 539                                 COMPARE_STRING(tctx, cur->info4, ref->info8, driver_name);
 540                                 COMPARE_STRING(tctx, cur->info4, ref->info8, architecture);
 541                                 COMPARE_STRING(tctx, cur->info4, ref->info8, driver_path);
 542                                 COMPARE_STRING(tctx, cur->info4, ref->info8, data_file);
 543                                 COMPARE_STRING(tctx, cur->info4, ref->info8, config_file);
 544                                 COMPARE_STRING(tctx, cur->info4, ref->info8, help_file);
 545                                 COMPARE_STRING_ARRAY(tctx, cur->info4, ref->info8, dependent_files);
 546                                 COMPARE_STRING(tctx, cur->info4, ref->info8, monitor_name);
 547                                 COMPARE_STRING(tctx, cur->info4, ref->info8, default_datatype);
 548                                 COMPARE_STRING_ARRAY(tctx, cur->info4, ref->info8, previous_names);
 549                                 break;
 550                         case 5:
 551                                 COMPARE_UINT32(tctx, cur->info5, ref->info8, version);
 552                                 COMPARE_STRING(tctx, cur->info5, ref->info8, driver_name);
 553                                 COMPARE_STRING(tctx, cur->info5, ref->info8, architecture);
 554                                 COMPARE_STRING(tctx, cur->info5, ref->info8, driver_path);
 555                                 COMPARE_STRING(tctx, cur->info5, ref->info8, data_file);
 556                                 COMPARE_STRING(tctx, cur->info5, ref->info8, config_file);
 557                                 /*COMPARE_UINT32(tctx, cur->info5, ref->info8, driver_attributes);*/
 558                                 /*COMPARE_UINT32(tctx, cur->info5, ref->info8, config_version);*/
 559                                 /*TODO: ! COMPARE_UINT32(tctx, cur->info5, ref->info8, driver_version); */
 560                                 break;
 561                         case 6:
 562                                 COMPARE_UINT32(tctx, cur->info6, ref->info8, version);
 563                                 COMPARE_STRING(tctx, cur->info6, ref->info8, driver_name);
 564                                 COMPARE_STRING(tctx, cur->info6, ref->info8, architecture);
 565                                 COMPARE_STRING(tctx, cur->info6, ref->info8, driver_path);
 566                                 COMPARE_STRING(tctx, cur->info6, ref->info8, data_file);
 567                                 COMPARE_STRING(tctx, cur->info6, ref->info8, config_file);
 568                                 COMPARE_STRING(tctx, cur->info6, ref->info8, help_file);
 569                                 COMPARE_STRING_ARRAY(tctx, cur->info6, ref->info8, dependent_files);
 570                                 COMPARE_STRING(tctx, cur->info6, ref->info8, monitor_name);
 571                                 COMPARE_STRING(tctx, cur->info6, ref->info8, default_datatype);
 572                                 COMPARE_STRING_ARRAY(tctx, cur->info6, ref->info8, previous_names);
 573                                 COMPARE_NTTIME(tctx, cur->info6, ref->info8, driver_date);
 574                                 COMPARE_UINT64(tctx, cur->info6, ref->info8, driver_version);
 575                                 COMPARE_STRING(tctx, cur->info6, ref->info8, manufacturer_name);
 576                                 COMPARE_STRING(tctx, cur->info6, ref->info8, manufacturer_url);
 577                                 COMPARE_STRING(tctx, cur->info6, ref->info8, hardware_id);
 578                                 COMPARE_STRING(tctx, cur->info6, ref->info8, provider);
 579                                 break;
 580                         case 8:
 581                                 /* level 8 is our reference, and it makes no sense to compare it to itself */
 582                                 break;
 583                         }
 584                 }
 585         }
 586
 587         return true;
 588 }
 589
 590 static bool test_EnumMonitors(struct torture_context *tctx,
 591                               struct dcerpc_binding_handle *b,
 592                               struct test_spoolss_context *ctx)
 593 {
 594         NTSTATUS status;
 595         struct spoolss_EnumMonitors r;
 596         uint16_t levels[] = { 1, 2 };
 597         int i, j;
 598
 599         for (i=0;i<ARRAY_SIZE(levels);i++) {
 600                 int level = levels[i];
 601                 DATA_BLOB blob;
 602                 uint32_t needed;
 603                 uint32_t count;
 604                 union spoolss_MonitorInfo *info;
 605
 606                 r.in.servername = "";
 607                 r.in.level = level;
 608                 r.in.buffer = NULL;
 609                 r.in.offered = 0;
 610                 r.out.needed = &needed;
 611                 r.out.count = &count;
 612                 r.out.info = &info;
 613
 614                 torture_comment(tctx, "Testing EnumMonitors level %u\n", r.in.level);
 615
 616                 status = dcerpc_spoolss_EnumMonitors_r(b, ctx, &r);
 617                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
 618                 if (W_ERROR_IS_OK(r.out.result)) {
 619                         /* TODO: do some more checks here */
 620                         continue;
 621                 }
 622                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 623                         "EnumMonitors failed");
 624
 625                 blob = data_blob_talloc_zero(ctx, needed);
 626                 r.in.buffer = &blob;
 627                 r.in.offered = needed;
 628
 629                 status = dcerpc_spoolss_EnumMonitors_r(b, ctx, &r);
 630                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
 631
 632                 torture_assert_werr_ok(tctx, r.out.result, "EnumMonitors failed");
 633
 634                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumMonitors, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
 635
 636                 ctx->monitor_count[level]       = count;
 637                 ctx->monitors[level]            = info;
 638         }
 639
 640         for (i=1;i<ARRAY_SIZE(levels);i++) {
 641                 int level = levels[i];
 642                 int old_level = levels[i-1];
 643                 torture_assert_int_equal(tctx, ctx->monitor_count[level], ctx->monitor_count[old_level],
 644                                          "EnumMonitors invalid value");
 645         }
 646
 647         for (i=0;i<ARRAY_SIZE(levels);i++) {
 648                 int level = levels[i];
 649                 for (j=0;j<ctx->monitor_count[level];j++) {
 650                         union spoolss_MonitorInfo *cur = &ctx->monitors[level][j];
 651                         union spoolss_MonitorInfo *ref = &ctx->monitors[2][j];
 652                         switch (level) {
 653                         case 1:
 654                                 COMPARE_STRING(tctx, cur->info1, ref->info2, monitor_name);
 655                                 break;
 656                         case 2:
 657                                 /* level 2 is our reference, and it makes no sense to compare it to itself */
 658                                 break;
 659                         }
 660                 }
 661         }
 662
 663         return true;
 664 }
 665
 666 static bool test_EnumPrintProcessors(struct torture_context *tctx,
 667                                      struct dcerpc_binding_handle *b,
 668                                      struct test_spoolss_context *ctx,
 669                                      const char *environment)
 670 {
 671         NTSTATUS status;
 672         struct spoolss_EnumPrintProcessors r;
 673         uint16_t levels[] = { 1 };
 674         int i, j;
 675
 676         for (i=0;i<ARRAY_SIZE(levels);i++) {
 677                 int level = levels[i];
 678                 DATA_BLOB blob;
 679                 uint32_t needed;
 680                 uint32_t count;
 681                 union spoolss_PrintProcessorInfo *info;
 682
 683                 r.in.servername = "";
 684                 r.in.environment = environment;
 685                 r.in.level = level;
 686                 r.in.buffer = NULL;
 687                 r.in.offered = 0;
 688                 r.out.needed = &needed;
 689                 r.out.count = &count;
 690                 r.out.info = &info;
 691
 692                 torture_comment(tctx, "Testing EnumPrintProcessors level %u\n", r.in.level);
 693
 694                 status = dcerpc_spoolss_EnumPrintProcessors_r(b, ctx, &r);
 695                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcessors failed");
 696                 if (W_ERROR_IS_OK(r.out.result)) {
 697                         /* TODO: do some more checks here */
 698                         continue;
 699                 }
 700                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 701                         "EnumPrintProcessors unexpected return code");
 702
 703                 blob = data_blob_talloc_zero(ctx, needed);
 704                 r.in.buffer = &blob;
 705                 r.in.offered = needed;
 706
 707                 status = dcerpc_spoolss_EnumPrintProcessors_r(b, ctx, &r);
 708                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcessors failed");
 709
 710                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcessors failed");
 711
 712                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcessors, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
 713
 714                 ctx->print_processor_count[level]       = count;
 715                 ctx->print_processors[level]            = info;
 716         }
 717
 718         for (i=1;i<ARRAY_SIZE(levels);i++) {
 719                 int level = levels[i];
 720                 int old_level = levels[i-1];
 721                 torture_assert_int_equal(tctx, ctx->print_processor_count[level], ctx->print_processor_count[old_level],
 722                         "EnumPrintProcessors failed");
 723         }
 724
 725         for (i=0;i<ARRAY_SIZE(levels);i++) {
 726                 int level = levels[i];
 727                 for (j=0;j<ctx->print_processor_count[level];j++) {
 728 #if 0
 729                         union spoolss_PrintProcessorInfo *cur = &ctx->print_processors[level][j];
 730                         union spoolss_PrintProcessorInfo *ref = &ctx->print_processors[1][j];
 731 #endif
 732                         switch (level) {
 733                         case 1:
 734                                 /* level 1 is our reference, and it makes no sense to compare it to itself */
 735                                 break;
 736                         }
 737                 }
 738         }
 739
 740         return true;
 741 }
 742
 743 static bool test_EnumPrintProcDataTypes(struct torture_context *tctx,
 744                                         struct dcerpc_binding_handle *b)
 745 {
 746         NTSTATUS status;
 747         struct spoolss_EnumPrintProcDataTypes r;
 748         uint16_t levels[] = { 1 };
 749         int i;
 750
 751         for (i=0;i<ARRAY_SIZE(levels);i++) {
 752                 int level = levels[i];
 753                 DATA_BLOB blob;
 754                 uint32_t needed;
 755                 uint32_t count;
 756                 union spoolss_PrintProcDataTypesInfo *info;
 757
 758                 r.in.servername = "";
 759                 r.in.print_processor_name = "winprint";
 760                 r.in.level = level;
 761                 r.in.buffer = NULL;
 762                 r.in.offered = 0;
 763                 r.out.needed = &needed;
 764                 r.out.count = &count;
 765                 r.out.info = &info;
 766
 767                 torture_comment(tctx, "Testing EnumPrintProcDataTypes level %u\n", r.in.level);
 768
 769                 status = dcerpc_spoolss_EnumPrintProcDataTypes_r(b, tctx, &r);
 770                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcDataType failed");
 771                 if (W_ERROR_IS_OK(r.out.result)) {
 772                         /* TODO: do some more checks here */
 773                         continue;
 774                 }
 775                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 776                         "EnumPrintProcDataTypes unexpected return code");
 777
 778                 blob = data_blob_talloc_zero(tctx, needed);
 779                 r.in.buffer = &blob;
 780                 r.in.offered = needed;
 781
 782                 status = dcerpc_spoolss_EnumPrintProcDataTypes_r(b, tctx, &r);
 783                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcDataTypes failed");
 784
 785                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcDataTypes failed");
 786
 787                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcDataTypes, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
 788
 789         }
 790
 791         return true;
 792 }
 793
 794
 795 static bool test_EnumPrinters(struct torture_context *tctx,
 796                               struct dcerpc_binding_handle *b,
 797                               struct test_spoolss_context *ctx)
 798 {
 799         struct spoolss_EnumPrinters r;
 800         NTSTATUS status;
 801         uint16_t levels[] = { 0, 1, 2, 4, 5 };
 802         int i, j;
 803
 804         for (i=0;i<ARRAY_SIZE(levels);i++) {
 805                 int level = levels[i];
 806                 DATA_BLOB blob;
 807                 uint32_t needed;
 808                 uint32_t count;
 809                 union spoolss_PrinterInfo *info;
 810
 811                 r.in.flags      = PRINTER_ENUM_LOCAL;
 812                 r.in.server     = "";
 813                 r.in.level      = level;
 814                 r.in.buffer     = NULL;
 815                 r.in.offered    = 0;
 816                 r.out.needed    = &needed;
 817                 r.out.count     = &count;
 818                 r.out.info      = &info;
 819
 820                 torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
 821
 822                 status = dcerpc_spoolss_EnumPrinters_r(b, ctx, &r);
 823                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
 824                 if (W_ERROR_IS_OK(r.out.result)) {
 825                         /* TODO: do some more checks here */
 826                         continue;
 827                 }
 828                 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
 829                         "EnumPrinters unexpected return code");
 830
 831                 blob = data_blob_talloc_zero(ctx, needed);
 832                 r.in.buffer = &blob;
 833                 r.in.offered = needed;
 834
 835                 status = dcerpc_spoolss_EnumPrinters_r(b, ctx, &r);
 836                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
 837
 838                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
 839
 840                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
 841
 842                 ctx->printer_count[level]       = count;
 843                 ctx->printers[level]            = info;
 844         }
 845
 846         for (i=1;i<ARRAY_SIZE(levels);i++) {
 847                 int level = levels[i];
 848                 int old_level = levels[i-1];
 849                 torture_assert_int_equal(tctx, ctx->printer_count[level], ctx->printer_count[old_level],
 850                                          "EnumPrinters invalid value");
 851         }
 852
 853         for (i=0;i<ARRAY_SIZE(levels);i++) {
 854                 int level = levels[i];
 855                 for (j=0;j<ctx->printer_count[level];j++) {
 856                         union spoolss_PrinterInfo *cur = &ctx->printers[level][j];
 857                         union spoolss_PrinterInfo *ref = &ctx->printers[2][j];
 858                         switch (level) {
 859                         case 0:
 860                                 COMPARE_STRING(tctx, cur->info0, ref->info2, printername);
 861                                 COMPARE_STRING(tctx, cur->info0, ref->info2, servername);
 862                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, cjobs);
 863                                 /*COMPARE_UINT32(tctx, cur->info0, ref->info2, total_jobs);
 864                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, total_bytes);
 865                                 COMPARE_SPOOLSS_TIME(cur->info0, ref->info2, spoolss_Time time);
 866                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, global_counter);
 867                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, total_pages);
 868                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, version);
 869                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown10);
 870                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown11);
 871                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown12);
 872                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, session_counter);
 873                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown14);
 874                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, printer_errors);
 875                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown16);
 876                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown17);
 877                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown18);
 878                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown19);
 879                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, change_id);
 880                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown21);*/
 881                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, status);
 882                                 /*COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown23);
 883                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, c_setprinter);
 884                                 COMPARE_UINT16(cur->info0, ref->info2, unknown25);
 885                                 COMPARE_UINT16(cur->info0, ref->info2, unknown26);
 886                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown27);
 887                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown28);
 888                                 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown29);*/
 889                                 break;
 890                         case 1:
 891                                 /*COMPARE_UINT32(tctx, cur->info1, ref->info2, flags);*/
 892                                 /*COMPARE_STRING(tctx, cur->info1, ref->info2, name);*/
 893                                 /*COMPARE_STRING(tctx, cur->info1, ref->info2, description);*/
 894                                 COMPARE_STRING(tctx, cur->info1, ref->info2, comment);
 895                                 break;
 896                         case 2:
 897                                 /* level 2 is our reference, and it makes no sense to compare it to itself */
 898                                 break;
 899                         case 4:
 900                                 COMPARE_STRING(tctx, cur->info4, ref->info2, printername);
 901                                 COMPARE_STRING(tctx, cur->info4, ref->info2, servername);
 902                                 COMPARE_UINT32(tctx, cur->info4, ref->info2, attributes);
 903                                 break;
 904                         case 5:
 905                                 COMPARE_STRING(tctx, cur->info5, ref->info2, printername);
 906                                 COMPARE_STRING(tctx, cur->info5, ref->info2, portname);
 907                                 COMPARE_UINT32(tctx, cur->info5, ref->info2, attributes);
 908                                 /*COMPARE_UINT32(tctx, cur->info5, ref->info2, device_not_selected_timeout);
 909                                 COMPARE_UINT32(tctx, cur->info5, ref->info2, transmission_retry_timeout);*/
 910                                 break;
 911                         }
 912                 }
 913         }
 914
 915         /* TODO:
 916          *      - verify that the port of a printer was in the list returned by EnumPorts
 917          */
 918
 919         return true;
 920 }
 921
 922 static bool test_GetPrinterDriver2(struct torture_context *tctx,
 923                                    struct dcerpc_binding_handle *b,
 924                                    struct policy_handle *handle,
 925                                    const char *driver_name,
 926                                    const char *environment);
 927
 928 bool test_GetPrinter_level(struct torture_context *tctx,
 929                            struct dcerpc_binding_handle *b,
 930                            struct policy_handle *handle,
 931                            uint32_t level,
 932                            union spoolss_PrinterInfo *info)
 933 {
 934         struct spoolss_GetPrinter r;
 935         uint32_t needed;
 936
 937         r.in.handle = handle;
 938         r.in.level = level;
 939         r.in.buffer = NULL;
 940         r.in.offered = 0;
 941         r.out.needed = &needed;
 942
 943         torture_comment(tctx, "Testing GetPrinter level %u\n", r.in.level);
 944
 945         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinter_r(b, tctx, &r),
 946                 "GetPrinter failed");
 947
 948         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 949                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
 950                 r.in.buffer = &blob;
 951                 r.in.offered = needed;
 952
 953                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinter_r(b, tctx, &r),
 954                         "GetPrinter failed");
 955         }
 956
 957         torture_assert_werr_ok(tctx, r.out.result, "GetPrinter failed");
 958
 959         CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
 960
 961         if (info && r.out.info) {
 962                 *info = *r.out.info;
 963         }
 964
 965         return true;
 966 }
 967
 968
 969 static bool test_GetPrinter(struct torture_context *tctx,
 970                             struct dcerpc_binding_handle *b,
 971                             struct policy_handle *handle,
 972                             const char *environment)
 973 {
 974         uint32_t levels[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
 975         int i;
 976
 977         for (i=0;i<ARRAY_SIZE(levels);i++) {
 978
 979                 union spoolss_PrinterInfo info;
 980
 981                 ZERO_STRUCT(info);
 982
 983                 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, levels[i], &info),
 984                         "failed to call GetPrinter");
 985
 986                 if ((levels[i] == 2) && info.info2.drivername && strlen(info.info2.drivername)) {
 987                         torture_assert(tctx,
 988                                 test_GetPrinterDriver2(tctx, b, handle, info.info2.drivername, environment),
 989                                 "failed to call test_GetPrinterDriver2");
 990                 }
 991         }
 992
 993         return true;
 994 }
 995
 996 static bool test_SetPrinter(struct torture_context *tctx,
 997                             struct dcerpc_binding_handle *b,
 998                             struct policy_handle *handle,
 999                             struct spoolss_SetPrinterInfoCtr *info_ctr,
1000                             struct spoolss_DevmodeContainer *devmode_ctr,
1001                             struct sec_desc_buf *secdesc_ctr,
1002                             enum spoolss_PrinterControl command)
1003 {
1004         struct spoolss_SetPrinter r;
1005
1006         r.in.handle = handle;
1007         r.in.info_ctr = info_ctr;
1008         r.in.devmode_ctr = devmode_ctr;
1009         r.in.secdesc_ctr = secdesc_ctr;
1010         r.in.command = command;
1011
1012         torture_comment(tctx, "Testing SetPrinter level %d\n", r.in.info_ctr->level);
1013
1014         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r),
1015                 "failed to call SetPrinter");
1016         torture_assert_werr_ok(tctx, r.out.result,
1017                 "failed to call SetPrinter");
1018
1019         return true;
1020 }
1021
1022 static bool test_SetPrinter_errors(struct torture_context *tctx,
1023                                    struct dcerpc_binding_handle *b,
1024                                    struct policy_handle *handle)
1025 {
1026         struct spoolss_SetPrinter r;
1027         uint16_t levels[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
1028         int i;
1029
1030         struct spoolss_SetPrinterInfoCtr info_ctr;
1031         struct spoolss_DevmodeContainer devmode_ctr;
1032         struct sec_desc_buf secdesc_ctr;
1033
1034         info_ctr.level = 0;
1035         info_ctr.info.info0 = NULL;
1036
1037         ZERO_STRUCT(devmode_ctr);
1038         ZERO_STRUCT(secdesc_ctr);
1039
1040         r.in.handle = handle;
1041         r.in.info_ctr = &info_ctr;
1042         r.in.devmode_ctr = &devmode_ctr;
1043         r.in.secdesc_ctr = &secdesc_ctr;
1044         r.in.command = 0;
1045
1046         torture_comment(tctx, "Testing SetPrinter all zero\n");
1047
1048         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r),
1049                 "failed to call SetPrinter");
1050         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
1051                 "failed to call SetPrinter");
1052
1053  again:
1054         for (i=0; i < ARRAY_SIZE(levels); i++) {
1055
1056                 struct spoolss_SetPrinterInfo0 info0;
1057                 struct spoolss_SetPrinterInfo1 info1;
1058                 struct spoolss_SetPrinterInfo2 info2;
1059                 struct spoolss_SetPrinterInfo3 info3;
1060                 struct spoolss_SetPrinterInfo4 info4;
1061                 struct spoolss_SetPrinterInfo5 info5;
1062                 struct spoolss_SetPrinterInfo6 info6;
1063                 struct spoolss_SetPrinterInfo7 info7;
1064                 struct spoolss_SetPrinterInfo8 info8;
1065                 struct spoolss_SetPrinterInfo9 info9;
1066
1067
1068                 info_ctr.level = levels[i];
1069                 switch (levels[i]) {
1070                 case 0:
1071                         ZERO_STRUCT(info0);
1072                         info_ctr.info.info0 = &info0;
1073                         break;
1074                 case 1:
1075                         ZERO_STRUCT(info1);
1076                         info_ctr.info.info1 = &info1;
1077                         break;
1078                 case 2:
1079                         ZERO_STRUCT(info2);
1080                         info_ctr.info.info2 = &info2;
1081                         break;
1082                 case 3:
1083                         ZERO_STRUCT(info3);
1084                         info_ctr.info.info3 = &info3;
1085                         break;
1086                 case 4:
1087                         ZERO_STRUCT(info4);
1088                         info_ctr.info.info4 = &info4;
1089                         break;
1090                 case 5:
1091                         ZERO_STRUCT(info5);
1092                         info_ctr.info.info5 = &info5;
1093                         break;
1094                 case 6:
1095                         ZERO_STRUCT(info6);
1096                         info_ctr.info.info6 = &info6;
1097                         break;
1098                 case 7:
1099                         ZERO_STRUCT(info7);
1100                         info_ctr.info.info7 = &info7;
1101                         break;
1102                 case 8:
1103                         ZERO_STRUCT(info8);
1104                         info_ctr.info.info8 = &info8;
1105                         break;
1106                 case 9:
1107                         ZERO_STRUCT(info9);
1108                         info_ctr.info.info9 = &info9;
1109                         break;
1110                 }
1111
1112                 torture_comment(tctx, "Testing SetPrinter level %d, command %d\n",
1113                         info_ctr.level, r.in.command);
1114
1115                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r),
1116                         "failed to call SetPrinter");
1117
1118                 switch (r.in.command) {
1119                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: /* 0 */
1120                         /* is ignored for all levels other then 0 */
1121                         if (info_ctr.level > 0) {
1122                                 /* ignored then */
1123                                 break;
1124                         }
1125                 case SPOOLSS_PRINTER_CONTROL_PAUSE: /* 1 */
1126                 case SPOOLSS_PRINTER_CONTROL_RESUME: /* 2 */
1127                 case SPOOLSS_PRINTER_CONTROL_PURGE: /* 3 */
1128                         if (info_ctr.level > 0) {
1129                                 /* is invalid for all levels other then 0 */
1130                                 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PRINTER_COMMAND,
1131                                         "unexpected error code returned");
1132                                 continue;
1133                         } else {
1134                                 torture_assert_werr_ok(tctx, r.out.result,
1135                                         "failed to call SetPrinter with non 0 command");
1136                                 continue;
1137                         }
1138                         break;
1139
1140                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: /* 4 */
1141                         /* FIXME: gd needs further investigation */
1142                 default:
1143                         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PRINTER_COMMAND,
1144                                 "unexpected error code returned");
1145                         continue;
1146                 }
1147
1148                 switch (info_ctr.level) {
1149                 case 1:
1150                         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
1151                                 "unexpected error code returned");
1152                         break;
1153                 case 2:
1154                         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_PRINTER_DRIVER,
1155                                 "unexpected error code returned");
1156                         break;
1157                 case 3:
1158                 case 4:
1159                 case 5:
1160                 case 7:
1161                         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
1162                                 "unexpected error code returned");
1163                         break;
1164                 case 9:
1165                         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1166                                 "unexpected error code returned");
1167                         break;
1168                 default:
1169                         torture_assert_werr_ok(tctx, r.out.result,
1170                                 "failed to call SetPrinter");
1171                         break;
1172                 }
1173         }
1174
1175         if (r.in.command < 5) {
1176                 r.in.command++;
1177                 goto again;
1178         }
1179
1180         return true;
1181 }
1182
1183 static void clear_info2(struct spoolss_SetPrinterInfoCtr *r)
1184 {
1185         if ((r->level == 2) && (r->info.info2)) {
1186                 r->info.info2->secdesc_ptr = 0;
1187                 r->info.info2->devmode_ptr = 0;
1188         }
1189 }
1190
1191 static bool test_PrinterInfo(struct torture_context *tctx,
1192                              struct dcerpc_binding_handle *b,
1193                              struct policy_handle *handle)
1194 {
1195         NTSTATUS status;
1196         struct spoolss_SetPrinter s;
1197         struct spoolss_GetPrinter q;
1198         struct spoolss_GetPrinter q0;
1199         struct spoolss_SetPrinterInfoCtr info_ctr;
1200         union spoolss_PrinterInfo info;
1201         struct spoolss_DevmodeContainer devmode_ctr;
1202         struct sec_desc_buf secdesc_ctr;
1203         uint32_t needed;
1204         bool ret = true;
1205         int i;
1206
1207         uint32_t status_list[] = {
1208                 /* these do not stick
1209                 PRINTER_STATUS_PAUSED,
1210                 PRINTER_STATUS_ERROR,
1211                 PRINTER_STATUS_PENDING_DELETION, */
1212                 PRINTER_STATUS_PAPER_JAM,
1213                 PRINTER_STATUS_PAPER_OUT,
1214                 PRINTER_STATUS_MANUAL_FEED,
1215                 PRINTER_STATUS_PAPER_PROBLEM,
1216                 PRINTER_STATUS_OFFLINE,
1217                 PRINTER_STATUS_IO_ACTIVE,
1218                 PRINTER_STATUS_BUSY,
1219                 PRINTER_STATUS_PRINTING,
1220                 PRINTER_STATUS_OUTPUT_BIN_FULL,
1221                 PRINTER_STATUS_NOT_AVAILABLE,
1222                 PRINTER_STATUS_WAITING,
1223                 PRINTER_STATUS_PROCESSING,
1224                 PRINTER_STATUS_INITIALIZING,
1225                 PRINTER_STATUS_WARMING_UP,
1226                 PRINTER_STATUS_TONER_LOW,
1227                 PRINTER_STATUS_NO_TONER,
1228                 PRINTER_STATUS_PAGE_PUNT,
1229                 PRINTER_STATUS_USER_INTERVENTION,
1230                 PRINTER_STATUS_OUT_OF_MEMORY,
1231                 PRINTER_STATUS_DOOR_OPEN,
1232                 PRINTER_STATUS_SERVER_UNKNOWN,
1233                 PRINTER_STATUS_POWER_SAVE,
1234                 /* these do not stick
1235                 0x02000000,
1236                 0x04000000,
1237                 0x08000000,
1238                 0x10000000,
1239                 0x20000000,
1240                 0x40000000,
1241                 0x80000000 */
1242         };
1243         uint32_t default_attribute = PRINTER_ATTRIBUTE_LOCAL;
1244         uint32_t attribute_list[] = {
1245                 PRINTER_ATTRIBUTE_QUEUED,
1246                 /* fails with WERR_INVALID_DATATYPE:
1247                 PRINTER_ATTRIBUTE_DIRECT, */
1248                 /* does not stick
1249                 PRINTER_ATTRIBUTE_DEFAULT, */
1250                 PRINTER_ATTRIBUTE_SHARED,
1251                 /* does not stick
1252                 PRINTER_ATTRIBUTE_NETWORK, */
1253                 PRINTER_ATTRIBUTE_HIDDEN,
1254                 PRINTER_ATTRIBUTE_LOCAL,
1255                 PRINTER_ATTRIBUTE_ENABLE_DEVQ,
1256                 PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS,
1257                 PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST,
1258                 PRINTER_ATTRIBUTE_WORK_OFFLINE,
1259                 /* does not stick
1260                 PRINTER_ATTRIBUTE_ENABLE_BIDI, */
1261                 /* fails with WERR_INVALID_DATATYPE:
1262                 PRINTER_ATTRIBUTE_RAW_ONLY, */
1263                 /* these do not stick
1264                 PRINTER_ATTRIBUTE_PUBLISHED,
1265                 PRINTER_ATTRIBUTE_FAX,
1266                 PRINTER_ATTRIBUTE_TS,
1267                 0x00010000,
1268                 0x00020000,
1269                 0x00040000,
1270                 0x00080000,
1271                 0x00100000,
1272                 0x00200000,
1273                 0x00400000,
1274                 0x00800000,
1275                 0x01000000,
1276                 0x02000000,
1277                 0x04000000,
1278                 0x08000000,
1279                 0x10000000,
1280                 0x20000000,
1281                 0x40000000,
1282                 0x80000000 */
1283         };
1284
1285         ZERO_STRUCT(devmode_ctr);
1286         ZERO_STRUCT(secdesc_ctr);
1287
1288         s.in.handle = handle;
1289         s.in.command = 0;
1290         s.in.info_ctr = &info_ctr;
1291         s.in.devmode_ctr = &devmode_ctr;
1292         s.in.secdesc_ctr = &secdesc_ctr;
1293
1294         q.in.handle = handle;
1295         q.out.info = &info;
1296         q0 = q;
1297
1298 #define TESTGETCALL(call, r) \
1299                 r.in.buffer = NULL; \
1300                 r.in.offered = 0;\
1301                 r.out.needed = &needed; \
1302                 status = dcerpc_spoolss_ ##call## _r(b, tctx, &r); \
1303                 if (!NT_STATUS_IS_OK(status)) { \
1304                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1305                                r.in.level, nt_errstr(status), __location__); \
1306                         ret = false; \
1307                         break; \
1308                 }\
1309                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {\
1310                         DATA_BLOB blob = data_blob_talloc_zero(tctx, needed); \
1311                         r.in.buffer = &blob; \
1312                         r.in.offered = needed; \
1313                 }\
1314                 status = dcerpc_spoolss_ ##call## _r(b, tctx, &r); \
1315                 if (!NT_STATUS_IS_OK(status)) { \
1316                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1317                                r.in.level, nt_errstr(status), __location__); \
1318                         ret = false; \
1319                         break; \
1320                 } \
1321                 if (!W_ERROR_IS_OK(r.out.result)) { \
1322                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1323                                r.in.level, win_errstr(r.out.result), __location__); \
1324                         ret = false; \
1325                         break; \
1326                 }
1327
1328
1329 #define TESTSETCALL_EXP(call, r, err) \
1330                 clear_info2(&info_ctr);\
1331                 status = dcerpc_spoolss_ ##call## _r(b, tctx, &r); \
1332                 if (!NT_STATUS_IS_OK(status)) { \
1333                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1334                                r.in.info_ctr->level, nt_errstr(status), __location__); \
1335                         ret = false; \
1336                         break; \
1337                 } \
1338                 if (!W_ERROR_IS_OK(err)) { \
1339                         if (!W_ERROR_EQUAL(err, r.out.result)) { \
1340                                 torture_comment(tctx, #call " level %u failed - %s, expected %s (%s)\n", \
1341                                        r.in.info_ctr->level, win_errstr(r.out.result), win_errstr(err), __location__); \
1342                                 ret = false; \
1343                         } \
1344                         break; \
1345                 } \
1346                 if (!W_ERROR_IS_OK(r.out.result)) { \
1347                         torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1348                                r.in.info_ctr->level, win_errstr(r.out.result), __location__); \
1349                         ret = false; \
1350                         break; \
1351                 }
1352
1353 #define TESTSETCALL(call, r) \
1354         TESTSETCALL_EXP(call, r, WERR_OK)
1355
1356 #define STRING_EQUAL(s1, s2, field) \
1357                 if ((s1 && !s2) || (s2 && !s1) || strcmp(s1, s2)) { \
1358                         torture_comment(tctx, "Failed to set %s to '%s' (%s)\n", \
1359                                #field, s2, __location__); \
1360                         ret = false; \
1361                         break; \
1362                 }
1363
1364 #define MEM_EQUAL(s1, s2, length, field) \
1365                 if ((s1 && !s2) || (s2 && !s1) || memcmp(s1, s2, length)) { \
1366                         torture_comment(tctx, "Failed to set %s to '%s' (%s)\n", \
1367                                #field, (const char *)s2, __location__); \
1368                         ret = false; \
1369                         break; \
1370                 }
1371
1372 #define INT_EQUAL(i1, i2, field) \
1373                 if (i1 != i2) { \
1374                         torture_comment(tctx, "Failed to set %s to 0x%llx - got 0x%llx (%s)\n", \
1375                                #field, (unsigned long long)i2, (unsigned long long)i1, __location__); \
1376                         ret = false; \
1377                         break; \
1378                 }
1379
1380 #define SD_EQUAL(sd1, sd2, field) \
1381                 if (!security_descriptor_equal(sd1, sd2)) { \
1382                         torture_comment(tctx, "Failed to set %s (%s)\n", \
1383                                #field, __location__); \
1384                         ret = false; \
1385                         break; \
1386                 }
1387
1388 #define TEST_PRINTERINFO_STRING_EXP_ERR(lvl1, field1, lvl2, field2, value, err) do { \
1389                 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
1390                 q.in.level = lvl1; \
1391                 TESTGETCALL(GetPrinter, q) \
1392                 info_ctr.level = lvl1; \
1393                 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
1394                 info_ctr.info.info ## lvl1->field1 = value;\
1395                 TESTSETCALL_EXP(SetPrinter, s, err) \
1396                 info_ctr.info.info ## lvl1->field1 = ""; \
1397                 TESTGETCALL(GetPrinter, q) \
1398                 info_ctr.info.info ## lvl1->field1 = value; \
1399                 STRING_EQUAL(info_ctr.info.info ## lvl1->field1, value, field1); \
1400                 q.in.level = lvl2; \
1401                 TESTGETCALL(GetPrinter, q) \
1402                 info_ctr.info.info ## lvl2 = (struct spoolss_SetPrinterInfo ## lvl2 *)(void *)&q.out.info->info ## lvl2; \
1403                 STRING_EQUAL(info_ctr.info.info ## lvl2->field2, value, field2); \
1404         } while (0)
1405
1406 #define TEST_PRINTERINFO_STRING(lvl1, field1, lvl2, field2, value) do { \
1407         TEST_PRINTERINFO_STRING_EXP_ERR(lvl1, field1, lvl2, field2, value, WERR_OK); \
1408         } while (0);
1409
1410 #define TEST_PRINTERINFO_INT_EXP(lvl1, field1, lvl2, field2, value, exp_value) do { \
1411                 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
1412                 q.in.level = lvl1; \
1413                 TESTGETCALL(GetPrinter, q) \
1414                 info_ctr.level = lvl1; \
1415                 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
1416                 info_ctr.info.info ## lvl1->field1 = value; \
1417                 TESTSETCALL(SetPrinter, s) \
1418                 info_ctr.info.info ## lvl1->field1 = 0; \
1419                 TESTGETCALL(GetPrinter, q) \
1420                 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
1421                 INT_EQUAL(info_ctr.info.info ## lvl1->field1, exp_value, field1); \
1422                 q.in.level = lvl2; \
1423                 TESTGETCALL(GetPrinter, q) \
1424                 info_ctr.info.info ## lvl2 = (struct spoolss_SetPrinterInfo ## lvl2 *)(void *)&q.out.info->info ## lvl2; \
1425                 INT_EQUAL(info_ctr.info.info ## lvl2->field2, exp_value, field1); \
1426         } while (0)
1427
1428 #define TEST_PRINTERINFO_INT(lvl1, field1, lvl2, field2, value) do { \
1429         TEST_PRINTERINFO_INT_EXP(lvl1, field1, lvl2, field2, value, value); \
1430         } while (0)
1431
1432         q0.in.level = 0;
1433         do { TESTGETCALL(GetPrinter, q0) } while (0);
1434
1435         TEST_PRINTERINFO_STRING(2, comment,  1, comment, "xx2-1 comment");
1436         TEST_PRINTERINFO_STRING(2, comment,  2, comment, "xx2-2 comment");
1437
1438         /* level 0 printername does not stick */
1439 /*      TEST_PRINTERINFO_STRING(2, printername,  0, printername, "xx2-0 printer"); */
1440         TEST_PRINTERINFO_STRING(2, printername,  1, name,        "xx2-1 printer");
1441         TEST_PRINTERINFO_STRING(2, printername,  2, printername, "xx2-2 printer");
1442         TEST_PRINTERINFO_STRING(2, printername,  4, printername, "xx2-4 printer");
1443         TEST_PRINTERINFO_STRING(2, printername,  5, printername, "xx2-5 printer");
1444 /*      TEST_PRINTERINFO_STRING(4, printername,  0, printername, "xx4-0 printer"); */
1445         TEST_PRINTERINFO_STRING(4, printername,  1, name,        "xx4-1 printer");
1446         TEST_PRINTERINFO_STRING(4, printername,  2, printername, "xx4-2 printer");
1447         TEST_PRINTERINFO_STRING(4, printername,  4, printername, "xx4-4 printer");
1448         TEST_PRINTERINFO_STRING(4, printername,  5, printername, "xx4-5 printer");
1449 /*      TEST_PRINTERINFO_STRING(5, printername,  0, printername, "xx5-0 printer"); */
1450         TEST_PRINTERINFO_STRING(5, printername,  1, name,        "xx5-1 printer");
1451         TEST_PRINTERINFO_STRING(5, printername,  2, printername, "xx5-2 printer");
1452         TEST_PRINTERINFO_STRING(5, printername,  4, printername, "xx5-4 printer");
1453         TEST_PRINTERINFO_STRING(5, printername,  5, printername, "xx5-5 printer");
1454
1455         /* servername can be set but does not stick
1456         TEST_PRINTERINFO_STRING(2, servername,  0, servername, "xx2-0 servername");
1457         TEST_PRINTERINFO_STRING(2, servername,  2, servername, "xx2-2 servername");
1458         TEST_PRINTERINFO_STRING(2, servername,  4, servername, "xx2-4 servername");
1459         */
1460
1461         /* passing an invalid port will result in WERR_UNKNOWN_PORT */
1462         TEST_PRINTERINFO_STRING_EXP_ERR(2, portname,  2, portname, "xx2-2 portname", WERR_UNKNOWN_PORT);
1463         TEST_PRINTERINFO_STRING_EXP_ERR(2, portname,  5, portname, "xx2-5 portname", WERR_UNKNOWN_PORT);
1464         TEST_PRINTERINFO_STRING_EXP_ERR(5, portname,  2, portname, "xx5-2 portname", WERR_UNKNOWN_PORT);
1465         TEST_PRINTERINFO_STRING_EXP_ERR(5, portname,  5, portname, "xx5-5 portname", WERR_UNKNOWN_PORT);
1466
1467         TEST_PRINTERINFO_STRING(2, sharename,   2, sharename,   "xx2-2 sharename");
1468         /* passing an invalid driver will result in WERR_UNKNOWN_PRINTER_DRIVER */
1469         TEST_PRINTERINFO_STRING_EXP_ERR(2, drivername,  2, drivername,  "xx2-2 drivername", WERR_UNKNOWN_PRINTER_DRIVER);
1470         TEST_PRINTERINFO_STRING(2, location,    2, location,    "xx2-2 location");
1471         /* passing an invalid sepfile will result in WERR_INVALID_SEPARATOR_FILE */
1472         TEST_PRINTERINFO_STRING_EXP_ERR(2, sepfile,     2, sepfile,     "xx2-2 sepfile", WERR_INVALID_SEPARATOR_FILE);
1473         /* passing an invalid printprocessor will result in WERR_UNKNOWN_PRINTPROCESSOR */
1474         TEST_PRINTERINFO_STRING_EXP_ERR(2, printprocessor, 2, printprocessor, "xx2-2 printprocessor", WERR_UNKNOWN_PRINTPROCESSOR);
1475         TEST_PRINTERINFO_STRING(2, datatype,    2, datatype,    "xx2-2 datatype");
1476         TEST_PRINTERINFO_STRING(2, parameters,  2, parameters,  "xx2-2 parameters");
1477
1478         for (i=0; i < ARRAY_SIZE(attribute_list); i++) {
1479 /*              TEST_PRINTERINFO_INT_EXP(2, attributes, 1, flags,
1480                         attribute_list[i],
1481                         (attribute_list[i] | default_attribute)
1482                         ); */
1483                 TEST_PRINTERINFO_INT_EXP(2, attributes, 2, attributes,
1484                         attribute_list[i],
1485                         (attribute_list[i] | default_attribute)
1486                         );
1487                 TEST_PRINTERINFO_INT_EXP(2, attributes, 4, attributes,
1488                         attribute_list[i],
1489                         (attribute_list[i] | default_attribute)
1490                         );
1491                 TEST_PRINTERINFO_INT_EXP(2, attributes, 5, attributes,
1492                         attribute_list[i],
1493                         (attribute_list[i] | default_attribute)
1494                         );
1495 /*              TEST_PRINTERINFO_INT_EXP(4, attributes, 1, flags,
1496                         attribute_list[i],
1497                         (attribute_list[i] | default_attribute)
1498                         ); */
1499                 TEST_PRINTERINFO_INT_EXP(4, attributes, 2, attributes,
1500                         attribute_list[i],
1501                         (attribute_list[i] | default_attribute)
1502                         );
1503                 TEST_PRINTERINFO_INT_EXP(4, attributes, 4, attributes,
1504                         attribute_list[i],
1505                         (attribute_list[i] | default_attribute)
1506                         );
1507                 TEST_PRINTERINFO_INT_EXP(4, attributes, 5, attributes,
1508                         attribute_list[i],
1509                         (attribute_list[i] | default_attribute)
1510                         );
1511 /*              TEST_PRINTERINFO_INT_EXP(5, attributes, 1, flags,
1512                         attribute_list[i],
1513                         (attribute_list[i] | default_attribute)
1514                         ); */
1515                 TEST_PRINTERINFO_INT_EXP(5, attributes, 2, attributes,
1516                         attribute_list[i],
1517                         (attribute_list[i] | default_attribute)
1518                         );
1519                 TEST_PRINTERINFO_INT_EXP(5, attributes, 4, attributes,
1520                         attribute_list[i],
1521                         (attribute_list[i] | default_attribute)
1522                         );
1523                 TEST_PRINTERINFO_INT_EXP(5, attributes, 5, attributes,
1524                         attribute_list[i],
1525                         (attribute_list[i] | default_attribute)
1526                         );
1527         }
1528
1529         for (i=0; i < ARRAY_SIZE(status_list); i++) {
1530                 /* level 2 sets do not stick
1531                 TEST_PRINTERINFO_INT(2, status, 0, status, status_list[i]);
1532                 TEST_PRINTERINFO_INT(2, status, 2, status, status_list[i]);
1533                 TEST_PRINTERINFO_INT(2, status, 6, status, status_list[i]); */
1534                 TEST_PRINTERINFO_INT(6, status, 0, status, status_list[i]);
1535                 TEST_PRINTERINFO_INT(6, status, 2, status, status_list[i]);
1536                 TEST_PRINTERINFO_INT(6, status, 6, status, status_list[i]);
1537         }
1538
1539         /* priorities need to be between 0 and 99
1540            passing an invalid priority will result in WERR_INVALID_PRIORITY */
1541         TEST_PRINTERINFO_INT(2, priority,       2, priority, 0);
1542         TEST_PRINTERINFO_INT(2, priority,       2, priority, 1);
1543         TEST_PRINTERINFO_INT(2, priority,       2, priority, 99);
1544         /* TEST_PRINTERINFO_INT(2, priority,    2, priority, 100); */
1545         TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 0);
1546         TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 1);
1547         TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 99);
1548         /* TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 100); */
1549
1550         TEST_PRINTERINFO_INT(2, starttime,      2, starttime, __LINE__);
1551         TEST_PRINTERINFO_INT(2, untiltime,      2, untiltime, __LINE__);
1552
1553         /* does not stick
1554         TEST_PRINTERINFO_INT(2, cjobs,          2, cjobs, __LINE__);
1555         TEST_PRINTERINFO_INT(2, averageppm,     2, averageppm, __LINE__); */
1556
1557         /* does not stick
1558         TEST_PRINTERINFO_INT(5, device_not_selected_timeout, 5, device_not_selected_timeout, __LINE__);
1559         TEST_PRINTERINFO_INT(5, transmission_retry_timeout, 5, transmission_retry_timeout, __LINE__); */
1560
1561         /* FIXME: gd also test devmode and secdesc behavior */
1562
1563         {
1564                 /* verify composition of level 1 description field */
1565                 const char *description;
1566                 const char *tmp;
1567
1568                 q0.in.level = 1;
1569                 do { TESTGETCALL(GetPrinter, q0) } while (0);
1570
1571                 description = talloc_strdup(tctx, q0.out.info->info1.description);
1572
1573                 q0.in.level = 2;
1574                 do { TESTGETCALL(GetPrinter, q0) } while (0);
1575
1576                 tmp = talloc_asprintf(tctx, "%s,%s,%s",
1577                         q0.out.info->info2.printername,
1578                         q0.out.info->info2.drivername,
1579                         q0.out.info->info2.location);
1580
1581                 do { STRING_EQUAL(description, tmp, "description")} while (0);
1582         }
1583
1584         return ret;
1585 }
1586
1587 #define torture_assert_sid_equal(torture_ctx,got,expected,cmt)\
1588         do { struct dom_sid *__got = (got), *__expected = (expected); \
1589         if (!dom_sid_equal(__got, __expected)) { \
1590                 torture_result(torture_ctx, TORTURE_FAIL, \
1591                                            __location__": "#got" was %s, expected %s: %s", \
1592                                            dom_sid_string(torture_ctx, __got), dom_sid_string(torture_ctx, __expected), cmt); \
1593                 return false; \
1594         } \
1595         } while(0)
1596
1597 static bool test_security_descriptor_equal(struct torture_context *tctx,
1598                                            const struct security_descriptor *sd1,
1599                                            const struct security_descriptor *sd2)
1600 {
1601         if (sd1 == sd2) {
1602                 return true;
1603         }
1604
1605         if (!sd1 || !sd2) {
1606                 torture_comment(tctx, "%s\n", __location__);
1607                 return false;
1608         }
1609
1610         torture_assert_int_equal(tctx, sd1->revision, sd2->revision, "revision mismatch");
1611         torture_assert_int_equal(tctx, sd1->type, sd2->type, "type mismatch");
1612
1613         torture_assert_sid_equal(tctx, sd1->owner_sid, sd2->owner_sid, "owner mismatch");
1614         torture_assert_sid_equal(tctx, sd1->group_sid, sd2->group_sid, "group mismatch");
1615
1616         if (!security_acl_equal(sd1->sacl, sd2->sacl)) {
1617                 torture_comment(tctx, "%s: sacl mismatch\n", __location__);
1618                 NDR_PRINT_DEBUG(security_acl, sd1->sacl);
1619                 NDR_PRINT_DEBUG(security_acl, sd2->sacl);
1620                 return false;
1621         }
1622         if (!security_acl_equal(sd1->dacl, sd2->dacl)) {
1623                 torture_comment(tctx, "%s: dacl mismatch\n", __location__);
1624                 NDR_PRINT_DEBUG(security_acl, sd1->dacl);
1625                 NDR_PRINT_DEBUG(security_acl, sd2->dacl);
1626                 return false;
1627         }
1628
1629         return true;
1630 }
1631
1632 static bool test_sd_set_level(struct torture_context *tctx,
1633                               struct dcerpc_binding_handle *b,
1634                               struct policy_handle *handle,
1635                               uint32_t level,
1636                               struct security_descriptor *sd)
1637 {
1638         struct spoolss_SetPrinterInfoCtr info_ctr;
1639         struct spoolss_DevmodeContainer devmode_ctr;
1640         struct sec_desc_buf secdesc_ctr;
1641         union spoolss_SetPrinterInfo sinfo;
1642
1643         ZERO_STRUCT(devmode_ctr);
1644         ZERO_STRUCT(secdesc_ctr);
1645
1646         switch (level) {
1647         case 2: {
1648                 union spoolss_PrinterInfo info;
1649                 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1650                 torture_assert(tctx, PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
1651
1652                 info_ctr.level = 2;
1653                 info_ctr.info = sinfo;
1654
1655                 break;
1656         }
1657         case 3: {
1658                 struct spoolss_SetPrinterInfo3 info3;
1659
1660                 info3.sec_desc_ptr = 0;
1661
1662                 info_ctr.level = 3;
1663                 info_ctr.info.info3 = &info3;
1664
1665                 break;
1666         }
1667         default:
1668                 return false;
1669         }
1670
1671         secdesc_ctr.sd = sd;
1672
1673         torture_assert(tctx,
1674                 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0), "");
1675
1676         return true;
1677 }
1678
1679 static bool test_PrinterInfo_SDs(struct torture_context *tctx,
1680                                  struct dcerpc_binding_handle *b,
1681                                  struct policy_handle *handle)
1682 {
1683         union spoolss_PrinterInfo info;
1684         struct security_descriptor *sd1, *sd2;
1685         int i;
1686
1687         /* just compare level 2 and level 3 */
1688
1689         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1690
1691         sd1 = info.info2.secdesc;
1692
1693         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 3, &info), "");
1694
1695         sd2 = info.info3.secdesc;
1696
1697         torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1698                 "SD level 2 != SD level 3");
1699
1700
1701         /* query level 2, set level 2, query level 2 */
1702
1703         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1704
1705         sd1 = info.info2.secdesc;
1706
1707         torture_assert(tctx, test_sd_set_level(tctx, b, handle, 2, sd1), "");
1708
1709         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1710
1711         sd2 = info.info2.secdesc;
1712         if (sd1->type & SEC_DESC_DACL_DEFAULTED) {
1713                 torture_comment(tctx, "removing SEC_DESC_DACL_DEFAULTED\n");
1714                 sd1->type &= ~SEC_DESC_DACL_DEFAULTED;
1715         }
1716
1717         torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1718                 "SD level 2 != SD level 2 after SD has been set via level 2");
1719
1720
1721         /* query level 2, set level 3, query level 2 */
1722
1723         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1724
1725         sd1 = info.info2.secdesc;
1726
1727         torture_assert(tctx, test_sd_set_level(tctx, b, handle, 3, sd1), "");
1728
1729         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1730
1731         sd2 = info.info2.secdesc;
1732
1733         torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1734                 "SD level 2 != SD level 2 after SD has been set via level 3");
1735
1736         /* set modified sd level 3, query level 2 */
1737
1738         for (i=0; i < 93; i++) {
1739                 struct security_ace a;
1740                 const char *sid_string = talloc_asprintf(tctx, "S-1-5-32-9999%i", i);
1741                 a.type = SEC_ACE_TYPE_ACCESS_ALLOWED;
1742                 a.flags = 0;
1743                 a.size = 0; /* autogenerated */
1744                 a.access_mask = 0;
1745                 a.trustee = *dom_sid_parse_talloc(tctx, sid_string);
1746                 torture_assert_ntstatus_ok(tctx, security_descriptor_dacl_add(sd1, &a), "");
1747         }
1748
1749         torture_assert(tctx, test_sd_set_level(tctx, b, handle, 3, sd1), "");
1750
1751         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1752         sd2 = info.info2.secdesc;
1753
1754         if (sd1->type & SEC_DESC_DACL_DEFAULTED) {
1755                 torture_comment(tctx, "removing SEC_DESC_DACL_DEFAULTED\n");
1756                 sd1->type &= ~SEC_DESC_DACL_DEFAULTED;
1757         }
1758
1759         torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1760                 "modified SD level 2 != SD level 2 after SD has been set via level 3");
1761
1762
1763         return true;
1764 }
1765
1766 /*
1767  * wrapper call that saves original sd, runs tests, and restores sd
1768  */
1769
1770 static bool test_PrinterInfo_SD(struct torture_context *tctx,
1771                                 struct dcerpc_binding_handle *b,
1772                                 struct policy_handle *handle)
1773 {
1774         union spoolss_PrinterInfo info;
1775         struct security_descriptor *sd;
1776         bool ret = true;
1777
1778         torture_comment(tctx, "Testing Printer Security Descriptors\n");
1779
1780         /* save original sd */
1781
1782         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info),
1783                 "failed to get initial security descriptor");
1784
1785         sd = security_descriptor_copy(tctx, info.info2.secdesc);
1786
1787         /* run tests */
1788
1789         ret = test_PrinterInfo_SDs(tctx, b, handle);
1790
1791         /* restore original sd */
1792
1793         torture_assert(tctx, test_sd_set_level(tctx, b, handle, 3, sd),
1794                 "failed to restore initial security descriptor");
1795
1796         torture_comment(tctx, "Printer Security Descriptors test %s\n\n",
1797                 ret ? "succeeded" : "failed");
1798
1799
1800         return ret;
1801 }
1802
1803 static bool test_devmode_set_level(struct torture_context *tctx,
1804                                    struct dcerpc_binding_handle *b,
1805                                    struct policy_handle *handle,
1806                                    uint32_t level,
1807                                    struct spoolss_DeviceMode *devmode)
1808 {
1809         struct spoolss_SetPrinterInfoCtr info_ctr;
1810         struct spoolss_DevmodeContainer devmode_ctr;
1811         struct sec_desc_buf secdesc_ctr;
1812         union spoolss_SetPrinterInfo sinfo;
1813
1814         ZERO_STRUCT(devmode_ctr);
1815         ZERO_STRUCT(secdesc_ctr);
1816
1817         switch (level) {
1818         case 2: {
1819                 union spoolss_PrinterInfo info;
1820                 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1821                 torture_assert(tctx, PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
1822
1823                 info_ctr.level = 2;
1824                 info_ctr.info = sinfo;
1825
1826                 break;
1827         }
1828         case 8: {
1829                 struct spoolss_SetPrinterInfo8 info8;
1830
1831                 info8.devmode_ptr = 0;
1832
1833                 info_ctr.level = 8;
1834                 info_ctr.info.info8 = &info8;
1835
1836                 break;
1837         }
1838         default:
1839                 return false;
1840         }
1841
1842         devmode_ctr.devmode = devmode;
1843
1844         torture_assert(tctx,
1845                 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0), "");
1846
1847         return true;
1848 }
1849
1850
1851 static bool test_devicemode_equal(struct torture_context *tctx,
1852                                   const struct spoolss_DeviceMode *d1,
1853                                   const struct spoolss_DeviceMode *d2)
1854 {
1855         if (d1 == d2) {
1856                 return true;
1857         }
1858
1859         if (!d1 || !d2) {
1860                 torture_comment(tctx, "%s\n", __location__);
1861                 return false;
1862         }
1863         torture_assert_str_equal(tctx, d1->devicename, d2->devicename, "devicename mismatch");
1864         torture_assert_int_equal(tctx, d1->specversion, d2->specversion, "specversion mismatch");
1865         torture_assert_int_equal(tctx, d1->driverversion, d2->driverversion, "driverversion mismatch");
1866         torture_assert_int_equal(tctx, d1->size, d2->size, "size mismatch");
1867         torture_assert_int_equal(tctx, d1->__driverextra_length, d2->__driverextra_length, "__driverextra_length mismatch");
1868         torture_assert_int_equal(tctx, d1->fields, d2->fields, "fields mismatch");
1869         torture_assert_int_equal(tctx, d1->orientation, d2->orientation, "orientation mismatch");
1870         torture_assert_int_equal(tctx, d1->papersize, d2->papersize, "papersize mismatch");
1871         torture_assert_int_equal(tctx, d1->paperlength, d2->paperlength, "paperlength mismatch");
1872         torture_assert_int_equal(tctx, d1->paperwidth, d2->paperwidth, "paperwidth mismatch");
1873         torture_assert_int_equal(tctx, d1->scale, d2->scale, "scale mismatch");
1874         torture_assert_int_equal(tctx, d1->copies, d2->copies, "copies mismatch");
1875         torture_assert_int_equal(tctx, d1->defaultsource, d2->defaultsource, "defaultsource mismatch");
1876         torture_assert_int_equal(tctx, d1->printquality, d2->printquality, "printquality mismatch");
1877         torture_assert_int_equal(tctx, d1->color, d2->color, "color mismatch");
1878         torture_assert_int_equal(tctx, d1->duplex, d2->duplex, "duplex mismatch");
1879         torture_assert_int_equal(tctx, d1->yresolution, d2->yresolution, "yresolution mismatch");
1880         torture_assert_int_equal(tctx, d1->ttoption, d2->ttoption, "ttoption mismatch");
1881         torture_assert_int_equal(tctx, d1->collate, d2->collate, "collate mismatch");
1882         torture_assert_str_equal(tctx, d1->formname, d2->formname, "formname mismatch");
1883         torture_assert_int_equal(tctx, d1->logpixels, d2->logpixels, "logpixels mismatch");
1884         torture_assert_int_equal(tctx, d1->bitsperpel, d2->bitsperpel, "bitsperpel mismatch");
1885         torture_assert_int_equal(tctx, d1->pelswidth, d2->pelswidth, "pelswidth mismatch");
1886         torture_assert_int_equal(tctx, d1->pelsheight, d2->pelsheight, "pelsheight mismatch");
1887         torture_assert_int_equal(tctx, d1->displayflags, d2->displayflags, "displayflags mismatch");
1888         torture_assert_int_equal(tctx, d1->displayfrequency, d2->displayfrequency, "displayfrequency mismatch");
1889         torture_assert_int_equal(tctx, d1->icmmethod, d2->icmmethod, "icmmethod mismatch");
1890         torture_assert_int_equal(tctx, d1->icmintent, d2->icmintent, "icmintent mismatch");
1891         torture_assert_int_equal(tctx, d1->mediatype, d2->mediatype, "mediatype mismatch");
1892         torture_assert_int_equal(tctx, d1->dithertype, d2->dithertype, "dithertype mismatch");
1893         torture_assert_int_equal(tctx, d1->reserved1, d2->reserved1, "reserved1 mismatch");
1894         torture_assert_int_equal(tctx, d1->reserved2, d2->reserved2, "reserved2 mismatch");
1895         torture_assert_int_equal(tctx, d1->panningwidth, d2->panningwidth, "panningwidth mismatch");
1896         torture_assert_int_equal(tctx, d1->panningheight, d2->panningheight, "panningheight mismatch");
1897         torture_assert_data_blob_equal(tctx, d1->driverextra_data, d2->driverextra_data, "driverextra_data mismatch");
1898
1899         return true;
1900 }
1901
1902 static bool test_devicemode_full(struct torture_context *tctx,
1903                                  struct dcerpc_binding_handle *b,
1904                                  struct policy_handle *handle)
1905 {
1906         struct spoolss_SetPrinter s;
1907         struct spoolss_GetPrinter q;
1908         struct spoolss_GetPrinter q0;
1909         struct spoolss_SetPrinterInfoCtr info_ctr;
1910         struct spoolss_SetPrinterInfo8 info8;
1911         union spoolss_PrinterInfo info;
1912         struct spoolss_DevmodeContainer devmode_ctr;
1913         struct sec_desc_buf secdesc_ctr;
1914         uint32_t needed;
1915         bool ret = true;
1916         NTSTATUS status;
1917
1918 #define TEST_DEVMODE_INT_EXP(lvl1, field1, lvl2, field2, value, exp_value) do { \
1919                 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
1920                 q.in.level = lvl1; \
1921                 TESTGETCALL(GetPrinter, q) \
1922                 info_ctr.level = lvl1; \
1923                 if (lvl1 == 2) {\
1924                         info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
1925                 } else if (lvl1 == 8) {\
1926                         info_ctr.info.info ## lvl1 = &info8; \
1927                 }\
1928                 devmode_ctr.devmode = q.out.info->info ## lvl1.devmode; \
1929                 devmode_ctr.devmode->field1 = value; \
1930                 TESTSETCALL(SetPrinter, s) \
1931                 TESTGETCALL(GetPrinter, q) \
1932                 INT_EQUAL(q.out.info->info ## lvl1.devmode->field1, exp_value, field1); \
1933                 q.in.level = lvl2; \
1934                 TESTGETCALL(GetPrinter, q) \
1935                 INT_EQUAL(q.out.info->info ## lvl2.devmode->field2, exp_value, field1); \
1936         } while (0)
1937
1938 #define TEST_DEVMODE_INT(lvl1, field1, lvl2, field2, value) do { \
1939         TEST_DEVMODE_INT_EXP(lvl1, field1, lvl2, field2, value, value); \
1940         } while (0)
1941
1942         ZERO_STRUCT(devmode_ctr);
1943         ZERO_STRUCT(secdesc_ctr);
1944         ZERO_STRUCT(info8);
1945
1946         s.in.handle = handle;
1947         s.in.command = 0;
1948         s.in.info_ctr = &info_ctr;
1949         s.in.devmode_ctr = &devmode_ctr;
1950         s.in.secdesc_ctr = &secdesc_ctr;
1951
1952         q.in.handle = handle;
1953         q.out.info = &info;
1954         q0 = q;
1955
1956 #if 0
1957         const char *devicename;/* [charset(UTF16)] */
1958         enum spoolss_DeviceModeSpecVersion specversion;
1959         uint16_t driverversion;
1960         uint16_t size;
1961         uint16_t __driverextra_length;/* [value(r->driverextra_data.length)] */
1962         uint32_t fields;
1963 #endif
1964
1965         TEST_DEVMODE_INT(8, orientation,        8, orientation, __LINE__);
1966         TEST_DEVMODE_INT(8, papersize,          8, papersize, __LINE__);
1967         TEST_DEVMODE_INT(8, paperlength,        8, paperlength, __LINE__);
1968         TEST_DEVMODE_INT(8, paperwidth,         8, paperwidth, __LINE__);
1969         TEST_DEVMODE_INT(8, scale,              8, scale, __LINE__);
1970         TEST_DEVMODE_INT(8, copies,             8, copies, __LINE__);
1971         TEST_DEVMODE_INT(8, defaultsource,      8, defaultsource, __LINE__);
1972         TEST_DEVMODE_INT(8, printquality,       8, printquality, __LINE__);
1973         TEST_DEVMODE_INT(8, color,              8, color, __LINE__);
1974         TEST_DEVMODE_INT(8, duplex,             8, duplex, __LINE__);
1975         TEST_DEVMODE_INT(8, yresolution,        8, yresolution, __LINE__);
1976         TEST_DEVMODE_INT(8, ttoption,           8, ttoption, __LINE__);
1977         TEST_DEVMODE_INT(8, collate,            8, collate, __LINE__);
1978 #if 0
1979         const char *formname;/* [charset(UTF16)] */
1980 #endif
1981         TEST_DEVMODE_INT(8, logpixels,          8, logpixels, __LINE__);
1982         TEST_DEVMODE_INT(8, bitsperpel,         8, bitsperpel, __LINE__);
1983         TEST_DEVMODE_INT(8, pelswidth,          8, pelswidth, __LINE__);
1984         TEST_DEVMODE_INT(8, pelsheight,         8, pelsheight, __LINE__);
1985         TEST_DEVMODE_INT(8, displayflags,       8, displayflags, __LINE__);
1986         TEST_DEVMODE_INT(8, displayfrequency,   8, displayfrequency, __LINE__);
1987         TEST_DEVMODE_INT(8, icmmethod,          8, icmmethod, __LINE__);
1988         TEST_DEVMODE_INT(8, icmintent,          8, icmintent, __LINE__);
1989         TEST_DEVMODE_INT(8, mediatype,          8, mediatype, __LINE__);
1990         TEST_DEVMODE_INT(8, dithertype,         8, dithertype, __LINE__);
1991         TEST_DEVMODE_INT(8, reserved1,          8, reserved1, __LINE__);
1992         TEST_DEVMODE_INT(8, reserved2,          8, reserved2, __LINE__);
1993         TEST_DEVMODE_INT(8, panningwidth,       8, panningwidth, __LINE__);
1994         TEST_DEVMODE_INT(8, panningheight,      8, panningheight, __LINE__);
1995
1996         return ret;
1997 }
1998
1999 static bool call_OpenPrinterEx(struct torture_context *tctx,
2000                                struct dcerpc_pipe *p,
2001                                const char *name,
2002                                struct spoolss_DeviceMode *devmode,
2003                                struct policy_handle *handle);
2004
2005 static bool test_ClosePrinter(struct torture_context *tctx,
2006                               struct dcerpc_binding_handle *b,
2007                               struct policy_handle *handle);
2008
2009 static bool test_PrinterInfo_DevModes(struct torture_context *tctx,
2010                                       struct dcerpc_pipe *p,
2011                                       struct policy_handle *handle,
2012                                       const char *name)
2013 {
2014         union spoolss_PrinterInfo info;
2015         struct spoolss_DeviceMode *devmode;
2016         struct spoolss_DeviceMode *devmode2;
2017         struct policy_handle handle_devmode;
2018         struct dcerpc_binding_handle *b = p->binding_handle;
2019
2020         /* simply compare level8 and level2 devmode */
2021
2022         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info), "");
2023
2024         devmode = info.info8.devmode;
2025
2026         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
2027
2028         devmode2 = info.info2.devmode;
2029
2030         torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2031                 "DM level 8 != DM level 2");
2032
2033
2034         /* set devicemode level 8 and see if it persists */
2035
2036         devmode->copies = 93;
2037         devmode->formname = talloc_strdup(tctx, "Legal");
2038
2039         torture_assert(tctx, test_devmode_set_level(tctx, b, handle, 8, devmode), "");
2040
2041         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info), "");
2042
2043         devmode2 = info.info8.devmode;
2044
2045         torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2046                 "modified DM level 8 != DM level 8 after DM has been set via level 8");
2047
2048         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
2049
2050         devmode2 = info.info2.devmode;
2051
2052         torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2053                 "modified DM level 8 != DM level 2");
2054
2055
2056         /* set devicemode level 2 and see if it persists */
2057
2058         devmode->copies = 39;
2059         devmode->formname = talloc_strdup(tctx, "Executive");
2060
2061         torture_assert(tctx, test_devmode_set_level(tctx, b, handle, 2, devmode), "");
2062
2063         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info), "");
2064
2065         devmode2 = info.info8.devmode;
2066
2067         torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2068                 "modified DM level 8 != DM level 8 after DM has been set via level 2");
2069
2070         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
2071
2072         devmode2 = info.info2.devmode;
2073
2074         torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2075                 "modified DM level 8 != DM level 2");
2076
2077
2078         /* check every single bit in public part of devicemode */
2079
2080         torture_assert(tctx, test_devicemode_full(tctx, b, handle),
2081                 "failed to set every single devicemode component");
2082
2083
2084         /* change formname upon open and see if it persists in getprinter calls */
2085
2086         devmode->formname = talloc_strdup(tctx, "A4");
2087         devmode->copies = 42;
2088
2089         torture_assert(tctx, call_OpenPrinterEx(tctx, p, name, devmode, &handle_devmode),
2090                 "failed to open printer handle");
2091
2092         torture_assert(tctx, test_GetPrinter_level(tctx, b, &handle_devmode, 8, &info), "");
2093
2094         devmode2 = info.info8.devmode;
2095
2096         if (strequal(devmode->devicename, devmode2->devicename)) {
2097                 torture_warning(tctx, "devicenames are the same\n");
2098         } else {
2099                 torture_comment(tctx, "devicename passed in for open: %s\n", devmode->devicename);
2100                 torture_comment(tctx, "devicename after level 8 get: %s\n", devmode2->devicename);
2101         }
2102
2103         if (strequal(devmode->formname, devmode2->formname)) {
2104                 torture_warning(tctx, "formname are the same\n");
2105         } else {
2106                 torture_comment(tctx, "formname passed in for open: %s\n", devmode->formname);
2107                 torture_comment(tctx, "formname after level 8 get: %s\n", devmode2->formname);
2108         }
2109
2110         if (devmode->copies == devmode2->copies) {
2111                 torture_warning(tctx, "copies are the same\n");
2112         } else {
2113                 torture_comment(tctx, "copies passed in for open: %d\n", devmode->copies);
2114                 torture_comment(tctx, "copies after level 8 get: %d\n", devmode2->copies);
2115         }
2116
2117         torture_assert(tctx, test_GetPrinter_level(tctx, b, &handle_devmode, 2, &info), "");
2118
2119         devmode2 = info.info2.devmode;
2120
2121         if (strequal(devmode->devicename, devmode2->devicename)) {
2122                 torture_warning(tctx, "devicenames are the same\n");
2123         } else {
2124                 torture_comment(tctx, "devicename passed in for open: %s\n", devmode->devicename);
2125                 torture_comment(tctx, "devicename after level 2 get: %s\n", devmode2->devicename);
2126         }
2127
2128         if (strequal(devmode->formname, devmode2->formname)) {
2129                 torture_warning(tctx, "formname is the same\n");
2130         } else {
2131                 torture_comment(tctx, "formname passed in for open: %s\n", devmode->formname);
2132                 torture_comment(tctx, "formname after level 2 get: %s\n", devmode2->formname);
2133         }
2134
2135         if (devmode->copies == devmode2->copies) {
2136                 torture_warning(tctx, "copies are the same\n");
2137         } else {
2138                 torture_comment(tctx, "copies passed in for open: %d\n", devmode->copies);
2139                 torture_comment(tctx, "copies after level 2 get: %d\n", devmode2->copies);
2140         }
2141
2142         test_ClosePrinter(tctx, b, &handle_devmode);
2143
2144         return true;
2145 }
2146
2147 /*
2148  * wrapper call that saves original devmode, runs tests, and restores devmode
2149  */
2150
2151 static bool test_PrinterInfo_DevMode(struct torture_context *tctx,
2152                                      struct dcerpc_pipe *p,
2153                                      struct policy_handle *handle,
2154                                      const char *name)
2155 {
2156         union spoolss_PrinterInfo info;
2157         struct spoolss_DeviceMode *devmode;
2158         bool ret = true;
2159         struct dcerpc_binding_handle *b = p->binding_handle;
2160
2161         torture_comment(tctx, "Testing Printer Devicemodes\n");
2162
2163         /* save original devmode */
2164
2165         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info),
2166                 "failed to get initial global devicemode");
2167
2168         devmode = info.info8.devmode;
2169
2170         /* run tests */
2171
2172         ret = test_PrinterInfo_DevModes(tctx, p, handle, name);
2173
2174         /* restore original devmode */
2175
2176         torture_assert(tctx, test_devmode_set_level(tctx, b, handle, 8, devmode),
2177                 "failed to restore initial global device mode");
2178
2179         torture_comment(tctx, "Printer Devicemodes test %s\n\n",
2180                 ret ? "succeeded" : "failed");
2181
2182
2183         return ret;
2184 }
2185
2186 static bool test_ClosePrinter(struct torture_context *tctx,
2187                               struct dcerpc_binding_handle *b,
2188                               struct policy_handle *handle)
2189 {
2190         NTSTATUS status;
2191         struct spoolss_ClosePrinter r;
2192
2193         r.in.handle = handle;
2194         r.out.handle = handle;
2195
2196         torture_comment(tctx, "Testing ClosePrinter\n");
2197
2198         status = dcerpc_spoolss_ClosePrinter_r(b, tctx, &r);
2199         torture_assert_ntstatus_ok(tctx, status, "ClosePrinter failed");
2200         torture_assert_werr_ok(tctx, r.out.result, "ClosePrinter failed");
2201
2202         return true;
2203 }
2204
2205 static bool test_GetForm_args(struct torture_context *tctx,
2206                               struct dcerpc_binding_handle *b,
2207                               struct policy_handle *handle,
2208                               const char *form_name,
2209                               uint32_t level,
2210                               union spoolss_FormInfo *info_p)
2211 {
2212         NTSTATUS status;
2213         struct spoolss_GetForm r;
2214         uint32_t needed;
2215
2216         r.in.handle = handle;
2217         r.in.form_name = form_name;
2218         r.in.level = level;
2219         r.in.buffer = NULL;
2220         r.in.offered = 0;
2221         r.out.needed = &needed;
2222
2223         torture_comment(tctx, "Testing GetForm(%s) level %d\n", form_name, r.in.level);
2224
2225         status = dcerpc_spoolss_GetForm_r(b, tctx, &r);
2226         torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
2227
2228         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2229                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2230                 r.in.buffer = &blob;
2231                 r.in.offered = needed;
2232                 status = dcerpc_spoolss_GetForm_r(b, tctx, &r);
2233                 torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
2234
2235                 torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
2236
2237                 torture_assert(tctx, r.out.info, "No form info returned");
2238         }
2239
2240         torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
2241
2242         CHECK_NEEDED_SIZE_LEVEL(spoolss_FormInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
2243
2244         if (info_p) {
2245                 *info_p = *r.out.info;
2246         }
2247
2248         return true;
2249 }
2250
2251 static bool test_GetForm(struct torture_context *tctx,
2252                          struct dcerpc_binding_handle *b,
2253                          struct policy_handle *handle,
2254                          const char *form_name,
2255                          uint32_t level)
2256 {
2257         return test_GetForm_args(tctx, b, handle, form_name, level, NULL);
2258 }
2259
2260 static bool test_EnumForms(struct torture_context *tctx,
2261                            struct dcerpc_binding_handle *b,
2262                            struct policy_handle *handle,
2263                            bool print_server,
2264                            uint32_t level,
2265                            uint32_t *count_p,
2266                            union spoolss_FormInfo **info_p)
2267 {
2268         struct spoolss_EnumForms r;
2269         uint32_t needed;
2270         uint32_t count;
2271         union spoolss_FormInfo *info;
2272
2273         r.in.handle = handle;
2274         r.in.level = level;
2275         r.in.buffer = NULL;
2276         r.in.offered = 0;
2277         r.out.needed = &needed;
2278         r.out.count = &count;
2279         r.out.info = &info;
2280
2281         torture_comment(tctx, "Testing EnumForms level %d\n", r.in.level);
2282
2283         torture_assert_ntstatus_ok(tctx,
2284                 dcerpc_spoolss_EnumForms_r(b, tctx, &r),
2285                 "EnumForms failed");
2286
2287         if ((r.in.level == 2) && (W_ERROR_EQUAL(r.out.result, WERR_UNKNOWN_LEVEL))) {
2288                 torture_skip(tctx, "EnumForms level 2 not supported");
2289         }
2290
2291         if (print_server && W_ERROR_EQUAL(r.out.result, WERR_BADFID)) {
2292                 torture_fail(tctx, "EnumForms on the PrintServer isn't supported by test server (NT4)");
2293         }
2294
2295         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2296                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2297                 r.in.buffer = &blob;
2298                 r.in.offered = needed;
2299
2300                 torture_assert_ntstatus_ok(tctx,
2301                         dcerpc_spoolss_EnumForms_r(b, tctx, &r),
2302                         "EnumForms failed");
2303
2304                 torture_assert(tctx, info, "No forms returned");
2305         }
2306
2307         torture_assert_werr_ok(tctx, r.out.result, "EnumForms failed");
2308
2309         CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumForms, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
2310
2311         if (info_p) {
2312                 *info_p = info;
2313         }
2314         if (count_p) {
2315                 *count_p = count;
2316         }
2317
2318         return true;
2319 }
2320
2321 static bool test_EnumForms_all(struct torture_context *tctx,
2322                                struct dcerpc_binding_handle *b,
2323                                struct policy_handle *handle,
2324                                bool print_server)
2325 {
2326         uint32_t levels[] = { 1, 2 };
2327         int i, j;
2328
2329         for (i=0; i<ARRAY_SIZE(levels); i++) {
2330
2331                 uint32_t count = 0;
2332                 union spoolss_FormInfo *info = NULL;
2333
2334                 torture_assert(tctx,
2335                         test_EnumForms(tctx, b, handle, print_server, levels[i], &count, &info),
2336                         "failed to enum forms");
2337
2338                 for (j = 0; j < count; j++) {
2339                         if (!print_server) {
2340                                 torture_assert(tctx,
2341                                         test_GetForm(tctx, b, handle, info[j].info1.form_name, levels[i]),
2342                                         "failed to get form");
2343                         }
2344                 }
2345         }
2346
2347         return true;
2348 }
2349
2350 static bool test_EnumForms_find_one(struct torture_context *tctx,
2351                                     struct dcerpc_binding_handle *b,
2352                                     struct policy_handle *handle,
2353                                     bool print_server,
2354                                     const char *form_name)
2355 {
2356         union spoolss_FormInfo *info;
2357         uint32_t count;
2358         bool found = false;
2359         int i;
2360
2361         torture_assert(tctx,
2362                 test_EnumForms(tctx, b, handle, print_server, 1, &count, &info),
2363                 "failed to enumerate forms");
2364
2365         for (i=0; i<count; i++) {
2366                 if (strequal(form_name, info[i].info1.form_name)) {
2367                         found = true;
2368                         break;
2369                 }
2370         }
2371
2372         return found;
2373 }
2374
2375 static bool test_DeleteForm(struct torture_context *tctx,
2376                             struct dcerpc_binding_handle *b,
2377                             struct policy_handle *handle,
2378                             const char *form_name,
2379                             WERROR expected_result)
2380 {
2381         struct spoolss_DeleteForm r;
2382
2383         r.in.handle = handle;
2384         r.in.form_name = form_name;
2385
2386         torture_comment(tctx, "Testing DeleteForm(%s)\n", form_name);
2387
2388         torture_assert_ntstatus_ok(tctx,
2389                 dcerpc_spoolss_DeleteForm_r(b, tctx, &r),
2390                 "DeleteForm failed");
2391         torture_assert_werr_equal(tctx, r.out.result, expected_result,
2392                 "DeleteForm gave unexpected result");
2393         if (W_ERROR_IS_OK(r.out.result)) {
2394                 torture_assert_ntstatus_ok(tctx,
2395                         dcerpc_spoolss_DeleteForm_r(b, tctx, &r),
2396                         "2nd DeleteForm failed");
2397                 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_FORM_NAME,
2398                         "2nd DeleteForm failed");
2399         }
2400
2401         return true;
2402 }
2403
2404 static bool test_AddForm(struct torture_context *tctx,
2405                          struct dcerpc_binding_handle *b,
2406                          struct policy_handle *handle,
2407                          uint32_t level,
2408                          union spoolss_AddFormInfo *info,
2409                          WERROR expected_result)
2410 {
2411         struct spoolss_AddForm r;
2412
2413         if (level != 1) {
2414                 torture_skip(tctx, "only level 1 supported");
2415         }
2416
2417         r.in.handle     = handle;
2418         r.in.level      = level;
2419         r.in.info       = *info;
2420
2421         torture_comment(tctx, "Testing AddForm(%s) level %d, type %d\n",
2422                 r.in.info.info1->form_name, r.in.level,
2423                 r.in.info.info1->flags);
2424
2425         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_AddForm_r(b, tctx, &r),
2426                 "AddForm failed");
2427         torture_assert_werr_equal(tctx, r.out.result, expected_result,
2428                 "AddForm gave unexpected result");
2429
2430         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_AddForm_r(b, tctx, &r),
2431                 "2nd AddForm failed");
2432         if (W_ERROR_EQUAL(expected_result, WERR_INVALID_PARAM)) {
2433                 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
2434                         "2nd AddForm gave unexpected result");
2435         } else {
2436                 torture_assert_werr_equal(tctx, r.out.result, WERR_FILE_EXISTS,
2437                         "2nd AddForm gave unexpected result");
2438         }
2439
2440         return true;
2441 }
2442
2443 static bool test_SetForm(struct torture_context *tctx,
2444                          struct dcerpc_binding_handle *b,
2445                          struct policy_handle *handle,
2446                          const char *form_name,
2447                          uint32_t level,
2448                          union spoolss_AddFormInfo *info)
2449 {
2450         struct spoolss_SetForm r;
2451
2452         r.in.handle     = handle;
2453         r.in.form_name  = form_name;
2454         r.in.level      = level;
2455         r.in.info       = *info;
2456
2457         torture_comment(tctx, "Testing SetForm(%s) level %d\n",
2458                 form_name, r.in.level);
2459
2460         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetForm_r(b, tctx, &r),
2461                 "SetForm failed");
2462
2463         torture_assert_werr_ok(tctx, r.out.result,
2464                 "SetForm failed");
2465
2466         return true;
2467 }
2468
2469 static bool test_GetForm_winreg(struct torture_context *tctx,
2470                                 struct dcerpc_binding_handle *b,
2471                                 struct policy_handle *handle,
2472                                 const char *key_name,
2473                                 const char *form_name,
2474                                 enum winreg_Type *w_type,
2475                                 uint32_t *w_size,
2476                                 uint32_t *w_length,
2477                                 uint8_t **w_data);
2478
2479 static bool test_Forms_args(struct torture_context *tctx,
2480                             struct dcerpc_binding_handle *b,
2481                             struct policy_handle *handle,
2482                             bool print_server,
2483                             const char *printer_name,
2484                             struct dcerpc_binding_handle *winreg_handle,
2485                             struct policy_handle *hive_handle,
2486                             const char *form_name,
2487                             struct spoolss_AddFormInfo1 *info1,
2488                             WERROR expected_add_result,
2489                             WERROR expected_delete_result)
2490 {
2491         union spoolss_FormInfo info;
2492         union spoolss_AddFormInfo add_info;
2493
2494         enum winreg_Type w_type;
2495         uint32_t w_size;
2496         uint32_t w_length;
2497         uint8_t *w_data;
2498
2499         add_info.info1 = info1;
2500
2501         torture_assert(tctx,
2502                 test_AddForm(tctx, b, handle, 1, &add_info, expected_add_result),
2503                 "failed to add form");
2504
2505         if (winreg_handle && hive_handle && W_ERROR_IS_OK(expected_add_result)) {
2506
2507                 torture_assert(tctx,
2508                         test_GetForm_winreg(tctx, winreg_handle, hive_handle, TOP_LEVEL_CONTROL_FORMS_KEY, form_name, &w_type, &w_size, &w_length, &w_data),
2509                         "failed to get form via winreg");
2510
2511                 torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");
2512                 torture_assert_int_equal(tctx, w_size, 0x20, "unexpected size");
2513                 torture_assert_int_equal(tctx, w_length, 0x20, "unexpected length");
2514                 torture_assert_mem_equal(tctx, &w_data[0], &add_info.info1->size.width, 4, "width mismatch");
2515                 torture_assert_mem_equal(tctx, &w_data[4], &add_info.info1->size.height, 4, "height mismatch");
2516                 torture_assert_mem_equal(tctx, &w_data[8], &add_info.info1->area.left, 4, "left mismatch");
2517                 torture_assert_mem_equal(tctx, &w_data[12], &add_info.info1->area.top, 4, "top mismatch");
2518                 torture_assert_mem_equal(tctx, &w_data[16], &add_info.info1->area.right, 4, "right mismatch");
2519                 torture_assert_mem_equal(tctx, &w_data[20], &add_info.info1->area.bottom, 4, "bottom mismatch");
2520                 /* skip index here */
2521                 torture_assert_mem_equal(tctx, &w_data[28], &add_info.info1->flags, 4, "flags mismatch");
2522         }
2523
2524         if (!print_server && W_ERROR_IS_OK(expected_add_result)) {
2525                 torture_assert(tctx,
2526                         test_GetForm_args(tctx, b, handle, form_name, 1, &info),
2527                         "failed to get added form");
2528
2529                 torture_assert_int_equal(tctx, info.info1.size.width, add_info.info1->size.width, "width mismatch");
2530                 torture_assert_int_equal(tctx, info.info1.size.height, add_info.info1->size.height, "height mismatch");
2531                 torture_assert_int_equal(tctx, info.info1.area.left, add_info.info1->area.left, "left mismatch");
2532                 torture_assert_int_equal(tctx, info.info1.area.top, add_info.info1->area.top, "top mismatch");
2533                 torture_assert_int_equal(tctx, info.info1.area.right, add_info.info1->area.right, "right mismatch");
2534                 torture_assert_int_equal(tctx, info.info1.area.bottom, add_info.info1->area.bottom, "bottom mismatch");
2535                 torture_assert_int_equal(tctx, info.info1.flags, add_info.info1->flags, "flags mismatch");
2536
2537                 if (winreg_handle && hive_handle) {
2538                         torture_assert_mem_equal(tctx, &w_data[0], &info.info1.size.width, 4, "width mismatch");
2539                         torture_assert_mem_equal(tctx, &w_data[4], &info.info1.size.height, 4, "height mismatch");
2540                         torture_assert_mem_equal(tctx, &w_data[8], &info.info1.area.left, 4, "left mismatch");
2541                         torture_assert_mem_equal(tctx, &w_data[12], &info.info1.area.top, 4, "top mismatch");
2542                         torture_assert_mem_equal(tctx, &w_data[16], &info.info1.area.right, 4, "right mismatch");
2543                         torture_assert_mem_equal(tctx, &w_data[20], &info.info1.area.bottom, 4, "bottom mismatch");
2544                         /* skip index here */
2545                         torture_assert_mem_equal(tctx, &w_data[28], &info.info1.flags, 4, "flags mismatch");
2546                 }
2547
2548                 add_info.info1->size.width = 1234;
2549
2550                 torture_assert(tctx,
2551                         test_SetForm(tctx, b, handle, form_name, 1, &add_info),
2552                         "failed to set form");
2553                 torture_assert(tctx,
2554                         test_GetForm_args(tctx, b, handle, form_name, 1, &info),
2555                         "failed to get setted form");
2556
2557                 torture_assert_int_equal(tctx, info.info1.size.width, add_info.info1->size.width, "width mismatch");
2558         }
2559
2560         if (!W_ERROR_EQUAL(expected_add_result, WERR_INVALID_PARAM)) {
2561                 torture_assert(tctx,
2562                         test_EnumForms_find_one(tctx, b, handle, print_server, form_name),
2563                         "Newly added form not found in enum call");
2564         }
2565
2566         torture_assert(tctx,
2567                 test_DeleteForm(tctx, b, handle, form_name, expected_delete_result),
2568                 "failed to delete form");
2569
2570         return true;
2571 }
2572
2573 static bool test_Forms(struct torture_context *tctx,
2574                        struct dcerpc_binding_handle *b,
2575                        struct policy_handle *handle,
2576                        bool print_server,
2577                        const char *printer_name,
2578                        struct dcerpc_binding_handle *winreg_handle,
2579                        struct policy_handle *hive_handle)
2580 {
2581         const struct spoolss_FormSize size = {
2582                 .width  = 50,
2583                 .height = 25
2584         };
2585         const struct spoolss_FormArea area = {
2586                 .left   = 5,
2587                 .top    = 10,
2588                 .right  = 45,
2589                 .bottom = 15
2590         };
2591         int i;
2592
2593         struct {
2594                 struct spoolss_AddFormInfo1 info1;
2595                 WERROR expected_add_result;
2596                 WERROR expected_delete_result;
2597         } forms[] = {
2598                 {
2599                         .info1 = {
2600                                 .flags          = SPOOLSS_FORM_USER,
2601                                 .form_name      = "testform_user",
2602                                 .size           = size,
2603                                 .area           = area,
2604                         },
2605                         .expected_add_result    = WERR_OK,
2606                         .expected_delete_result = WERR_OK
2607                 },
2608 /*
2609                 weird, we can add a builtin form but we can never remove it
2610                 again - gd
2611
2612                 {
2613                         .info1 = {
2614                                 .flags          = SPOOLSS_FORM_BUILTIN,
2615                                 .form_name      = "testform_builtin",
2616                                 .size           = size,
2617                                 .area           = area,
2618                         },
2619                         .expected_add_result    = WERR_OK,
2620                         .expected_delete_result = WERR_INVALID_PARAM,
2621                 },
2622 */
2623                 {
2624                         .info1 = {
2625                                 .flags          = SPOOLSS_FORM_PRINTER,
2626                                 .form_name      = "testform_printer",
2627                                 .size           = size,
2628                                 .area           = area,
2629                         },
2630                         .expected_add_result    = WERR_OK,
2631                         .expected_delete_result = WERR_OK
2632                 },
2633                 {
2634                         .info1 = {
2635                                 .flags          = SPOOLSS_FORM_USER,
2636                                 .form_name      = "Letter",
2637                                 .size           = size,
2638                                 .area           = area,
2639                         },
2640                         .expected_add_result    = WERR_FILE_EXISTS,
2641                         .expected_delete_result = WERR_INVALID_PARAM
2642                 },
2643                 {
2644                         .info1 = {
2645                                 .flags          = SPOOLSS_FORM_BUILTIN,
2646                                 .form_name      = "Letter",
2647                                 .size           = size,
2648                                 .area           = area,
2649                         },
2650                         .expected_add_result    = WERR_FILE_EXISTS,
2651                         .expected_delete_result = WERR_INVALID_PARAM
2652                 },
2653                 {
2654                         .info1 = {
2655                                 .flags          = SPOOLSS_FORM_PRINTER,
2656                                 .form_name      = "Letter",
2657                                 .size           = size,
2658                                 .area           = area,
2659                         },
2660                         .expected_add_result    = WERR_FILE_EXISTS,
2661                         .expected_delete_result = WERR_INVALID_PARAM
2662                 },
2663                 {
2664                         .info1 = {
2665                                 .flags          = 12345,
2666                                 .form_name      = "invalid_flags",
2667                                 .size           = size,
2668                                 .area           = area,
2669                         },
2670                         .expected_add_result    = WERR_INVALID_PARAM,
2671                         .expected_delete_result = WERR_INVALID_FORM_NAME
2672                 }
2673
2674         };
2675
2676         for (i=0; i < ARRAY_SIZE(forms); i++) {
2677                 torture_assert(tctx,
2678                         test_Forms_args(tctx, b, handle, print_server, printer_name,
2679                                         winreg_handle, hive_handle,
2680                                         forms[i].info1.form_name,
2681                                         &forms[i].info1,
2682                                         forms[i].expected_add_result,
2683                                         forms[i].expected_delete_result),
2684                         talloc_asprintf(tctx, "failed to test form '%s'", forms[i].info1.form_name));
2685         }
2686
2687         return true;
2688 }
2689
2690 static bool test_EnumPorts_old(struct torture_context *tctx,
2691                                struct dcerpc_pipe *p)
2692 {
2693         NTSTATUS status;
2694         struct spoolss_EnumPorts r;
2695         uint32_t needed;
2696         uint32_t count;
2697         union spoolss_PortInfo *info;
2698         struct dcerpc_binding_handle *b = p->binding_handle;
2699
2700         r.in.servername = talloc_asprintf(tctx, "\\\\%s",
2701                                           dcerpc_server_name(p));
2702         r.in.level = 2;
2703         r.in.buffer = NULL;
2704         r.in.offered = 0;
2705         r.out.needed = &needed;
2706         r.out.count = &count;
2707         r.out.info = &info;
2708
2709         torture_comment(tctx, "Testing EnumPorts\n");
2710
2711         status = dcerpc_spoolss_EnumPorts_r(b, tctx, &r);
2712
2713         torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
2714
2715         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2716                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2717                 r.in.buffer = &blob;
2718                 r.in.offered = needed;
2719
2720                 status = dcerpc_spoolss_EnumPorts_r(b, tctx, &r);
2721                 torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
2722                 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
2723
2724                 torture_assert(tctx, info, "No ports returned");
2725         }
2726
2727         torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
2728
2729         CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPorts, info, 2, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
2730
2731         return true;
2732 }
2733
2734 static bool test_AddPort(struct torture_context *tctx,
2735                          struct dcerpc_pipe *p)
2736 {
2737         NTSTATUS status;
2738         struct spoolss_AddPort r;
2739         struct dcerpc_binding_handle *b = p->binding_handle;
2740
2741         r.in.server_name = talloc_asprintf(tctx, "\\\\%s",
2742                                            dcerpc_server_name(p));
2743         r.in.unknown = 0;
2744         r.in.monitor_name = "foo";
2745
2746         torture_comment(tctx, "Testing AddPort\n");
2747
2748         status = dcerpc_spoolss_AddPort_r(b, tctx, &r);
2749
2750         torture_assert_ntstatus_ok(tctx, status, "AddPort failed");
2751
2752         /* win2k3 returns WERR_NOT_SUPPORTED */
2753
2754 #if 0
2755
2756         if (!W_ERROR_IS_OK(r.out.result)) {
2757                 printf("AddPort failed - %s\n", win_errstr(r.out.result));
2758                 return false;
2759         }
2760
2761 #endif
2762
2763         return true;
2764 }
2765
2766 static bool test_GetJob_args(struct torture_context *tctx,
2767                              struct dcerpc_binding_handle *b,
2768                              struct policy_handle *handle,
2769                              uint32_t job_id,
2770                              uint32_t level,
2771                              union spoolss_JobInfo *info_p)
2772 {
2773         NTSTATUS status;
2774         struct spoolss_GetJob r;
2775         union spoolss_JobInfo info;
2776         uint32_t needed;
2777
2778         r.in.handle = handle;
2779         r.in.job_id = job_id;
2780         r.in.level = level;
2781         r.in.buffer = NULL;
2782         r.in.offered = 0;
2783         r.out.needed = &needed;
2784         r.out.info = &info;
2785
2786         torture_comment(tctx, "Testing GetJob(%d), level %d\n", job_id, r.in.level);
2787
2788         status = dcerpc_spoolss_GetJob_r(b, tctx, &r);
2789         torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
2790         if (level == 0) {
2791                 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "Unexpected return code");
2792         }
2793
2794         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2795                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2796                 r.in.buffer = &blob;
2797                 r.in.offered = needed;
2798
2799                 status = dcerpc_spoolss_GetJob_r(b, tctx, &r);
2800                 torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
2801         }
2802
2803         torture_assert_werr_ok(tctx, r.out.result, "GetJob failed");
2804         torture_assert(tctx, r.out.info, "No job info returned");
2805
2806         CHECK_NEEDED_SIZE_LEVEL(spoolss_JobInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
2807
2808         if (info_p) {
2809                 *info_p = *r.out.info;
2810         }
2811
2812         return true;
2813 }
2814
2815 static bool test_GetJob(struct torture_context *tctx,
2816                         struct dcerpc_binding_handle *b,
2817                         struct policy_handle *handle,
2818                         uint32_t job_id)
2819 {
2820         uint32_t levels[] = {0, 1, 2 /* 3, 4 */};
2821         uint32_t i;
2822
2823         for (i=0; i < ARRAY_SIZE(levels); i++) {
2824                 torture_assert(tctx,
2825                         test_GetJob_args(tctx, b, handle, job_id, levels[i], NULL),
2826                         "GetJob failed");
2827         }
2828
2829         return true;
2830 }
2831
2832 static bool test_SetJob(struct torture_context *tctx,
2833                         struct dcerpc_binding_handle *b,
2834                         struct policy_handle *handle, uint32_t job_id,
2835                         enum spoolss_JobControl command)
2836 {
2837         NTSTATUS status;
2838         struct spoolss_SetJob r;
2839
2840         r.in.handle     = handle;
2841         r.in.job_id     = job_id;
2842         r.in.ctr        = NULL;
2843         r.in.command    = command;
2844
2845         switch (command) {
2846         case SPOOLSS_JOB_CONTROL_PAUSE:
2847                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_PAUSE\n", job_id);
2848                 break;
2849         case SPOOLSS_JOB_CONTROL_RESUME:
2850                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RESUME\n", job_id);
2851                 break;
2852         case SPOOLSS_JOB_CONTROL_CANCEL:
2853                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_CANCEL\n", job_id);
2854                 break;
2855         case SPOOLSS_JOB_CONTROL_RESTART:
2856                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RESTART\n", job_id);
2857                 break;
2858         case SPOOLSS_JOB_CONTROL_DELETE:
2859                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_DELETE\n", job_id);
2860                 break;
2861         case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER:
2862                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER\n", job_id);
2863                 break;
2864         case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED:
2865                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED\n", job_id);
2866                 break;
2867         case SPOOLSS_JOB_CONTROL_RETAIN:
2868                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RETAIN\n", job_id);
2869                 break;
2870         case SPOOLSS_JOB_CONTROL_RELEASE:
2871                 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RELEASE\n", job_id);
2872                 break;
2873         default:
2874                 torture_comment(tctx, "Testing SetJob(%d)\n", job_id);
2875                 break;
2876         }
2877
2878         status = dcerpc_spoolss_SetJob_r(b, tctx, &r);
2879         torture_assert_ntstatus_ok(tctx, status, "SetJob failed");
2880         torture_assert_werr_ok(tctx, r.out.result, "SetJob failed");
2881
2882         return true;
2883 }
2884
2885 static bool test_AddJob(struct torture_context *tctx,
2886                         struct dcerpc_binding_handle *b,
2887                         struct policy_handle *handle)
2888 {
2889         NTSTATUS status;
2890         struct spoolss_AddJob r;
2891         uint32_t needed;
2892
2893         r.in.level = 0;
2894         r.in.handle = handle;
2895         r.in.offered = 0;
2896         r.out.needed = &needed;
2897         r.in.buffer = r.out.buffer = NULL;
2898
2899         torture_comment(tctx, "Testing AddJob\n");
2900
2901         status = dcerpc_spoolss_AddJob_r(b, tctx, &r);
2902         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "AddJob failed");
2903
2904         r.in.level = 1;
2905
2906         status = dcerpc_spoolss_AddJob_r(b, tctx, &r);
2907         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM, "AddJob failed");
2908
2909         return true;
2910 }
2911
2912
2913 static bool test_EnumJobs_args(struct torture_context *tctx,
2914                                struct dcerpc_binding_handle *b,
2915                                struct policy_handle *handle,
2916                                uint32_t level,
2917                                uint32_t *count_p,
2918                                union spoolss_JobInfo **info_p)
2919 {
2920         NTSTATUS status;
2921         struct spoolss_EnumJobs r;
2922         uint32_t needed;
2923         uint32_t count;
2924         union spoolss_JobInfo *info;
2925
2926         r.in.handle = handle;
2927         r.in.firstjob = 0;
2928         r.in.numjobs = 0xffffffff;
2929         r.in.level = level;
2930         r.in.buffer = NULL;
2931         r.in.offered = 0;
2932         r.out.needed = &needed;
2933         r.out.count = &count;
2934         r.out.info = &info;
2935
2936         torture_comment(tctx, "Testing EnumJobs level %d\n", level);
2937
2938         status = dcerpc_spoolss_EnumJobs_r(b, tctx, &r);
2939
2940         torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
2941
2942         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2943                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2944                 r.in.buffer = &blob;
2945                 r.in.offered = needed;
2946
2947                 status = dcerpc_spoolss_EnumJobs_r(b, tctx, &r);
2948
2949                 torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
2950                 torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
2951                 torture_assert(tctx, info, "No jobs returned");
2952
2953                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumJobs, *r.out.info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
2954
2955         } else {
2956                 torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
2957         }
2958
2959         if (count_p) {
2960                 *count_p = count;
2961         }
2962         if (info_p) {
2963                 *info_p = info;
2964         }
2965
2966         return true;
2967 }
2968
2969 static bool test_DoPrintTest_add_one_job(struct torture_context *tctx,
2970                                          struct dcerpc_binding_handle *b,
2971                                          struct policy_handle *handle,
2972                                          uint32_t *job_id)
2973 {
2974         NTSTATUS status;
2975         struct spoolss_StartDocPrinter s;
2976         struct spoolss_DocumentInfo1 info1;
2977         struct spoolss_StartPagePrinter sp;
2978         struct spoolss_WritePrinter w;
2979         struct spoolss_EndPagePrinter ep;
2980         struct spoolss_EndDocPrinter e;
2981         int i;
2982         uint32_t num_written;
2983
2984         torture_comment(tctx, "Testing StartDocPrinter\n");
2985
2986         s.in.handle             = handle;
2987         s.in.level              = 1;
2988         s.in.info.info1         = &info1;
2989         s.out.job_id            = job_id;
2990         info1.document_name     = "TorturePrintJob";
2991         info1.output_file       = NULL;
2992         info1.datatype          = "RAW";
2993
2994         status = dcerpc_spoolss_StartDocPrinter_r(b, tctx, &s);
2995         torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_StartDocPrinter failed");
2996         torture_assert_werr_ok(tctx, s.out.result, "StartDocPrinter failed");
2997
2998         for (i=1; i < 4; i++) {
2999                 torture_comment(tctx, "Testing StartPagePrinter: Page[%d], JobId[%d]\n", i, *job_id);
3000
3001                 sp.in.handle            = handle;
3002
3003                 status = dcerpc_spoolss_StartPagePrinter_r(b, tctx, &sp);
3004                 torture_assert_ntstatus_ok(tctx, status,
3005                                            "dcerpc_spoolss_StartPagePrinter failed");
3006                 torture_assert_werr_ok(tctx, sp.out.result, "StartPagePrinter failed");
3007
3008                 torture_comment(tctx, "Testing WritePrinter: Page[%d], JobId[%d]\n", i, *job_id);
3009
3010                 w.in.handle             = handle;
3011                 w.in.data               = data_blob_string_const(talloc_asprintf(tctx,"TortureTestPage: %d\nData\n",i));
3012                 w.out.num_written       = &num_written;
3013
3014                 status = dcerpc_spoolss_WritePrinter_r(b, tctx, &w);
3015                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_WritePrinter failed");
3016                 torture_assert_werr_ok(tctx, w.out.result, "WritePrinter failed");
3017
3018                 torture_comment(tctx, "Testing EndPagePrinter: Page[%d], JobId[%d]\n", i, *job_id);
3019
3020                 ep.in.handle            = handle;
3021
3022                 status = dcerpc_spoolss_EndPagePrinter_r(b, tctx, &ep);
3023                 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndPagePrinter failed");
3024                 torture_assert_werr_ok(tctx, ep.out.result, "EndPagePrinter failed");
3025         }
3026
3027         torture_comment(tctx, "Testing EndDocPrinter: JobId[%d]\n", *job_id);
3028
3029         e.in.handle = handle;
3030
3031         status = dcerpc_spoolss_EndDocPrinter_r(b, tctx, &e);
3032         torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndDocPrinter failed");
3033         torture_assert_werr_ok(tctx, e.out.result, "EndDocPrinter failed");
3034
3035         return true;
3036 }
3037
3038 static bool test_DoPrintTest_check_jobs(struct torture_context *tctx,
3039                                         struct dcerpc_binding_handle *b,
3040                                         struct policy_handle *handle,
3041                                         uint32_t num_jobs,
3042                                         uint32_t *job_ids)
3043 {
3044         uint32_t count;
3045         union spoolss_JobInfo *info = NULL;
3046         int i;
3047
3048         torture_assert(tctx,
3049                 test_AddJob(tctx, b, handle),
3050                 "AddJob failed");
3051
3052         torture_assert(tctx,
3053                 test_EnumJobs_args(tctx, b, handle, 1, &count, &info),
3054                 "EnumJobs level 1 failed");
3055
3056         torture_assert_int_equal(tctx, count, num_jobs, "unexpected number of jobs in queue");
3057
3058         for (i=0; i < num_jobs; i++) {
3059                 union spoolss_JobInfo ginfo;
3060
3061                 torture_assert_int_equal(tctx, info[i].info1.job_id, job_ids[i], "job id mismatch");
3062
3063                 torture_assert(tctx,
3064                         test_GetJob_args(tctx, b, handle, info[i].info1.job_id, 1, &ginfo),
3065                         "failed to call test_GetJob");
3066
3067                 torture_assert_int_equal(tctx, ginfo.info1.job_id, info[i].info1.job_id, "job id mismatch");
3068         }
3069
3070         for (i=0; i < num_jobs; i++) {
3071                 torture_assert(tctx,
3072                         test_SetJob(tctx, b, handle, info[i].info1.job_id, SPOOLSS_JOB_CONTROL_PAUSE),
3073                         "failed to pause printjob");
3074                 torture_assert(tctx,
3075                         test_SetJob(tctx, b, handle, info[i].info1.job_id, SPOOLSS_JOB_CONTROL_RESUME),
3076                         "failed to resume printjob");
3077         }
3078
3079         return true;
3080 }
3081
3082 static bool test_DoPrintTest(struct torture_context *tctx,
3083                              struct dcerpc_binding_handle *b,
3084                              struct policy_handle *handle)
3085 {
3086         bool ret = true;
3087         uint32_t num_jobs = 8;
3088         uint32_t *job_ids;
3089         int i;
3090
3091         job_ids = talloc_zero_array(tctx, uint32_t, num_jobs);
3092
3093         for (i=0; i < num_jobs; i++) {
3094                 ret &= test_DoPrintTest_add_one_job(tctx, b, handle, &job_ids[i]);
3095         }
3096
3097         ret &= test_DoPrintTest_check_jobs(tctx, b, handle, num_jobs, job_ids);
3098
3099         for (i=0; i < num_jobs; i++) {
3100                 ret &= test_SetJob(tctx, b, handle, job_ids[i], SPOOLSS_JOB_CONTROL_DELETE);
3101         }
3102
3103         return ret;
3104 }
3105
3106 static bool test_PausePrinter(struct torture_context *tctx,
3107                               struct dcerpc_binding_handle *b,
3108                               struct policy_handle *handle)
3109 {
3110         NTSTATUS status;
3111         struct spoolss_SetPrinter r;
3112         struct spoolss_SetPrinterInfoCtr info_ctr;
3113         struct spoolss_DevmodeContainer devmode_ctr;
3114         struct sec_desc_buf secdesc_ctr;
3115
3116         info_ctr.level = 0;
3117         info_ctr.info.info0 = NULL;
3118
3119         ZERO_STRUCT(devmode_ctr);
3120         ZERO_STRUCT(secdesc_ctr);
3121
3122         r.in.handle             = handle;
3123         r.in.info_ctr           = &info_ctr;
3124         r.in.devmode_ctr        = &devmode_ctr;
3125         r.in.secdesc_ctr        = &secdesc_ctr;
3126         r.in.command            = SPOOLSS_PRINTER_CONTROL_PAUSE;
3127
3128         torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_PAUSE\n");
3129
3130         status = dcerpc_spoolss_SetPrinter_r(b, tctx, &r);
3131
3132         torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
3133
3134         torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
3135
3136         return true;
3137 }
3138
3139 static bool test_ResumePrinter(struct torture_context *tctx,
3140                                struct dcerpc_binding_handle *b,
3141                                struct policy_handle *handle)
3142 {
3143         NTSTATUS status;
3144         struct spoolss_SetPrinter r;
3145         struct spoolss_SetPrinterInfoCtr info_ctr;
3146         struct spoolss_DevmodeContainer devmode_ctr;
3147         struct sec_desc_buf secdesc_ctr;
3148
3149         info_ctr.level = 0;
3150         info_ctr.info.info0 = NULL;
3151
3152         ZERO_STRUCT(devmode_ctr);
3153         ZERO_STRUCT(secdesc_ctr);
3154
3155         r.in.handle             = handle;
3156         r.in.info_ctr           = &info_ctr;
3157         r.in.devmode_ctr        = &devmode_ctr;
3158         r.in.secdesc_ctr        = &secdesc_ctr;
3159         r.in.command            = SPOOLSS_PRINTER_CONTROL_RESUME;
3160
3161         torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_RESUME\n");
3162
3163         status = dcerpc_spoolss_SetPrinter_r(b, tctx, &r);
3164
3165         torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
3166
3167         torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
3168
3169         return true;
3170 }
3171
3172 static bool test_GetPrinterData(struct torture_context *tctx,
3173                                 struct dcerpc_binding_handle *b,
3174                                 struct policy_handle *handle,
3175                                 const char *value_name,
3176                                 enum winreg_Type *type_p,
3177                                 uint8_t **data_p,
3178                                 uint32_t *needed_p)
3179 {
3180         NTSTATUS status;
3181         struct spoolss_GetPrinterData r;
3182         uint32_t needed;
3183         enum winreg_Type type;
3184         union spoolss_PrinterData data;
3185
3186         r.in.handle = handle;
3187         r.in.value_name = value_name;
3188         r.in.offered = 0;
3189         r.out.needed = &needed;
3190         r.out.type = &type;
3191         r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3192
3193         torture_comment(tctx, "Testing GetPrinterData(%s)\n", r.in.value_name);
3194
3195         status = dcerpc_spoolss_GetPrinterData_r(b, tctx, &r);
3196         torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
3197
3198         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3199                 r.in.offered = needed;
3200                 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3201                 status = dcerpc_spoolss_GetPrinterData_r(b, tctx, &r);
3202                 torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
3203         }
3204
3205         torture_assert_werr_ok(tctx, r.out.result,
3206                 talloc_asprintf(tctx, "GetPrinterData(%s) failed", r.in.value_name));
3207
3208         CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterData, &data, type, lp_iconv_convenience(tctx->lp_ctx), needed, 1);
3209
3210         if (type_p) {
3211                 *type_p = type;
3212         }
3213
3214         if (data_p) {
3215                 *data_p = r.out.data;
3216         }
3217
3218         if (needed_p) {
3219                 *needed_p = needed;
3220         }
3221
3222         return true;
3223 }
3224
3225 static bool test_GetPrinterDataEx(struct torture_context *tctx,
3226                                   struct dcerpc_pipe *p,
3227                                   struct policy_handle *handle,
3228                                   const char *key_name,
3229                                   const char *value_name,
3230                                   enum winreg_Type *type_p,
3231                                   uint8_t **data_p,
3232                                   uint32_t *needed_p)
3233 {
3234         NTSTATUS status;
3235         struct spoolss_GetPrinterDataEx r;
3236         enum winreg_Type type;
3237         uint32_t needed;
3238         union spoolss_PrinterData data;
3239         struct dcerpc_binding_handle *b = p->binding_handle;
3240
3241         r.in.handle = handle;
3242         r.in.key_name = key_name;
3243         r.in.value_name = value_name;
3244         r.in.offered = 0;
3245         r.out.type = &type;
3246         r.out.needed = &needed;
3247         r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3248
3249         torture_comment(tctx, "Testing GetPrinterDataEx(%s - %s)\n",
3250                 r.in.key_name, r.in.value_name);
3251
3252         status = dcerpc_spoolss_GetPrinterDataEx_r(b, tctx, &r);
3253         if (!NT_STATUS_IS_OK(status)) {
3254                 if (NT_STATUS_EQUAL(status,NT_STATUS_NET_WRITE_FAULT) &&
3255                     p->last_fault_code == DCERPC_FAULT_OP_RNG_ERROR) {
3256                         torture_skip(tctx, "GetPrinterDataEx not supported by server\n");
3257                 }
3258                 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
3259         }
3260
3261         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3262                 r.in.offered = needed;
3263                 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3264                 status = dcerpc_spoolss_GetPrinterDataEx_r(b, tctx, &r);
3265                 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
3266         }
3267
3268         torture_assert_werr_ok(tctx, r.out.result,
3269                 talloc_asprintf(tctx, "GetPrinterDataEx(%s - %s) failed", r.in.key_name, r.in.value_name));
3270
3271         CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterData, &data, type, lp_iconv_convenience(tctx->lp_ctx), needed, 1);
3272
3273         if (type_p) {
3274                 *type_p = type;
3275         }
3276
3277         if (data_p) {
3278                 *data_p = r.out.data;
3279         }
3280
3281         if (needed_p) {
3282                 *needed_p = needed;
3283         }
3284
3285         return true;
3286 }
3287
3288 static bool test_GetPrinterData_list(struct torture_context *tctx,
3289                                      struct dcerpc_pipe *p,
3290                                      struct policy_handle *handle,
3291                                      const char **architecture)
3292 {
3293         struct dcerpc_binding_handle *b = p->binding_handle;
3294         const char *list[] = {
3295                 "W3SvcInstalled",
3296                 "BeepEnabled",
3297                 "EventLog",
3298                 /* "NetPopup", not on w2k8 */
3299                 /* "NetPopupToComputer", not on w2k8 */
3300                 "MajorVersion",
3301                 "MinorVersion",
3302                 "DefaultSpoolDirectory",
3303                 "Architecture",
3304                 "DsPresent",
3305                 "OSVersion",
3306                 /* "OSVersionEx", not on s3 */
3307                 "DNSMachineName"
3308         };
3309         int i;
3310
3311         for (i=0; i < ARRAY_SIZE(list); i++) {
3312                 enum winreg_Type type, type_ex;
3313                 uint8_t *data, *data_ex;
3314                 uint32_t needed, needed_ex;
3315
3316                 torture_assert(tctx, test_GetPrinterData(tctx, b, handle, list[i], &type, &data, &needed),
3317                         talloc_asprintf(tctx, "GetPrinterData failed on %s\n", list[i]));
3318                 torture_assert(tctx, test_GetPrinterDataEx(tctx, p, handle, "random_string", list[i], &type_ex, &data_ex, &needed_ex),
3319                         talloc_asprintf(tctx, "GetPrinterDataEx failed on %s\n", list[i]));
3320                 torture_assert_int_equal(tctx, type, type_ex, "type mismatch");
3321                 torture_assert_int_equal(tctx, needed, needed_ex, "needed mismatch");
3322                 torture_assert_mem_equal(tctx, data, data_ex, needed, "data mismatch");
3323
3324                 if (strequal(list[i], "Architecture")) {
3325                         if (architecture) {
3326                                 DATA_BLOB blob = data_blob_const(data, needed);
3327                                 *architecture = reg_val_data_string(tctx, lp_iconv_convenience(tctx->lp_ctx), REG_SZ, blob);
3328                         }
3329                 }
3330         }
3331
3332         return true;
3333 }
3334
3335 static bool test_EnumPrinterData(struct torture_context *tctx,
3336                                  struct dcerpc_pipe *p,
3337                                  struct policy_handle *handle,
3338                                  uint32_t enum_index,
3339                                  uint32_t value_offered,
3340                                  uint32_t data_offered,
3341                                  enum winreg_Type *type_p,
3342                                  uint32_t *value_needed_p,
3343                                  uint32_t *data_needed_p,
3344                                  const char **value_name_p,
3345                                  uint8_t **data_p,
3346                                  WERROR *result_p)
3347 {
3348         struct spoolss_EnumPrinterData r;
3349         uint32_t data_needed;
3350         uint32_t value_needed;
3351         enum winreg_Type type;
3352         struct dcerpc_binding_handle *b = p->binding_handle;
3353
3354         r.in.handle = handle;
3355         r.in.enum_index = enum_index;
3356         r.in.value_offered = value_offered;
3357         r.in.data_offered = data_offered;
3358         r.out.data_needed = &data_needed;
3359         r.out.value_needed = &value_needed;
3360         r.out.type = &type;
3361         r.out.data = talloc_zero_array(tctx, uint8_t, r.in.data_offered);
3362         r.out.value_name = talloc_zero_array(tctx, const char, r.in.value_offered);
3363
3364         torture_comment(tctx, "Testing EnumPrinterData(%d)\n", enum_index);
3365
3366         torture_assert_ntstatus_ok(tctx,
3367                 dcerpc_spoolss_EnumPrinterData_r(b, tctx, &r),
3368                 "EnumPrinterData failed");
3369
3370         if (type_p) {
3371                 *type_p = type;
3372         }
3373         if (value_needed_p) {
3374                 *value_needed_p = value_needed;
3375         }
3376         if (data_needed_p) {
3377                 *data_needed_p = data_needed;
3378         }
3379         if (value_name_p) {
3380                 *value_name_p = r.out.value_name;
3381         }
3382         if (data_p) {
3383                 *data_p = r.out.data;
3384         }
3385         if (result_p) {
3386                 *result_p = r.out.result;
3387         }
3388
3389         return true;
3390 }
3391
3392
3393 static bool test_EnumPrinterData_all(struct torture_context *tctx,
3394                                      struct dcerpc_pipe *p,
3395                                      struct policy_handle *handle)
3396 {
3397         uint32_t enum_index = 0;
3398         enum winreg_Type type;
3399         uint32_t value_needed;
3400         uint32_t data_needed;
3401         uint8_t *data;
3402         const char *value_name;
3403         WERROR result;
3404
3405         torture_comment(tctx, "Testing EnumPrinterData\n");
3406
3407         do {
3408                 torture_assert(tctx,
3409                         test_EnumPrinterData(tctx, p, handle, enum_index, 0, 0,
3410                                              &type, &value_needed, &data_needed,
3411                                              &value_name, &data, &result),
3412                         "EnumPrinterData failed");
3413
3414                 if (W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS)) {
3415                         break;
3416                 }
3417
3418                 torture_assert(tctx,
3419                         test_EnumPrinterData(tctx, p, handle, enum_index, value_needed, data_needed,
3420                                              &type, &value_needed, &data_needed,
3421                                              &value_name, &data, &result),
3422                         "EnumPrinterData failed");
3423
3424                 if (W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS)) {
3425                         break;
3426                 }
3427
3428                 enum_index++;
3429
3430         } while (W_ERROR_IS_OK(result));
3431
3432         torture_comment(tctx, "EnumPrinterData test succeeded\n");
3433
3434         return true;
3435 }
3436
3437 static bool test_EnumPrinterDataEx(struct torture_context *tctx,
3438                                    struct dcerpc_binding_handle *b,
3439                                    struct policy_handle *handle,
3440                                    const char *key_name,
3441                                    uint32_t *count_p,
3442                                    struct spoolss_PrinterEnumValues **info_p)
3443 {
3444         struct spoolss_EnumPrinterDataEx r;
3445         struct spoolss_PrinterEnumValues *info;
3446         uint32_t needed;
3447         uint32_t count;
3448
3449         r.in.handle = handle;
3450         r.in.key_name = key_name;
3451         r.in.offered = 0;
3452         r.out.needed = &needed;
3453         r.out.count = &count;
3454         r.out.info = &info;
3455
3456         torture_comment(tctx, "Testing EnumPrinterDataEx(%s)\n", key_name);
3457
3458         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterDataEx_r(b, tctx, &r),
3459                 "EnumPrinterDataEx failed");
3460         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3461                 r.in.offered = needed;
3462                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterDataEx_r(b, tctx, &r),
3463                         "EnumPrinterDataEx failed");
3464         }
3465
3466         torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDataEx failed");
3467
3468         CHECK_NEEDED_SIZE_ENUM(spoolss_EnumPrinterDataEx, info, count, lp_iconv_convenience(tctx->lp_ctx), needed, 1);
3469
3470         if (count_p) {
3471                 *count_p = count;
3472         }
3473         if (info_p) {
3474                 *info_p = info;
3475         }
3476
3477         return true;
3478 }
3479
3480 static bool test_SetPrinterData(struct torture_context *tctx,
3481                                 struct dcerpc_binding_handle *b,
3482                                 struct policy_handle *handle,
3483                                 const char *value_name,
3484                                 enum winreg_Type type,
3485                                 uint8_t *data,
3486                                 uint32_t offered);
3487 static bool test_DeletePrinterData(struct torture_context *tctx,
3488                                    struct dcerpc_binding_handle *b,
3489                                    struct policy_handle *handle,
3490                                    const char *value_name);
3491
3492 static bool test_EnumPrinterData_consistency(struct torture_context *tctx,
3493                                              struct dcerpc_pipe *p,
3494                                              struct policy_handle *handle)
3495 {
3496         uint32_t count;
3497         struct spoolss_PrinterEnumValues *info;
3498         int i;
3499         uint32_t value_needed, data_needed;
3500         uint32_t value_offered, data_offered;
3501         WERROR result;
3502         struct dcerpc_binding_handle *b = p->binding_handle;
3503
3504         enum winreg_Type type;
3505         DATA_BLOB blob;
3506
3507         torture_comment(tctx, "Testing EnumPrinterData vs EnumPrinterDataEx consistency\n");
3508
3509         torture_assert(tctx,
3510                 reg_string_to_val(tctx, lp_iconv_convenience(tctx->lp_ctx),
3511                                   "REG_SZ", "torture_data1", &type, &blob), "");
3512
3513         torture_assert(tctx,
3514                 test_SetPrinterData(tctx, b, handle, "torture_value1", type, blob.data, blob.length),
3515                 "SetPrinterData failed");
3516
3517         blob = data_blob_string_const("torture_data2");
3518
3519         torture_assert(tctx,
3520                 test_SetPrinterData(tctx, b, handle, "torture_value2", REG_BINARY, blob.data, blob.length),
3521                 "SetPrinterData failed");
3522
3523         blob = data_blob_talloc(tctx, NULL, 4);
3524         SIVAL(blob.data, 0, 0x11223344);
3525
3526         torture_assert(tctx,
3527                 test_SetPrinterData(tctx, b, handle, "torture_value3", type, blob.data, blob.length),
3528                 "SetPrinterData failed");
3529
3530         torture_assert(tctx,
3531                 test_EnumPrinterDataEx(tctx, b, handle, "PrinterDriverData", &count, &info),
3532                 "failed to call EnumPrinterDataEx");
3533
3534         /* get the max sizes for value and data */
3535
3536         torture_assert(tctx,
3537                 test_EnumPrinterData(tctx, p, handle, 0, 0, 0,
3538                                      NULL, &value_needed, &data_needed,
3539                                      NULL, NULL, &result),
3540                 "EnumPrinterData failed");
3541         torture_assert_werr_ok(tctx, result, "unexpected result");
3542
3543         /* check if the reply from the EnumPrinterData really matches max values */
3544
3545         for (i=0; i < count; i++) {
3546                 if (info[i].value_name_len > value_needed) {
3547                         torture_fail(tctx,
3548                                 talloc_asprintf(tctx,
3549                                 "EnumPrinterDataEx gave a reply with value length %d which is larger then expected max value length %d from EnumPrinterData",
3550                                 info[i].value_name_len, value_needed));
3551                 }
3552                 if (info[i].data_length > data_needed) {
3553                         torture_fail(tctx,
3554                                 talloc_asprintf(tctx,
3555                                 "EnumPrinterDataEx gave a reply with data length %d which is larger then expected max data length %d from EnumPrinterData",
3556                                 info[i].data_length, data_needed));
3557                 }
3558         }
3559
3560         /* assuming that both EnumPrinterData and EnumPrinterDataEx do either
3561          * sort or not sort the replies by value name, we should be able to do
3562          * the following entry comparison */
3563
3564         data_offered = data_needed;
3565         value_offered = value_needed;
3566
3567         for (i=0; i < count; i++) {
3568
3569                 const char *value_name;
3570                 uint8_t *data;
3571
3572                 torture_assert(tctx,
3573                         test_EnumPrinterData(tctx, p, handle, i, value_offered, data_offered,
3574                                              &type, &value_needed, &data_needed,
3575                                              &value_name, &data, &result),
3576                         "EnumPrinterData failed");
3577
3578                 if (i -1 == count) {
3579                         torture_assert_werr_equal(tctx, result, WERR_NO_MORE_ITEMS,
3580                                 "unexpected result");
3581                         break;
3582                 } else {
3583                         torture_assert_werr_ok(tctx, result, "unexpected result");
3584                 }
3585
3586                 torture_assert_int_equal(tctx, type, info[i].type, "type mismatch");
3587                 torture_assert_int_equal(tctx, value_needed, info[i].value_name_len, "value name length mismatch");
3588                 torture_assert_str_equal(tctx, value_name, info[i].value_name, "value name mismatch");
3589                 torture_assert_int_equal(tctx, data_needed, info[i].data_length, "data length mismatch");
3590                 torture_assert_mem_equal(tctx, data, info[i].data->data, info[i].data_length, "data mismatch");
3591         }
3592
3593         torture_assert(tctx,
3594                 test_DeletePrinterData(tctx, b, handle, "torture_value1"),
3595                 "DeletePrinterData failed");
3596         torture_assert(tctx,
3597                 test_DeletePrinterData(tctx, b, handle, "torture_value2"),
3598                 "DeletePrinterData failed");
3599         torture_assert(tctx,
3600                 test_DeletePrinterData(tctx, b, handle, "torture_value3"),
3601                 "DeletePrinterData failed");
3602
3603         torture_comment(tctx, "EnumPrinterData vs EnumPrinterDataEx consistency test succeeded\n\n");
3604
3605         return true;
3606 }
3607
3608 static bool test_DeletePrinterData(struct torture_context *tctx,
3609                                    struct dcerpc_binding_handle *b,
3610                                    struct policy_handle *handle,
3611                                    const char *value_name)
3612 {
3613         NTSTATUS status;
3614         struct spoolss_DeletePrinterData r;
3615
3616         r.in.handle = handle;
3617         r.in.value_name = value_name;
3618
3619         torture_comment(tctx, "Testing DeletePrinterData(%s)\n",
3620                 r.in.value_name);
3621
3622         status = dcerpc_spoolss_DeletePrinterData_r(b, tctx, &r);
3623
3624         torture_assert_ntstatus_ok(tctx, status, "DeletePrinterData failed");
3625         torture_assert_werr_ok(tctx, r.out.result, "DeletePrinterData failed");
3626
3627         return true;
3628 }
3629
3630 static bool test_DeletePrinterDataEx(struct torture_context *tctx,
3631                                      struct dcerpc_binding_handle *b,
3632                                      struct policy_handle *handle,
3633                                      const char *key_name,
3634                                      const char *value_name)
3635 {
3636         struct spoolss_DeletePrinterDataEx r;
3637
3638         r.in.handle = handle;
3639         r.in.key_name = key_name;
3640         r.in.value_name = value_name;
3641
3642         torture_comment(tctx, "Testing DeletePrinterDataEx(%s - %s)\n",
3643                 r.in.key_name, r.in.value_name);
3644
3645         torture_assert_ntstatus_ok(tctx,
3646                 dcerpc_spoolss_DeletePrinterDataEx_r(b, tctx, &r),
3647                 "DeletePrinterDataEx failed");
3648         torture_assert_werr_ok(tctx, r.out.result,
3649                 "DeletePrinterDataEx failed");
3650
3651         return true;
3652 }
3653
3654 static bool test_DeletePrinterKey(struct torture_context *tctx,
3655                                   struct dcerpc_binding_handle *b,
3656                                   struct policy_handle *handle,
3657                                   const char *key_name)
3658 {
3659         struct spoolss_DeletePrinterKey r;
3660
3661         r.in.handle = handle;
3662         r.in.key_name = key_name;
3663
3664         torture_comment(tctx, "Testing DeletePrinterKey(%s)\n", r.in.key_name);
3665
3666         if (strequal(key_name, "") && !torture_setting_bool(tctx, "dangerous", false)) {
3667                 torture_skip(tctx, "not wiping out printer registry - enable dangerous tests to use\n");
3668                 return true;
3669         }
3670
3671         torture_assert_ntstatus_ok(tctx,
3672                 dcerpc_spoolss_DeletePrinterKey_r(b, tctx, &r),
3673                 "DeletePrinterKey failed");
3674         torture_assert_werr_ok(tctx, r.out.result,
3675                 "DeletePrinterKey failed");
3676
3677         return true;
3678 }
3679
3680 static bool test_winreg_OpenHKLM(struct torture_context *tctx,
3681                                  struct dcerpc_binding_handle *b,
3682                                  struct policy_handle *handle)
3683 {
3684         struct winreg_OpenHKLM r;
3685
3686         r.in.system_name = NULL;
3687         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
3688         r.out.handle = handle;
3689
3690         torture_comment(tctx, "Testing winreg_OpenHKLM\n");
3691
3692         torture_assert_ntstatus_ok(tctx, dcerpc_winreg_OpenHKLM_r(b, tctx, &r), "OpenHKLM failed");
3693         torture_assert_werr_ok(tctx, r.out.result, "OpenHKLM failed");
3694
3695         return true;
3696 }
3697
3698 static void init_winreg_String(struct winreg_String *name, const char *s)
3699 {
3700         name->name = s;
3701         if (s) {
3702                 name->name_len = 2 * (strlen_m(s) + 1);
3703                 name->name_size = name->name_len;
3704         } else {
3705                 name->name_len = 0;
3706                 name->name_size = 0;
3707         }
3708 }
3709
3710 static bool test_winreg_OpenKey_opts(struct torture_context *tctx,
3711                                      struct dcerpc_binding_handle *b,
3712                                      struct policy_handle *hive_handle,
3713                                      const char *keyname,
3714                                      uint32_t options,
3715                                      struct policy_handle *key_handle)
3716 {
3717         struct winreg_OpenKey r;
3718
3719         r.in.parent_handle = hive_handle;
3720         init_winreg_String(&r.in.keyname, keyname);
3721         r.in.options = options;
3722         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
3723         r.out.handle = key_handle;
3724
3725         torture_comment(tctx, "Testing winreg_OpenKey(%s)\n", keyname);
3726
3727         torture_assert_ntstatus_ok(tctx, dcerpc_winreg_OpenKey_r(b, tctx, &r), "OpenKey failed");
3728         torture_assert_werr_ok(tctx, r.out.result, "OpenKey failed");
3729
3730         return true;
3731 }
3732
3733 static bool test_winreg_OpenKey(struct torture_context *tctx,
3734                                 struct dcerpc_binding_handle *b,
3735                                 struct policy_handle *hive_handle,
3736                                 const char *keyname,
3737                                 struct policy_handle *key_handle)
3738 {
3739         return test_winreg_OpenKey_opts(tctx, b, hive_handle, keyname,
3740                                         REG_OPTION_NON_VOLATILE, key_handle);
3741 }
3742
3743 static bool test_winreg_CloseKey(struct torture_context *tctx,
3744                                  struct dcerpc_binding_handle *b,
3745                                  struct policy_handle *handle)
3746 {
3747         struct winreg_CloseKey r;
3748
3749         r.in.handle = handle;
3750         r.out.handle = handle;
3751
3752         torture_comment(tctx, "Testing winreg_CloseKey\n");
3753
3754         torture_assert_ntstatus_ok(tctx, dcerpc_winreg_CloseKey_r(b, tctx, &r), "CloseKey failed");
3755         torture_assert_werr_ok(tctx, r.out.result, "CloseKey failed");
3756
3757         return true;
3758 }
3759
3760 bool test_winreg_QueryValue(struct torture_context *tctx,
3761                             struct dcerpc_binding_handle *b,
3762                             struct policy_handle *handle,
3763                             const char *value_name,
3764                             enum winreg_Type *type_p,
3765                             uint32_t *data_size_p,
3766                             uint32_t *data_length_p,
3767                             uint8_t **data_p)
3768 {
3769         struct winreg_QueryValue r;
3770         enum winreg_Type type = REG_NONE;
3771         uint32_t data_size = 0;
3772         uint32_t data_length = 0;
3773         struct winreg_String valuename;
3774         uint8_t *data = NULL;
3775
3776         init_winreg_String(&valuename, value_name);
3777
3778         data = talloc_zero_array(tctx, uint8_t, 0);
3779
3780         r.in.handle = handle;
3781         r.in.value_name = &valuename;
3782         r.in.type = &type;
3783         r.in.data_size = &data_size;
3784         r.in.data_length = &data_length;
3785         r.in.data = data;
3786         r.out.type = &type;
3787         r.out.data = data;
3788         r.out.data_size = &data_size;
3789         r.out.data_length = &data_length;
3790
3791         torture_comment(tctx, "Testing winreg_QueryValue(%s)\n", value_name);
3792
3793         torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue_r(b, tctx, &r), "QueryValue failed");
3794         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3795                 *r.in.data_size = *r.out.data_size;
3796                 data = talloc_zero_array(tctx, uint8_t, *r.in.data_size);
3797                 r.in.data = data;
3798                 r.out.data = data;
3799                 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue_r(b, tctx, &r), "QueryValue failed");
3800         }
3801         torture_assert_werr_ok(tctx, r.out.result, "QueryValue failed");
3802
3803         if (type_p) {
3804                 *type_p = *r.out.type;
3805         }
3806         if (data_size_p) {
3807                 *data_size_p = *r.out.data_size;
3808         }
3809         if (data_length_p) {
3810                 *data_length_p = *r.out.data_length;
3811         }
3812         if (data_p) {
3813                 *data_p = r.out.data;
3814         }
3815
3816         return true;
3817 }
3818
3819 static bool test_winreg_query_printerdata(struct torture_context *tctx,
3820                                           struct dcerpc_binding_handle *b,
3821                                           struct policy_handle *handle,
3822                                           const char *printer_name,
3823                                           const char *key_name,
3824                                           const char *value_name,
3825                                           enum winreg_Type *w_type,
3826                                           uint32_t *w_size,
3827                                           uint32_t *w_length,
3828                                           uint8_t **w_data)
3829 {
3830         const char *printer_key;
3831         struct policy_handle key_handle;
3832
3833         printer_key = talloc_asprintf(tctx, "%s\\%s\\%s",
3834                 TOP_LEVEL_PRINT_PRINTERS_KEY, printer_name, key_name);
3835
3836         torture_assert(tctx,
3837                 test_winreg_OpenKey(tctx, b, handle, printer_key, &key_handle), "");
3838
3839         torture_assert(tctx,
3840                 test_winreg_QueryValue(tctx, b, &key_handle, value_name, w_type, w_size, w_length, w_data), "");
3841
3842         torture_assert(tctx,
3843                 test_winreg_CloseKey(tctx, b, &key_handle), "");
3844
3845         return true;
3846 }
3847
3848 static bool test_GetForm_winreg(struct torture_context *tctx,
3849                                 struct dcerpc_binding_handle *b,
3850                                 struct policy_handle *handle,
3851                                 const char *key_name,
3852                                 const char *form_name,
3853                                 enum winreg_Type *w_type,
3854                                 uint32_t *w_size,
3855                                 uint32_t *w_length,
3856                                 uint8_t **w_data)
3857 {
3858         struct policy_handle key_handle;
3859
3860         torture_assert(tctx,
3861                 test_winreg_OpenKey(tctx, b, handle, key_name, &key_handle), "");
3862
3863         torture_assert(tctx,
3864                 test_winreg_QueryValue(tctx, b, &key_handle, form_name, w_type, w_size, w_length, w_data), "");
3865
3866         torture_assert(tctx,
3867                 test_winreg_CloseKey(tctx, b, &key_handle), "");
3868
3869         return true;
3870 }
3871
3872 static bool test_winreg_symbolic_link(struct torture_context *tctx,
3873                                       struct dcerpc_binding_handle *b,
3874                                       struct policy_handle *handle,
3875                                       const char *symlink_keyname,
3876                                       const char *symlink_destination)
3877 {
3878         /* check if the first key is a symlink to the second key */
3879
3880         enum winreg_Type w_type;
3881         uint32_t w_size;
3882         uint32_t w_length;
3883         uint8_t *w_data;
3884         struct policy_handle key_handle;
3885         DATA_BLOB blob;
3886         const char *str;
3887
3888         if (torture_setting_bool(tctx, "samba3", false)) {
3889                 torture_skip(tctx, "skip winreg symlink test against samba");
3890         }
3891
3892         torture_assert(tctx,
3893                 test_winreg_OpenKey_opts(tctx, b, handle, symlink_keyname, REG_OPTION_OPEN_LINK, &key_handle),
3894                         "failed to open key link");
3895
3896         torture_assert(tctx,
3897                 test_winreg_QueryValue(tctx, b, &key_handle,
3898                                        "SymbolicLinkValue",
3899                                        &w_type, &w_size, &w_length, &w_data),
3900                 "failed to query for 'SymbolicLinkValue' attribute");
3901
3902         torture_assert_int_equal(tctx, w_type, REG_LINK, "unexpected type");
3903
3904         blob = data_blob(w_data, w_size);
3905         str = reg_val_data_string(tctx, lp_iconv_convenience(tctx->lp_ctx), REG_SZ, blob);
3906
3907         torture_assert_str_equal(tctx, str, symlink_destination, "unexpected symlink target string");
3908
3909         torture_assert(tctx,
3910                 test_winreg_CloseKey(tctx, b, &key_handle),
3911                 "failed to close key link");
3912
3913         return true;
3914 }
3915
3916 static const char *strip_unc(const char *unc)
3917 {
3918         char *name;
3919
3920         if (!unc) {
3921                 return NULL;
3922         }
3923
3924         if (unc[0] == '\\' && unc[1] == '\\') {
3925                 unc +=2;
3926         }
3927
3928         name = strchr(unc, '\\');
3929         if (name) {
3930                 return name+1;
3931         }
3932
3933         return unc;
3934 }
3935
3936 static bool test_GetPrinterInfo_winreg(struct torture_context *tctx,
3937                                        struct dcerpc_binding_handle *b,
3938                                        struct policy_handle *handle,
3939                                        const char *printer_name,
3940                                        struct dcerpc_binding_handle *winreg_handle,
3941                                        struct policy_handle *hive_handle)
3942 {
3943         union spoolss_PrinterInfo info;
3944         const char *keys[] = {
3945                 TOP_LEVEL_CONTROL_PRINTERS_KEY,
3946                 TOP_LEVEL_PRINT_PRINTERS_KEY
3947         };
3948         int i;
3949         const char *printername, *sharename;
3950
3951         torture_comment(tctx, "Testing Printer Info and winreg consistency\n");
3952
3953         torture_assert(tctx,
3954                 test_GetPrinter_level(tctx, b, handle, 2, &info),
3955                 "failed to get printer info level 2");
3956
3957         printername = strip_unc(info.info2.printername);
3958         sharename = strip_unc(info.info2.sharename);
3959
3960 #define test_sz(key, wname, iname) \
3961 do {\
3962         DATA_BLOB blob;\
3963         const char *str;\
3964         enum winreg_Type w_type;\
3965         uint32_t w_size;\
3966         uint32_t w_length;\
3967         uint8_t *w_data;\
3968         torture_assert(tctx,\
3969                 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
3970                                        &w_type, &w_size, &w_length, &w_data),\
3971                 "failed to query winreg");\
3972         torture_assert_int_equal(tctx, w_type, REG_SZ, "unexpected type");\
3973         blob = data_blob(w_data, w_size);\
3974         str = reg_val_data_string(tctx, lp_iconv_convenience(tctx->lp_ctx), REG_SZ, blob);\
3975         if (w_size == 2 && iname == NULL) {\
3976                 /*torture_comment(tctx, "%s: \"\", %s: (null)\n", #wname, #iname);\ */\
3977         } else {\
3978                 torture_assert_str_equal(tctx, str, iname,\
3979                         talloc_asprintf(tctx, "%s - %s mismatch", #wname, #iname));\
3980         }\
3981 } while(0);
3982
3983 #define test_dword(key, wname, iname) \
3984 do {\
3985         uint32_t value;\
3986         enum winreg_Type w_type;\
3987         uint32_t w_size;\
3988         uint32_t w_length;\
3989         uint8_t *w_data;\
3990         torture_assert(tctx,\
3991                 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
3992                                        &w_type, &w_size, &w_length, &w_data),\
3993                 "failed to query winreg");\
3994         torture_assert_int_equal(tctx, w_type, REG_DWORD, "unexpected type");\
3995         torture_assert_int_equal(tctx, w_size, 4, "unexpected size");\
3996         torture_assert_int_equal(tctx, w_length, 4, "unexpected length");\
3997         value = IVAL(w_data, 0);\
3998         torture_assert_int_equal(tctx, value, iname,\
3999                 talloc_asprintf(tctx, "%s - %s mismatch", #wname, #iname));\
4000 } while(0);
4001
4002 #define test_dm(key, wname, iname) \
4003 do {\
4004         DATA_BLOB blob;\
4005         struct spoolss_DeviceMode dm;\
4006         enum ndr_err_code ndr_err;\
4007         enum winreg_Type w_type;\
4008         uint32_t w_size;\
4009         uint32_t w_length;\
4010         uint8_t *w_data;\
4011         torture_assert(tctx,\
4012                 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4013                                        &w_type, &w_size, &w_length, &w_data),\
4014                 "failed to query winreg");\
4015         torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");\
4016         blob = data_blob(w_data, w_size);\
4017         ndr_err = ndr_pull_struct_blob(&blob, tctx, lp_iconv_convenience(tctx->lp_ctx), &dm,\
4018                 (ndr_pull_flags_fn_t)ndr_pull_spoolss_DeviceMode);\
4019         torture_assert_ndr_success(tctx, ndr_err, "failed to unmarshall dm");\
4020         torture_assert(tctx, test_devicemode_equal(tctx, &dm, iname),\
4021                 "dm unequal");\
4022 } while(0);
4023
4024 #define test_sd(key, wname, iname) \
4025 do {\
4026         DATA_BLOB blob;\
4027         struct security_descriptor sd;\
4028         enum ndr_err_code ndr_err;\
4029         enum winreg_Type w_type;\
4030         uint32_t w_size;\
4031         uint32_t w_length;\
4032         uint8_t *w_data;\
4033         torture_assert(tctx,\
4034                 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4035                                        &w_type, &w_size, &w_length, &w_data),\
4036                 "failed to query winreg");\
4037         torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");\
4038         blob = data_blob(w_data, w_size);\
4039         ndr_err = ndr_pull_struct_blob(&blob, tctx, lp_iconv_convenience(tctx->lp_ctx), &sd,\
4040                 (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);\
4041         torture_assert_ndr_success(tctx, ndr_err, "failed to unmarshall sd");\
4042         torture_assert(tctx, test_security_descriptor_equal(tctx, &sd, iname),\
4043                 "sd unequal");\
4044 } while(0);
4045
4046
4047         if (!test_winreg_symbolic_link(tctx, winreg_handle, hive_handle,
4048                                        TOP_LEVEL_CONTROL_PRINTERS_KEY,
4049                                        "\\Registry\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Print\\Printers"))
4050         {
4051                 torture_warning(tctx, "failed to check for winreg symlink");
4052         }
4053
4054
4055         for (i=0; i < ARRAY_SIZE(keys); i++) {
4056
4057                 const char *printer_key;
4058                 struct policy_handle key_handle;
4059
4060                 printer_key = talloc_asprintf(tctx, "%s\\%s",
4061                         keys[i], printer_name);
4062
4063                 torture_assert(tctx,
4064                         test_winreg_OpenKey(tctx, winreg_handle, hive_handle, printer_key, &key_handle), "");
4065
4066                 test_sz(keys[i], "Name", printername);
4067                 test_sz(keys[i], "Share Name", sharename);
4068                 test_sz(keys[i], "Port", info.info2.portname);
4069                 test_sz(keys[i], "Printer Driver", info.info2.drivername);
4070                 test_sz(keys[i], "Description", info.info2.comment);
4071                 test_sz(keys[i], "Location", info.info2.location);
4072                 test_sz(keys[i], "Separator File", info.info2.sepfile);
4073                 test_sz(keys[i], "Print Processor", info.info2.printprocessor);
4074                 test_sz(keys[i], "Datatype", info.info2.datatype);
4075                 test_sz(keys[i], "Parameters", info.info2.parameters);
4076                 /* winreg: 0, spoolss not */
4077 /*              test_dword(keys[i], "Attributes", info.info2.attributes); */
4078                 test_dword(keys[i], "Priority", info.info2.priority);
4079                 test_dword(keys[i], "Default Priority", info.info2.defaultpriority);
4080                 /* winreg: 60, spoolss: 0 */
4081 /*              test_dword(keys[i], "StartTime", info.info2.starttime); */
4082 /*              test_dword(keys[i], "UntilTime", info.info2.untiltime); */
4083                 /* winreg != spoolss */
4084 /*              test_dword(keys[i], "Status", info.info2.status); */
4085                 test_dm(keys[i], "Default DevMode", info.info2.devmode);
4086                 test_sd(keys[i], "Security", info.info2.secdesc);
4087
4088                 torture_assert(tctx,
4089                         test_winreg_CloseKey(tctx, winreg_handle, &key_handle), "");
4090         }
4091
4092 #undef test_sz
4093 #undef test_dword
4094 #undef test_dm
4095 #undef test_sd
4096
4097         torture_comment(tctx, "Printer Info and winreg consistency test succeeded\n\n");
4098
4099         return true;
4100 }
4101
4102 static bool test_SetPrinterData(struct torture_context *tctx,
4103                                 struct dcerpc_binding_handle *b,
4104                                 struct policy_handle *handle,
4105                                 const char *value_name,
4106                                 enum winreg_Type type,
4107                                 uint8_t *data,
4108                                 uint32_t offered)
4109 {
4110         struct spoolss_SetPrinterData r;
4111
4112         r.in.handle = handle;
4113         r.in.value_name = value_name;
4114         r.in.type = type;
4115         r.in.data = data;
4116         r.in.offered = offered;
4117
4118         torture_comment(tctx, "Testing SetPrinterData(%s)\n",
4119                 r.in.value_name);
4120
4121         torture_assert_ntstatus_ok(tctx,
4122                 dcerpc_spoolss_SetPrinterData_r(b, tctx, &r),
4123                 "SetPrinterData failed");
4124         torture_assert_werr_ok(tctx, r.out.result,
4125                 "SetPrinterData failed");
4126
4127         return true;
4128 }
4129
4130 static bool test_SetPrinterData_matrix(struct torture_context *tctx,
4131                                        struct dcerpc_binding_handle *b,
4132                                        struct policy_handle *handle,
4133                                        const char *printer_name,
4134                                        struct dcerpc_binding_handle *winreg_handle,
4135                                        struct policy_handle *hive_handle)
4136 {
4137         const char *values[] = {
4138                 "spootyfoot",
4139                 "spooty\\foot",
4140 #if 0
4141         /* FIXME: not working with s3 atm. */
4142                 "spooty,foot",
4143                 "spooty,fo,ot",
4144 #endif
4145                 "spooty foot",
4146 #if 0
4147         /* FIXME: not working with s3 atm. */
4148                 "spooty\\fo,ot",
4149                 "spooty,fo\\ot"
4150 #endif
4151         };
4152         int i;
4153
4154         for (i=0; i < ARRAY_SIZE(values); i++) {
4155
4156                 enum winreg_Type type;
4157                 DATA_BLOB blob;
4158                 uint8_t *data;
4159                 uint32_t needed;
4160
4161                 torture_assert(tctx,
4162                         reg_string_to_val(tctx, lp_iconv_convenience(tctx->lp_ctx),
4163                                           "REG_SZ", "dog", &type, &blob), "");
4164
4165                 torture_assert(tctx,
4166                         test_SetPrinterData(tctx, b, handle, values[i], REG_SZ, blob.data, blob.length),
4167                         "SetPrinterData failed");
4168
4169                 torture_assert(tctx,
4170                         test_GetPrinterData(tctx, b, handle, values[i], &type, &data, &needed),
4171                         "GetPrinterData failed");
4172
4173                 torture_assert_int_equal(tctx, type, REG_SZ, "type mismatch");
4174                 torture_assert_int_equal(tctx, needed, blob.length, "size mismatch");
4175                 torture_assert_mem_equal(tctx, data, blob.data, blob.length, "buffer mismatch");
4176
4177                 if (winreg_handle && hive_handle) {
4178
4179                         enum winreg_Type w_type;
4180                         uint32_t w_size;
4181                         uint32_t w_length;
4182                         uint8_t *w_data;
4183
4184                         torture_assert(tctx,
4185                                 test_winreg_query_printerdata(tctx, winreg_handle, hive_handle,
4186                                         printer_name, "PrinterDriverData", values[i],
4187                                         &w_type, &w_size, &w_length, &w_data), "");
4188
4189                         torture_assert_int_equal(tctx, w_type, REG_SZ, "winreg type mismatch");
4190                         torture_assert_int_equal(tctx, w_size, blob.length, "winreg size mismatch");
4191                         torture_assert_int_equal(tctx, w_length, blob.length, "winreg length mismatch");
4192                         torture_assert_mem_equal(tctx, w_data, blob.data, blob.length, "winreg buffer mismatch");
4193                 }
4194
4195                 torture_assert(tctx,
4196                         test_DeletePrinterData(tctx, b, handle, values[i]),
4197                         "DeletePrinterData failed");
4198         }
4199
4200         return true;
4201 }
4202
4203
4204 static bool test_EnumPrinterKey(struct torture_context *tctx,
4205                                 struct dcerpc_binding_handle *b,
4206                                 struct policy_handle *handle,
4207                                 const char *key_name,
4208                                 const char ***array);
4209
4210 static bool test_SetPrinterDataEx(struct torture_context *tctx,
4211                                   struct dcerpc_binding_handle *b,
4212                                   struct policy_handle *handle,
4213                                   const char *key_name,
4214                                   const char *value_name,
4215                                   enum winreg_Type type,
4216                                   uint8_t *data,
4217                                   uint32_t offered)
4218 {
4219         NTSTATUS status;
4220         struct spoolss_SetPrinterDataEx r;
4221
4222         r.in.handle = handle;
4223         r.in.key_name = key_name;
4224         r.in.value_name = value_name;
4225         r.in.type = type;
4226         r.in.data = data;
4227         r.in.offered = offered;
4228
4229         torture_comment(tctx, "Testing SetPrinterDataEx(%s - %s) type: %s, offered: 0x%08x\n",
4230                 r.in.key_name, r.in.value_name, str_regtype(r.in.type), r.in.offered);
4231
4232         status = dcerpc_spoolss_SetPrinterDataEx_r(b, tctx, &r);
4233
4234         torture_assert_ntstatus_ok(tctx, status, "SetPrinterDataEx failed");
4235         torture_assert_werr_ok(tctx, r.out.result, "SetPrinterDataEx failed");
4236
4237         return true;
4238 }
4239
4240 static bool test_SetPrinterDataEx_matrix(struct torture_context *tctx,
4241                                          struct dcerpc_pipe *p,
4242                                          struct policy_handle *handle,
4243                                          const char *printername,
4244                                          struct dcerpc_binding_handle *winreg_handle,
4245                                          struct policy_handle *hive_handle)
4246 {
4247         struct dcerpc_binding_handle *b = p->binding_handle;
4248         const char *value_name = "dog";
4249         const char *keys[] = {
4250                 "torturedataex",
4251                 "torture data ex",
4252 #if 0
4253         /* FIXME: not working with s3 atm. */
4254                 "torturedataex_with_subkey\\subkey",
4255                 "torturedataex_with_subkey\\subkey:0",
4256                 "torturedataex_with_subkey\\subkey:1",
4257                 "torturedataex_with_subkey\\subkey\\subsubkey",
4258                 "torturedataex_with_subkey\\subkey\\subsubkey:0",
4259                 "torturedataex_with_subkey\\subkey\\subsubkey:1",
4260 #endif
4261                 "torture,data",
4262 #if 0
4263         /* FIXME: not working with s3 atm. */
4264
4265                 "torture,data,ex",
4266                 "torture,data\\ex",
4267                 "torture\\data,ex"
4268 #endif
4269         };
4270         enum winreg_Type types[] = {
4271                 REG_SZ,
4272                 REG_MULTI_SZ,
4273                 REG_DWORD,
4274                 REG_BINARY
4275         };
4276         const char *str = "abcdefghijklmnopqrstuvwxzy";
4277         int i, t, s;
4278
4279
4280         for (i=0; i < ARRAY_SIZE(keys); i++) {
4281         for (t=0; t < ARRAY_SIZE(types); t++) {
4282         for (s=0; s < strlen(str); s++) {
4283
4284                 char *c;
4285                 const char *key;
4286                 enum winreg_Type type;
4287                 const char *string = talloc_strndup(tctx, str, s);
4288                 DATA_BLOB blob = data_blob_string_const(string);
4289                 const char **subkeys;
4290                 DATA_BLOB data;
4291                 uint8_t *data_out;
4292                 uint32_t needed, offered = 0;
4293                 uint32_t ecount;
4294                 struct spoolss_PrinterEnumValues *einfo;
4295
4296                 if (types[t] == REG_DWORD) {
4297                         s = 0xffff;
4298                 }
4299
4300                 if (torture_setting_bool(tctx, "samba3", false)) {
4301                         if ((types[t] == REG_MULTI_SZ) && s == 0) {
4302                                 torture_warning(tctx, "samba3 does not handle 4 byte emtpy REG_MULTI_SZ buffers");
4303                                 continue;
4304                         }
4305                 }
4306
4307                 switch (types[t]) {
4308                 case REG_BINARY:
4309                         data = blob;
4310                         offered = blob.length;
4311                         break;
4312                 case REG_DWORD:
4313                         data = data_blob_talloc(tctx, NULL, 4);
4314                         SIVAL(data.data, 0, 0x12345678);
4315                         offered = 4;
4316                         break;
4317                 case REG_SZ:
4318                         torture_assert(tctx,
4319                                 reg_string_to_val(tctx, lp_iconv_convenience(tctx->lp_ctx),
4320                                                   "REG_SZ", string, &type, &data), "");
4321                         offered = data.length;
4322                         /*strlen_m_term(data.string)*2;*/
4323                         break;
4324                 case REG_MULTI_SZ:
4325                         torture_assert(tctx,
4326                                 reg_string_to_val(tctx, lp_iconv_convenience(tctx->lp_ctx),
4327                                                   "REG_SZ", string, &type, &data), "");
4328                         torture_assert(tctx, data_blob_realloc(tctx, &data, data.length + 2), "");
4329                         memset(&data.data[data.length - 2], '\0', 2);
4330                         offered = data.length;
4331                         break;
4332                 default:
4333                         torture_fail(tctx, talloc_asprintf(tctx, "type %d untested\n", types[t]));
4334                 }
4335
4336                 torture_assert(tctx,
4337                         test_SetPrinterDataEx(tctx, b, handle, keys[i], value_name, types[t], data.data, offered),
4338                         "failed to call SetPrinterDataEx");
4339
4340                 torture_assert(tctx,
4341                         test_GetPrinterDataEx(tctx, p, handle, keys[i], value_name, &type, &data_out, &needed),
4342                         "failed to call GetPrinterDataEx");
4343
4344                 torture_assert(tctx,
4345                         test_EnumPrinterDataEx(tctx, b, handle, keys[i], &ecount, &einfo),
4346                         "failed to call EnumPrinterDataEx");
4347
4348                 torture_assert_int_equal(tctx, types[t], type, "type mismatch");
4349                 torture_assert_int_equal(tctx, needed, offered, "size mismatch");
4350                 torture_assert_mem_equal(tctx, data_out, data.data, offered, "buffer mismatch");
4351
4352                 torture_assert_int_equal(tctx, ecount, 1, "unexpected enum count");
4353                 torture_assert_str_equal(tctx, einfo[0].value_name, value_name, "value_name mismatch");
4354                 torture_assert_int_equal(tctx, einfo[0].value_name_len, strlen_m_term(value_name)*2, "unexpected value_name_len");
4355                 torture_assert_int_equal(tctx, einfo[0].type, types[t], "type mismatch");
4356                 torture_assert_int_equal(tctx, einfo[0].data_length, offered, "size mismatch");
4357                 if (einfo[0].data_length > 0) {
4358                         torture_assert_mem_equal(tctx, einfo[0].data->data, data.data, offered, "buffer mismatch");
4359                 }
4360
4361                 if (winreg_handle && hive_handle) {
4362                         enum winreg_Type w_type;
4363                         uint32_t w_size;
4364                         uint32_t w_length;
4365                         uint8_t *w_data;
4366
4367                         torture_assert(tctx,
4368                                 test_winreg_query_printerdata(tctx, winreg_handle, hive_handle,
4369                                         printername, keys[i], value_name,
4370                                         &w_type, &w_size, &w_length, &w_data), "");
4371
4372                         torture_assert_int_equal(tctx, w_type, types[t], "winreg type mismatch");
4373                         torture_assert_int_equal(tctx, w_size, offered, "winreg size mismatch");
4374                         torture_assert_int_equal(tctx, w_length, offered, "winreg length mismatch");
4375                         torture_assert_mem_equal(tctx, w_data, data.data, offered, "winreg buffer mismatch");
4376                 }
4377
4378                 key = talloc_strdup(tctx, keys[i]);
4379
4380                 if (!test_DeletePrinterDataEx(tctx, b, handle, keys[i], value_name)) {
4381                         return false;
4382                 }
4383
4384                 c = strchr(key, '\\');
4385                 if (c) {
4386                         int k;
4387
4388                         /* we have subkeys */
4389
4390                         *c = 0;
4391
4392                         if (!test_EnumPrinterKey(tctx, b, handle, key, &subkeys)) {
4393                                 return false;
4394                         }
4395
4396                         for (k=0; subkeys && subkeys[k]; k++) {
4397
4398                                 const char *current_key = talloc_asprintf(tctx, "%s\\%s", key, subkeys[k]);
4399
4400                                 if (!test_DeletePrinterKey(tctx, b, handle, current_key)) {
4401                                         return false;
4402                                 }
4403                         }
4404
4405                         if (!test_DeletePrinterKey(tctx, b, handle, key)) {
4406                                 return false;
4407                         }
4408
4409                 } else {
4410                         if (!test_DeletePrinterKey(tctx, b, handle, key)) {
4411                                 return false;
4412                         }
4413                 }
4414         }
4415         }
4416         }
4417
4418         return true;
4419 }
4420
4421 static bool test_PrinterData_winreg(struct torture_context *tctx,
4422                                     struct dcerpc_pipe *p,
4423                                     struct policy_handle *handle,
4424                                     const char *printer_name)
4425 {
4426         struct dcerpc_binding_handle *b = p->binding_handle;
4427         struct dcerpc_pipe *p2;
4428         bool ret = true;
4429         struct policy_handle hive_handle;
4430         struct dcerpc_binding_handle *b2;
4431
4432         torture_assert_ntstatus_ok(tctx,
4433                 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
4434                 "could not open winreg pipe");
4435         b2 = p2->binding_handle;
4436
4437         torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
4438
4439         ret &= test_SetPrinterData_matrix(tctx, b, handle, printer_name, b2, &hive_handle);
4440         ret &= test_SetPrinterDataEx_matrix(tctx, p, handle, printer_name, b2, &hive_handle);
4441
4442         test_winreg_CloseKey(tctx, b2, &hive_handle);
4443
4444         talloc_free(p2);
4445
4446         return ret;
4447 }
4448
4449 static bool test_Forms_winreg(struct torture_context *tctx,
4450                               struct dcerpc_binding_handle *b,
4451                               struct policy_handle *handle,
4452                               bool print_server,
4453                               const char *printer_name)
4454 {
4455         struct dcerpc_pipe *p2;
4456         bool ret = true;
4457         struct policy_handle hive_handle;
4458         struct dcerpc_binding_handle *b2;
4459
4460         torture_assert_ntstatus_ok(tctx,
4461                 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
4462                 "could not open winreg pipe");
4463         b2 = p2->binding_handle;
4464
4465         torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
4466
4467         ret = test_Forms(tctx, b, handle, print_server, printer_name, b2, &hive_handle);
4468
4469         test_winreg_CloseKey(tctx, b2, &hive_handle);
4470
4471         talloc_free(p2);
4472
4473         return ret;
4474 }
4475
4476 static bool test_PrinterInfo_winreg(struct torture_context *tctx,
4477                                     struct dcerpc_pipe *p,
4478                                     struct policy_handle *handle,
4479                                     const char *printer_name)
4480 {
4481         struct dcerpc_binding_handle *b = p->binding_handle;
4482         struct dcerpc_pipe *p2;
4483         bool ret = true;
4484         struct policy_handle hive_handle;
4485         struct dcerpc_binding_handle *b2;
4486
4487         torture_assert_ntstatus_ok(tctx,
4488                 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
4489                 "could not open winreg pipe");
4490         b2 = p2->binding_handle;
4491
4492         torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
4493
4494         ret = test_GetPrinterInfo_winreg(tctx, b, handle, printer_name, b2, &hive_handle);
4495
4496         test_winreg_CloseKey(tctx, b2, &hive_handle);
4497
4498         talloc_free(p2);
4499
4500         return ret;
4501 }
4502
4503 static bool test_GetChangeID_PrinterData(struct torture_context *tctx,
4504                                          struct dcerpc_binding_handle *b,
4505                                          struct policy_handle *handle,
4506                                          uint32_t *change_id)
4507 {
4508         enum winreg_Type type;
4509         uint8_t *data;
4510         uint32_t needed;
4511
4512         torture_assert(tctx,
4513                 test_GetPrinterData(tctx, b, handle, "ChangeID", &type, &data, &needed),
4514                 "failed to call GetPrinterData");
4515
4516         torture_assert(tctx, type == REG_DWORD, "unexpected type");
4517         torture_assert_int_equal(tctx, needed, 4, "unexpected size");
4518
4519         *change_id = IVAL(data, 0);
4520
4521         return true;
4522 }
4523
4524 static bool test_GetChangeID_PrinterDataEx(struct torture_context *tctx,
4525                                            struct dcerpc_pipe *p,
4526                                            struct policy_handle *handle,
4527                                            uint32_t *change_id)
4528 {
4529         enum winreg_Type type;
4530         uint8_t *data;
4531         uint32_t needed;
4532
4533         torture_assert(tctx,
4534                 test_GetPrinterDataEx(tctx, p, handle, "PrinterDriverData", "ChangeID", &type, &data, &needed),
4535                 "failed to call GetPrinterData");
4536
4537         torture_assert(tctx, type == REG_DWORD, "unexpected type");
4538         torture_assert_int_equal(tctx, needed, 4, "unexpected size");
4539
4540         *change_id = IVAL(data, 0);
4541
4542         return true;
4543 }
4544
4545 static bool test_GetChangeID_PrinterInfo(struct torture_context *tctx,
4546                                          struct dcerpc_binding_handle *b,
4547                                          struct policy_handle *handle,
4548                                          uint32_t *change_id)
4549 {
4550         union spoolss_PrinterInfo info;
4551
4552         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 0, &info),
4553                 "failed to query Printer level 0");
4554
4555         *change_id = info.info0.change_id;
4556
4557         return true;
4558 }
4559
4560 static bool test_ChangeID(struct torture_context *tctx,
4561                           struct dcerpc_pipe *p,
4562                           struct policy_handle *handle)
4563 {
4564         uint32_t change_id, change_id_ex, change_id_info;
4565         uint32_t change_id2, change_id_ex2, change_id_info2;
4566         union spoolss_PrinterInfo info;
4567         const char *comment;
4568         struct dcerpc_binding_handle *b = p->binding_handle;
4569
4570         torture_comment(tctx, "Testing ChangeID: id change test #1\n");
4571
4572         torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id),
4573                 "failed to query for ChangeID");
4574         torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
4575                 "failed to query for ChangeID");
4576         torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info),
4577                 "failed to query for ChangeID");
4578
4579         torture_assert_int_equal(tctx, change_id, change_id_ex,
4580                 "change_ids should all be equal");
4581         torture_assert_int_equal(tctx, change_id_ex, change_id_info,
4582                 "change_ids should all be equal");
4583
4584
4585         torture_comment(tctx, "Testing ChangeID: id change test #2\n");
4586
4587         torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id),
4588                 "failed to query for ChangeID");
4589         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info),
4590                 "failed to query Printer level 2");
4591         torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
4592                 "failed to query for ChangeID");
4593         torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info),
4594                 "failed to query for ChangeID");
4595         torture_assert_int_equal(tctx, change_id, change_id_ex,
4596                 "change_id should not have changed");
4597         torture_assert_int_equal(tctx, change_id_ex, change_id_info,
4598                 "change_id should not have changed");
4599
4600
4601         torture_comment(tctx, "Testing ChangeID: id change test #3\n");
4602
4603         torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id),
4604                 "failed to query for ChangeID");
4605         torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
4606                 "failed to query for ChangeID");
4607         torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info),
4608                 "failed to query for ChangeID");
4609         torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info),
4610                 "failed to query Printer level 2");
4611         comment = talloc_strdup(tctx, info.info2.comment);
4612
4613         {
4614                 struct spoolss_SetPrinterInfoCtr info_ctr;
4615                 struct spoolss_DevmodeContainer devmode_ctr;
4616                 struct sec_desc_buf secdesc_ctr;
4617                 union spoolss_SetPrinterInfo sinfo;
4618
4619                 ZERO_STRUCT(info_ctr);
4620                 ZERO_STRUCT(devmode_ctr);
4621                 ZERO_STRUCT(secdesc_ctr);
4622
4623
4624                 torture_assert(tctx, PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
4625                 sinfo.info2->comment    = "torture_comment";
4626
4627                 info_ctr.level = 2;
4628                 info_ctr.info = sinfo;
4629
4630                 torture_assert(tctx, test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
4631                         "failed to call SetPrinter");
4632
4633                 sinfo.info2->comment    = comment;
4634
4635                 torture_assert(tctx, test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
4636                         "failed to call SetPrinter");
4637
4638         }
4639
4640         torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id2),
4641                 "failed to query for ChangeID");
4642         torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex2),
4643                 "failed to query for ChangeID");
4644         torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info2),
4645                 "failed to query for ChangeID");
4646
4647         torture_assert_int_equal(tctx, change_id2, change_id_ex2,
4648                 "change_ids should all be equal");
4649         torture_assert_int_equal(tctx, change_id_ex2, change_id_info2,
4650                 "change_ids should all be equal");
4651
4652         torture_assert(tctx, (change_id < change_id2),
4653                 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
4654                 change_id2, change_id));
4655         torture_assert(tctx, (change_id_ex < change_id_ex2),
4656                 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
4657                 change_id_ex2, change_id_ex));
4658         torture_assert(tctx, (change_id_info < change_id_info2),
4659                 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
4660                 change_id_info2, change_id_info));
4661
4662         torture_comment(tctx, "ChangeID tests succeeded\n\n");
4663
4664         return true;
4665 }
4666
4667 static bool test_SecondaryClosePrinter(struct torture_context *tctx,
4668                                        struct dcerpc_pipe *p,
4669                                        struct policy_handle *handle)
4670 {
4671         NTSTATUS status;
4672         struct dcerpc_binding *b;
4673         struct dcerpc_pipe *p2;
4674         struct spoolss_ClosePrinter cp;
4675
4676         /* only makes sense on SMB */
4677         if (p->conn->transport.transport != NCACN_NP) {
4678                 return true;
4679         }
4680
4681         torture_comment(tctx, "Testing close on secondary pipe\n");
4682
4683         status = dcerpc_parse_binding(tctx, p->conn->binding_string, &b);
4684         torture_assert_ntstatus_ok(tctx, status, "Failed to parse dcerpc binding");
4685
4686         status = dcerpc_secondary_connection(p, &p2, b);
4687         torture_assert_ntstatus_ok(tctx, status, "Failed to create secondary connection");
4688
4689         status = dcerpc_bind_auth_none(p2, &ndr_table_spoolss);
4690         torture_assert_ntstatus_ok(tctx, status, "Failed to create bind on secondary connection");
4691
4692         cp.in.handle = handle;
4693         cp.out.handle = handle;
4694
4695         status = dcerpc_spoolss_ClosePrinter_r(p2->binding_handle, tctx, &cp);
4696         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_NET_WRITE_FAULT,
4697                         "ERROR: Allowed close on secondary connection");
4698
4699         torture_assert_int_equal(tctx, p2->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
4700                                  "Unexpected fault code");
4701
4702         talloc_free(p2);
4703
4704         return true;
4705 }
4706
4707 static bool test_OpenPrinter_badname(struct torture_context *tctx,
4708                                      struct dcerpc_binding_handle *b, const char *name)
4709 {
4710         NTSTATUS status;
4711         struct spoolss_OpenPrinter op;
4712         struct spoolss_OpenPrinterEx opEx;
4713         struct policy_handle handle;
4714         bool ret = true;
4715
4716         op.in.printername       = name;
4717         op.in.datatype          = NULL;
4718         op.in.devmode_ctr.devmode= NULL;
4719         op.in.access_mask       = 0;
4720         op.out.handle           = &handle;
4721
4722         torture_comment(tctx, "Testing OpenPrinter(%s) with bad name\n", op.in.printername);
4723
4724         status = dcerpc_spoolss_OpenPrinter_r(b, tctx, &op);
4725         torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
4726         torture_assert_werr_equal(tctx, op.out.result, WERR_INVALID_PRINTER_NAME,
4727                 "unexpected result");
4728
4729         if (W_ERROR_IS_OK(op.out.result)) {
4730                 ret &=test_ClosePrinter(tctx, b, &handle);
4731         }
4732
4733         opEx.in.printername             = name;
4734         opEx.in.datatype                = NULL;
4735         opEx.in.devmode_ctr.devmode     = NULL;
4736         opEx.in.access_mask             = 0;
4737         opEx.in.level                   = 1;
4738         opEx.in.userlevel.level1        = NULL;
4739         opEx.out.handle                 = &handle;
4740
4741         torture_comment(tctx, "Testing OpenPrinterEx(%s) with bad name\n", opEx.in.printername);
4742
4743         status = dcerpc_spoolss_OpenPrinterEx_r(b, tctx, &opEx);
4744         torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
4745         torture_assert_werr_equal(tctx, opEx.out.result, WERR_INVALID_PARAM,
4746                 "unexpected result");
4747
4748         if (W_ERROR_IS_OK(opEx.out.result)) {
4749                 ret &=test_ClosePrinter(tctx, b, &handle);
4750         }
4751
4752         return ret;
4753 }
4754
4755 static bool test_OpenPrinter_badname_list(struct torture_context *tctx,
4756                                           struct dcerpc_binding_handle *b,
4757                                           const char *server_name)
4758 {
4759         const char *badnames[] = {
4760                 "__INVALID_PRINTER__",
4761                 "\\\\__INVALID_HOST__",
4762                 "",
4763                 "\\\\\\",
4764                 "\\\\\\__INVALID_PRINTER__"
4765         };
4766         const char *badname;
4767         int i;
4768
4769         for (i=0; i < ARRAY_SIZE(badnames); i++) {
4770                 torture_assert(tctx,
4771                         test_OpenPrinter_badname(tctx, b, badnames[i]),
4772                         "");
4773         }
4774
4775         badname = talloc_asprintf(tctx, "\\\\%s\\", server_name);
4776         torture_assert(tctx,
4777                 test_OpenPrinter_badname(tctx, b, badname),
4778                 "");
4779
4780         badname = talloc_asprintf(tctx, "\\\\%s\\__INVALID_PRINTER__", server_name);
4781         torture_assert(tctx,
4782                 test_OpenPrinter_badname(tctx, b, badname),
4783                 "");
4784
4785         return true;
4786 }
4787
4788 static bool test_OpenPrinter(struct torture_context *tctx,
4789                              struct dcerpc_pipe *p,
4790                              const char *name,
4791                              const char *environment)
4792 {
4793         NTSTATUS status;
4794         struct spoolss_OpenPrinter r;
4795         struct policy_handle handle;
4796         bool ret = true;
4797         struct dcerpc_binding_handle *b = p->binding_handle;
4798
4799         r.in.printername        = talloc_asprintf(tctx, "\\\\%s\\%s", dcerpc_server_name(p), name);
4800         r.in.datatype           = NULL;
4801         r.in.devmode_ctr.devmode= NULL;
4802         r.in.access_mask        = SEC_FLAG_MAXIMUM_ALLOWED;
4803         r.out.handle            = &handle;
4804
4805         torture_comment(tctx, "Testing OpenPrinter(%s)\n", r.in.printername);
4806
4807         status = dcerpc_spoolss_OpenPrinter_r(b, tctx, &r);
4808
4809         torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
4810
4811         torture_assert_werr_ok(tctx, r.out.result, "OpenPrinter failed");
4812
4813         if (!test_GetPrinter(tctx, b, &handle, environment)) {
4814                 ret = false;
4815         }
4816
4817         if (!torture_setting_bool(tctx, "samba3", false)) {
4818                 if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
4819                         ret = false;
4820                 }
4821         }
4822
4823         if (!test_ClosePrinter(tctx, b, &handle)) {
4824                 ret = false;
4825         }
4826
4827         return ret;
4828 }
4829
4830 static bool call_OpenPrinterEx(struct torture_context *tctx,
4831                                struct dcerpc_pipe *p,
4832                                const char *name,
4833                                struct spoolss_DeviceMode *devmode,
4834                                struct policy_handle *handle)
4835 {
4836         struct spoolss_OpenPrinterEx r;
4837         struct spoolss_UserLevel1 userlevel1;
4838         NTSTATUS status;
4839         struct dcerpc_binding_handle *b = p->binding_handle;
4840
4841         if (name && name[0]) {
4842                 r.in.printername = talloc_asprintf(tctx, "\\\\%s\\%s",
4843                                                    dcerpc_server_name(p), name);
4844         } else {
4845                 r.in.printername = talloc_asprintf(tctx, "\\\\%s",
4846                                                    dcerpc_server_name(p));
4847         }
4848
4849         r.in.datatype           = NULL;
4850         r.in.devmode_ctr.devmode= devmode;
4851         r.in.access_mask        = SEC_FLAG_MAXIMUM_ALLOWED;
4852         r.in.level              = 1;
4853         r.in.userlevel.level1   = &userlevel1;
4854         r.out.handle = handle;
4855
4856         userlevel1.size = 1234;
4857         userlevel1.client = "hello";
4858         userlevel1.user = "spottyfoot!";
4859         userlevel1.build = 1;
4860         userlevel1.major = 2;
4861         userlevel1.minor = 3;
4862         userlevel1.processor = 4;
4863
4864         torture_comment(tctx, "Testing OpenPrinterEx(%s)\n", r.in.printername);
4865
4866         status = dcerpc_spoolss_OpenPrinterEx_r(b, tctx, &r);
4867
4868         torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
4869
4870         torture_assert_werr_ok(tctx, r.out.result, "OpenPrinterEx failed");
4871
4872         return true;
4873 }
4874
4875 static bool test_printer_rename(struct torture_context *tctx,
4876                                 struct dcerpc_pipe *p,
4877                                 struct policy_handle *handle,
4878                                 const char *name)
4879 {
4880         bool ret = true;
4881         union spoolss_PrinterInfo info;
4882         union spoolss_SetPrinterInfo sinfo;
4883         struct spoolss_SetPrinterInfoCtr info_ctr;
4884         struct spoolss_DevmodeContainer devmode_ctr;
4885         struct sec_desc_buf secdesc_ctr;
4886         const char *printer_name;
4887         const char *printer_name_orig;
4888         const char *printer_name_new = "SAMBA smbtorture Test Printer (Copy 2)";
4889         struct policy_handle new_handle;
4890         const char *q;
4891         struct dcerpc_binding_handle *b = p->binding_handle;
4892
4893         ZERO_STRUCT(devmode_ctr);
4894         ZERO_STRUCT(secdesc_ctr);
4895
4896         torture_comment(tctx, "Testing Printer rename operations\n");
4897
4898         torture_assert(tctx,
4899                 test_GetPrinter_level(tctx, b, handle, 2, &info),
4900                 "failed to call GetPrinter level 2");
4901
4902         printer_name_orig = talloc_strdup(tctx, info.info2.printername);
4903
4904         q = strrchr(info.info2.printername, '\\');
4905         if (q) {
4906                 torture_warning(tctx,
4907                         "server returns printername %s incl. servername although we did not set servername", info.info2.printername);
4908         }
4909
4910         torture_assert(tctx,
4911                 PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
4912
4913         sinfo.info2->printername = printer_name_new;
4914
4915         info_ctr.level = 2;
4916         info_ctr.info = sinfo;
4917
4918         torture_assert(tctx,
4919                 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
4920                 "failed to call SetPrinter level 2");
4921
4922         torture_assert(tctx,
4923                 test_GetPrinter_level(tctx, b, handle, 2, &info),
4924                 "failed to call GetPrinter level 2");
4925
4926         printer_name = talloc_strdup(tctx, info.info2.printername);
4927
4928         q = strrchr(info.info2.printername, '\\');
4929         if (q) {
4930                 torture_warning(tctx,
4931                         "server returns printername %s incl. servername although we did not set servername", info.info2.printername);
4932                 q++;
4933                 printer_name = q;
4934         }
4935
4936         torture_assert_str_equal(tctx, printer_name, printer_name_new,
4937                 "new printer name was not set");
4938
4939         /* samba currently cannot fully rename printers */
4940         if (!torture_setting_bool(tctx, "samba3", false)) {
4941                 torture_assert(tctx,
4942                         test_OpenPrinter_badname(tctx, b, printer_name_orig),
4943                         "still can open printer with oldname after rename");
4944         } else {
4945                 torture_warning(tctx, "*not* checking for open with oldname after rename for samba3");
4946         }
4947
4948         torture_assert(tctx,
4949                 call_OpenPrinterEx(tctx, p, printer_name_new, NULL, &new_handle),
4950                 "failed to open printer with new name");
4951
4952         torture_assert(tctx,
4953                 test_GetPrinter_level(tctx, b, &new_handle, 2, &info),
4954                 "failed to call GetPrinter level 2");
4955
4956         /* FIXME: we openend with servername! */
4957         printer_name = talloc_asprintf(tctx, "\\\\%s\\%s",
4958                 dcerpc_server_name(p), printer_name_new);
4959
4960         torture_assert_str_equal(tctx, info.info2.printername, printer_name,
4961                 "new printer name was not set");
4962
4963         torture_assert(tctx,
4964                 test_ClosePrinter(tctx, b, &new_handle),
4965                 "failed to close printer");
4966
4967         torture_comment(tctx, "Printer rename operations test succeeded\n\n");
4968
4969         return ret;
4970 }
4971
4972
4973 static bool test_OpenPrinterEx(struct torture_context *tctx,
4974                                struct dcerpc_pipe *p,
4975                                const char *name,
4976                                const char *environment)
4977 {
4978         struct policy_handle handle;
4979         bool ret = true;
4980         struct dcerpc_binding_handle *b = p->binding_handle;
4981
4982         if (!call_OpenPrinterEx(tctx, p, name, NULL, &handle)) {
4983                 return false;
4984         }
4985
4986         if (!test_PrinterInfo_SD(tctx, b, &handle)) {
4987                 ret = false;
4988         }
4989
4990         if (!test_GetPrinter(tctx, b, &handle, environment)) {
4991                 ret = false;
4992         }
4993
4994         if (!test_EnumForms_all(tctx, b, &handle, false)) {
4995                 ret = false;
4996         }
4997
4998         if (!test_Forms(tctx, b, &handle, false, name, NULL, NULL)) {
4999                 ret = false;
5000         }
5001
5002         if (!test_Forms_winreg(tctx, b, &handle, false, name)) {
5003                 ret = false;
5004         }
5005
5006         if (!test_EnumPrinterData_all(tctx, p, &handle)) {
5007                 ret = false;
5008         }
5009
5010         if (!test_EnumPrinterDataEx(tctx, b, &handle, "PrinterDriverData", NULL, NULL)) {
5011                 ret = false;
5012         }
5013
5014         if (!test_EnumPrinterData_consistency(tctx, p, &handle)) {
5015                 ret = false;
5016         }
5017
5018         if (!test_printer_keys(tctx, b, &handle)) {
5019                 ret = false;
5020         }
5021
5022         if (!test_PausePrinter(tctx, b, &handle)) {
5023                 ret = false;
5024         }
5025
5026         if (!test_DoPrintTest(tctx, b, &handle)) {
5027                 ret = false;
5028         }
5029
5030         if (!test_ResumePrinter(tctx, b, &handle)) {
5031                 ret = false;
5032         }
5033
5034         if (!test_SetPrinterData_matrix(tctx, b, &handle, name, NULL, NULL)) {
5035                 ret = false;
5036         }
5037
5038         if (!test_SetPrinterDataEx_matrix(tctx, p, &handle, name, NULL, NULL)) {
5039                 ret = false;
5040         }
5041
5042         if (!torture_setting_bool(tctx, "samba3", false)) {
5043                 if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
5044                         ret = false;
5045                 }
5046         }
5047
5048         if (!test_ClosePrinter(tctx, b, &handle)) {
5049                 ret = false;
5050         }
5051
5052         return ret;
5053 }
5054
5055 static bool test_EnumPrinters_old(struct torture_context *tctx,
5056                                   struct dcerpc_pipe *p,
5057                                   const char *environment)
5058 {
5059         struct spoolss_EnumPrinters r;
5060         NTSTATUS status;
5061         uint16_t levels[] = {1, 2, 4, 5};
5062         int i;
5063         bool ret = true;
5064         struct dcerpc_binding_handle *b = p->binding_handle;
5065
5066         for (i=0;i<ARRAY_SIZE(levels);i++) {
5067                 union spoolss_PrinterInfo *info;
5068                 int j;
5069                 uint32_t needed;
5070                 uint32_t count;
5071
5072                 r.in.flags      = PRINTER_ENUM_LOCAL;
5073                 r.in.server     = "";
5074                 r.in.level      = levels[i];
5075                 r.in.buffer     = NULL;
5076                 r.in.offered    = 0;
5077                 r.out.needed    = &needed;
5078                 r.out.count     = &count;
5079                 r.out.info      = &info;
5080
5081                 torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
5082
5083                 status = dcerpc_spoolss_EnumPrinters_r(b, tctx, &r);
5084                 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
5085
5086                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
5087                         DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
5088                         r.in.buffer = &blob;
5089                         r.in.offered = needed;
5090                         status = dcerpc_spoolss_EnumPrinters_r(b, tctx, &r);
5091                 }
5092
5093                 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
5094
5095                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
5096
5097                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
5098
5099                 if (!info) {
5100                         torture_comment(tctx, "No printers returned\n");
5101                         return true;
5102                 }
5103
5104                 for (j=0;j<count;j++) {
5105                         if (r.in.level == 1) {
5106                                 char *unc = talloc_strdup(tctx, info[j].info1.name);
5107                                 char *slash, *name;
5108                                 name = unc;
5109                                 if (unc[0] == '\\' && unc[1] == '\\') {
5110                                         unc +=2;
5111                                 }
5112                                 slash = strchr(unc, '\\');
5113                                 if (slash) {
5114                                         slash++;
5115                                         name = slash;
5116                                 }
5117                                 if (!test_OpenPrinter(tctx, p, name, environment)) {
5118                                         ret = false;
5119                                 }
5120                                 if (!test_OpenPrinterEx(tctx, p, name, environment)) {
5121                                         ret = false;
5122                                 }
5123                         }
5124                 }
5125         }
5126
5127         return ret;
5128 }
5129
5130 static bool test_GetPrinterDriver(struct torture_context *tctx,
5131                                   struct dcerpc_binding_handle *b,
5132                                   struct policy_handle *handle,
5133                                   const char *driver_name)
5134 {
5135         struct spoolss_GetPrinterDriver r;
5136         uint32_t needed;
5137
5138         r.in.handle = handle;
5139         r.in.architecture = "W32X86";
5140         r.in.level = 1;
5141         r.in.buffer = NULL;
5142         r.in.offered = 0;
5143         r.out.needed = &needed;
5144
5145         torture_comment(tctx, "Testing GetPrinterDriver level %d\n", r.in.level);
5146
5147         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver_r(b, tctx, &r),
5148                 "failed to call GetPrinterDriver");
5149         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
5150                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
5151                 r.in.buffer = &blob;
5152                 r.in.offered = needed;
5153                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver_r(b, tctx, &r),
5154                         "failed to call GetPrinterDriver");
5155         }
5156
5157         torture_assert_werr_ok(tctx, r.out.result,
5158                 "failed to call GetPrinterDriver");
5159
5160         CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
5161
5162         return true;
5163 }
5164
5165 static bool test_GetPrinterDriver2(struct torture_context *tctx,
5166                                    struct dcerpc_binding_handle *b,
5167                                    struct policy_handle *handle,
5168                                    const char *driver_name,
5169                                    const char *architecture)
5170 {
5171         struct spoolss_GetPrinterDriver2 r;
5172         uint16_t levels[] = {1, 2, 3, 4, 5, 6, 8, 101 };
5173         uint32_t needed;
5174         uint32_t server_major_version;
5175         uint32_t server_minor_version;
5176         int i;
5177
5178         r.in.handle = handle;
5179         r.in.architecture = architecture;
5180         r.in.client_major_version = 3;
5181         r.in.client_minor_version = 0;
5182         r.out.needed = &needed;
5183         r.out.server_major_version = &server_major_version;
5184         r.out.server_minor_version = &server_minor_version;
5185
5186         for (i=0;i<ARRAY_SIZE(levels);i++) {
5187
5188                 r.in.buffer = NULL;
5189                 r.in.offered = 0;
5190                 r.in.level = levels[i];
5191
5192                 torture_comment(tctx, "Testing GetPrinterDriver2(%s) level %d\n",
5193                         driver_name, r.in.level);
5194
5195                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver2_r(b, tctx, &r),
5196                         "failed to call GetPrinterDriver2");
5197                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
5198                         DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
5199                         r.in.buffer = &blob;
5200                         r.in.offered = needed;
5201                         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver2_r(b, tctx, &r),
5202                                 "failed to call GetPrinterDriver2");
5203                 }
5204
5205                 if (W_ERROR_EQUAL(r.out.result, WERR_INVALID_LEVEL)) {
5206                         switch (r.in.level) {
5207                         case 101:
5208                         case 8:
5209                                 continue;
5210                         default:
5211                                 break;
5212                         }
5213                 }
5214
5215                 torture_assert_werr_ok(tctx, r.out.result,
5216                         "failed to call GetPrinterDriver2");
5217
5218                 CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
5219         }
5220
5221         return true;
5222 }
5223
5224 static bool test_EnumPrinterDrivers_old(struct torture_context *tctx,
5225                                         struct dcerpc_pipe *p,
5226                                         const char *environment)
5227 {
5228         struct spoolss_EnumPrinterDrivers r;
5229         NTSTATUS status;
5230         uint16_t levels[] = {1, 2, 3, 4, 5, 6};
5231         int i;
5232         struct dcerpc_binding_handle *b = p->binding_handle;
5233
5234         for (i=0;i<ARRAY_SIZE(levels);i++) {
5235
5236                 uint32_t needed;
5237                 uint32_t count;
5238                 union spoolss_DriverInfo *info;
5239
5240                 r.in.server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
5241                 r.in.environment = environment;
5242                 r.in.level = levels[i];
5243                 r.in.buffer = NULL;
5244                 r.in.offered = 0;
5245                 r.out.needed = &needed;
5246                 r.out.count = &count;
5247                 r.out.info = &info;
5248
5249                 torture_comment(tctx, "Testing EnumPrinterDrivers level %u\n", r.in.level);
5250
5251                 status = dcerpc_spoolss_EnumPrinterDrivers_r(b, tctx, &r);
5252
5253                 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDrivers failed");
5254
5255                 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
5256                         DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
5257                         r.in.buffer = &blob;
5258                         r.in.offered = needed;
5259                         status = dcerpc_spoolss_EnumPrinterDrivers_r(b, tctx, &r);
5260                 }
5261
5262                 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDrivers failed");
5263
5264                 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDrivers failed");
5265
5266                 if (!info) {
5267                         torture_comment(tctx, "No printer drivers returned\n");
5268                         break;
5269                 }
5270
5271                 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinterDrivers, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
5272         }
5273
5274         return true;
5275 }
5276
5277 static bool test_DeletePrinter(struct torture_context *tctx,
5278                                struct dcerpc_binding_handle *b,
5279                                struct policy_handle *handle)
5280 {
5281         struct spoolss_DeletePrinter r;
5282
5283         torture_comment(tctx, "Testing DeletePrinter\n");
5284
5285         r.in.handle = handle;
5286
5287         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_DeletePrinter_r(b, tctx, &r),
5288                 "failed to delete printer");
5289         torture_assert_werr_ok(tctx, r.out.result,
5290                 "failed to delete printer");
5291
5292         return true;
5293 }
5294
5295 static bool test_EnumPrinters_findname(struct torture_context *tctx,
5296                                        struct dcerpc_binding_handle *b,
5297                                        uint32_t flags,
5298                                        uint32_t level,
5299                                        const char *name,
5300                                        bool *found)
5301 {
5302         struct spoolss_EnumPrinters e;
5303         uint32_t count;
5304         union spoolss_PrinterInfo *info;
5305         uint32_t needed;
5306         int i;
5307
5308         *found = false;
5309
5310         e.in.flags = flags;
5311         e.in.server = NULL;
5312         e.in.level = level;
5313         e.in.buffer = NULL;
5314         e.in.offered = 0;
5315         e.out.count = &count;
5316         e.out.info = &info;
5317         e.out.needed = &needed;
5318
5319         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters_r(b, tctx, &e),
5320                 "failed to enum printers");
5321
5322         if (W_ERROR_EQUAL(e.out.result, WERR_INSUFFICIENT_BUFFER)) {
5323                 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
5324                 e.in.buffer = &blob;
5325                 e.in.offered = needed;
5326
5327                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters_r(b, tctx, &e),
5328                         "failed to enum printers");
5329         }
5330
5331         torture_assert_werr_ok(tctx, e.out.result,
5332                 "failed to enum printers");
5333
5334         for (i=0; i < count; i++) {
5335
5336                 const char *current = NULL;
5337                 const char *q;
5338
5339                 switch (level) {
5340                 case 1:
5341                         current = info[i].info1.name;
5342                         break;
5343                 }
5344
5345                 if (strequal(current, name)) {
5346                         *found = true;
5347                         break;
5348                 }
5349
5350                 q = strrchr(current, '\\');
5351                 if (q) {
5352                         if (!e.in.server) {
5353                                 torture_warning(tctx,
5354                                         "server returns printername %s incl. servername although we did not set servername", current);
5355                         }
5356                         q++;
5357                         if (strequal(q, name)) {
5358                                 *found = true;
5359                                 break;
5360                         }
5361                 }
5362         }
5363
5364         return true;
5365 }
5366
5367 static bool test_AddPrinter_wellknown(struct torture_context *tctx,
5368                                       struct dcerpc_pipe *p,
5369                                       const char *printername,
5370                                       bool ex)
5371 {
5372         WERROR result;
5373         struct spoolss_AddPrinter r;
5374         struct spoolss_AddPrinterEx rex;
5375         struct spoolss_SetPrinterInfoCtr info_ctr;
5376         struct spoolss_SetPrinterInfo1 info1;
5377         struct spoolss_DevmodeContainer devmode_ctr;
5378         struct sec_desc_buf secdesc_ctr;
5379         struct spoolss_UserLevelCtr userlevel_ctr;
5380         struct policy_handle handle;
5381         bool found = false;
5382         struct dcerpc_binding_handle *b = p->binding_handle;
5383
5384         ZERO_STRUCT(devmode_ctr);
5385         ZERO_STRUCT(secdesc_ctr);
5386         ZERO_STRUCT(userlevel_ctr);
5387         ZERO_STRUCT(info1);
5388
5389         torture_comment(tctx, "Testing AddPrinter%s level 1\n", ex ? "Ex":"");
5390
5391         /* try to add printer to wellknown printer list (level 1) */
5392
5393         userlevel_ctr.level = 1;
5394
5395         info_ctr.info.info1 = &info1;
5396         info_ctr.level = 1;
5397
5398         rex.in.server = NULL;
5399         rex.in.info_ctr = &info_ctr;
5400         rex.in.devmode_ctr = &devmode_ctr;
5401         rex.in.secdesc_ctr = &secdesc_ctr;
5402         rex.in.userlevel_ctr = &userlevel_ctr;
5403         rex.out.handle = &handle;
5404
5405         r.in.server = NULL;
5406         r.in.info_ctr = &info_ctr;
5407         r.in.devmode_ctr = &devmode_ctr;
5408         r.in.secdesc_ctr = &secdesc_ctr;
5409         r.out.handle = &handle;
5410
5411         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
5412                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
5413                 "failed to add printer");
5414         result = ex ? rex.out.result : r.out.result;
5415         torture_assert_werr_equal(tctx, result, WERR_INVALID_PRINTER_NAME,
5416                 "unexpected result code");
5417
5418         info1.name = printername;
5419         info1.flags = PRINTER_ATTRIBUTE_SHARED;
5420
5421         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
5422                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
5423                 "failed to add printer");
5424         result = ex ? rex.out.result : r.out.result;
5425         torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
5426                 "unexpected result code");
5427
5428         /* bizarre protocol, WERR_PRINTER_ALREADY_EXISTS means success here,
5429            better do a real check to see the printer is really there */
5430
5431         torture_assert(tctx, test_EnumPrinters_findname(tctx, b,
5432                                                         PRINTER_ENUM_NETWORK, 1,
5433                                                         printername,
5434                                                         &found),
5435                         "failed to enum printers");
5436
5437         torture_assert(tctx, found, "failed to find newly added printer");
5438
5439         info1.flags = 0;
5440
5441         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
5442                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
5443                 "failed to add printer");
5444         result = ex ? rex.out.result : r.out.result;
5445         torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
5446                 "unexpected result code");
5447
5448         /* bizarre protocol, WERR_PRINTER_ALREADY_EXISTS means success here,
5449            better do a real check to see the printer has really been removed
5450            from the well known printer list */
5451
5452         found = false;
5453
5454         torture_assert(tctx, test_EnumPrinters_findname(tctx, b,
5455                                                         PRINTER_ENUM_NETWORK, 1,
5456                                                         printername,
5457                                                         &found),
5458                         "failed to enum printers");
5459 #if 0
5460         torture_assert(tctx, !found, "printer still in well known printer list");
5461 #endif
5462         return true;
5463 }
5464
5465 static bool test_AddPrinter_normal(struct torture_context *tctx,
5466                                    struct dcerpc_pipe *p,
5467                                    struct policy_handle *handle_p,
5468                                    const char *printername,
5469                                    const char *drivername,
5470                                    const char *portname,
5471                                    bool ex)
5472 {
5473         WERROR result;
5474         struct spoolss_AddPrinter r;
5475         struct spoolss_AddPrinterEx rex;
5476         struct spoolss_SetPrinterInfoCtr info_ctr;
5477         struct spoolss_SetPrinterInfo2 info2;
5478         struct spoolss_DevmodeContainer devmode_ctr;
5479         struct sec_desc_buf secdesc_ctr;
5480         struct spoolss_UserLevelCtr userlevel_ctr;
5481         struct policy_handle handle;
5482         bool found = false;
5483         bool existing_printer_deleted = false;
5484         struct dcerpc_binding_handle *b = p->binding_handle;
5485
5486         ZERO_STRUCT(devmode_ctr);
5487         ZERO_STRUCT(secdesc_ctr);
5488         ZERO_STRUCT(userlevel_ctr);
5489
5490         torture_comment(tctx, "Testing AddPrinter%s level 2\n", ex ? "Ex":"");
5491
5492         userlevel_ctr.level = 1;
5493
5494         rex.in.server = NULL;
5495         rex.in.info_ctr = &info_ctr;
5496         rex.in.devmode_ctr = &devmode_ctr;
5497         rex.in.secdesc_ctr = &secdesc_ctr;
5498         rex.in.userlevel_ctr = &userlevel_ctr;
5499         rex.out.handle = &handle;
5500
5501         r.in.server = NULL;
5502         r.in.info_ctr = &info_ctr;
5503         r.in.devmode_ctr = &devmode_ctr;
5504         r.in.secdesc_ctr = &secdesc_ctr;
5505         r.out.handle = &handle;
5506
5507  again:
5508
5509         /* try to add printer to printer list (level 2) */
5510
5511         ZERO_STRUCT(info2);
5512
5513         info_ctr.info.info2 = &info2;
5514         info_ctr.level = 2;
5515
5516         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
5517                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
5518                 "failed to add printer");
5519         result = ex ? rex.out.result : r.out.result;
5520         torture_assert_werr_equal(tctx, result, WERR_INVALID_PRINTER_NAME,
5521                 "unexpected result code");
5522
5523         info2.printername = printername;
5524
5525         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
5526                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
5527                 "failed to add printer");
5528         result = ex ? rex.out.result : r.out.result;
5529
5530         if (W_ERROR_EQUAL(result, WERR_PRINTER_ALREADY_EXISTS)) {
5531                 struct policy_handle printer_handle;
5532
5533                 if (existing_printer_deleted) {
5534                         torture_fail(tctx, "already deleted printer still existing?");
5535                 }
5536
5537                 torture_assert(tctx, call_OpenPrinterEx(tctx, p, printername, NULL, &printer_handle),
5538                         "failed to open printer handle");
5539
5540                 torture_assert(tctx, test_DeletePrinter(tctx, b, &printer_handle),
5541                         "failed to delete printer");
5542
5543                 torture_assert(tctx, test_ClosePrinter(tctx, b, &printer_handle),
5544                         "failed to close server handle");
5545
5546                 existing_printer_deleted = true;
5547
5548                 goto again;
5549         }
5550
5551         torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PORT,
5552                 "unexpected result code");
5553
5554         info2.portname = portname;
5555
5556         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
5557                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
5558                 "failed to add printer");
5559         result = ex ? rex.out.result : r.out.result;
5560         torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PRINTER_DRIVER,
5561                 "unexpected result code");
5562
5563         info2.drivername = drivername;
5564
5565         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
5566                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
5567                 "failed to add printer");
5568         result = ex ? rex.out.result : r.out.result;
5569
5570         /* w2k8r2 allows to add printer w/o defining printprocessor */
5571
5572         if (!W_ERROR_IS_OK(result)) {
5573                 torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PRINTPROCESSOR,
5574                         "unexpected result code");
5575
5576                 info2.printprocessor = "winprint";
5577
5578                 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
5579                                                       dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
5580                         "failed to add printer");
5581                 result = ex ? rex.out.result : r.out.result;
5582                 torture_assert_werr_ok(tctx, result,
5583                         "failed to add printer");
5584         }
5585
5586         *handle_p = handle;
5587
5588         /* we are paranoid, really check if the printer is there now */
5589
5590         torture_assert(tctx, test_EnumPrinters_findname(tctx, b,
5591                                                         PRINTER_ENUM_LOCAL, 1,
5592                                                         printername,
5593                                                         &found),
5594                         "failed to enum printers");
5595         torture_assert(tctx, found, "failed to find newly added printer");
5596
5597         torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
5598                                               dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
5599                 "failed to add printer");
5600         result = ex ? rex.out.result : r.out.result;
5601         torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
5602                 "unexpected result code");
5603
5604         return true;
5605 }
5606
5607 static bool test_AddPrinterEx(struct torture_context *tctx,
5608                               struct dcerpc_pipe *p,
5609                               struct policy_handle *handle_p,
5610                               const char *printername,
5611                               const char *drivername,
5612                               const char *portname)
5613 {
5614         bool ret = true;
5615
5616         if (!torture_setting_bool(tctx, "samba3", false)) {
5617                 if (!test_AddPrinter_wellknown(tctx, p, TORTURE_WELLKNOWN_PRINTER_EX, true)) {
5618                         torture_comment(tctx, "failed to add printer to well known list\n");
5619                         ret = false;
5620                 }
5621         }
5622
5623         if (!test_AddPrinter_normal(tctx, p, handle_p,
5624                                     printername, drivername, portname,
5625                                     true)) {
5626                 torture_comment(tctx, "failed to add printer to printer list\n");
5627                 ret = false;
5628         }
5629
5630         return ret;
5631 }
5632
5633 static bool test_AddPrinter(struct torture_context *tctx,
5634                             struct dcerpc_pipe *p,
5635                             struct policy_handle *handle_p,
5636                             const char *printername,
5637                             const char *drivername,
5638                             const char *portname)
5639 {
5640         bool ret = true;
5641
5642         if (!torture_setting_bool(tctx, "samba3", false)) {
5643                 if (!test_AddPrinter_wellknown(tctx, p, TORTURE_WELLKNOWN_PRINTER, false)) {
5644                         torture_comment(tctx, "failed to add printer to well known list\n");
5645                         ret = false;
5646                 }
5647         }
5648
5649         if (!test_AddPrinter_normal(tctx, p, handle_p,
5650                                     printername, drivername, portname,
5651                                     false)) {
5652                 torture_comment(tctx, "failed to add printer to printer list\n");
5653                 ret = false;
5654         }
5655
5656         return ret;
5657 }
5658
5659 static bool test_printer_info(struct torture_context *tctx,
5660                               struct dcerpc_binding_handle *b,
5661                               struct policy_handle *handle)
5662 {
5663         bool ret = true;
5664
5665         if (torture_setting_bool(tctx, "samba3", false)) {
5666                 torture_skip(tctx, "skipping printer info cross tests against samba 3");
5667         }
5668
5669         if (!test_PrinterInfo(tctx, b, handle)) {
5670                 ret = false;
5671         }
5672
5673         if (!test_SetPrinter_errors(tctx, b, handle)) {
5674                 ret = false;
5675         }
5676
5677         return ret;
5678 }
5679
5680 static bool test_EnumPrinterKey(struct torture_context *tctx,
5681                                 struct dcerpc_binding_handle *b,
5682                                 struct policy_handle *handle,
5683                                 const char *key_name,
5684                                 const char ***array)
5685 {
5686         struct spoolss_EnumPrinterKey r;
5687         uint32_t needed = 0;
5688         union spoolss_KeyNames key_buffer;
5689         int32_t offered[] = { 0, 1, 2, 3, 4, 5, -1, -2, -3, -4, -5, 256, 512, 1024, 2048 };
5690         uint32_t _ndr_size;
5691         int i;
5692
5693         r.in.handle = handle;
5694         r.in.key_name = key_name;
5695         r.out.key_buffer = &key_buffer;
5696         r.out.needed = &needed;
5697         r.out._ndr_size = &_ndr_size;
5698
5699         for (i=0; i < ARRAY_SIZE(offered); i++) {
5700
5701                 if (offered[i] < 0 && needed) {
5702                         if (needed <= 4) {
5703                                 continue;
5704                         }
5705                         r.in.offered = needed + offered[i];
5706                 } else {
5707                         r.in.offered = offered[i];
5708                 }
5709
5710                 ZERO_STRUCT(key_buffer);
5711
5712                 torture_comment(tctx, "Testing EnumPrinterKey(%s) with %d offered\n", r.in.key_name, r.in.offered);
5713
5714                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterKey_r(b, tctx, &r),
5715                         "failed to call EnumPrinterKey");
5716                 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
5717
5718                         torture_assert(tctx, (_ndr_size == r.in.offered/2),
5719                                 talloc_asprintf(tctx, "EnumPrinterKey size mismatch, _ndr_size %d (expected %d)",
5720                                         _ndr_size, r.in.offered/2));
5721
5722                         r.in.offered = needed;
5723                         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterKey_r(b, tctx, &r),
5724                                 "failed to call EnumPrinterKey");
5725                 }
5726
5727                 if (offered[i] > 0) {
5728                         torture_assert_werr_ok(tctx, r.out.result,
5729                                 "failed to call EnumPrinterKey");
5730                 }
5731
5732                 torture_assert(tctx, (_ndr_size == r.in.offered/2),
5733                         talloc_asprintf(tctx, "EnumPrinterKey size mismatch, _ndr_size %d (expected %d)",
5734                                 _ndr_size, r.in.offered/2));
5735
5736                 torture_assert(tctx, (*r.out.needed <= r.in.offered),
5737                         talloc_asprintf(tctx, "EnumPrinterKey size mismatch: needed %d is not <= offered %d", *r.out.needed, r.in.offered));
5738
5739                 torture_assert(tctx, (*r.out.needed <= _ndr_size * 2),
5740                         talloc_asprintf(tctx, "EnumPrinterKey size mismatch: needed %d is not <= _ndr_size %d * 2", *r.out.needed, _ndr_size));
5741
5742                 if (key_buffer.string_array) {
5743                         uint32_t calc_needed = 0;
5744                         int s;
5745                         for (s=0; key_buffer.string_array[s]; s++) {
5746                                 calc_needed += strlen_m_term(key_buffer.string_array[s])*2;
5747                         }
5748                         if (!key_buffer.string_array[0]) {
5749                                 calc_needed += 2;
5750                         }
5751                         calc_needed += 2;
5752
5753                         torture_assert_int_equal(tctx, *r.out.needed, calc_needed,
5754                                 "EnumPrinterKey unexpected size");
5755                 }
5756         }
5757
5758         if (array) {
5759                 *array = key_buffer.string_array;
5760         }
5761
5762         return true;
5763 }
5764
5765 bool test_printer_keys(struct torture_context *tctx,
5766                        struct dcerpc_binding_handle *b,
5767                        struct policy_handle *handle)
5768 {
5769         const char **key_array = NULL;
5770         int i;
5771
5772         torture_comment(tctx, "Testing Printer Keys\n");
5773
5774         torture_assert(tctx, test_EnumPrinterKey(tctx, b, handle, "", &key_array),
5775                 "failed to call test_EnumPrinterKey");
5776
5777         for (i=0; key_array && key_array[i]; i++) {
5778                 torture_assert(tctx, test_EnumPrinterKey(tctx, b, handle, key_array[i], NULL),
5779                         "failed to call test_EnumPrinterKey");
5780         }
5781         for (i=0; key_array && key_array[i]; i++) {
5782                 torture_assert(tctx, test_EnumPrinterDataEx(tctx, b, handle, key_array[i], NULL, NULL),
5783                         "failed to call test_EnumPrinterDataEx");
5784         }
5785
5786         torture_comment(tctx, "Printer Keys test succeeded\n\n");
5787
5788         return true;
5789 }
5790
5791 static bool test_one_printer(struct torture_context *tctx,
5792                              struct dcerpc_pipe *p,
5793                              struct policy_handle *handle,
5794                              const char *name)
5795 {
5796         bool ret = true;
5797         struct dcerpc_binding_handle *b = p->binding_handle;
5798
5799         if (!test_PausePrinter(tctx, b, handle)) {
5800                 ret = false;
5801         }
5802
5803         if (!test_DoPrintTest(tctx, b, handle)) {
5804                 ret = false;
5805         }
5806
5807         if (!test_ResumePrinter(tctx, b, handle)) {
5808                 ret = false;
5809         }
5810
5811         if (!test_printer_info(tctx, b, handle)) {
5812                 ret = false;
5813         }
5814
5815         if (!test_PrinterInfo_SD(tctx, b, handle)) {
5816                 ret = false;
5817         }
5818
5819         if (!test_PrinterInfo_DevMode(tctx, p, handle, name)) {
5820                 ret = false;
5821         }
5822
5823         if (!test_PrinterInfo_winreg(tctx, p, handle, name)) {
5824                 ret = false;
5825         }
5826
5827         if (!test_ChangeID(tctx, p, handle)) {
5828                 ret = false;
5829         }
5830
5831         if (!test_printer_keys(tctx, b, handle)) {
5832                 ret = false;
5833         }
5834
5835         if (!test_EnumPrinterData_consistency(tctx, p, handle)) {
5836                 ret = false;
5837         }
5838
5839         if (!test_SetPrinterDataEx_matrix(tctx, p, handle, name, NULL, NULL)) {
5840                 ret = false;
5841         }
5842
5843         if (!test_PrinterData_winreg(tctx, p, handle, name)) {
5844                 ret = false;
5845         }
5846
5847         if (!test_printer_rename(tctx, p, handle, name)) {
5848                 ret = false;
5849         }
5850
5851         return ret;
5852 }
5853
5854 static bool test_printer(struct torture_context *tctx,
5855                          struct dcerpc_pipe *p)
5856 {
5857         bool ret = true;
5858         struct policy_handle handle[2];
5859         bool found = false;
5860         const char *drivername = "Microsoft XPS Document Writer";
5861         const char *portname = "LPT1:";
5862         struct dcerpc_binding_handle *b = p->binding_handle;
5863
5864         /* test printer created via AddPrinter */
5865
5866         if (!test_AddPrinter(tctx, p, &handle[0], TORTURE_PRINTER, drivername, portname)) {
5867                 return false;
5868         }
5869
5870         if (!test_one_printer(tctx, p, &handle[0], TORTURE_PRINTER)) {
5871                 ret = false;
5872         }
5873
5874         if (!test_DeletePrinter(tctx, b, &handle[0])) {
5875                 ret = false;
5876         }
5877
5878         if (!test_EnumPrinters_findname(tctx, b, PRINTER_ENUM_LOCAL, 1,
5879                                         TORTURE_PRINTER, &found)) {
5880                 ret = false;
5881         }
5882
5883         torture_assert(tctx, !found, "deleted printer still there");
5884
5885         /* test printer created via AddPrinterEx */
5886
5887         if (!test_AddPrinterEx(tctx, p, &handle[1], TORTURE_PRINTER_EX, drivername, portname)) {
5888                 return false;
5889         }
5890
5891         if (!test_one_printer(tctx, p, &handle[1], TORTURE_PRINTER_EX)) {
5892                 ret = false;
5893         }
5894
5895         if (!test_DeletePrinter(tctx, b, &handle[1])) {
5896                 ret = false;
5897         }
5898
5899         if (!test_EnumPrinters_findname(tctx, b, PRINTER_ENUM_LOCAL, 1,
5900                                         TORTURE_PRINTER_EX, &found)) {
5901                 ret = false;
5902         }
5903
5904         torture_assert(tctx, !found, "deleted printer still there");
5905
5906         return ret;
5907 }
5908
5909 static bool test_architecture_buffer(struct torture_context *tctx,
5910                                      struct dcerpc_pipe *p)
5911 {
5912         struct spoolss_OpenPrinterEx r;
5913         struct spoolss_UserLevel1 u1;
5914         struct policy_handle handle;
5915         uint32_t architectures[] = {
5916                 PROCESSOR_ARCHITECTURE_INTEL,
5917                 PROCESSOR_ARCHITECTURE_IA64,
5918                 PROCESSOR_ARCHITECTURE_AMD64
5919         };
5920         uint32_t needed[3];
5921         int i;
5922         struct dcerpc_binding_handle *b = p->binding_handle;
5923
5924         for (i=0; i < ARRAY_SIZE(architectures); i++) {
5925
5926                 torture_comment(tctx, "Testing OpenPrinterEx with architecture %d\n", architectures[i]);
5927
5928                 u1.size = 0;
5929                 u1.client = NULL;
5930                 u1.user = NULL;
5931                 u1.build = 0;
5932                 u1.major = 3;
5933                 u1.minor = 0;
5934                 u1.processor = architectures[i];
5935
5936                 r.in.printername        = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
5937                 r.in.datatype           = NULL;
5938                 r.in.devmode_ctr.devmode= NULL;
5939                 r.in.access_mask        = SEC_FLAG_MAXIMUM_ALLOWED;
5940                 r.in.level               = 1;
5941                 r.in.userlevel.level1   = &u1;
5942                 r.out.handle            = &handle;
5943
5944                 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_OpenPrinterEx_r(b, tctx, &r), "");
5945                 torture_assert_werr_ok(tctx, r.out.result, "");
5946
5947                 {
5948                         struct spoolss_EnumPrinters e;
5949                         uint32_t count;
5950                         union spoolss_PrinterInfo *info;
5951
5952                         e.in.flags = PRINTER_ENUM_LOCAL;
5953                         e.in.server = NULL;
5954                         e.in.level = 2;
5955                         e.in.buffer = NULL;
5956                         e.in.offered = 0;
5957                         e.out.count = &count;
5958                         e.out.info = &info;
5959                         e.out.needed = &needed[i];
5960
5961                         torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters_r(b, tctx, &e), "");
5962 #if 0
5963                         torture_comment(tctx, "needed was %d\n", needed[i]);
5964 #endif
5965                 }
5966
5967                 torture_assert(tctx, test_ClosePrinter(tctx, b, &handle), "");
5968         }
5969
5970         for (i=1; i < ARRAY_SIZE(architectures); i++) {
5971                 if (needed[i-1] != needed[i]) {
5972                         torture_fail(tctx,
5973                                 talloc_asprintf(tctx, "needed size %d for architecture %d != needed size %d for architecture %d\n",
5974                                                 needed[i-1], architectures[i-1], needed[i], architectures[i]));
5975                 }
5976         }
5977
5978         return true;
5979 }
5980
5981 bool torture_rpc_spoolss(struct torture_context *torture)
5982 {
5983         NTSTATUS status;
5984         struct dcerpc_pipe *p;
5985         struct dcerpc_binding_handle *b;
5986         bool ret = true;
5987         struct test_spoolss_context *ctx;
5988         const char *environment = SPOOLSS_ARCHITECTURE_NT_X86;
5989
5990         status = torture_rpc_connection(torture, &p, &ndr_table_spoolss);
5991         if (!NT_STATUS_IS_OK(status)) {
5992                 return false;
5993         }
5994         b = p->binding_handle;
5995
5996         ctx = talloc_zero(torture, struct test_spoolss_context);
5997
5998         ret &= test_OpenPrinter_server(torture, p, &ctx->server_handle);
5999         ret &= test_GetPrinterData_list(torture, p, &ctx->server_handle, &environment);
6000         ret &= test_EnumForms_all(torture, b, &ctx->server_handle, true);
6001         ret &= test_Forms(torture, b, &ctx->server_handle, true, NULL, NULL, NULL);
6002         ret &= test_Forms_winreg(torture, b, &ctx->server_handle, true, NULL);
6003         ret &= test_EnumPorts(torture, b, ctx);
6004         ret &= test_GetPrinterDriverDirectory(torture, p, environment);
6005         ret &= test_GetPrintProcessorDirectory(torture, p, environment);
6006         ret &= test_EnumPrinterDrivers(torture, p, ctx, environment);
6007         ret &= test_EnumPrinterDrivers(torture, p, ctx, SPOOLSS_ARCHITECTURE_ALL);
6008         ret &= test_EnumMonitors(torture, b, ctx);
6009         ret &= test_EnumPrintProcessors(torture, b, ctx, environment);
6010         ret &= test_EnumPrintProcDataTypes(torture, b);
6011         ret &= test_EnumPrinters(torture, b, ctx);
6012         ret &= test_OpenPrinter_badname_list(torture, b, dcerpc_server_name(p));
6013
6014         ret &= test_AddPort(torture, p);
6015         ret &= test_EnumPorts_old(torture, p);
6016         ret &= test_EnumPrinters_old(torture, p, environment);
6017         ret &= test_EnumPrinterDrivers_old(torture, p, environment);
6018         ret &= test_architecture_buffer(torture, p);
6019
6020         return ret;
6021 }
6022
6023 struct torture_suite *torture_rpc_spoolss_printer(TALLOC_CTX *mem_ctx)
6024 {
6025         struct torture_suite *suite = torture_suite_create(mem_ctx, "SPOOLSS-PRINTER");
6026
6027         struct torture_rpc_tcase *tcase = torture_suite_add_rpc_iface_tcase(suite,
6028                                                         "printer", &ndr_table_spoolss);
6029
6030         torture_rpc_tcase_add_test(tcase, "printer", test_printer);
6031
6032         return suite;
6033 }