?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4-smbtorture: also test for "all" architecture in enum driver tests in RPC-SPOOLSS.
[Samba/aatanasov.git] / source4 / torture / rpc / spoolss.c
blob464049405c759eaae0c7b96179325d6db578bb42
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
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "torture/torture.h"
25 #include "torture/rpc/rpc.h"
26 #include "librpc/gen_ndr/ndr_spoolss_c.h"
27
28 struct test_spoolss_context {
29 /* print server handle */
30 struct policy_handle server_handle;
31
32 /* for EnumPorts */
33 uint32_t port_count[3];
34 union spoolss_PortInfo *ports[3];
35
36 /* for EnumPrinterDrivers */
37 uint32_t driver_count[7];
38 union spoolss_DriverInfo *drivers[7];
39
40 /* for EnumMonitors */
41 uint32_t monitor_count[3];
42 union spoolss_MonitorInfo *monitors[3];
43
44 /* for EnumPrintProcessors */
45 uint32_t print_processor_count[2];
46 union spoolss_PrintProcessorInfo *print_processors[2];
47
48 /* for EnumPrinters */
49 uint32_t printer_count[6];
50 union spoolss_PrinterInfo *printers[6];
51 };
52
53 #define COMPARE_STRING(tctx, c,r,e) \
54 torture_assert_str_equal(tctx, c.e, r.e, "invalid value")
55
56 /* not every compiler supports __typeof__() */
57 #if (__GNUC__ >= 3)
58 #define _CHECK_FIELD_SIZE(c,r,e,type) do {\
59 if (sizeof(__typeof__(c.e)) != sizeof(type)) { \
60 torture_fail(tctx, #c "." #e "field is not " #type "\n"); \
61 }\
62 if (sizeof(__typeof__(r.e)) != sizeof(type)) { \
63 torture_fail(tctx, #r "." #e "field is not " #type "\n"); \
64 }\
65 } while(0)
66 #else
67 #define _CHECK_FIELD_SIZE(c,r,e,type) do {} while(0)
68 #endif
69
70 #define COMPARE_UINT32(tctx, c, r, e) do {\
71 _CHECK_FIELD_SIZE(c, r, e, uint32_t); \
72 torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
73 } while(0)
74
75 #define COMPARE_STRING_ARRAY(tctx, c,r,e)
76
77 static bool test_OpenPrinter_server(struct torture_context *tctx, struct dcerpc_pipe *p, struct test_spoolss_context *ctx)
78 {
79 NTSTATUS status;
80 struct spoolss_OpenPrinter op;
81
82 op.in.printername = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p));
83 op.in.datatype = NULL;
84 op.in.devmode_ctr.devmode= NULL;
85 op.in.access_mask = 0;
86 op.out.handle = &ctx->server_handle;
87
88 torture_comment(tctx, "Testing OpenPrinter(%s)\n", op.in.printername);
89
90 status = dcerpc_spoolss_OpenPrinter(p, ctx, &op);
91 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_OpenPrinter failed");
92 torture_assert_werr_ok(tctx, op.out.result, "dcerpc_spoolss_OpenPrinter failed");
93
94 return true;
95 }
96
97 static bool test_EnumPorts(struct torture_context *tctx,
98 struct dcerpc_pipe *p,
99 struct test_spoolss_context *ctx)
100 {
101 NTSTATUS status;
102 struct spoolss_EnumPorts r;
103 uint16_t levels[] = { 1, 2 };
104 int i, j;
105
106 for (i=0;i<ARRAY_SIZE(levels);i++) {
107 int level = levels[i];
108 DATA_BLOB blob;
109 uint32_t needed;
110 uint32_t count;
111 union spoolss_PortInfo *info;
112
113 r.in.servername = "";
114 r.in.level = level;
115 r.in.buffer = NULL;
116 r.in.offered = 0;
117 r.out.needed = &needed;
118 r.out.count = &count;
119 r.out.info = &info;
120
121 torture_comment(tctx, "Testing EnumPorts level %u\n", r.in.level);
122
123 status = dcerpc_spoolss_EnumPorts(p, ctx, &r);
124 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
125 if (W_ERROR_IS_OK(r.out.result)) {
126 /* TODO: do some more checks here */
127 continue;
128 }
129 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
130 "EnumPorts unexpected return code");
131
132 blob = data_blob_talloc(ctx, NULL, needed);
133 data_blob_clear(&blob);
134 r.in.buffer = &blob;
135 r.in.offered = needed;
136
137 status = dcerpc_spoolss_EnumPorts(p, ctx, &r);
138 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
139
140 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
141
142 torture_assert(tctx, info, "EnumPorts returned no info");
143
144 ctx->port_count[level] = count;
145 ctx->ports[level] = info;
146 }
147
148 for (i=1;i<ARRAY_SIZE(levels);i++) {
149 int level = levels[i];
150 int old_level = levels[i-1];
151 torture_assert_int_equal(tctx, ctx->port_count[level], ctx->port_count[old_level],
152 "EnumPorts invalid value");
153 }
154 /* if the array sizes are not the same we would maybe segfault in the following code */
155
156 for (i=0;i<ARRAY_SIZE(levels);i++) {
157 int level = levels[i];
158 for (j=0;j<ctx->port_count[level];j++) {
159 union spoolss_PortInfo *cur = &ctx->ports[level][j];
160 union spoolss_PortInfo *ref = &ctx->ports[2][j];
161 switch (level) {
162 case 1:
163 COMPARE_STRING(tctx, cur->info1, ref->info2, port_name);
164 break;
165 case 2:
166 /* level 2 is our reference, and it makes no sense to compare it to itself */
167 break;
168 }
169 }
170 }
171
172 return true;
173 }
174
175 static bool test_GetPrintProcessorDirectory(struct torture_context *tctx,
176 struct dcerpc_pipe *p,
177 struct test_spoolss_context *ctx)
178 {
179 NTSTATUS status;
180 struct spoolss_GetPrintProcessorDirectory r;
181 struct {
182 uint16_t level;
183 const char *server;
184 } levels[] = {{
185 .level = 1,
186 .server = NULL
187 },{
188 .level = 1,
189 .server = ""
190 },{
191 .level = 78,
192 .server = ""
193 },{
194 .level = 1,
195 .server = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p))
196 },{
197 .level = 1024,
198 .server = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p))
199 }
200 };
201 int i;
202 uint32_t needed;
203
204 for (i=0;i<ARRAY_SIZE(levels);i++) {
205 int level = levels[i].level;
206 DATA_BLOB blob;
207
208 r.in.server = levels[i].server;
209 r.in.environment = SPOOLSS_ARCHITECTURE_NT_X86;
210 r.in.level = level;
211 r.in.buffer = NULL;
212 r.in.offered = 0;
213 r.out.needed = &needed;
214
215 torture_comment(tctx, "Testing GetPrintProcessorDirectory level %u\n", r.in.level);
216
217 status = dcerpc_spoolss_GetPrintProcessorDirectory(p, ctx, &r);
218 torture_assert_ntstatus_ok(tctx, status,
219 "dcerpc_spoolss_GetPrintProcessorDirectory failed");
220 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
221 "GetPrintProcessorDirectory unexpected return code");
222
223 blob = data_blob_talloc(ctx, NULL, needed);
224 data_blob_clear(&blob);
225 r.in.buffer = &blob;
226 r.in.offered = needed;
227
228 status = dcerpc_spoolss_GetPrintProcessorDirectory(p, ctx, &r);
229 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrintProcessorDirectory failed");
230
231 torture_assert_werr_ok(tctx, r.out.result, "GetPrintProcessorDirectory failed");
232 }
233
234 return true;
235 }
236
237
238 static bool test_GetPrinterDriverDirectory(struct torture_context *tctx,
239 struct dcerpc_pipe *p,
240 struct test_spoolss_context *ctx)
241 {
242 NTSTATUS status;
243 struct spoolss_GetPrinterDriverDirectory r;
244 struct {
245 uint16_t level;
246 const char *server;
247 } levels[] = {{
248 .level = 1,
249 .server = NULL
250 },{
251 .level = 1,
252 .server = ""
253 },{
254 .level = 78,
255 .server = ""
256 },{
257 .level = 1,
258 .server = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p))
259 },{
260 .level = 1024,
261 .server = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p))
262 }
263 };
264 int i;
265 uint32_t needed;
266
267 for (i=0;i<ARRAY_SIZE(levels);i++) {
268 int level = levels[i].level;
269 DATA_BLOB blob;
270
271 r.in.server = levels[i].server;
272 r.in.environment = SPOOLSS_ARCHITECTURE_NT_X86;
273 r.in.level = level;
274 r.in.buffer = NULL;
275 r.in.offered = 0;
276 r.out.needed = &needed;
277
278 torture_comment(tctx, "Testing GetPrinterDriverDirectory level %u\n", r.in.level);
279
280 status = dcerpc_spoolss_GetPrinterDriverDirectory(p, ctx, &r);
281 torture_assert_ntstatus_ok(tctx, status,
282 "dcerpc_spoolss_GetPrinterDriverDirectory failed");
283 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
284 "GetPrinterDriverDirectory unexpected return code");
285
286 blob = data_blob_talloc(ctx, NULL, needed);
287 data_blob_clear(&blob);
288 r.in.buffer = &blob;
289 r.in.offered = needed;
290
291 status = dcerpc_spoolss_GetPrinterDriverDirectory(p, ctx, &r);
292 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrinterDriverDirectory failed");
293
294 torture_assert_werr_ok(tctx, r.out.result, "GetPrinterDriverDirectory failed");
295 }
296
297 return true;
298 }
299
300 static bool test_EnumPrinterDrivers(struct torture_context *tctx,
301 struct dcerpc_pipe *p,
302 struct test_spoolss_context *ctx)
303 {
304 NTSTATUS status;
305 struct spoolss_EnumPrinterDrivers r;
306 uint16_t levels[] = { 1, 2, 3, 4, 5, 6 };
307 int i, j, a;
308 const char *architectures[] = {
309 SPOOLSS_ARCHITECTURE_NT_X86,
310 SPOOLSS_ARCHITECTURE_ALL
311 };
312
313 for (i=0;i<ARRAY_SIZE(levels);i++) {
314 for (a=0;a<ARRAY_SIZE(architectures);a++) {
315 int level = levels[i];
316 DATA_BLOB blob;
317 uint32_t needed;
318 uint32_t count;
319 union spoolss_DriverInfo *info;
320
321 /* FIXME: gd, come back and fix "" as server, and handle
322 * priority of returned error codes in torture test and samba 3
323 * server */
324
325 r.in.server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
326 r.in.environment = architectures[a];
327 r.in.level = level;
328 r.in.buffer = NULL;
329 r.in.offered = 0;
330 r.out.needed = &needed;
331 r.out.count = &count;
332 r.out.info = &info;
333
334 torture_comment(tctx, "Testing EnumPrinterDrivers level %u (%s)\n", r.in.level, r.in.environment);
335
336 status = dcerpc_spoolss_EnumPrinterDrivers(p, ctx, &r);
337 torture_assert_ntstatus_ok(tctx, status,
338 "dcerpc_spoolss_EnumPrinterDrivers failed");
339 if (W_ERROR_IS_OK(r.out.result)) {
340 /* TODO: do some more checks here */
341 continue;
342 }
343 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
344 blob = data_blob_talloc(ctx, NULL, needed);
345 data_blob_clear(&blob);
346 r.in.buffer = &blob;
347 r.in.offered = needed;
348
349 status = dcerpc_spoolss_EnumPrinterDrivers(p, ctx, &r);
350 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinterDrivers failed");
351 }
352
353 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDrivers failed");
354
355 /* don't do cross-architecture comparison */
356 if (strequal(r.in.environment, SPOOLSS_ARCHITECTURE_ALL)) {
357 continue;
358 }
359
360 ctx->driver_count[level] = count;
361 ctx->drivers[level] = info;
362 }
363 }
364
365 for (i=1;i<ARRAY_SIZE(levels);i++) {
366 int level = levels[i];
367 int old_level = levels[i-1];
368
369 /* don't do cross-architecture comparison */
370 if (strequal(r.in.environment, SPOOLSS_ARCHITECTURE_ALL)) {
371 continue;
372 }
373
374 torture_assert_int_equal(tctx, ctx->driver_count[level], ctx->driver_count[old_level],
375 "EnumPrinterDrivers invalid value");
376 }
377
378 for (i=0;i<ARRAY_SIZE(levels);i++) {
379 int level = levels[i];
380
381 /* don't do cross-architecture comparison */
382 if (strequal(r.in.environment, SPOOLSS_ARCHITECTURE_ALL)) {
383 continue;
384 }
385
386 for (j=0;j<ctx->driver_count[level];j++) {
387 union spoolss_DriverInfo *cur = &ctx->drivers[level][j];
388 union spoolss_DriverInfo *ref = &ctx->drivers[6][j];
389 switch (level) {
390 case 1:
391 COMPARE_STRING(tctx, cur->info1, ref->info6, driver_name);
392 break;
393 case 2:
394 COMPARE_UINT32(tctx, cur->info2, ref->info6, version);
395 COMPARE_STRING(tctx, cur->info2, ref->info6, driver_name);
396 COMPARE_STRING(tctx, cur->info2, ref->info6, architecture);
397 COMPARE_STRING(tctx, cur->info2, ref->info6, driver_path);
398 COMPARE_STRING(tctx, cur->info2, ref->info6, data_file);
399 COMPARE_STRING(tctx, cur->info2, ref->info6, config_file);
400 break;
401 case 3:
402 COMPARE_UINT32(tctx, cur->info3, ref->info6, version);
403 COMPARE_STRING(tctx, cur->info3, ref->info6, driver_name);
404 COMPARE_STRING(tctx, cur->info3, ref->info6, architecture);
405 COMPARE_STRING(tctx, cur->info3, ref->info6, driver_path);
406 COMPARE_STRING(tctx, cur->info3, ref->info6, data_file);
407 COMPARE_STRING(tctx, cur->info3, ref->info6, config_file);
408 COMPARE_STRING(tctx, cur->info3, ref->info6, help_file);
409 COMPARE_STRING_ARRAY(tctx, cur->info3, ref->info6, dependent_files);
410 COMPARE_STRING(tctx, cur->info3, ref->info6, monitor_name);
411 COMPARE_STRING(tctx, cur->info3, ref->info6, default_datatype);
412 break;
413 case 4:
414 COMPARE_UINT32(tctx, cur->info4, ref->info6, version);
415 COMPARE_STRING(tctx, cur->info4, ref->info6, driver_name);
416 COMPARE_STRING(tctx, cur->info4, ref->info6, architecture);
417 COMPARE_STRING(tctx, cur->info4, ref->info6, driver_path);
418 COMPARE_STRING(tctx, cur->info4, ref->info6, data_file);
419 COMPARE_STRING(tctx, cur->info4, ref->info6, config_file);
420 COMPARE_STRING(tctx, cur->info4, ref->info6, help_file);
421 COMPARE_STRING_ARRAY(tctx, cur->info4, ref->info6, dependent_files);
422 COMPARE_STRING(tctx, cur->info4, ref->info6, monitor_name);
423 COMPARE_STRING(tctx, cur->info4, ref->info6, default_datatype);
424 COMPARE_STRING_ARRAY(tctx, cur->info4, ref->info6, previous_names);
425 break;
426 case 5:
427 COMPARE_UINT32(tctx, cur->info5, ref->info6, version);
428 COMPARE_STRING(tctx, cur->info5, ref->info6, driver_name);
429 COMPARE_STRING(tctx, cur->info5, ref->info6, architecture);
430 COMPARE_STRING(tctx, cur->info5, ref->info6, driver_path);
431 COMPARE_STRING(tctx, cur->info5, ref->info6, data_file);
432 COMPARE_STRING(tctx, cur->info5, ref->info6, config_file);
433 /*COMPARE_UINT32(tctx, cur->info5, ref->info6, driver_attributes);*/
434 /*COMPARE_UINT32(tctx, cur->info5, ref->info6, config_version);*/
435 /*TODO: ! COMPARE_UINT32(tctx, cur->info5, ref->info6, driver_version); */
436 break;
437 case 6:
438 /* level 6 is our reference, and it makes no sense to compare it to itself */
439 break;
440 }
441 }
442 }
443
444 return true;
445 }
446
447 static bool test_EnumMonitors(struct torture_context *tctx,
448 struct dcerpc_pipe *p,
449 struct test_spoolss_context *ctx)
450 {
451 NTSTATUS status;
452 struct spoolss_EnumMonitors r;
453 uint16_t levels[] = { 1, 2 };
454 int i, j;
455
456 for (i=0;i<ARRAY_SIZE(levels);i++) {
457 int level = levels[i];
458 DATA_BLOB blob;
459 uint32_t needed;
460 uint32_t count;
461 union spoolss_MonitorInfo *info;
462
463 r.in.servername = "";
464 r.in.level = level;
465 r.in.buffer = NULL;
466 r.in.offered = 0;
467 r.out.needed = &needed;
468 r.out.count = &count;
469 r.out.info = &info;
470
471 torture_comment(tctx, "Testing EnumMonitors level %u\n", r.in.level);
472
473 status = dcerpc_spoolss_EnumMonitors(p, ctx, &r);
474 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
475 if (W_ERROR_IS_OK(r.out.result)) {
476 /* TODO: do some more checks here */
477 continue;
478 }
479 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
480 "EnumMonitors failed");
481
482 blob = data_blob_talloc(ctx, NULL, needed);
483 data_blob_clear(&blob);
484 r.in.buffer = &blob;
485 r.in.offered = needed;
486
487 status = dcerpc_spoolss_EnumMonitors(p, ctx, &r);
488 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
489
490 torture_assert_werr_ok(tctx, r.out.result, "EnumMonitors failed");
491
492 ctx->monitor_count[level] = count;
493 ctx->monitors[level] = info;
494 }
495
496 for (i=1;i<ARRAY_SIZE(levels);i++) {
497 int level = levels[i];
498 int old_level = levels[i-1];
499 torture_assert_int_equal(tctx, ctx->monitor_count[level], ctx->monitor_count[old_level],
500 "EnumMonitors invalid value");
501 }
502
503 for (i=0;i<ARRAY_SIZE(levels);i++) {
504 int level = levels[i];
505 for (j=0;j<ctx->monitor_count[level];j++) {
506 union spoolss_MonitorInfo *cur = &ctx->monitors[level][j];
507 union spoolss_MonitorInfo *ref = &ctx->monitors[2][j];
508 switch (level) {
509 case 1:
510 COMPARE_STRING(tctx, cur->info1, ref->info2, monitor_name);
511 break;
512 case 2:
513 /* level 2 is our reference, and it makes no sense to compare it to itself */
514 break;
515 }
516 }
517 }
518
519 return true;
520 }
521
522 static bool test_EnumPrintProcessors(struct torture_context *tctx,
523 struct dcerpc_pipe *p,
524 struct test_spoolss_context *ctx)
525 {
526 NTSTATUS status;
527 struct spoolss_EnumPrintProcessors r;
528 uint16_t levels[] = { 1 };
529 int i, j;
530
531 for (i=0;i<ARRAY_SIZE(levels);i++) {
532 int level = levels[i];
533 DATA_BLOB blob;
534 uint32_t needed;
535 uint32_t count;
536 union spoolss_PrintProcessorInfo *info;
537
538 r.in.servername = "";
539 r.in.environment = SPOOLSS_ARCHITECTURE_NT_X86;
540 r.in.level = level;
541 r.in.buffer = NULL;
542 r.in.offered = 0;
543 r.out.needed = &needed;
544 r.out.count = &count;
545 r.out.info = &info;
546
547 torture_comment(tctx, "Testing EnumPrintProcessors level %u\n", r.in.level);
548
549 status = dcerpc_spoolss_EnumPrintProcessors(p, ctx, &r);
550 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcessors failed");
551 if (W_ERROR_IS_OK(r.out.result)) {
552 /* TODO: do some more checks here */
553 continue;
554 }
555 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
556 "EnumPrintProcessors unexpected return code");
557
558 blob = data_blob_talloc(ctx, NULL, needed);
559 data_blob_clear(&blob);
560 r.in.buffer = &blob;
561 r.in.offered = needed;
562
563 status = dcerpc_spoolss_EnumPrintProcessors(p, ctx, &r);
564 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcessors failed");
565
566 torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcessors failed");
567
568 ctx->print_processor_count[level] = count;
569 ctx->print_processors[level] = info;
570 }
571
572 for (i=1;i<ARRAY_SIZE(levels);i++) {
573 int level = levels[i];
574 int old_level = levels[i-1];
575 torture_assert_int_equal(tctx, ctx->print_processor_count[level], ctx->print_processor_count[old_level],
576 "EnumPrintProcessors failed");
577 }
578
579 for (i=0;i<ARRAY_SIZE(levels);i++) {
580 int level = levels[i];
581 for (j=0;j<ctx->print_processor_count[level];j++) {
582 #if 0
583 union spoolss_PrintProcessorInfo *cur = &ctx->print_processors[level][j];
584 union spoolss_PrintProcessorInfo *ref = &ctx->print_processors[1][j];
585 #endif
586 switch (level) {
587 case 1:
588 /* level 1 is our reference, and it makes no sense to compare it to itself */
589 break;
590 }
591 }
592 }
593
594 return true;
595 }
596
597 static bool test_EnumPrintProcDataTypes(struct torture_context *tctx,
598 struct dcerpc_pipe *p,
599 struct test_spoolss_context *ctx)
600 {
601 NTSTATUS status;
602 struct spoolss_EnumPrintProcDataTypes r;
603 uint16_t levels[] = { 1 };
604 int i;
605
606 for (i=0;i<ARRAY_SIZE(levels);i++) {
607 int level = levels[i];
608 DATA_BLOB blob;
609 uint32_t needed;
610 uint32_t count;
611 union spoolss_PrintProcDataTypesInfo *info;
612
613 r.in.servername = "";
614 r.in.print_processor_name = "winprint";
615 r.in.level = level;
616 r.in.buffer = NULL;
617 r.in.offered = 0;
618 r.out.needed = &needed;
619 r.out.count = &count;
620 r.out.info = &info;
621
622 torture_comment(tctx, "Testing EnumPrintProcDataTypes level %u\n", r.in.level);
623
624 status = dcerpc_spoolss_EnumPrintProcDataTypes(p, ctx, &r);
625 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcDataType failed");
626 if (W_ERROR_IS_OK(r.out.result)) {
627 /* TODO: do some more checks here */
628 continue;
629 }
630 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
631 "EnumPrintProcDataTypes unexpected return code");
632
633 blob = data_blob_talloc(ctx, NULL, needed);
634 data_blob_clear(&blob);
635 r.in.buffer = &blob;
636 r.in.offered = needed;
637
638 status = dcerpc_spoolss_EnumPrintProcDataTypes(p, ctx, &r);
639 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcDataTypes failed");
640
641 torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcDataTypes failed");
642 }
643
644 return true;
645 }
646
647
648 static bool test_EnumPrinters(struct torture_context *tctx,
649 struct dcerpc_pipe *p,
650 struct test_spoolss_context *ctx)
651 {
652 struct spoolss_EnumPrinters r;
653 NTSTATUS status;
654 uint16_t levels[] = { 0, 1, 2, 4, 5 };
655 int i, j;
656
657 for (i=0;i<ARRAY_SIZE(levels);i++) {
658 int level = levels[i];
659 DATA_BLOB blob;
660 uint32_t needed;
661 uint32_t count;
662 union spoolss_PrinterInfo *info;
663
664 r.in.flags = PRINTER_ENUM_LOCAL;
665 r.in.server = "";
666 r.in.level = level;
667 r.in.buffer = NULL;
668 r.in.offered = 0;
669 r.out.needed = &needed;
670 r.out.count = &count;
671 r.out.info = &info;
672
673 torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
674
675 status = dcerpc_spoolss_EnumPrinters(p, ctx, &r);
676 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
677 if (W_ERROR_IS_OK(r.out.result)) {
678 /* TODO: do some more checks here */
679 continue;
680 }
681 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
682 "EnumPrinters unexpected return code");
683
684 blob = data_blob_talloc(ctx, NULL, needed);
685 data_blob_clear(&blob);
686 r.in.buffer = &blob;
687 r.in.offered = needed;
688
689 status = dcerpc_spoolss_EnumPrinters(p, ctx, &r);
690 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
691
692 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
693
694 ctx->printer_count[level] = count;
695 ctx->printers[level] = info;
696 }
697
698 for (i=1;i<ARRAY_SIZE(levels);i++) {
699 int level = levels[i];
700 int old_level = levels[i-1];
701 torture_assert_int_equal(tctx, ctx->printer_count[level], ctx->printer_count[old_level],
702 "EnumPrinters invalid value");
703 }
704
705 for (i=0;i<ARRAY_SIZE(levels);i++) {
706 int level = levels[i];
707 for (j=0;j<ctx->printer_count[level];j++) {
708 union spoolss_PrinterInfo *cur = &ctx->printers[level][j];
709 union spoolss_PrinterInfo *ref = &ctx->printers[2][j];
710 switch (level) {
711 case 0:
712 COMPARE_STRING(tctx, cur->info0, ref->info2, printername);
713 COMPARE_STRING(tctx, cur->info0, ref->info2, servername);
714 COMPARE_UINT32(tctx, cur->info0, ref->info2, cjobs);
715 /*COMPARE_UINT32(tctx, cur->info0, ref->info2, total_jobs);
716 COMPARE_UINT32(tctx, cur->info0, ref->info2, total_bytes);
717 COMPARE_SPOOLSS_TIME(cur->info0, ref->info2, spoolss_Time time);
718 COMPARE_UINT32(tctx, cur->info0, ref->info2, global_counter);
719 COMPARE_UINT32(tctx, cur->info0, ref->info2, total_pages);
720 COMPARE_UINT32(tctx, cur->info0, ref->info2, version);
721 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown10);
722 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown11);
723 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown12);
724 COMPARE_UINT32(tctx, cur->info0, ref->info2, session_counter);
725 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown14);
726 COMPARE_UINT32(tctx, cur->info0, ref->info2, printer_errors);
727 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown16);
728 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown17);
729 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown18);
730 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown19);
731 COMPARE_UINT32(tctx, cur->info0, ref->info2, change_id);
732 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown21);*/
733 COMPARE_UINT32(tctx, cur->info0, ref->info2, status);
734 /*COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown23);
735 COMPARE_UINT32(tctx, cur->info0, ref->info2, c_setprinter);
736 COMPARE_UINT16(cur->info0, ref->info2, unknown25);
737 COMPARE_UINT16(cur->info0, ref->info2, unknown26);
738 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown27);
739 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown28);
740 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown29);*/
741 break;
742 case 1:
743 /*COMPARE_UINT32(tctx, cur->info1, ref->info2, flags);*/
744 /*COMPARE_STRING(tctx, cur->info1, ref->info2, name);*/
745 /*COMPARE_STRING(tctx, cur->info1, ref->info2, description);*/
746 COMPARE_STRING(tctx, cur->info1, ref->info2, comment);
747 break;
748 case 2:
749 /* level 2 is our reference, and it makes no sense to compare it to itself */
750 break;
751 case 4:
752 COMPARE_STRING(tctx, cur->info4, ref->info2, printername);
753 COMPARE_STRING(tctx, cur->info4, ref->info2, servername);
754 COMPARE_UINT32(tctx, cur->info4, ref->info2, attributes);
755 break;
756 case 5:
757 COMPARE_STRING(tctx, cur->info5, ref->info2, printername);
758 COMPARE_STRING(tctx, cur->info5, ref->info2, portname);
759 COMPARE_UINT32(tctx, cur->info5, ref->info2, attributes);
760 /*COMPARE_UINT32(tctx, cur->info5, ref->info2, device_not_selected_timeout);
761 COMPARE_UINT32(tctx, cur->info5, ref->info2, transmission_retry_timeout);*/
762 break;
763 }
764 }
765 }
766
767 /* TODO:
768 * - verify that the port of a printer was in the list returned by EnumPorts
769 */
770
771 return true;
772 }
773
774 static bool test_GetPrinter(struct torture_context *tctx,
775 struct dcerpc_pipe *p,
776 struct policy_handle *handle)
777 {
778 NTSTATUS status;
779 struct spoolss_GetPrinter r;
780 uint16_t levels[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
781 int i;
782 uint32_t needed;
783
784 for (i=0;i<ARRAY_SIZE(levels);i++) {
785 r.in.handle = handle;
786 r.in.level = levels[i];
787 r.in.buffer = NULL;
788 r.in.offered = 0;
789 r.out.needed = &needed;
790
791 torture_comment(tctx, "Testing GetPrinter level %u\n", r.in.level);
792
793 status = dcerpc_spoolss_GetPrinter(p, tctx, &r);
794 torture_assert_ntstatus_ok(tctx, status, "GetPrinter failed");
795
796 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
797 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
798 data_blob_clear(&blob);
799 r.in.buffer = &blob;
800 r.in.offered = needed;
801 status = dcerpc_spoolss_GetPrinter(p, tctx, &r);
802 }
803
804 torture_assert_ntstatus_ok(tctx, status, "GetPrinter failed");
805
806 torture_assert_werr_ok(tctx, r.out.result, "GetPrinter failed");
807 }
808
809 return true;
810 }
811
812
813 static bool test_ClosePrinter(struct torture_context *tctx,
814 struct dcerpc_pipe *p,
815 struct policy_handle *handle)
816 {
817 NTSTATUS status;
818 struct spoolss_ClosePrinter r;
819
820 r.in.handle = handle;
821 r.out.handle = handle;
822
823 torture_comment(tctx, "Testing ClosePrinter\n");
824
825 status = dcerpc_spoolss_ClosePrinter(p, tctx, &r);
826 torture_assert_ntstatus_ok(tctx, status, "ClosePrinter failed");
827
828 return true;
829 }
830
831 static bool test_GetForm(struct torture_context *tctx,
832 struct dcerpc_pipe *p,
833 struct policy_handle *handle,
834 const char *form_name,
835 uint32_t level)
836 {
837 NTSTATUS status;
838 struct spoolss_GetForm r;
839 uint32_t needed;
840
841 r.in.handle = handle;
842 r.in.form_name = form_name;
843 r.in.level = level;
844 r.in.buffer = NULL;
845 r.in.offered = 0;
846 r.out.needed = &needed;
847
848 torture_comment(tctx, "Testing GetForm level %d\n", r.in.level);
849
850 status = dcerpc_spoolss_GetForm(p, tctx, &r);
851 torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
852
853 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
854 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
855 data_blob_clear(&blob);
856 r.in.buffer = &blob;
857 r.in.offered = needed;
858 status = dcerpc_spoolss_GetForm(p, tctx, &r);
859 torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
860
861 torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
862
863 torture_assert(tctx, r.out.info, "No form info returned");
864 }
865
866 torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
867
868 return true;
869 }
870
871 static bool test_EnumForms(struct torture_context *tctx,
872 struct dcerpc_pipe *p,
873 struct policy_handle *handle, bool print_server)
874 {
875 NTSTATUS status;
876 struct spoolss_EnumForms r;
877 bool ret = true;
878 uint32_t needed;
879 uint32_t count;
880 uint32_t levels[] = { 1, 2 };
881 int i;
882
883 for (i=0; i<ARRAY_SIZE(levels); i++) {
884
885 union spoolss_FormInfo *info;
886
887 r.in.handle = handle;
888 r.in.level = levels[i];
889 r.in.buffer = NULL;
890 r.in.offered = 0;
891 r.out.needed = &needed;
892 r.out.count = &count;
893 r.out.info = &info;
894
895 torture_comment(tctx, "Testing EnumForms level %d\n", levels[i]);
896
897 status = dcerpc_spoolss_EnumForms(p, tctx, &r);
898 torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
899
900 if ((r.in.level == 2) && (W_ERROR_EQUAL(r.out.result, WERR_UNKNOWN_LEVEL))) {
901 break;
902 }
903
904 if (print_server && W_ERROR_EQUAL(r.out.result, WERR_BADFID))
905 torture_fail(tctx, "EnumForms on the PrintServer isn't supported by test server (NT4)");
906
907 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
908 int j;
909 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
910 data_blob_clear(&blob);
911 r.in.buffer = &blob;
912 r.in.offered = needed;
913
914 status = dcerpc_spoolss_EnumForms(p, tctx, &r);
915
916 torture_assert(tctx, info, "No forms returned");
917
918 for (j = 0; j < count; j++) {
919 if (!print_server)
920 ret &= test_GetForm(tctx, p, handle, info[j].info1.form_name, levels[i]);
921 }
922 }
923
924 torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
925
926 torture_assert_werr_ok(tctx, r.out.result, "EnumForms failed");
927 }
928
929 return true;
930 }
931
932 static bool test_DeleteForm(struct torture_context *tctx,
933 struct dcerpc_pipe *p,
934 struct policy_handle *handle,
935 const char *form_name)
936 {
937 NTSTATUS status;
938 struct spoolss_DeleteForm r;
939
940 r.in.handle = handle;
941 r.in.form_name = form_name;
942
943 status = dcerpc_spoolss_DeleteForm(p, tctx, &r);
944
945 torture_assert_ntstatus_ok(tctx, status, "DeleteForm failed");
946
947 torture_assert_werr_ok(tctx, r.out.result, "DeleteForm failed");
948
949 return true;
950 }
951
952 static bool test_AddForm(struct torture_context *tctx,
953 struct dcerpc_pipe *p,
954 struct policy_handle *handle, bool print_server)
955 {
956 struct spoolss_AddForm r;
957 struct spoolss_AddFormInfo1 addform;
958 const char *form_name = "testform3";
959 NTSTATUS status;
960 bool ret = true;
961
962 r.in.handle = handle;
963 r.in.level = 1;
964 r.in.info.info1 = &addform;
965 addform.flags = SPOOLSS_FORM_USER;
966 addform.form_name = form_name;
967 addform.size.width = 50;
968 addform.size.height = 25;
969 addform.area.left = 5;
970 addform.area.top = 10;
971 addform.area.right = 45;
972 addform.area.bottom = 15;
973
974 status = dcerpc_spoolss_AddForm(p, tctx, &r);
975
976 torture_assert_ntstatus_ok(tctx, status, "AddForm failed");
977
978 torture_assert_werr_ok(tctx, r.out.result, "AddForm failed");
979
980 if (!print_server) ret &= test_GetForm(tctx, p, handle, form_name, 1);
981
982 {
983 struct spoolss_SetForm sf;
984 struct spoolss_AddFormInfo1 setform;
985
986 sf.in.handle = handle;
987 sf.in.form_name = form_name;
988 sf.in.level = 1;
989 sf.in.info.info1= &setform;
990 setform.flags = addform.flags;
991 setform.form_name = addform.form_name;
992 setform.size = addform.size;
993 setform.area = addform.area;
994
995 setform.size.width = 1234;
996
997 status = dcerpc_spoolss_SetForm(p, tctx, &sf);
998
999 torture_assert_ntstatus_ok(tctx, status, "SetForm failed");
1000
1001 torture_assert_werr_ok(tctx, r.out.result, "SetForm failed");
1002 }
1003
1004 if (!print_server) ret &= test_GetForm(tctx, p, handle, form_name, 1);
1005
1006 if (!test_DeleteForm(tctx, p, handle, form_name)) {
1007 ret = false;
1008 }
1009
1010 return ret;
1011 }
1012
1013 static bool test_EnumPorts_old(struct torture_context *tctx,
1014 struct dcerpc_pipe *p)
1015 {
1016 NTSTATUS status;
1017 struct spoolss_EnumPorts r;
1018 uint32_t needed;
1019 uint32_t count;
1020 union spoolss_PortInfo *info;
1021
1022 r.in.servername = talloc_asprintf(tctx, "\\\\%s",
1023 dcerpc_server_name(p));
1024 r.in.level = 2;
1025 r.in.buffer = NULL;
1026 r.in.offered = 0;
1027 r.out.needed = &needed;
1028 r.out.count = &count;
1029 r.out.info = &info;
1030
1031 torture_comment(tctx, "Testing EnumPorts\n");
1032
1033 status = dcerpc_spoolss_EnumPorts(p, tctx, &r);
1034
1035 torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
1036
1037 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
1038 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
1039 data_blob_clear(&blob);
1040 r.in.buffer = &blob;
1041 r.in.offered = needed;
1042
1043 status = dcerpc_spoolss_EnumPorts(p, tctx, &r);
1044 torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
1045
1046 torture_assert(tctx, info, "No ports returned");
1047 }
1048
1049 return true;
1050 }
1051
1052 static bool test_AddPort(struct torture_context *tctx,
1053 struct dcerpc_pipe *p)
1054 {
1055 NTSTATUS status;
1056 struct spoolss_AddPort r;
1057
1058 r.in.server_name = talloc_asprintf(tctx, "\\\\%s",
1059 dcerpc_server_name(p));
1060 r.in.unknown = 0;
1061 r.in.monitor_name = "foo";
1062
1063 torture_comment(tctx, "Testing AddPort\n");
1064
1065 status = dcerpc_spoolss_AddPort(p, tctx, &r);
1066
1067 torture_assert_ntstatus_ok(tctx, status, "AddPort failed");
1068
1069 /* win2k3 returns WERR_NOT_SUPPORTED */
1070
1071 #if 0
1072
1073 if (!W_ERROR_IS_OK(r.out.result)) {
1074 printf("AddPort failed - %s\n", win_errstr(r.out.result));
1075 return false;
1076 }
1077
1078 #endif
1079
1080 return true;
1081 }
1082
1083 static bool test_GetJob(struct torture_context *tctx,
1084 struct dcerpc_pipe *p,
1085 struct policy_handle *handle, uint32_t job_id)
1086 {
1087 NTSTATUS status;
1088 struct spoolss_GetJob r;
1089 uint32_t needed;
1090 uint32_t levels[] = {1, 2 /* 3, 4 */};
1091 uint32_t i;
1092
1093 r.in.handle = handle;
1094 r.in.job_id = job_id;
1095 r.in.level = 0;
1096 r.in.buffer = NULL;
1097 r.in.offered = 0;
1098 r.out.needed = &needed;
1099
1100 torture_comment(tctx, "Testing GetJob level %d\n", r.in.level);
1101
1102 status = dcerpc_spoolss_GetJob(p, tctx, &r);
1103 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "Unexpected return code");
1104
1105 for (i = 0; i < ARRAY_SIZE(levels); i++) {
1106
1107 torture_comment(tctx, "Testing GetJob level %d\n", r.in.level);
1108
1109 r.in.level = levels[i];
1110 r.in.offered = 0;
1111
1112 status = dcerpc_spoolss_GetJob(p, tctx, &r);
1113 torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
1114
1115 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
1116 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
1117 data_blob_clear(&blob);
1118 r.in.buffer = &blob;
1119 r.in.offered = needed;
1120
1121 status = dcerpc_spoolss_GetJob(p, tctx, &r);
1122 torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
1123
1124 }
1125 torture_assert(tctx, r.out.info, "No job info returned");
1126 torture_assert_werr_ok(tctx, r.out.result, "GetJob failed");
1127 }
1128
1129 return true;
1130 }
1131
1132 static bool test_SetJob(struct torture_context *tctx,
1133 struct dcerpc_pipe *p,
1134 struct policy_handle *handle, uint32_t job_id,
1135 enum spoolss_JobControl command)
1136 {
1137 NTSTATUS status;
1138 struct spoolss_SetJob r;
1139
1140 r.in.handle = handle;
1141 r.in.job_id = job_id;
1142 r.in.ctr = NULL;
1143 r.in.command = command;
1144
1145 switch (command) {
1146 case SPOOLSS_JOB_CONTROL_PAUSE:
1147 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_PAUSE\n");
1148 break;
1149 case SPOOLSS_JOB_CONTROL_RESUME:
1150 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RESUME\n");
1151 break;
1152 case SPOOLSS_JOB_CONTROL_CANCEL:
1153 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_CANCEL\n");
1154 break;
1155 case SPOOLSS_JOB_CONTROL_RESTART:
1156 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RESTART\n");
1157 break;
1158 case SPOOLSS_JOB_CONTROL_DELETE:
1159 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_DELETE\n");
1160 break;
1161 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER:
1162 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER\n");
1163 break;
1164 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED:
1165 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED\n");
1166 break;
1167 case SPOOLSS_JOB_CONTROL_RETAIN:
1168 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RETAIN\n");
1169 break;
1170 case SPOOLSS_JOB_CONTROL_RELEASE:
1171 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RELEASE\n");
1172 break;
1173 default:
1174 torture_comment(tctx, "Testing SetJob\n");
1175 break;
1176 }
1177
1178 status = dcerpc_spoolss_SetJob(p, tctx, &r);
1179 torture_assert_ntstatus_ok(tctx, status, "SetJob failed");
1180 torture_assert_werr_ok(tctx, r.out.result, "SetJob failed");
1181
1182 return true;
1183 }
1184
1185 static bool test_AddJob(struct torture_context *tctx,
1186 struct dcerpc_pipe *p,
1187 struct policy_handle *handle)
1188 {
1189 NTSTATUS status;
1190 struct spoolss_AddJob r;
1191 uint32_t needed;
1192
1193 r.in.level = 0;
1194 r.in.handle = handle;
1195 r.in.offered = 0;
1196 r.out.needed = &needed;
1197 r.in.buffer = r.out.buffer = NULL;
1198
1199 torture_comment(tctx, "Testing AddJob\n");
1200
1201 status = dcerpc_spoolss_AddJob(p, tctx, &r);
1202 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "AddJob failed");
1203
1204 r.in.level = 1;
1205
1206 status = dcerpc_spoolss_AddJob(p, tctx, &r);
1207 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM, "AddJob failed");
1208
1209 return true;
1210 }
1211
1212
1213 static bool test_EnumJobs(struct torture_context *tctx,
1214 struct dcerpc_pipe *p,
1215 struct policy_handle *handle)
1216 {
1217 NTSTATUS status;
1218 struct spoolss_EnumJobs r;
1219 uint32_t needed;
1220 uint32_t count;
1221 union spoolss_JobInfo *info;
1222
1223 r.in.handle = handle;
1224 r.in.firstjob = 0;
1225 r.in.numjobs = 0xffffffff;
1226 r.in.level = 1;
1227 r.in.buffer = NULL;
1228 r.in.offered = 0;
1229 r.out.needed = &needed;
1230 r.out.count = &count;
1231 r.out.info = &info;
1232
1233 torture_comment(tctx, "Testing EnumJobs\n");
1234
1235 status = dcerpc_spoolss_EnumJobs(p, tctx, &r);
1236
1237 torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
1238
1239 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
1240 int j;
1241 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
1242 data_blob_clear(&blob);
1243 r.in.buffer = &blob;
1244 r.in.offered = needed;
1245
1246 status = dcerpc_spoolss_EnumJobs(p, tctx, &r);
1247
1248 torture_assert(tctx, info, "No jobs returned");
1249
1250 for (j = 0; j < count; j++) {
1251
1252 test_GetJob(tctx, p, handle, info[j].info1.job_id);
1253
1254 /* FIXME - gd */
1255 if (!torture_setting_bool(tctx, "samba3", false)) {
1256 test_SetJob(tctx, p, handle, info[j].info1.job_id, SPOOLSS_JOB_CONTROL_PAUSE);
1257 test_SetJob(tctx, p, handle, info[j].info1.job_id, SPOOLSS_JOB_CONTROL_RESUME);
1258 }
1259 }
1260
1261 } else {
1262 torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
1263 }
1264
1265 return true;
1266 }
1267
1268 static bool test_DoPrintTest(struct torture_context *tctx,
1269 struct dcerpc_pipe *p,
1270 struct policy_handle *handle)
1271 {
1272 bool ret = true;
1273 NTSTATUS status;
1274 struct spoolss_StartDocPrinter s;
1275 struct spoolss_DocumentInfo1 info1;
1276 struct spoolss_StartPagePrinter sp;
1277 struct spoolss_WritePrinter w;
1278 struct spoolss_EndPagePrinter ep;
1279 struct spoolss_EndDocPrinter e;
1280 int i;
1281 uint32_t job_id;
1282 uint32_t num_written;
1283
1284 torture_comment(tctx, "Testing StartDocPrinter\n");
1285
1286 s.in.handle = handle;
1287 s.in.level = 1;
1288 s.in.info.info1 = &info1;
1289 s.out.job_id = &job_id;
1290 info1.document_name = "TorturePrintJob";
1291 info1.output_file = NULL;
1292 info1.datatype = "RAW";
1293
1294 status = dcerpc_spoolss_StartDocPrinter(p, tctx, &s);
1295 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_StartDocPrinter failed");
1296 torture_assert_werr_ok(tctx, s.out.result, "StartDocPrinter failed");
1297
1298 for (i=1; i < 4; i++) {
1299 torture_comment(tctx, "Testing StartPagePrinter: Page[%d]\n", i);
1300
1301 sp.in.handle = handle;
1302
1303 status = dcerpc_spoolss_StartPagePrinter(p, tctx, &sp);
1304 torture_assert_ntstatus_ok(tctx, status,
1305 "dcerpc_spoolss_StartPagePrinter failed");
1306 torture_assert_werr_ok(tctx, sp.out.result, "StartPagePrinter failed");
1307
1308 torture_comment(tctx, "Testing WritePrinter: Page[%d]\n", i);
1309
1310 w.in.handle = handle;
1311 w.in.data = data_blob_string_const(talloc_asprintf(tctx,"TortureTestPage: %d\nData\n",i));
1312 w.out.num_written = &num_written;
1313
1314 status = dcerpc_spoolss_WritePrinter(p, tctx, &w);
1315 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_WritePrinter failed");
1316 torture_assert_werr_ok(tctx, w.out.result, "WritePrinter failed");
1317
1318 torture_comment(tctx, "Testing EndPagePrinter: Page[%d]\n", i);
1319
1320 ep.in.handle = handle;
1321
1322 status = dcerpc_spoolss_EndPagePrinter(p, tctx, &ep);
1323 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndPagePrinter failed");
1324 torture_assert_werr_ok(tctx, ep.out.result, "EndPagePrinter failed");
1325 }
1326
1327 torture_comment(tctx, "Testing EndDocPrinter\n");
1328
1329 e.in.handle = handle;
1330
1331 status = dcerpc_spoolss_EndDocPrinter(p, tctx, &e);
1332 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndDocPrinter failed");
1333 torture_assert_werr_ok(tctx, e.out.result, "EndDocPrinter failed");
1334
1335 ret &= test_AddJob(tctx, p, handle);
1336 ret &= test_EnumJobs(tctx, p, handle);
1337
1338 ret &= test_SetJob(tctx, p, handle, job_id, SPOOLSS_JOB_CONTROL_DELETE);
1339
1340 return ret;
1341 }
1342
1343 static bool test_PausePrinter(struct torture_context *tctx,
1344 struct dcerpc_pipe *p,
1345 struct policy_handle *handle)
1346 {
1347 NTSTATUS status;
1348 struct spoolss_SetPrinter r;
1349 struct spoolss_SetPrinterInfoCtr info_ctr;
1350 struct spoolss_DevmodeContainer devmode_ctr;
1351 struct sec_desc_buf secdesc_ctr;
1352
1353 info_ctr.level = 0;
1354 info_ctr.info.info0 = NULL;
1355
1356 ZERO_STRUCT(devmode_ctr);
1357 ZERO_STRUCT(secdesc_ctr);
1358
1359 r.in.handle = handle;
1360 r.in.info_ctr = &info_ctr;
1361 r.in.devmode_ctr = &devmode_ctr;
1362 r.in.secdesc_ctr = &secdesc_ctr;
1363 r.in.command = SPOOLSS_PRINTER_CONTROL_PAUSE;
1364
1365 torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_PAUSE\n");
1366
1367 status = dcerpc_spoolss_SetPrinter(p, tctx, &r);
1368
1369 torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
1370
1371 torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
1372
1373 return true;
1374 }
1375
1376 static bool test_ResumePrinter(struct torture_context *tctx,
1377 struct dcerpc_pipe *p,
1378 struct policy_handle *handle)
1379 {
1380 NTSTATUS status;
1381 struct spoolss_SetPrinter r;
1382 struct spoolss_SetPrinterInfoCtr info_ctr;
1383 struct spoolss_DevmodeContainer devmode_ctr;
1384 struct sec_desc_buf secdesc_ctr;
1385
1386 info_ctr.level = 0;
1387 info_ctr.info.info0 = NULL;
1388
1389 ZERO_STRUCT(devmode_ctr);
1390 ZERO_STRUCT(secdesc_ctr);
1391
1392 r.in.handle = handle;
1393 r.in.info_ctr = &info_ctr;
1394 r.in.devmode_ctr = &devmode_ctr;
1395 r.in.secdesc_ctr = &secdesc_ctr;
1396 r.in.command = SPOOLSS_PRINTER_CONTROL_RESUME;
1397
1398 torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_RESUME\n");
1399
1400 status = dcerpc_spoolss_SetPrinter(p, tctx, &r);
1401
1402 torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
1403
1404 torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
1405
1406 return true;
1407 }
1408
1409 static bool test_GetPrinterData(struct torture_context *tctx,
1410 struct dcerpc_pipe *p,
1411 struct policy_handle *handle,
1412 const char *value_name)
1413 {
1414 NTSTATUS status;
1415 struct spoolss_GetPrinterData r;
1416 uint32_t needed;
1417 enum winreg_Type type;
1418 union spoolss_PrinterData data;
1419
1420 r.in.handle = handle;
1421 r.in.value_name = value_name;
1422 r.in.offered = 0;
1423 r.out.needed = &needed;
1424 r.out.type = &type;
1425 r.out.data = &data;
1426
1427 torture_comment(tctx, "Testing GetPrinterData\n");
1428
1429 status = dcerpc_spoolss_GetPrinterData(p, tctx, &r);
1430 torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
1431
1432 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
1433 r.in.offered = needed;
1434
1435 status = dcerpc_spoolss_GetPrinterData(p, tctx, &r);
1436 torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
1437
1438 torture_assert_werr_ok(tctx, r.out.result, "GetPrinterData failed");
1439 }
1440
1441 return true;
1442 }
1443
1444 static bool test_GetPrinterDataEx(struct torture_context *tctx,
1445 struct dcerpc_pipe *p,
1446 struct policy_handle *handle,
1447 const char *key_name,
1448 const char *value_name)
1449 {
1450 NTSTATUS status;
1451 struct spoolss_GetPrinterDataEx r;
1452 enum winreg_Type type;
1453 uint32_t needed;
1454
1455 r.in.handle = handle;
1456 r.in.key_name = key_name;
1457 r.in.value_name = value_name;
1458 r.in.offered = 0;
1459 r.out.type = &type;
1460 r.out.needed = &needed;
1461 r.out.buffer = NULL;
1462
1463 torture_comment(tctx, "Testing GetPrinterDataEx\n");
1464
1465 status = dcerpc_spoolss_GetPrinterDataEx(p, tctx, &r);
1466 if (!NT_STATUS_IS_OK(status)) {
1467 if (NT_STATUS_EQUAL(status,NT_STATUS_NET_WRITE_FAULT) &&
1468 p->last_fault_code == DCERPC_FAULT_OP_RNG_ERROR) {
1469 torture_skip(tctx, "GetPrinterDataEx not supported by server\n");
1470 }
1471 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
1472 }
1473
1474 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
1475 r.in.offered = needed;
1476 r.out.buffer = talloc_array(tctx, uint8_t, needed);
1477
1478 status = dcerpc_spoolss_GetPrinterDataEx(p, tctx, &r);
1479 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
1480
1481 torture_assert_werr_ok(tctx, r.out.result, "GetPrinterDataEx failed");
1482 }
1483
1484 return true;
1485 }
1486
1487 static bool test_EnumPrinterData(struct torture_context *tctx, struct dcerpc_pipe *p,
1488 struct policy_handle *handle)
1489 {
1490 NTSTATUS status;
1491 struct spoolss_EnumPrinterData r;
1492
1493 ZERO_STRUCT(r);
1494 r.in.handle = handle;
1495 r.in.enum_index = 0;
1496
1497 do {
1498 uint32_t value_size = 0;
1499 uint32_t data_size = 0;
1500 enum winreg_Type type = 0;
1501
1502 r.in.value_offered = value_size;
1503 r.out.value_needed = &value_size;
1504 r.in.data_offered = data_size;
1505 r.out.data_needed = &data_size;
1506
1507 r.out.type = &type;
1508 r.out.data = talloc_zero_array(tctx, uint8_t, 0);
1509
1510 torture_comment(tctx, "Testing EnumPrinterData\n");
1511
1512 status = dcerpc_spoolss_EnumPrinterData(p, tctx, &r);
1513
1514 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterData failed");
1515
1516 r.in.value_offered = value_size;
1517 r.out.value_name = talloc_zero_array(tctx, const char, value_size);
1518 r.in.data_offered = data_size;
1519 r.out.data = talloc_zero_array(tctx, uint8_t, data_size);
1520
1521 status = dcerpc_spoolss_EnumPrinterData(p, tctx, &r);
1522
1523 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterData failed");
1524
1525 test_GetPrinterData(tctx, p, handle, r.out.value_name);
1526
1527 test_GetPrinterDataEx(tctx,
1528 p, handle, "PrinterDriverData",
1529 r.out.value_name);
1530
1531 r.in.enum_index++;
1532
1533 } while (W_ERROR_IS_OK(r.out.result));
1534
1535 return true;
1536 }
1537
1538 static bool test_EnumPrinterDataEx(struct torture_context *tctx,
1539 struct dcerpc_pipe *p,
1540 struct policy_handle *handle)
1541 {
1542 NTSTATUS status;
1543 struct spoolss_EnumPrinterDataEx r;
1544 struct spoolss_PrinterEnumValues *info;
1545 uint32_t needed;
1546 uint32_t count;
1547
1548 r.in.handle = handle;
1549 r.in.key_name = "PrinterDriverData";
1550 r.in.offered = 0;
1551 r.out.needed = &needed;
1552 r.out.count = &count;
1553 r.out.info = &info;
1554
1555 torture_comment(tctx, "Testing EnumPrinterDataEx\n");
1556
1557 status = dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &r);
1558 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDataEx failed");
1559
1560 r.in.offered = needed;
1561
1562 status = dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &r);
1563
1564 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDataEx failed");
1565
1566 return true;
1567 }
1568
1569
1570 static bool test_DeletePrinterData(struct torture_context *tctx,
1571 struct dcerpc_pipe *p,
1572 struct policy_handle *handle,
1573 const char *value_name)
1574 {
1575 NTSTATUS status;
1576 struct spoolss_DeletePrinterData r;
1577
1578 r.in.handle = handle;
1579 r.in.value_name = value_name;
1580
1581 torture_comment(tctx, "Testing DeletePrinterData\n");
1582
1583 status = dcerpc_spoolss_DeletePrinterData(p, tctx, &r);
1584
1585 torture_assert_ntstatus_ok(tctx, status, "DeletePrinterData failed");
1586
1587 return true;
1588 }
1589
1590 static bool test_SetPrinterData(struct torture_context *tctx,
1591 struct dcerpc_pipe *p,
1592 struct policy_handle *handle)
1593 {
1594 NTSTATUS status;
1595 struct spoolss_SetPrinterData r;
1596 const char *value_name = "spottyfoot";
1597
1598 r.in.handle = handle;
1599 r.in.value_name = value_name;
1600 r.in.type = REG_SZ;
1601 r.in.data.string = "dog";
1602
1603 torture_comment(tctx, "Testing SetPrinterData\n");
1604
1605 status = dcerpc_spoolss_SetPrinterData(p, tctx, &r);
1606
1607 torture_assert_ntstatus_ok(tctx, status, "SetPrinterData failed");
1608
1609 if (!test_GetPrinterData(tctx, p, handle, value_name)) {
1610 return false;
1611 }
1612
1613 if (!test_DeletePrinterData(tctx, p, handle, value_name)) {
1614 return false;
1615 }
1616
1617 return true;
1618 }
1619
1620 static bool test_SecondaryClosePrinter(struct torture_context *tctx,
1621 struct dcerpc_pipe *p,
1622 struct policy_handle *handle)
1623 {
1624 NTSTATUS status;
1625 struct dcerpc_binding *b;
1626 struct dcerpc_pipe *p2;
1627 struct spoolss_ClosePrinter cp;
1628
1629 /* only makes sense on SMB */
1630 if (p->conn->transport.transport != NCACN_NP) {
1631 return true;
1632 }
1633
1634 torture_comment(tctx, "testing close on secondary pipe\n");
1635
1636 status = dcerpc_parse_binding(tctx, p->conn->binding_string, &b);
1637 torture_assert_ntstatus_ok(tctx, status, "Failed to parse dcerpc binding");
1638
1639 status = dcerpc_secondary_connection(p, &p2, b);
1640 torture_assert_ntstatus_ok(tctx, status, "Failed to create secondary connection");
1641
1642 status = dcerpc_bind_auth_none(p2, &ndr_table_spoolss);
1643 torture_assert_ntstatus_ok(tctx, status, "Failed to create bind on secondary connection");
1644
1645 cp.in.handle = handle;
1646 cp.out.handle = handle;
1647
1648 status = dcerpc_spoolss_ClosePrinter(p2, tctx, &cp);
1649 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_NET_WRITE_FAULT,
1650 "ERROR: Allowed close on secondary connection");
1651
1652 torture_assert_int_equal(tctx, p2->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
1653 "Unexpected fault code");
1654
1655 talloc_free(p2);
1656
1657 return true;
1658 }
1659
1660 static bool test_OpenPrinter_badname(struct torture_context *tctx,
1661 struct dcerpc_pipe *p, const char *name)
1662 {
1663 NTSTATUS status;
1664 struct spoolss_OpenPrinter op;
1665 struct spoolss_OpenPrinterEx opEx;
1666 struct policy_handle handle;
1667 bool ret = true;
1668
1669 op.in.printername = name;
1670 op.in.datatype = NULL;
1671 op.in.devmode_ctr.devmode= NULL;
1672 op.in.access_mask = 0;
1673 op.out.handle = &handle;
1674
1675 torture_comment(tctx, "\nTesting OpenPrinter(%s) with bad name\n", op.in.printername);
1676
1677 status = dcerpc_spoolss_OpenPrinter(p, tctx, &op);
1678 torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
1679 if (!W_ERROR_EQUAL(WERR_INVALID_PRINTER_NAME,op.out.result)) {
1680 torture_comment(tctx, "OpenPrinter(%s) unexpected result[%s] should be WERR_INVALID_PRINTER_NAME\n",
1681 name, win_errstr(op.out.result));
1682 }
1683
1684 if (W_ERROR_IS_OK(op.out.result)) {
1685 ret &=test_ClosePrinter(tctx, p, &handle);
1686 }
1687
1688 opEx.in.printername = name;
1689 opEx.in.datatype = NULL;
1690 opEx.in.devmode_ctr.devmode = NULL;
1691 opEx.in.access_mask = 0;
1692 opEx.in.level = 1;
1693 opEx.in.userlevel.level1 = NULL;
1694 opEx.out.handle = &handle;
1695
1696 torture_comment(tctx, "Testing OpenPrinterEx(%s) with bad name\n", opEx.in.printername);
1697
1698 status = dcerpc_spoolss_OpenPrinterEx(p, tctx, &opEx);
1699 torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
1700 if (!W_ERROR_EQUAL(WERR_INVALID_PARAM,opEx.out.result)) {
1701 torture_comment(tctx, "OpenPrinterEx(%s) unexpected result[%s] should be WERR_INVALID_PARAM\n",
1702 name, win_errstr(opEx.out.result));
1703 }
1704
1705 if (W_ERROR_IS_OK(opEx.out.result)) {
1706 ret &=test_ClosePrinter(tctx, p, &handle);
1707 }
1708
1709 return ret;
1710 }
1711
1712 static bool test_OpenPrinter(struct torture_context *tctx,
1713 struct dcerpc_pipe *p,
1714 const char *name)
1715 {
1716 NTSTATUS status;
1717 struct spoolss_OpenPrinter r;
1718 struct policy_handle handle;
1719 bool ret = true;
1720
1721 r.in.printername = talloc_asprintf(tctx, "\\\\%s\\%s", dcerpc_server_name(p), name);
1722 r.in.datatype = NULL;
1723 r.in.devmode_ctr.devmode= NULL;
1724 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1725 r.out.handle = &handle;
1726
1727 torture_comment(tctx, "Testing OpenPrinter(%s)\n", r.in.printername);
1728
1729 status = dcerpc_spoolss_OpenPrinter(p, tctx, &r);
1730
1731 torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
1732
1733 torture_assert_werr_ok(tctx, r.out.result, "OpenPrinter failed");
1734
1735 if (!test_GetPrinter(tctx, p, &handle)) {
1736 ret = false;
1737 }
1738
1739 if (!torture_setting_bool(tctx, "samba3", false)) {
1740 if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
1741 ret = false;
1742 }
1743 }
1744
1745 if (!test_ClosePrinter(tctx, p, &handle)) {
1746 ret = false;
1747 }
1748
1749 return ret;
1750 }
1751
1752 static bool call_OpenPrinterEx(struct torture_context *tctx,
1753 struct dcerpc_pipe *p,
1754 const char *name, struct policy_handle *handle)
1755 {
1756 struct spoolss_OpenPrinterEx r;
1757 struct spoolss_UserLevel1 userlevel1;
1758 NTSTATUS status;
1759
1760 if (name && name[0]) {
1761 r.in.printername = talloc_asprintf(tctx, "\\\\%s\\%s",
1762 dcerpc_server_name(p), name);
1763 } else {
1764 r.in.printername = talloc_asprintf(tctx, "\\\\%s",
1765 dcerpc_server_name(p));
1766 }
1767
1768 r.in.datatype = NULL;
1769 r.in.devmode_ctr.devmode= NULL;
1770 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1771 r.in.level = 1;
1772 r.in.userlevel.level1 = &userlevel1;
1773 r.out.handle = handle;
1774
1775 userlevel1.size = 1234;
1776 userlevel1.client = "hello";
1777 userlevel1.user = "spottyfoot!";
1778 userlevel1.build = 1;
1779 userlevel1.major = 2;
1780 userlevel1.minor = 3;
1781 userlevel1.processor = 4;
1782
1783 torture_comment(tctx, "Testing OpenPrinterEx(%s)\n", r.in.printername);
1784
1785 status = dcerpc_spoolss_OpenPrinterEx(p, tctx, &r);
1786
1787 torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
1788
1789 torture_assert_werr_ok(tctx, r.out.result, "OpenPrinterEx failed");
1790
1791 return true;
1792 }
1793
1794 static bool test_OpenPrinterEx(struct torture_context *tctx,
1795 struct dcerpc_pipe *p,
1796 const char *name)
1797 {
1798 struct policy_handle handle;
1799 bool ret = true;
1800
1801 if (!call_OpenPrinterEx(tctx, p, name, &handle)) {
1802 return false;
1803 }
1804
1805 if (!test_GetPrinter(tctx, p, &handle)) {
1806 ret = false;
1807 }
1808
1809 if (!test_EnumForms(tctx, p, &handle, false)) {
1810 ret = false;
1811 }
1812
1813 if (!test_AddForm(tctx, p, &handle, false)) {
1814 ret = false;
1815 }
1816
1817 if (!test_EnumPrinterData(tctx, p, &handle)) {
1818 ret = false;
1819 }
1820
1821 if (!test_EnumPrinterDataEx(tctx, p, &handle)) {
1822 ret = false;
1823 }
1824
1825 if (!test_PausePrinter(tctx, p, &handle)) {
1826 ret = false;
1827 }
1828
1829 if (!test_DoPrintTest(tctx, p, &handle)) {
1830 ret = false;
1831 }
1832
1833 if (!test_ResumePrinter(tctx, p, &handle)) {
1834 ret = false;
1835 }
1836
1837 if (!test_SetPrinterData(tctx, p, &handle)) {
1838 ret = false;
1839 }
1840
1841 if (!torture_setting_bool(tctx, "samba3", false)) {
1842 if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
1843 ret = false;
1844 }
1845 }
1846
1847 if (!test_ClosePrinter(tctx, p, &handle)) {
1848 ret = false;
1849 }
1850
1851 return ret;
1852 }
1853
1854 static bool test_EnumPrinters_old(struct torture_context *tctx, struct dcerpc_pipe *p)
1855 {
1856 struct spoolss_EnumPrinters r;
1857 NTSTATUS status;
1858 uint16_t levels[] = {1, 2, 4, 5};
1859 int i;
1860 bool ret = true;
1861
1862 for (i=0;i<ARRAY_SIZE(levels);i++) {
1863 union spoolss_PrinterInfo *info;
1864 int j;
1865 uint32_t needed;
1866 uint32_t count;
1867
1868 r.in.flags = PRINTER_ENUM_LOCAL;
1869 r.in.server = "";
1870 r.in.level = levels[i];
1871 r.in.buffer = NULL;
1872 r.in.offered = 0;
1873 r.out.needed = &needed;
1874 r.out.count = &count;
1875 r.out.info = &info;
1876
1877 torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
1878
1879 status = dcerpc_spoolss_EnumPrinters(p, tctx, &r);
1880 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
1881
1882 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
1883 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
1884 data_blob_clear(&blob);
1885 r.in.buffer = &blob;
1886 r.in.offered = needed;
1887 status = dcerpc_spoolss_EnumPrinters(p, tctx, &r);
1888 }
1889
1890 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
1891
1892 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
1893
1894 if (!info) {
1895 torture_comment(tctx, "No printers returned\n");
1896 return true;
1897 }
1898
1899 for (j=0;j<count;j++) {
1900 if (r.in.level == 1) {
1901 char *unc = talloc_strdup(tctx, info[j].info1.name);
1902 char *slash, *name;
1903 name = unc;
1904 if (unc[0] == '\\' && unc[1] == '\\') {
1905 unc +=2;
1906 }
1907 slash = strchr(unc, '\\');
1908 if (slash) {
1909 slash++;
1910 name = slash;
1911 }
1912 if (!test_OpenPrinter(tctx, p, name)) {
1913 ret = false;
1914 }
1915 if (!test_OpenPrinterEx(tctx, p, name)) {
1916 ret = false;
1917 }
1918 }
1919 }
1920 }
1921
1922 return ret;
1923 }
1924
1925 #if 0
1926 static bool test_GetPrinterDriver2(struct dcerpc_pipe *p,
1927 struct policy_handle *handle,
1928 const char *driver_name)
1929 {
1930 NTSTATUS status;
1931 struct spoolss_GetPrinterDriver2 r;
1932 uint32_t needed;
1933 uint32_t server_major_version;
1934 uint32_t server_minor_version;
1935
1936 r.in.handle = handle;
1937 r.in.architecture = "W32X86";
1938 r.in.level = 1;
1939 r.in.buffer = NULL;
1940 r.in.offered = 0;
1941 r.in.client_major_version = 0;
1942 r.in.client_minor_version = 0;
1943 r.out.needed = &needed;
1944 r.out.server_major_version = &server_major_version;
1945 r.out.server_minor_version = &server_minor_version;
1946
1947 printf("Testing GetPrinterDriver2\n");
1948
1949 status = dcerpc_spoolss_GetPrinterDriver2(p, tctx, &r);
1950 if (!NT_STATUS_IS_OK(status)) {
1951 printf("GetPrinterDriver2 failed - %s\n", nt_errstr(status));
1952 return false;
1953 }
1954
1955 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
1956 r.in.offered = needed;
1957 status = dcerpc_spoolss_GetPrinterDriver2(p, tctx, &r);
1958 }
1959
1960 if (!NT_STATUS_IS_OK(status)) {
1961 printf("GetPrinterDriver2 failed - %s\n",
1962 nt_errstr(status));
1963 return false;
1964 }
1965
1966 if (!W_ERROR_IS_OK(r.out.result)) {
1967 printf("GetPrinterDriver2 failed - %s\n",
1968 win_errstr(r.out.result));
1969 return false;
1970 }
1971
1972 return true;
1973 }
1974 #endif
1975
1976 static bool test_EnumPrinterDrivers_old(struct torture_context *tctx,
1977 struct dcerpc_pipe *p)
1978 {
1979 struct spoolss_EnumPrinterDrivers r;
1980 NTSTATUS status;
1981 uint16_t levels[] = {1, 2, 3, 4, 5, 6};
1982 int i;
1983
1984 for (i=0;i<ARRAY_SIZE(levels);i++) {
1985
1986 uint32_t needed;
1987 uint32_t count;
1988 union spoolss_DriverInfo *info;
1989
1990 r.in.server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1991 r.in.environment = SPOOLSS_ARCHITECTURE_NT_X86;
1992 r.in.level = levels[i];
1993 r.in.buffer = NULL;
1994 r.in.offered = 0;
1995 r.out.needed = &needed;
1996 r.out.count = &count;
1997 r.out.info = &info;
1998
1999 torture_comment(tctx, "Testing EnumPrinterDrivers level %u\n", r.in.level);
2000
2001 status = dcerpc_spoolss_EnumPrinterDrivers(p, tctx, &r);
2002
2003 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDrivers failed");
2004
2005 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2006 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
2007 data_blob_clear(&blob);
2008 r.in.buffer = &blob;
2009 r.in.offered = needed;
2010 status = dcerpc_spoolss_EnumPrinterDrivers(p, tctx, &r);
2011 }
2012
2013 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDrivers failed");
2014
2015 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDrivers failed");
2016
2017 if (!info) {
2018 torture_comment(tctx, "No printer drivers returned\n");
2019 break;
2020 }
2021 }
2022
2023 return true;
2024 }
2025
2026 bool torture_rpc_spoolss(struct torture_context *torture)
2027 {
2028 NTSTATUS status;
2029 struct dcerpc_pipe *p;
2030 bool ret = true;
2031 struct test_spoolss_context *ctx;
2032
2033 status = torture_rpc_connection(torture, &p, &ndr_table_spoolss);
2034 if (!NT_STATUS_IS_OK(status)) {
2035 return false;
2036 }
2037
2038 ctx = talloc_zero(torture, struct test_spoolss_context);
2039
2040 ret &= test_OpenPrinter_server(torture, p, ctx);
2041
2042 ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "W3SvcInstalled");
2043 ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "BeepEnabled");
2044 ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "EventLog");
2045 ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "NetPopup");
2046 ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "NetPopupToComputer");
2047 ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "MajorVersion");
2048 ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "MinorVersion");
2049 ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "DefaultSpoolDirectory");
2050 ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "Architecture");
2051 ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "DsPresent");
2052 ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "OSVersion");
2053 ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "OSVersionEx");
2054 ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "DNSMachineName");
2055 ret &= test_EnumForms(torture, p, &ctx->server_handle, true);
2056 ret &= test_AddForm(torture, p, &ctx->server_handle, true);
2057 ret &= test_EnumPorts(torture, p, ctx);
2058 ret &= test_GetPrinterDriverDirectory(torture, p, ctx);
2059 ret &= test_GetPrintProcessorDirectory(torture, p, ctx);
2060 ret &= test_EnumPrinterDrivers(torture, p, ctx);
2061 ret &= test_EnumMonitors(torture, p, ctx);
2062 ret &= test_EnumPrintProcessors(torture, p, ctx);
2063 ret &= test_EnumPrintProcDataTypes(torture, p, ctx);
2064 ret &= test_EnumPrinters(torture, p, ctx);
2065 ret &= test_OpenPrinter_badname(torture, p, "__INVALID_PRINTER__");
2066 ret &= test_OpenPrinter_badname(torture, p, "\\\\__INVALID_HOST__");
2067 ret &= test_OpenPrinter_badname(torture, p, "");
2068 ret &= test_OpenPrinter_badname(torture, p, "\\\\\\");
2069 ret &= test_OpenPrinter_badname(torture, p, "\\\\\\__INVALID_PRINTER__");
2070 ret &= test_OpenPrinter_badname(torture, p, talloc_asprintf(torture, "\\\\%s\\", dcerpc_server_name(p)));
2071 ret &= test_OpenPrinter_badname(torture, p,
2072 talloc_asprintf(torture, "\\\\%s\\__INVALID_PRINTER__", dcerpc_server_name(p)));
2073
2074
2075 ret &= test_AddPort(torture, p);
2076 ret &= test_EnumPorts_old(torture, p);
2077 ret &= test_EnumPrinters_old(torture, p);
2078 ret &= test_EnumPrinterDrivers_old(torture, p);
2079
2080 return ret;
2081 }
aatanasov's samba4 branch