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