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