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