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