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