?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4-smbtorture: fix test_SetPrinterDataEx_matrix() call. sorry...
[Samba/nascimento.git] / source4 / torture / rpc / spoolss.c
blob909c37246dd4ebb5d7b854c2ee252d1a1406697d
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-2010
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 "librpc/gen_ndr/ndr_misc.h"
27 #include "librpc/gen_ndr/ndr_spoolss.h"
28 #include "librpc/gen_ndr/ndr_spoolss_c.h"
29 #include "librpc/gen_ndr/ndr_winreg_c.h"
30 #include "librpc/gen_ndr/ndr_security.h"
31 #include "libcli/security/security.h"
32 #include "torture/rpc/rpc.h"
33 #include "param/param.h"
34 #include "lib/registry/registry.h"
35
36 #define TORTURE_WELLKNOWN_PRINTER "torture_wkn_printer"
37 #define TORTURE_PRINTER "torture_printer"
38 #define TORTURE_WELLKNOWN_PRINTER_EX "torture_wkn_printer_ex"
39 #define TORTURE_PRINTER_EX "torture_printer_ex"
40
41 struct test_spoolss_context {
42 /* print server handle */
43 struct policy_handle server_handle;
44
45 /* for EnumPorts */
46 uint32_t port_count[3];
47 union spoolss_PortInfo *ports[3];
48
49 /* for EnumPrinterDrivers */
50 uint32_t driver_count[8];
51 union spoolss_DriverInfo *drivers[8];
52
53 /* for EnumMonitors */
54 uint32_t monitor_count[3];
55 union spoolss_MonitorInfo *monitors[3];
56
57 /* for EnumPrintProcessors */
58 uint32_t print_processor_count[2];
59 union spoolss_PrintProcessorInfo *print_processors[2];
60
61 /* for EnumPrinters */
62 uint32_t printer_count[6];
63 union spoolss_PrinterInfo *printers[6];
64 };
65
66 #define COMPARE_STRING(tctx, c,r,e) \
67 torture_assert_str_equal(tctx, c.e, r.e, "invalid value")
68
69 /* not every compiler supports __typeof__() */
70 #if (__GNUC__ >= 3)
71 #define _CHECK_FIELD_SIZE(c,r,e,type) do {\
72 if (sizeof(__typeof__(c.e)) != sizeof(type)) { \
73 torture_fail(tctx, #c "." #e "field is not " #type "\n"); \
74 }\
75 if (sizeof(__typeof__(r.e)) != sizeof(type)) { \
76 torture_fail(tctx, #r "." #e "field is not " #type "\n"); \
77 }\
78 } while(0)
79 #else
80 #define _CHECK_FIELD_SIZE(c,r,e,type) do {} while(0)
81 #endif
82
83 #define COMPARE_UINT32(tctx, c, r, e) do {\
84 _CHECK_FIELD_SIZE(c, r, e, uint32_t); \
85 torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
86 } while(0)
87
88 #define COMPARE_UINT64(tctx, c, r, e) do {\
89 _CHECK_FIELD_SIZE(c, r, e, uint64_t); \
90 torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
91 } while(0)
92
93
94 #define COMPARE_NTTIME(tctx, c, r, e) do {\
95 _CHECK_FIELD_SIZE(c, r, e, NTTIME); \
96 torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
97 } while(0)
98
99 #define COMPARE_STRING_ARRAY(tctx, c,r,e) do {\
100 int __i; \
101 if (!c.e && !r.e) { \
102 break; \
103 } \
104 if (c.e && !r.e) { \
105 torture_fail(tctx, #r "." #e " field is NULL and " #c "." #e " is not\n"); \
106 } \
107 if (!c.e && r.e) { \
108 torture_fail(tctx, #c "." #e " field is NULL and " #r "." #e " is not\n"); \
109 } \
110 for (__i=0;c.e[__i] != NULL; __i++) { \
111 torture_assert_str_equal(tctx, c.e[__i], r.e[__i], "invalid value"); \
112 } \
113 } while(0)
114
115 #define CHECK_ALIGN(size, n) do {\
116 if (size % n) {\
117 torture_warning(tctx, "%d is *NOT* %d byte aligned, should be %d",\
118 size, n, size + n - (size % n));\
119 }\
120 } while(0)
121
122 #define DO_ROUND(size, n) (((size)+((n)-1)) & ~((n)-1))
123
124 #define CHECK_NEEDED_SIZE_ENUM_LEVEL(fn, info, level, count, ic, needed, align) do { \
125 if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
126 uint32_t size = ndr_size_##fn##_info(tctx, ic, level, count, info);\
127 uint32_t round_size = DO_ROUND(size, align);\
128 if (round_size != needed) {\
129 torture_warning(tctx, __location__": "#fn" level %d (count: %d) got unexpected needed size: %d, we calculated: %d", level, count, needed, round_size);\
130 CHECK_ALIGN(size, align);\
131 }\
132 }\
133 } while(0)
134
135 #define CHECK_NEEDED_SIZE_ENUM(fn, info, count, ic, needed, align) do { \
136 if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
137 uint32_t size = ndr_size_##fn##_info(tctx, ic, count, info);\
138 uint32_t round_size = DO_ROUND(size, align);\
139 if (round_size != needed) {\
140 torture_warning(tctx, __location__": "#fn" (count: %d) got unexpected needed size: %d, we calculated: %d", count, needed, round_size);\
141 CHECK_ALIGN(size, align);\
142 }\
143 }\
144 } while(0)
145
146 #define CHECK_NEEDED_SIZE_LEVEL(fn, info, level, ic, needed, align) do { \
147 if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
148 uint32_t size = ndr_size_##fn(info, level, ic, 0);\
149 uint32_t round_size = DO_ROUND(size, align);\
150 if (round_size != needed) {\
151 torture_warning(tctx, __location__": "#fn" level %d got unexpected needed size: %d, we calculated: %d", level, needed, round_size);\
152 CHECK_ALIGN(size, align);\
153 }\
154 }\
155 } while(0)
156
157 static bool test_OpenPrinter_server(struct torture_context *tctx,
158 struct dcerpc_pipe *p,
159 struct policy_handle *server_handle)
160 {
161 NTSTATUS status;
162 struct spoolss_OpenPrinter op;
163
164 op.in.printername = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
165 op.in.datatype = NULL;
166 op.in.devmode_ctr.devmode= NULL;
167 op.in.access_mask = 0;
168 op.out.handle = server_handle;
169
170 torture_comment(tctx, "Testing OpenPrinter(%s)\n", op.in.printername);
171
172 status = dcerpc_spoolss_OpenPrinter(p, tctx, &op);
173 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_OpenPrinter failed");
174 torture_assert_werr_ok(tctx, op.out.result, "dcerpc_spoolss_OpenPrinter failed");
175
176 return true;
177 }
178
179 static bool test_EnumPorts(struct torture_context *tctx,
180 struct dcerpc_pipe *p,
181 struct test_spoolss_context *ctx)
182 {
183 NTSTATUS status;
184 struct spoolss_EnumPorts r;
185 uint16_t levels[] = { 1, 2 };
186 int i, j;
187
188 for (i=0;i<ARRAY_SIZE(levels);i++) {
189 int level = levels[i];
190 DATA_BLOB blob;
191 uint32_t needed;
192 uint32_t count;
193 union spoolss_PortInfo *info;
194
195 r.in.servername = "";
196 r.in.level = level;
197 r.in.buffer = NULL;
198 r.in.offered = 0;
199 r.out.needed = &needed;
200 r.out.count = &count;
201 r.out.info = &info;
202
203 torture_comment(tctx, "Testing EnumPorts level %u\n", r.in.level);
204
205 status = dcerpc_spoolss_EnumPorts(p, ctx, &r);
206 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
207 if (W_ERROR_IS_OK(r.out.result)) {
208 /* TODO: do some more checks here */
209 continue;
210 }
211 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
212 "EnumPorts unexpected return code");
213
214 blob = data_blob_talloc(ctx, NULL, needed);
215 data_blob_clear(&blob);
216 r.in.buffer = &blob;
217 r.in.offered = needed;
218
219 status = dcerpc_spoolss_EnumPorts(p, ctx, &r);
220 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
221
222 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
223
224 torture_assert(tctx, info, "EnumPorts returned no info");
225
226 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPorts, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
227
228 ctx->port_count[level] = count;
229 ctx->ports[level] = info;
230 }
231
232 for (i=1;i<ARRAY_SIZE(levels);i++) {
233 int level = levels[i];
234 int old_level = levels[i-1];
235 torture_assert_int_equal(tctx, ctx->port_count[level], ctx->port_count[old_level],
236 "EnumPorts invalid value");
237 }
238 /* if the array sizes are not the same we would maybe segfault in the following code */
239
240 for (i=0;i<ARRAY_SIZE(levels);i++) {
241 int level = levels[i];
242 for (j=0;j<ctx->port_count[level];j++) {
243 union spoolss_PortInfo *cur = &ctx->ports[level][j];
244 union spoolss_PortInfo *ref = &ctx->ports[2][j];
245 switch (level) {
246 case 1:
247 COMPARE_STRING(tctx, cur->info1, ref->info2, port_name);
248 break;
249 case 2:
250 /* level 2 is our reference, and it makes no sense to compare it to itself */
251 break;
252 }
253 }
254 }
255
256 return true;
257 }
258
259 static bool test_GetPrintProcessorDirectory(struct torture_context *tctx,
260 struct dcerpc_pipe *p,
261 struct test_spoolss_context *ctx,
262 const char *environment)
263 {
264 NTSTATUS status;
265 struct spoolss_GetPrintProcessorDirectory r;
266 struct {
267 uint16_t level;
268 const char *server;
269 } levels[] = {{
270 .level = 1,
271 .server = NULL
272 },{
273 .level = 1,
274 .server = ""
275 },{
276 .level = 78,
277 .server = ""
278 },{
279 .level = 1,
280 .server = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p))
281 },{
282 .level = 1024,
283 .server = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p))
284 }
285 };
286 int i;
287 uint32_t needed;
288
289 for (i=0;i<ARRAY_SIZE(levels);i++) {
290 int level = levels[i].level;
291 DATA_BLOB blob;
292
293 r.in.server = levels[i].server;
294 r.in.environment = environment;
295 r.in.level = level;
296 r.in.buffer = NULL;
297 r.in.offered = 0;
298 r.out.needed = &needed;
299
300 torture_comment(tctx, "Testing GetPrintProcessorDirectory level %u\n", r.in.level);
301
302 status = dcerpc_spoolss_GetPrintProcessorDirectory(p, ctx, &r);
303 torture_assert_ntstatus_ok(tctx, status,
304 "dcerpc_spoolss_GetPrintProcessorDirectory failed");
305 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
306 "GetPrintProcessorDirectory unexpected return code");
307
308 blob = data_blob_talloc(ctx, NULL, needed);
309 data_blob_clear(&blob);
310 r.in.buffer = &blob;
311 r.in.offered = needed;
312
313 status = dcerpc_spoolss_GetPrintProcessorDirectory(p, ctx, &r);
314 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrintProcessorDirectory failed");
315
316 torture_assert_werr_ok(tctx, r.out.result, "GetPrintProcessorDirectory failed");
317
318 CHECK_NEEDED_SIZE_LEVEL(spoolss_PrintProcessorDirectoryInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 2);
319 }
320
321 return true;
322 }
323
324
325 static bool test_GetPrinterDriverDirectory(struct torture_context *tctx,
326 struct dcerpc_pipe *p,
327 struct test_spoolss_context *ctx,
328 const char *environment)
329 {
330 NTSTATUS status;
331 struct spoolss_GetPrinterDriverDirectory r;
332 struct {
333 uint16_t level;
334 const char *server;
335 } levels[] = {{
336 .level = 1,
337 .server = NULL
338 },{
339 .level = 1,
340 .server = ""
341 },{
342 .level = 78,
343 .server = ""
344 },{
345 .level = 1,
346 .server = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p))
347 },{
348 .level = 1024,
349 .server = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p))
350 }
351 };
352 int i;
353 uint32_t needed;
354
355 for (i=0;i<ARRAY_SIZE(levels);i++) {
356 int level = levels[i].level;
357 DATA_BLOB blob;
358
359 r.in.server = levels[i].server;
360 r.in.environment = environment;
361 r.in.level = level;
362 r.in.buffer = NULL;
363 r.in.offered = 0;
364 r.out.needed = &needed;
365
366 torture_comment(tctx, "Testing GetPrinterDriverDirectory level %u\n", r.in.level);
367
368 status = dcerpc_spoolss_GetPrinterDriverDirectory(p, ctx, &r);
369 torture_assert_ntstatus_ok(tctx, status,
370 "dcerpc_spoolss_GetPrinterDriverDirectory failed");
371 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
372 "GetPrinterDriverDirectory unexpected return code");
373
374 blob = data_blob_talloc(ctx, NULL, needed);
375 data_blob_clear(&blob);
376 r.in.buffer = &blob;
377 r.in.offered = needed;
378
379 status = dcerpc_spoolss_GetPrinterDriverDirectory(p, ctx, &r);
380 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrinterDriverDirectory failed");
381
382 torture_assert_werr_ok(tctx, r.out.result, "GetPrinterDriverDirectory failed");
383
384 CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverDirectoryInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 2);
385 }
386
387 return true;
388 }
389
390 static bool test_EnumPrinterDrivers(struct torture_context *tctx,
391 struct dcerpc_pipe *p,
392 struct test_spoolss_context *ctx,
393 const char *architecture)
394 {
395 NTSTATUS status;
396 struct spoolss_EnumPrinterDrivers r;
397 uint16_t levels[] = { 1, 2, 3, 4, 5, 6, 8 };
398 int i, j;
399
400 for (i=0;i<ARRAY_SIZE(levels);i++) {
401 int level = levels[i];
402 DATA_BLOB blob;
403 uint32_t needed;
404 uint32_t count;
405 union spoolss_DriverInfo *info;
406
407 /* FIXME: gd, come back and fix "" as server, and handle
408 * priority of returned error codes in torture test and samba 3
409 * server */
410
411 r.in.server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
412 r.in.environment = architecture;
413 r.in.level = level;
414 r.in.buffer = NULL;
415 r.in.offered = 0;
416 r.out.needed = &needed;
417 r.out.count = &count;
418 r.out.info = &info;
419
420 torture_comment(tctx, "Testing EnumPrinterDrivers level %u (%s)\n", r.in.level, r.in.environment);
421
422 status = dcerpc_spoolss_EnumPrinterDrivers(p, ctx, &r);
423 torture_assert_ntstatus_ok(tctx, status,
424 "dcerpc_spoolss_EnumPrinterDrivers failed");
425 if (W_ERROR_IS_OK(r.out.result)) {
426 /* TODO: do some more checks here */
427 continue;
428 }
429 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
430 blob = data_blob_talloc(ctx, NULL, needed);
431 data_blob_clear(&blob);
432 r.in.buffer = &blob;
433 r.in.offered = needed;
434
435 status = dcerpc_spoolss_EnumPrinterDrivers(p, ctx, &r);
436 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinterDrivers failed");
437 }
438
439 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDrivers failed");
440
441 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinterDrivers, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
442
443 ctx->driver_count[level] = count;
444 ctx->drivers[level] = info;
445 }
446
447 for (i=1;i<ARRAY_SIZE(levels);i++) {
448 int level = levels[i];
449 int old_level = levels[i-1];
450
451 torture_assert_int_equal(tctx, ctx->driver_count[level], ctx->driver_count[old_level],
452 "EnumPrinterDrivers invalid value");
453 }
454
455 for (i=0;i<ARRAY_SIZE(levels);i++) {
456 int level = levels[i];
457
458 for (j=0;j<ctx->driver_count[level];j++) {
459 union spoolss_DriverInfo *cur = &ctx->drivers[level][j];
460 union spoolss_DriverInfo *ref = &ctx->drivers[8][j];
461
462 switch (level) {
463 case 1:
464 COMPARE_STRING(tctx, cur->info1, ref->info8, driver_name);
465 break;
466 case 2:
467 COMPARE_UINT32(tctx, cur->info2, ref->info8, version);
468 COMPARE_STRING(tctx, cur->info2, ref->info8, driver_name);
469 COMPARE_STRING(tctx, cur->info2, ref->info8, architecture);
470 COMPARE_STRING(tctx, cur->info2, ref->info8, driver_path);
471 COMPARE_STRING(tctx, cur->info2, ref->info8, data_file);
472 COMPARE_STRING(tctx, cur->info2, ref->info8, config_file);
473 break;
474 case 3:
475 COMPARE_UINT32(tctx, cur->info3, ref->info8, version);
476 COMPARE_STRING(tctx, cur->info3, ref->info8, driver_name);
477 COMPARE_STRING(tctx, cur->info3, ref->info8, architecture);
478 COMPARE_STRING(tctx, cur->info3, ref->info8, driver_path);
479 COMPARE_STRING(tctx, cur->info3, ref->info8, data_file);
480 COMPARE_STRING(tctx, cur->info3, ref->info8, config_file);
481 COMPARE_STRING(tctx, cur->info3, ref->info8, help_file);
482 COMPARE_STRING_ARRAY(tctx, cur->info3, ref->info8, dependent_files);
483 COMPARE_STRING(tctx, cur->info3, ref->info8, monitor_name);
484 COMPARE_STRING(tctx, cur->info3, ref->info8, default_datatype);
485 break;
486 case 4:
487 COMPARE_UINT32(tctx, cur->info4, ref->info8, version);
488 COMPARE_STRING(tctx, cur->info4, ref->info8, driver_name);
489 COMPARE_STRING(tctx, cur->info4, ref->info8, architecture);
490 COMPARE_STRING(tctx, cur->info4, ref->info8, driver_path);
491 COMPARE_STRING(tctx, cur->info4, ref->info8, data_file);
492 COMPARE_STRING(tctx, cur->info4, ref->info8, config_file);
493 COMPARE_STRING(tctx, cur->info4, ref->info8, help_file);
494 COMPARE_STRING_ARRAY(tctx, cur->info4, ref->info8, dependent_files);
495 COMPARE_STRING(tctx, cur->info4, ref->info8, monitor_name);
496 COMPARE_STRING(tctx, cur->info4, ref->info8, default_datatype);
497 COMPARE_STRING_ARRAY(tctx, cur->info4, ref->info8, previous_names);
498 break;
499 case 5:
500 COMPARE_UINT32(tctx, cur->info5, ref->info8, version);
501 COMPARE_STRING(tctx, cur->info5, ref->info8, driver_name);
502 COMPARE_STRING(tctx, cur->info5, ref->info8, architecture);
503 COMPARE_STRING(tctx, cur->info5, ref->info8, driver_path);
504 COMPARE_STRING(tctx, cur->info5, ref->info8, data_file);
505 COMPARE_STRING(tctx, cur->info5, ref->info8, config_file);
506 /*COMPARE_UINT32(tctx, cur->info5, ref->info8, driver_attributes);*/
507 /*COMPARE_UINT32(tctx, cur->info5, ref->info8, config_version);*/
508 /*TODO: ! COMPARE_UINT32(tctx, cur->info5, ref->info8, driver_version); */
509 break;
510 case 6:
511 COMPARE_UINT32(tctx, cur->info6, ref->info8, version);
512 COMPARE_STRING(tctx, cur->info6, ref->info8, driver_name);
513 COMPARE_STRING(tctx, cur->info6, ref->info8, architecture);
514 COMPARE_STRING(tctx, cur->info6, ref->info8, driver_path);
515 COMPARE_STRING(tctx, cur->info6, ref->info8, data_file);
516 COMPARE_STRING(tctx, cur->info6, ref->info8, config_file);
517 COMPARE_STRING(tctx, cur->info6, ref->info8, help_file);
518 COMPARE_STRING_ARRAY(tctx, cur->info6, ref->info8, dependent_files);
519 COMPARE_STRING(tctx, cur->info6, ref->info8, monitor_name);
520 COMPARE_STRING(tctx, cur->info6, ref->info8, default_datatype);
521 COMPARE_STRING_ARRAY(tctx, cur->info6, ref->info8, previous_names);
522 COMPARE_NTTIME(tctx, cur->info6, ref->info8, driver_date);
523 COMPARE_UINT64(tctx, cur->info6, ref->info8, driver_version);
524 COMPARE_STRING(tctx, cur->info6, ref->info8, manufacturer_name);
525 COMPARE_STRING(tctx, cur->info6, ref->info8, manufacturer_url);
526 COMPARE_STRING(tctx, cur->info6, ref->info8, hardware_id);
527 COMPARE_STRING(tctx, cur->info6, ref->info8, provider);
528 break;
529 case 8:
530 /* level 8 is our reference, and it makes no sense to compare it to itself */
531 break;
532 }
533 }
534 }
535
536 return true;
537 }
538
539 static bool test_EnumMonitors(struct torture_context *tctx,
540 struct dcerpc_pipe *p,
541 struct test_spoolss_context *ctx)
542 {
543 NTSTATUS status;
544 struct spoolss_EnumMonitors r;
545 uint16_t levels[] = { 1, 2 };
546 int i, j;
547
548 for (i=0;i<ARRAY_SIZE(levels);i++) {
549 int level = levels[i];
550 DATA_BLOB blob;
551 uint32_t needed;
552 uint32_t count;
553 union spoolss_MonitorInfo *info;
554
555 r.in.servername = "";
556 r.in.level = level;
557 r.in.buffer = NULL;
558 r.in.offered = 0;
559 r.out.needed = &needed;
560 r.out.count = &count;
561 r.out.info = &info;
562
563 torture_comment(tctx, "Testing EnumMonitors level %u\n", r.in.level);
564
565 status = dcerpc_spoolss_EnumMonitors(p, ctx, &r);
566 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
567 if (W_ERROR_IS_OK(r.out.result)) {
568 /* TODO: do some more checks here */
569 continue;
570 }
571 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
572 "EnumMonitors failed");
573
574 blob = data_blob_talloc(ctx, NULL, needed);
575 data_blob_clear(&blob);
576 r.in.buffer = &blob;
577 r.in.offered = needed;
578
579 status = dcerpc_spoolss_EnumMonitors(p, ctx, &r);
580 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
581
582 torture_assert_werr_ok(tctx, r.out.result, "EnumMonitors failed");
583
584 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumMonitors, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
585
586 ctx->monitor_count[level] = count;
587 ctx->monitors[level] = info;
588 }
589
590 for (i=1;i<ARRAY_SIZE(levels);i++) {
591 int level = levels[i];
592 int old_level = levels[i-1];
593 torture_assert_int_equal(tctx, ctx->monitor_count[level], ctx->monitor_count[old_level],
594 "EnumMonitors invalid value");
595 }
596
597 for (i=0;i<ARRAY_SIZE(levels);i++) {
598 int level = levels[i];
599 for (j=0;j<ctx->monitor_count[level];j++) {
600 union spoolss_MonitorInfo *cur = &ctx->monitors[level][j];
601 union spoolss_MonitorInfo *ref = &ctx->monitors[2][j];
602 switch (level) {
603 case 1:
604 COMPARE_STRING(tctx, cur->info1, ref->info2, monitor_name);
605 break;
606 case 2:
607 /* level 2 is our reference, and it makes no sense to compare it to itself */
608 break;
609 }
610 }
611 }
612
613 return true;
614 }
615
616 static bool test_EnumPrintProcessors(struct torture_context *tctx,
617 struct dcerpc_pipe *p,
618 struct test_spoolss_context *ctx,
619 const char *environment)
620 {
621 NTSTATUS status;
622 struct spoolss_EnumPrintProcessors r;
623 uint16_t levels[] = { 1 };
624 int i, j;
625
626 for (i=0;i<ARRAY_SIZE(levels);i++) {
627 int level = levels[i];
628 DATA_BLOB blob;
629 uint32_t needed;
630 uint32_t count;
631 union spoolss_PrintProcessorInfo *info;
632
633 r.in.servername = "";
634 r.in.environment = environment;
635 r.in.level = level;
636 r.in.buffer = NULL;
637 r.in.offered = 0;
638 r.out.needed = &needed;
639 r.out.count = &count;
640 r.out.info = &info;
641
642 torture_comment(tctx, "Testing EnumPrintProcessors level %u\n", r.in.level);
643
644 status = dcerpc_spoolss_EnumPrintProcessors(p, ctx, &r);
645 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcessors failed");
646 if (W_ERROR_IS_OK(r.out.result)) {
647 /* TODO: do some more checks here */
648 continue;
649 }
650 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
651 "EnumPrintProcessors unexpected return code");
652
653 blob = data_blob_talloc(ctx, NULL, needed);
654 data_blob_clear(&blob);
655 r.in.buffer = &blob;
656 r.in.offered = needed;
657
658 status = dcerpc_spoolss_EnumPrintProcessors(p, ctx, &r);
659 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcessors failed");
660
661 torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcessors failed");
662
663 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcessors, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
664
665 ctx->print_processor_count[level] = count;
666 ctx->print_processors[level] = info;
667 }
668
669 for (i=1;i<ARRAY_SIZE(levels);i++) {
670 int level = levels[i];
671 int old_level = levels[i-1];
672 torture_assert_int_equal(tctx, ctx->print_processor_count[level], ctx->print_processor_count[old_level],
673 "EnumPrintProcessors failed");
674 }
675
676 for (i=0;i<ARRAY_SIZE(levels);i++) {
677 int level = levels[i];
678 for (j=0;j<ctx->print_processor_count[level];j++) {
679 #if 0
680 union spoolss_PrintProcessorInfo *cur = &ctx->print_processors[level][j];
681 union spoolss_PrintProcessorInfo *ref = &ctx->print_processors[1][j];
682 #endif
683 switch (level) {
684 case 1:
685 /* level 1 is our reference, and it makes no sense to compare it to itself */
686 break;
687 }
688 }
689 }
690
691 return true;
692 }
693
694 static bool test_EnumPrintProcDataTypes(struct torture_context *tctx,
695 struct dcerpc_pipe *p,
696 struct test_spoolss_context *ctx)
697 {
698 NTSTATUS status;
699 struct spoolss_EnumPrintProcDataTypes r;
700 uint16_t levels[] = { 1 };
701 int i;
702
703 for (i=0;i<ARRAY_SIZE(levels);i++) {
704 int level = levels[i];
705 DATA_BLOB blob;
706 uint32_t needed;
707 uint32_t count;
708 union spoolss_PrintProcDataTypesInfo *info;
709
710 r.in.servername = "";
711 r.in.print_processor_name = "winprint";
712 r.in.level = level;
713 r.in.buffer = NULL;
714 r.in.offered = 0;
715 r.out.needed = &needed;
716 r.out.count = &count;
717 r.out.info = &info;
718
719 torture_comment(tctx, "Testing EnumPrintProcDataTypes level %u\n", r.in.level);
720
721 status = dcerpc_spoolss_EnumPrintProcDataTypes(p, ctx, &r);
722 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcDataType failed");
723 if (W_ERROR_IS_OK(r.out.result)) {
724 /* TODO: do some more checks here */
725 continue;
726 }
727 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
728 "EnumPrintProcDataTypes unexpected return code");
729
730 blob = data_blob_talloc(ctx, NULL, needed);
731 data_blob_clear(&blob);
732 r.in.buffer = &blob;
733 r.in.offered = needed;
734
735 status = dcerpc_spoolss_EnumPrintProcDataTypes(p, ctx, &r);
736 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcDataTypes failed");
737
738 torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcDataTypes failed");
739
740 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcDataTypes, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
741
742 }
743
744 return true;
745 }
746
747
748 static bool test_EnumPrinters(struct torture_context *tctx,
749 struct dcerpc_pipe *p,
750 struct test_spoolss_context *ctx)
751 {
752 struct spoolss_EnumPrinters r;
753 NTSTATUS status;
754 uint16_t levels[] = { 0, 1, 2, 4, 5 };
755 int i, j;
756
757 for (i=0;i<ARRAY_SIZE(levels);i++) {
758 int level = levels[i];
759 DATA_BLOB blob;
760 uint32_t needed;
761 uint32_t count;
762 union spoolss_PrinterInfo *info;
763
764 r.in.flags = PRINTER_ENUM_LOCAL;
765 r.in.server = "";
766 r.in.level = level;
767 r.in.buffer = NULL;
768 r.in.offered = 0;
769 r.out.needed = &needed;
770 r.out.count = &count;
771 r.out.info = &info;
772
773 torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
774
775 status = dcerpc_spoolss_EnumPrinters(p, ctx, &r);
776 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
777 if (W_ERROR_IS_OK(r.out.result)) {
778 /* TODO: do some more checks here */
779 continue;
780 }
781 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
782 "EnumPrinters unexpected return code");
783
784 blob = data_blob_talloc(ctx, NULL, needed);
785 data_blob_clear(&blob);
786 r.in.buffer = &blob;
787 r.in.offered = needed;
788
789 status = dcerpc_spoolss_EnumPrinters(p, ctx, &r);
790 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
791
792 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
793
794 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
795
796 ctx->printer_count[level] = count;
797 ctx->printers[level] = info;
798 }
799
800 for (i=1;i<ARRAY_SIZE(levels);i++) {
801 int level = levels[i];
802 int old_level = levels[i-1];
803 torture_assert_int_equal(tctx, ctx->printer_count[level], ctx->printer_count[old_level],
804 "EnumPrinters invalid value");
805 }
806
807 for (i=0;i<ARRAY_SIZE(levels);i++) {
808 int level = levels[i];
809 for (j=0;j<ctx->printer_count[level];j++) {
810 union spoolss_PrinterInfo *cur = &ctx->printers[level][j];
811 union spoolss_PrinterInfo *ref = &ctx->printers[2][j];
812 switch (level) {
813 case 0:
814 COMPARE_STRING(tctx, cur->info0, ref->info2, printername);
815 COMPARE_STRING(tctx, cur->info0, ref->info2, servername);
816 COMPARE_UINT32(tctx, cur->info0, ref->info2, cjobs);
817 /*COMPARE_UINT32(tctx, cur->info0, ref->info2, total_jobs);
818 COMPARE_UINT32(tctx, cur->info0, ref->info2, total_bytes);
819 COMPARE_SPOOLSS_TIME(cur->info0, ref->info2, spoolss_Time time);
820 COMPARE_UINT32(tctx, cur->info0, ref->info2, global_counter);
821 COMPARE_UINT32(tctx, cur->info0, ref->info2, total_pages);
822 COMPARE_UINT32(tctx, cur->info0, ref->info2, version);
823 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown10);
824 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown11);
825 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown12);
826 COMPARE_UINT32(tctx, cur->info0, ref->info2, session_counter);
827 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown14);
828 COMPARE_UINT32(tctx, cur->info0, ref->info2, printer_errors);
829 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown16);
830 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown17);
831 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown18);
832 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown19);
833 COMPARE_UINT32(tctx, cur->info0, ref->info2, change_id);
834 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown21);*/
835 COMPARE_UINT32(tctx, cur->info0, ref->info2, status);
836 /*COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown23);
837 COMPARE_UINT32(tctx, cur->info0, ref->info2, c_setprinter);
838 COMPARE_UINT16(cur->info0, ref->info2, unknown25);
839 COMPARE_UINT16(cur->info0, ref->info2, unknown26);
840 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown27);
841 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown28);
842 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown29);*/
843 break;
844 case 1:
845 /*COMPARE_UINT32(tctx, cur->info1, ref->info2, flags);*/
846 /*COMPARE_STRING(tctx, cur->info1, ref->info2, name);*/
847 /*COMPARE_STRING(tctx, cur->info1, ref->info2, description);*/
848 COMPARE_STRING(tctx, cur->info1, ref->info2, comment);
849 break;
850 case 2:
851 /* level 2 is our reference, and it makes no sense to compare it to itself */
852 break;
853 case 4:
854 COMPARE_STRING(tctx, cur->info4, ref->info2, printername);
855 COMPARE_STRING(tctx, cur->info4, ref->info2, servername);
856 COMPARE_UINT32(tctx, cur->info4, ref->info2, attributes);
857 break;
858 case 5:
859 COMPARE_STRING(tctx, cur->info5, ref->info2, printername);
860 COMPARE_STRING(tctx, cur->info5, ref->info2, portname);
861 COMPARE_UINT32(tctx, cur->info5, ref->info2, attributes);
862 /*COMPARE_UINT32(tctx, cur->info5, ref->info2, device_not_selected_timeout);
863 COMPARE_UINT32(tctx, cur->info5, ref->info2, transmission_retry_timeout);*/
864 break;
865 }
866 }
867 }
868
869 /* TODO:
870 * - verify that the port of a printer was in the list returned by EnumPorts
871 */
872
873 return true;
874 }
875
876 static bool test_GetPrinterDriver2(struct torture_context *tctx,
877 struct dcerpc_pipe *p,
878 struct policy_handle *handle,
879 const char *driver_name,
880 const char *environment);
881
882 bool test_GetPrinter_level(struct torture_context *tctx,
883 struct dcerpc_pipe *p,
884 struct policy_handle *handle,
885 uint32_t level,
886 union spoolss_PrinterInfo *info)
887 {
888 struct spoolss_GetPrinter r;
889 uint32_t needed;
890
891 r.in.handle = handle;
892 r.in.level = level;
893 r.in.buffer = NULL;
894 r.in.offered = 0;
895 r.out.needed = &needed;
896
897 torture_comment(tctx, "Testing GetPrinter level %u\n", r.in.level);
898
899 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinter(p, tctx, &r),
900 "GetPrinter failed");
901
902 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
903 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
904 data_blob_clear(&blob);
905 r.in.buffer = &blob;
906 r.in.offered = needed;
907
908 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinter(p, tctx, &r),
909 "GetPrinter failed");
910 }
911
912 torture_assert_werr_ok(tctx, r.out.result, "GetPrinter failed");
913
914 CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
915
916 if (info && r.out.info) {
917 *info = *r.out.info;
918 }
919
920 return true;
921 }
922
923
924 static bool test_GetPrinter(struct torture_context *tctx,
925 struct dcerpc_pipe *p,
926 struct policy_handle *handle,
927 const char *environment)
928 {
929 uint32_t levels[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
930 int i;
931
932 for (i=0;i<ARRAY_SIZE(levels);i++) {
933
934 union spoolss_PrinterInfo info;
935
936 ZERO_STRUCT(info);
937
938 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, levels[i], &info),
939 "failed to call GetPrinter");
940
941 if ((levels[i] == 2) && info.info2.drivername && strlen(info.info2.drivername)) {
942 torture_assert(tctx,
943 test_GetPrinterDriver2(tctx, p, handle, info.info2.drivername, environment),
944 "failed to call test_GetPrinterDriver2");
945 }
946 }
947
948 return true;
949 }
950
951 static bool test_SetPrinter(struct torture_context *tctx,
952 struct dcerpc_pipe *p,
953 struct policy_handle *handle,
954 struct spoolss_SetPrinterInfoCtr *info_ctr,
955 struct spoolss_DevmodeContainer *devmode_ctr,
956 struct sec_desc_buf *secdesc_ctr,
957 enum spoolss_PrinterControl command)
958 {
959 struct spoolss_SetPrinter r;
960
961 r.in.handle = handle;
962 r.in.info_ctr = info_ctr;
963 r.in.devmode_ctr = devmode_ctr;
964 r.in.secdesc_ctr = secdesc_ctr;
965 r.in.command = command;
966
967 torture_comment(tctx, "Testing SetPrinter level %d\n", r.in.info_ctr->level);
968
969 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter(p, tctx, &r),
970 "failed to call SetPrinter");
971 torture_assert_werr_ok(tctx, r.out.result,
972 "failed to call SetPrinter");
973
974 return true;
975 }
976
977 static bool test_SetPrinter_errors(struct torture_context *tctx,
978 struct dcerpc_pipe *p,
979 struct policy_handle *handle)
980 {
981 struct spoolss_SetPrinter r;
982 uint16_t levels[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
983 int i;
984
985 struct spoolss_SetPrinterInfoCtr info_ctr;
986 struct spoolss_DevmodeContainer devmode_ctr;
987 struct sec_desc_buf secdesc_ctr;
988
989 info_ctr.level = 0;
990 info_ctr.info.info0 = NULL;
991
992 ZERO_STRUCT(devmode_ctr);
993 ZERO_STRUCT(secdesc_ctr);
994
995 r.in.handle = handle;
996 r.in.info_ctr = &info_ctr;
997 r.in.devmode_ctr = &devmode_ctr;
998 r.in.secdesc_ctr = &secdesc_ctr;
999 r.in.command = 0;
1000
1001 torture_comment(tctx, "Testing SetPrinter all zero\n");
1002
1003 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter(p, tctx, &r),
1004 "failed to call SetPrinter");
1005 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
1006 "failed to call SetPrinter");
1007
1008 again:
1009 for (i=0; i < ARRAY_SIZE(levels); i++) {
1010
1011 struct spoolss_SetPrinterInfo0 info0;
1012 struct spoolss_SetPrinterInfo1 info1;
1013 struct spoolss_SetPrinterInfo2 info2;
1014 struct spoolss_SetPrinterInfo3 info3;
1015 struct spoolss_SetPrinterInfo4 info4;
1016 struct spoolss_SetPrinterInfo5 info5;
1017 struct spoolss_SetPrinterInfo6 info6;
1018 struct spoolss_SetPrinterInfo7 info7;
1019 struct spoolss_SetPrinterInfo8 info8;
1020 struct spoolss_SetPrinterInfo9 info9;
1021
1022
1023 info_ctr.level = levels[i];
1024 switch (levels[i]) {
1025 case 0:
1026 ZERO_STRUCT(info0);
1027 info_ctr.info.info0 = &info0;
1028 break;
1029 case 1:
1030 ZERO_STRUCT(info1);
1031 info_ctr.info.info1 = &info1;
1032 break;
1033 case 2:
1034 ZERO_STRUCT(info2);
1035 info_ctr.info.info2 = &info2;
1036 break;
1037 case 3:
1038 ZERO_STRUCT(info3);
1039 info_ctr.info.info3 = &info3;
1040 break;
1041 case 4:
1042 ZERO_STRUCT(info4);
1043 info_ctr.info.info4 = &info4;
1044 break;
1045 case 5:
1046 ZERO_STRUCT(info5);
1047 info_ctr.info.info5 = &info5;
1048 break;
1049 case 6:
1050 ZERO_STRUCT(info6);
1051 info_ctr.info.info6 = &info6;
1052 break;
1053 case 7:
1054 ZERO_STRUCT(info7);
1055 info_ctr.info.info7 = &info7;
1056 break;
1057 case 8:
1058 ZERO_STRUCT(info8);
1059 info_ctr.info.info8 = &info8;
1060 break;
1061 case 9:
1062 ZERO_STRUCT(info9);
1063 info_ctr.info.info9 = &info9;
1064 break;
1065 }
1066
1067 torture_comment(tctx, "Testing SetPrinter level %d, command %d\n",
1068 info_ctr.level, r.in.command);
1069
1070 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter(p, tctx, &r),
1071 "failed to call SetPrinter");
1072
1073 switch (r.in.command) {
1074 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: /* 0 */
1075 /* is ignored for all levels other then 0 */
1076 if (info_ctr.level > 0) {
1077 /* ignored then */
1078 break;
1079 }
1080 case SPOOLSS_PRINTER_CONTROL_PAUSE: /* 1 */
1081 case SPOOLSS_PRINTER_CONTROL_RESUME: /* 2 */
1082 case SPOOLSS_PRINTER_CONTROL_PURGE: /* 3 */
1083 if (info_ctr.level > 0) {
1084 /* is invalid for all levels other then 0 */
1085 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PRINTER_COMMAND,
1086 "unexpected error code returned");
1087 continue;
1088 } else {
1089 torture_assert_werr_ok(tctx, r.out.result,
1090 "failed to call SetPrinter with non 0 command");
1091 continue;
1092 }
1093 break;
1094
1095 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: /* 4 */
1096 /* FIXME: gd needs further investigation */
1097 default:
1098 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PRINTER_COMMAND,
1099 "unexpected error code returned");
1100 continue;
1101 }
1102
1103 switch (info_ctr.level) {
1104 case 1:
1105 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
1106 "unexpected error code returned");
1107 break;
1108 case 2:
1109 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_PRINTER_DRIVER,
1110 "unexpected error code returned");
1111 break;
1112 case 3:
1113 case 4:
1114 case 5:
1115 case 7:
1116 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
1117 "unexpected error code returned");
1118 break;
1119 case 9:
1120 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1121 "unexpected error code returned");
1122 break;
1123 default:
1124 torture_assert_werr_ok(tctx, r.out.result,
1125 "failed to call SetPrinter");
1126 break;
1127 }
1128 }
1129
1130 if (r.in.command < 5) {
1131 r.in.command++;
1132 goto again;
1133 }
1134
1135 return true;
1136 }
1137
1138 static void clear_info2(struct spoolss_SetPrinterInfoCtr *r)
1139 {
1140 if ((r->level == 2) && (r->info.info2)) {
1141 r->info.info2->secdesc_ptr = 0;
1142 r->info.info2->devmode_ptr = 0;
1143 }
1144 }
1145
1146 static bool test_PrinterInfo(struct torture_context *tctx,
1147 struct dcerpc_pipe *p,
1148 struct policy_handle *handle)
1149 {
1150 NTSTATUS status;
1151 struct spoolss_SetPrinter s;
1152 struct spoolss_GetPrinter q;
1153 struct spoolss_GetPrinter q0;
1154 struct spoolss_SetPrinterInfoCtr info_ctr;
1155 union spoolss_PrinterInfo info;
1156 struct spoolss_DevmodeContainer devmode_ctr;
1157 struct sec_desc_buf secdesc_ctr;
1158 uint32_t needed;
1159 bool ret = true;
1160 int i;
1161
1162 uint32_t status_list[] = {
1163 /* these do not stick
1164 PRINTER_STATUS_PAUSED,
1165 PRINTER_STATUS_ERROR,
1166 PRINTER_STATUS_PENDING_DELETION, */
1167 PRINTER_STATUS_PAPER_JAM,
1168 PRINTER_STATUS_PAPER_OUT,
1169 PRINTER_STATUS_MANUAL_FEED,
1170 PRINTER_STATUS_PAPER_PROBLEM,
1171 PRINTER_STATUS_OFFLINE,
1172 PRINTER_STATUS_IO_ACTIVE,
1173 PRINTER_STATUS_BUSY,
1174 PRINTER_STATUS_PRINTING,
1175 PRINTER_STATUS_OUTPUT_BIN_FULL,
1176 PRINTER_STATUS_NOT_AVAILABLE,
1177 PRINTER_STATUS_WAITING,
1178 PRINTER_STATUS_PROCESSING,
1179 PRINTER_STATUS_INITIALIZING,
1180 PRINTER_STATUS_WARMING_UP,
1181 PRINTER_STATUS_TONER_LOW,
1182 PRINTER_STATUS_NO_TONER,
1183 PRINTER_STATUS_PAGE_PUNT,
1184 PRINTER_STATUS_USER_INTERVENTION,
1185 PRINTER_STATUS_OUT_OF_MEMORY,
1186 PRINTER_STATUS_DOOR_OPEN,
1187 PRINTER_STATUS_SERVER_UNKNOWN,
1188 PRINTER_STATUS_POWER_SAVE,
1189 /* these do not stick
1190 0x02000000,
1191 0x04000000,
1192 0x08000000,
1193 0x10000000,
1194 0x20000000,
1195 0x40000000,
1196 0x80000000 */
1197 };
1198 uint32_t default_attribute = PRINTER_ATTRIBUTE_LOCAL;
1199 uint32_t attribute_list[] = {
1200 PRINTER_ATTRIBUTE_QUEUED,
1201 /* fails with WERR_INVALID_DATATYPE:
1202 PRINTER_ATTRIBUTE_DIRECT, */
1203 /* does not stick
1204 PRINTER_ATTRIBUTE_DEFAULT, */
1205 PRINTER_ATTRIBUTE_SHARED,
1206 /* does not stick
1207 PRINTER_ATTRIBUTE_NETWORK, */
1208 PRINTER_ATTRIBUTE_HIDDEN,
1209 PRINTER_ATTRIBUTE_LOCAL,
1210 PRINTER_ATTRIBUTE_ENABLE_DEVQ,
1211 PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS,
1212 PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST,
1213 PRINTER_ATTRIBUTE_WORK_OFFLINE,
1214 /* does not stick
1215 PRINTER_ATTRIBUTE_ENABLE_BIDI, */
1216 /* fails with WERR_INVALID_DATATYPE:
1217 PRINTER_ATTRIBUTE_RAW_ONLY, */
1218 /* these do not stick
1219 PRINTER_ATTRIBUTE_PUBLISHED,
1220 PRINTER_ATTRIBUTE_FAX,
1221 PRINTER_ATTRIBUTE_TS,
1222 0x00010000,
1223 0x00020000,
1224 0x00040000,
1225 0x00080000,
1226 0x00100000,
1227 0x00200000,
1228 0x00400000,
1229 0x00800000,
1230 0x01000000,
1231 0x02000000,
1232 0x04000000,
1233 0x08000000,
1234 0x10000000,
1235 0x20000000,
1236 0x40000000,
1237 0x80000000 */
1238 };
1239
1240 ZERO_STRUCT(devmode_ctr);
1241 ZERO_STRUCT(secdesc_ctr);
1242
1243 s.in.handle = handle;
1244 s.in.command = 0;
1245 s.in.info_ctr = &info_ctr;
1246 s.in.devmode_ctr = &devmode_ctr;
1247 s.in.secdesc_ctr = &secdesc_ctr;
1248
1249 q.in.handle = handle;
1250 q.out.info = &info;
1251 q0 = q;
1252
1253 #define TESTGETCALL(call, r) \
1254 r.in.buffer = NULL; \
1255 r.in.offered = 0;\
1256 r.out.needed = &needed; \
1257 status = dcerpc_spoolss_ ##call(p, tctx, &r); \
1258 if (!NT_STATUS_IS_OK(status)) { \
1259 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1260 r.in.level, nt_errstr(status), __location__); \
1261 ret = false; \
1262 break; \
1263 }\
1264 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {\
1265 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed); \
1266 data_blob_clear(&blob); \
1267 r.in.buffer = &blob; \
1268 r.in.offered = needed; \
1269 }\
1270 status = dcerpc_spoolss_ ##call(p, tctx, &r); \
1271 if (!NT_STATUS_IS_OK(status)) { \
1272 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1273 r.in.level, nt_errstr(status), __location__); \
1274 ret = false; \
1275 break; \
1276 } \
1277 if (!W_ERROR_IS_OK(r.out.result)) { \
1278 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1279 r.in.level, win_errstr(r.out.result), __location__); \
1280 ret = false; \
1281 break; \
1282 }
1283
1284
1285 #define TESTSETCALL_EXP(call, r, err) \
1286 clear_info2(&info_ctr);\
1287 status = dcerpc_spoolss_ ##call(p, tctx, &r); \
1288 if (!NT_STATUS_IS_OK(status)) { \
1289 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1290 r.in.info_ctr->level, nt_errstr(status), __location__); \
1291 ret = false; \
1292 break; \
1293 } \
1294 if (!W_ERROR_IS_OK(err)) { \
1295 if (!W_ERROR_EQUAL(err, r.out.result)) { \
1296 torture_comment(tctx, #call " level %u failed - %s, expected %s (%s)\n", \
1297 r.in.info_ctr->level, win_errstr(r.out.result), win_errstr(err), __location__); \
1298 ret = false; \
1299 } \
1300 break; \
1301 } \
1302 if (!W_ERROR_IS_OK(r.out.result)) { \
1303 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1304 r.in.info_ctr->level, win_errstr(r.out.result), __location__); \
1305 ret = false; \
1306 break; \
1307 }
1308
1309 #define TESTSETCALL(call, r) \
1310 TESTSETCALL_EXP(call, r, WERR_OK)
1311
1312 #define STRING_EQUAL(s1, s2, field) \
1313 if ((s1 && !s2) || (s2 && !s1) || strcmp(s1, s2)) { \
1314 torture_comment(tctx, "Failed to set %s to '%s' (%s)\n", \
1315 #field, s2, __location__); \
1316 ret = false; \
1317 break; \
1318 }
1319
1320 #define MEM_EQUAL(s1, s2, length, field) \
1321 if ((s1 && !s2) || (s2 && !s1) || memcmp(s1, s2, length)) { \
1322 torture_comment(tctx, "Failed to set %s to '%s' (%s)\n", \
1323 #field, (const char *)s2, __location__); \
1324 ret = false; \
1325 break; \
1326 }
1327
1328 #define INT_EQUAL(i1, i2, field) \
1329 if (i1 != i2) { \
1330 torture_comment(tctx, "Failed to set %s to 0x%llx - got 0x%llx (%s)\n", \
1331 #field, (unsigned long long)i2, (unsigned long long)i1, __location__); \
1332 ret = false; \
1333 break; \
1334 }
1335
1336 #define SD_EQUAL(sd1, sd2, field) \
1337 if (!security_descriptor_equal(sd1, sd2)) { \
1338 torture_comment(tctx, "Failed to set %s (%s)\n", \
1339 #field, __location__); \
1340 ret = false; \
1341 break; \
1342 }
1343
1344 #define TEST_PRINTERINFO_STRING_EXP_ERR(lvl1, field1, lvl2, field2, value, err) do { \
1345 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
1346 q.in.level = lvl1; \
1347 TESTGETCALL(GetPrinter, q) \
1348 info_ctr.level = lvl1; \
1349 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)&q.out.info->info ## lvl1; \
1350 info_ctr.info.info ## lvl1->field1 = value;\
1351 TESTSETCALL_EXP(SetPrinter, s, err) \
1352 info_ctr.info.info ## lvl1->field1 = ""; \
1353 TESTGETCALL(GetPrinter, q) \
1354 info_ctr.info.info ## lvl1->field1 = value; \
1355 STRING_EQUAL(info_ctr.info.info ## lvl1->field1, value, field1); \
1356 q.in.level = lvl2; \
1357 TESTGETCALL(GetPrinter, q) \
1358 info_ctr.info.info ## lvl2 = (struct spoolss_SetPrinterInfo ## lvl2 *)&q.out.info->info ## lvl2; \
1359 STRING_EQUAL(info_ctr.info.info ## lvl2->field2, value, field2); \
1360 } while (0)
1361
1362 #define TEST_PRINTERINFO_STRING(lvl1, field1, lvl2, field2, value) do { \
1363 TEST_PRINTERINFO_STRING_EXP_ERR(lvl1, field1, lvl2, field2, value, WERR_OK); \
1364 } while (0);
1365
1366 #define TEST_PRINTERINFO_INT_EXP(lvl1, field1, lvl2, field2, value, exp_value) do { \
1367 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
1368 q.in.level = lvl1; \
1369 TESTGETCALL(GetPrinter, q) \
1370 info_ctr.level = lvl1; \
1371 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)&q.out.info->info ## lvl1; \
1372 info_ctr.info.info ## lvl1->field1 = value; \
1373 TESTSETCALL(SetPrinter, s) \
1374 info_ctr.info.info ## lvl1->field1 = 0; \
1375 TESTGETCALL(GetPrinter, q) \
1376 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)&q.out.info->info ## lvl1; \
1377 INT_EQUAL(info_ctr.info.info ## lvl1->field1, exp_value, field1); \
1378 q.in.level = lvl2; \
1379 TESTGETCALL(GetPrinter, q) \
1380 info_ctr.info.info ## lvl2 = (struct spoolss_SetPrinterInfo ## lvl2 *)&q.out.info->info ## lvl2; \
1381 INT_EQUAL(info_ctr.info.info ## lvl2->field2, exp_value, field1); \
1382 } while (0)
1383
1384 #define TEST_PRINTERINFO_INT(lvl1, field1, lvl2, field2, value) do { \
1385 TEST_PRINTERINFO_INT_EXP(lvl1, field1, lvl2, field2, value, value); \
1386 } while (0)
1387
1388 q0.in.level = 0;
1389 do { TESTGETCALL(GetPrinter, q0) } while (0);
1390
1391 TEST_PRINTERINFO_STRING(2, comment, 1, comment, "xx2-1 comment");
1392 TEST_PRINTERINFO_STRING(2, comment, 2, comment, "xx2-2 comment");
1393
1394 /* level 0 printername does not stick */
1395 /* TEST_PRINTERINFO_STRING(2, printername, 0, printername, "xx2-0 printer"); */
1396 TEST_PRINTERINFO_STRING(2, printername, 1, name, "xx2-1 printer");
1397 TEST_PRINTERINFO_STRING(2, printername, 2, printername, "xx2-2 printer");
1398 TEST_PRINTERINFO_STRING(2, printername, 4, printername, "xx2-4 printer");
1399 TEST_PRINTERINFO_STRING(2, printername, 5, printername, "xx2-5 printer");
1400 /* TEST_PRINTERINFO_STRING(4, printername, 0, printername, "xx4-0 printer"); */
1401 TEST_PRINTERINFO_STRING(4, printername, 1, name, "xx4-1 printer");
1402 TEST_PRINTERINFO_STRING(4, printername, 2, printername, "xx4-2 printer");
1403 TEST_PRINTERINFO_STRING(4, printername, 4, printername, "xx4-4 printer");
1404 TEST_PRINTERINFO_STRING(4, printername, 5, printername, "xx4-5 printer");
1405 /* TEST_PRINTERINFO_STRING(5, printername, 0, printername, "xx5-0 printer"); */
1406 TEST_PRINTERINFO_STRING(5, printername, 1, name, "xx5-1 printer");
1407 TEST_PRINTERINFO_STRING(5, printername, 2, printername, "xx5-2 printer");
1408 TEST_PRINTERINFO_STRING(5, printername, 4, printername, "xx5-4 printer");
1409 TEST_PRINTERINFO_STRING(5, printername, 5, printername, "xx5-5 printer");
1410
1411 /* servername can be set but does not stick
1412 TEST_PRINTERINFO_STRING(2, servername, 0, servername, "xx2-0 servername");
1413 TEST_PRINTERINFO_STRING(2, servername, 2, servername, "xx2-2 servername");
1414 TEST_PRINTERINFO_STRING(2, servername, 4, servername, "xx2-4 servername");
1415 */
1416
1417 /* passing an invalid port will result in WERR_UNKNOWN_PORT */
1418 TEST_PRINTERINFO_STRING_EXP_ERR(2, portname, 2, portname, "xx2-2 portname", WERR_UNKNOWN_PORT);
1419 TEST_PRINTERINFO_STRING_EXP_ERR(2, portname, 5, portname, "xx2-5 portname", WERR_UNKNOWN_PORT);
1420 TEST_PRINTERINFO_STRING_EXP_ERR(5, portname, 2, portname, "xx5-2 portname", WERR_UNKNOWN_PORT);
1421 TEST_PRINTERINFO_STRING_EXP_ERR(5, portname, 5, portname, "xx5-5 portname", WERR_UNKNOWN_PORT);
1422
1423 TEST_PRINTERINFO_STRING(2, sharename, 2, sharename, "xx2-2 sharename");
1424 /* passing an invalid driver will result in WERR_UNKNOWN_PRINTER_DRIVER */
1425 TEST_PRINTERINFO_STRING_EXP_ERR(2, drivername, 2, drivername, "xx2-2 drivername", WERR_UNKNOWN_PRINTER_DRIVER);
1426 TEST_PRINTERINFO_STRING(2, location, 2, location, "xx2-2 location");
1427 /* passing an invalid sepfile will result in WERR_INVALID_SEPARATOR_FILE */
1428 TEST_PRINTERINFO_STRING_EXP_ERR(2, sepfile, 2, sepfile, "xx2-2 sepfile", WERR_INVALID_SEPARATOR_FILE);
1429 /* passing an invalid printprocessor will result in WERR_UNKNOWN_PRINTPROCESSOR */
1430 TEST_PRINTERINFO_STRING_EXP_ERR(2, printprocessor, 2, printprocessor, "xx2-2 printprocessor", WERR_UNKNOWN_PRINTPROCESSOR);
1431 TEST_PRINTERINFO_STRING(2, datatype, 2, datatype, "xx2-2 datatype");
1432 TEST_PRINTERINFO_STRING(2, parameters, 2, parameters, "xx2-2 parameters");
1433
1434 for (i=0; i < ARRAY_SIZE(attribute_list); i++) {
1435 /* TEST_PRINTERINFO_INT_EXP(2, attributes, 1, flags,
1436 attribute_list[i],
1437 (attribute_list[i] | default_attribute)
1438 ); */
1439 TEST_PRINTERINFO_INT_EXP(2, attributes, 2, attributes,
1440 attribute_list[i],
1441 (attribute_list[i] | default_attribute)
1442 );
1443 TEST_PRINTERINFO_INT_EXP(2, attributes, 4, attributes,
1444 attribute_list[i],
1445 (attribute_list[i] | default_attribute)
1446 );
1447 TEST_PRINTERINFO_INT_EXP(2, attributes, 5, attributes,
1448 attribute_list[i],
1449 (attribute_list[i] | default_attribute)
1450 );
1451 /* TEST_PRINTERINFO_INT_EXP(4, attributes, 1, flags,
1452 attribute_list[i],
1453 (attribute_list[i] | default_attribute)
1454 ); */
1455 TEST_PRINTERINFO_INT_EXP(4, attributes, 2, attributes,
1456 attribute_list[i],
1457 (attribute_list[i] | default_attribute)
1458 );
1459 TEST_PRINTERINFO_INT_EXP(4, attributes, 4, attributes,
1460 attribute_list[i],
1461 (attribute_list[i] | default_attribute)
1462 );
1463 TEST_PRINTERINFO_INT_EXP(4, attributes, 5, attributes,
1464 attribute_list[i],
1465 (attribute_list[i] | default_attribute)
1466 );
1467 /* TEST_PRINTERINFO_INT_EXP(5, attributes, 1, flags,
1468 attribute_list[i],
1469 (attribute_list[i] | default_attribute)
1470 ); */
1471 TEST_PRINTERINFO_INT_EXP(5, attributes, 2, attributes,
1472 attribute_list[i],
1473 (attribute_list[i] | default_attribute)
1474 );
1475 TEST_PRINTERINFO_INT_EXP(5, attributes, 4, attributes,
1476 attribute_list[i],
1477 (attribute_list[i] | default_attribute)
1478 );
1479 TEST_PRINTERINFO_INT_EXP(5, attributes, 5, attributes,
1480 attribute_list[i],
1481 (attribute_list[i] | default_attribute)
1482 );
1483 }
1484
1485 for (i=0; i < ARRAY_SIZE(status_list); i++) {
1486 /* level 2 sets do not stick
1487 TEST_PRINTERINFO_INT(2, status, 0, status, status_list[i]);
1488 TEST_PRINTERINFO_INT(2, status, 2, status, status_list[i]);
1489 TEST_PRINTERINFO_INT(2, status, 6, status, status_list[i]); */
1490 TEST_PRINTERINFO_INT(6, status, 0, status, status_list[i]);
1491 TEST_PRINTERINFO_INT(6, status, 2, status, status_list[i]);
1492 TEST_PRINTERINFO_INT(6, status, 6, status, status_list[i]);
1493 }
1494
1495 /* priorities need to be between 0 and 99
1496 passing an invalid priority will result in WERR_INVALID_PRIORITY */
1497 TEST_PRINTERINFO_INT(2, priority, 2, priority, 0);
1498 TEST_PRINTERINFO_INT(2, priority, 2, priority, 1);
1499 TEST_PRINTERINFO_INT(2, priority, 2, priority, 99);
1500 /* TEST_PRINTERINFO_INT(2, priority, 2, priority, 100); */
1501 TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 0);
1502 TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 1);
1503 TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 99);
1504 /* TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 100); */
1505
1506 TEST_PRINTERINFO_INT(2, starttime, 2, starttime, __LINE__);
1507 TEST_PRINTERINFO_INT(2, untiltime, 2, untiltime, __LINE__);
1508
1509 /* does not stick
1510 TEST_PRINTERINFO_INT(2, cjobs, 2, cjobs, __LINE__);
1511 TEST_PRINTERINFO_INT(2, averageppm, 2, averageppm, __LINE__); */
1512
1513 /* does not stick
1514 TEST_PRINTERINFO_INT(5, device_not_selected_timeout, 5, device_not_selected_timeout, __LINE__);
1515 TEST_PRINTERINFO_INT(5, transmission_retry_timeout, 5, transmission_retry_timeout, __LINE__); */
1516
1517 /* FIXME: gd also test devmode and secdesc behavior */
1518
1519 {
1520 /* verify composition of level 1 description field */
1521 const char *description;
1522 const char *tmp;
1523
1524 q0.in.level = 1;
1525 do { TESTGETCALL(GetPrinter, q0) } while (0);
1526
1527 description = talloc_strdup(tctx, q0.out.info->info1.description);
1528
1529 q0.in.level = 2;
1530 do { TESTGETCALL(GetPrinter, q0) } while (0);
1531
1532 tmp = talloc_asprintf(tctx, "%s,%s,%s",
1533 q0.out.info->info2.printername,
1534 q0.out.info->info2.drivername,
1535 q0.out.info->info2.location);
1536
1537 do { STRING_EQUAL(description, tmp, "description")} while (0);
1538 }
1539
1540 return ret;
1541 }
1542
1543 #define torture_assert_sid_equal(torture_ctx,got,expected,cmt)\
1544 do { struct dom_sid *__got = (got), *__expected = (expected); \
1545 if (!dom_sid_equal(__got, __expected)) { \
1546 torture_result(torture_ctx, TORTURE_FAIL, \
1547 __location__": "#got" was %s, expected %s: %s", \
1548 dom_sid_string(torture_ctx, __got), dom_sid_string(torture_ctx, __expected), cmt); \
1549 return false; \
1550 } \
1551 } while(0)
1552
1553 static bool test_security_descriptor_equal(struct torture_context *tctx,
1554 const struct security_descriptor *sd1,
1555 const struct security_descriptor *sd2)
1556 {
1557 if (sd1 == sd2) {
1558 return true;
1559 }
1560
1561 if (!sd1 || !sd2) {
1562 torture_comment(tctx, "%s\n", __location__);
1563 return false;
1564 }
1565
1566 torture_assert_int_equal(tctx, sd1->revision, sd2->revision, "revision mismatch");
1567 torture_assert_int_equal(tctx, sd1->type, sd2->type, "type mismatch");
1568
1569 torture_assert_sid_equal(tctx, sd1->owner_sid, sd2->owner_sid, "owner mismatch");
1570 torture_assert_sid_equal(tctx, sd1->group_sid, sd2->group_sid, "group mismatch");
1571
1572 if (!security_acl_equal(sd1->sacl, sd2->sacl)) {
1573 torture_comment(tctx, "%s: sacl mismatch\n", __location__);
1574 NDR_PRINT_DEBUG(security_acl, sd1->sacl);
1575 NDR_PRINT_DEBUG(security_acl, sd2->sacl);
1576 return false;
1577 }
1578 if (!security_acl_equal(sd1->dacl, sd2->dacl)) {
1579 torture_comment(tctx, "%s: dacl mismatch\n", __location__);
1580 NDR_PRINT_DEBUG(security_acl, sd1->dacl);
1581 NDR_PRINT_DEBUG(security_acl, sd2->dacl);
1582 return false;
1583 }
1584
1585 return true;
1586 }
1587
1588 static bool test_sd_set_level(struct torture_context *tctx,
1589 struct dcerpc_pipe *p,
1590 struct policy_handle *handle,
1591 uint32_t level,
1592 struct security_descriptor *sd)
1593 {
1594 struct spoolss_SetPrinterInfoCtr info_ctr;
1595 struct spoolss_DevmodeContainer devmode_ctr;
1596 struct sec_desc_buf secdesc_ctr;
1597
1598 ZERO_STRUCT(devmode_ctr);
1599 ZERO_STRUCT(secdesc_ctr);
1600
1601 switch (level) {
1602 case 2: {
1603 union spoolss_PrinterInfo info;
1604 struct spoolss_SetPrinterInfo2 info2;
1605 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 2, &info), "");
1606
1607 info2.servername = info.info2.servername;
1608 info2.printername = info.info2.printername;
1609 info2.sharename = info.info2.sharename;
1610 info2.portname = info.info2.portname;
1611 info2.drivername = info.info2.drivername;
1612 info2.comment = info.info2.comment;
1613 info2.location = info.info2.location;
1614 info2.devmode_ptr = 0;
1615 info2.sepfile = info.info2.sepfile;
1616 info2.printprocessor = info.info2.printprocessor;
1617 info2.datatype = info.info2.datatype;
1618 info2.parameters = info.info2.parameters;
1619 info2.secdesc_ptr = 0;
1620 info2.attributes = info.info2.attributes;
1621 info2.priority = info.info2.priority;
1622 info2.defaultpriority = info.info2.defaultpriority;
1623 info2.starttime = info.info2.starttime;
1624 info2.untiltime = info.info2.untiltime;
1625 info2.status = info.info2.status;
1626 info2.cjobs = info.info2.cjobs;
1627 info2.averageppm = info.info2.averageppm;
1628
1629 info_ctr.level = 2;
1630 info_ctr.info.info2 = &info2;
1631
1632 break;
1633 }
1634 case 3: {
1635 struct spoolss_SetPrinterInfo3 info3;
1636
1637 info3.sec_desc_ptr = 0;
1638
1639 info_ctr.level = 3;
1640 info_ctr.info.info3 = &info3;
1641
1642 break;
1643 }
1644 default:
1645 return false;
1646 }
1647
1648 secdesc_ctr.sd = sd;
1649
1650 torture_assert(tctx,
1651 test_SetPrinter(tctx, p, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0), "");
1652
1653 return true;
1654 }
1655
1656 static bool test_PrinterInfo_SDs(struct torture_context *tctx,
1657 struct dcerpc_pipe *p,
1658 struct policy_handle *handle)
1659 {
1660 union spoolss_PrinterInfo info;
1661 struct security_descriptor *sd1, *sd2;
1662 int i;
1663
1664 /* just compare level 2 and level 3 */
1665
1666 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 2, &info), "");
1667
1668 sd1 = info.info2.secdesc;
1669
1670 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 3, &info), "");
1671
1672 sd2 = info.info3.secdesc;
1673
1674 torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1675 "SD level 2 != SD level 3");
1676
1677
1678 /* query level 2, set level 2, query level 2 */
1679
1680 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 2, &info), "");
1681
1682 sd1 = info.info2.secdesc;
1683
1684 torture_assert(tctx, test_sd_set_level(tctx, p, handle, 2, sd1), "");
1685
1686 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 2, &info), "");
1687
1688 sd2 = info.info2.secdesc;
1689 if (sd1->type & SEC_DESC_DACL_DEFAULTED) {
1690 torture_comment(tctx, "removing SEC_DESC_DACL_DEFAULTED\n");
1691 sd1->type &= ~SEC_DESC_DACL_DEFAULTED;
1692 }
1693
1694 torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1695 "SD level 2 != SD level 2 after SD has been set via level 2");
1696
1697
1698 /* query level 2, set level 3, query level 2 */
1699
1700 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 2, &info), "");
1701
1702 sd1 = info.info2.secdesc;
1703
1704 torture_assert(tctx, test_sd_set_level(tctx, p, handle, 3, sd1), "");
1705
1706 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 2, &info), "");
1707
1708 sd2 = info.info2.secdesc;
1709
1710 torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1711 "SD level 2 != SD level 2 after SD has been set via level 3");
1712
1713 /* set modified sd level 3, query level 2 */
1714
1715 for (i=0; i < 93; i++) {
1716 struct security_ace a;
1717 const char *sid_string = talloc_asprintf(tctx, "S-1-5-32-9999%i", i);
1718 a.type = SEC_ACE_TYPE_ACCESS_ALLOWED;
1719 a.flags = 0;
1720 a.size = 0; /* autogenerated */
1721 a.access_mask = 0;
1722 a.trustee = *dom_sid_parse_talloc(tctx, sid_string);
1723 torture_assert_ntstatus_ok(tctx, security_descriptor_dacl_add(sd1, &a), "");
1724 }
1725
1726 torture_assert(tctx, test_sd_set_level(tctx, p, handle, 3, sd1), "");
1727
1728 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 2, &info), "");
1729 sd2 = info.info2.secdesc;
1730
1731 if (sd1->type & SEC_DESC_DACL_DEFAULTED) {
1732 torture_comment(tctx, "removing SEC_DESC_DACL_DEFAULTED\n");
1733 sd1->type &= ~SEC_DESC_DACL_DEFAULTED;
1734 }
1735
1736 torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1737 "modified SD level 2 != SD level 2 after SD has been set via level 3");
1738
1739
1740 return true;
1741 }
1742
1743 /*
1744 * wrapper call that saves original sd, runs tests, and restores sd
1745 */
1746
1747 static bool test_PrinterInfo_SD(struct torture_context *tctx,
1748 struct dcerpc_pipe *p,
1749 struct policy_handle *handle)
1750 {
1751 union spoolss_PrinterInfo info;
1752 struct security_descriptor *sd;
1753 bool ret = true;
1754
1755 torture_comment(tctx, "\nTesting Printer Security Descriptors\n");
1756
1757 /* save original sd */
1758
1759 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 2, &info),
1760 "failed to get initial security descriptor");
1761
1762 sd = security_descriptor_copy(tctx, info.info2.secdesc);
1763
1764 /* run tests */
1765
1766 ret = test_PrinterInfo_SDs(tctx, p, handle);
1767
1768 /* restore original sd */
1769
1770 torture_assert(tctx, test_sd_set_level(tctx, p, handle, 3, sd),
1771 "failed to restore initial security descriptor");
1772
1773 torture_comment(tctx, "Printer Security Descriptors test %s\n",
1774 ret ? "succeeded" : "failed");
1775
1776
1777 return ret;
1778 }
1779
1780 static bool test_devmode_set_level(struct torture_context *tctx,
1781 struct dcerpc_pipe *p,
1782 struct policy_handle *handle,
1783 uint32_t level,
1784 struct spoolss_DeviceMode *devmode)
1785 {
1786 struct spoolss_SetPrinterInfoCtr info_ctr;
1787 struct spoolss_DevmodeContainer devmode_ctr;
1788 struct sec_desc_buf secdesc_ctr;
1789
1790 ZERO_STRUCT(devmode_ctr);
1791 ZERO_STRUCT(secdesc_ctr);
1792
1793 switch (level) {
1794 case 2: {
1795 union spoolss_PrinterInfo info;
1796 struct spoolss_SetPrinterInfo2 info2;
1797 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 2, &info), "");
1798
1799 info2.servername = info.info2.servername;
1800 info2.printername = info.info2.printername;
1801 info2.sharename = info.info2.sharename;
1802 info2.portname = info.info2.portname;
1803 info2.drivername = info.info2.drivername;
1804 info2.comment = info.info2.comment;
1805 info2.location = info.info2.location;
1806 info2.devmode_ptr = 0;
1807 info2.sepfile = info.info2.sepfile;
1808 info2.printprocessor = info.info2.printprocessor;
1809 info2.datatype = info.info2.datatype;
1810 info2.parameters = info.info2.parameters;
1811 info2.secdesc_ptr = 0;
1812 info2.attributes = info.info2.attributes;
1813 info2.priority = info.info2.priority;
1814 info2.defaultpriority = info.info2.defaultpriority;
1815 info2.starttime = info.info2.starttime;
1816 info2.untiltime = info.info2.untiltime;
1817 info2.status = info.info2.status;
1818 info2.cjobs = info.info2.cjobs;
1819 info2.averageppm = info.info2.averageppm;
1820
1821 info_ctr.level = 2;
1822 info_ctr.info.info2 = &info2;
1823
1824 break;
1825 }
1826 case 8: {
1827 struct spoolss_SetPrinterInfo8 info8;
1828
1829 info8.devmode_ptr = 0;
1830
1831 info_ctr.level = 8;
1832 info_ctr.info.info8 = &info8;
1833
1834 break;
1835 }
1836 default:
1837 return false;
1838 }
1839
1840 devmode_ctr.devmode = devmode;
1841
1842 torture_assert(tctx,
1843 test_SetPrinter(tctx, p, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0), "");
1844
1845 return true;
1846 }
1847
1848
1849 static bool test_devicemode_equal(struct torture_context *tctx,
1850 const struct spoolss_DeviceMode *d1,
1851 const struct spoolss_DeviceMode *d2)
1852 {
1853 if (d1 == d2) {
1854 return true;
1855 }
1856
1857 if (!d1 || !d2) {
1858 torture_comment(tctx, "%s\n", __location__);
1859 return false;
1860 }
1861 torture_assert_str_equal(tctx, d1->devicename, d2->devicename, "devicename mismatch");
1862 torture_assert_int_equal(tctx, d1->specversion, d2->specversion, "specversion mismatch");
1863 torture_assert_int_equal(tctx, d1->driverversion, d2->driverversion, "driverversion mismatch");
1864 torture_assert_int_equal(tctx, d1->size, d2->size, "size mismatch");
1865 torture_assert_int_equal(tctx, d1->__driverextra_length, d2->__driverextra_length, "__driverextra_length mismatch");
1866 torture_assert_int_equal(tctx, d1->fields, d2->fields, "fields mismatch");
1867 torture_assert_int_equal(tctx, d1->orientation, d2->orientation, "orientation mismatch");
1868 torture_assert_int_equal(tctx, d1->papersize, d2->papersize, "papersize mismatch");
1869 torture_assert_int_equal(tctx, d1->paperlength, d2->paperlength, "paperlength mismatch");
1870 torture_assert_int_equal(tctx, d1->paperwidth, d2->paperwidth, "paperwidth mismatch");
1871 torture_assert_int_equal(tctx, d1->scale, d2->scale, "scale mismatch");
1872 torture_assert_int_equal(tctx, d1->copies, d2->copies, "copies mismatch");
1873 torture_assert_int_equal(tctx, d1->defaultsource, d2->defaultsource, "defaultsource mismatch");
1874 torture_assert_int_equal(tctx, d1->printquality, d2->printquality, "printquality mismatch");
1875 torture_assert_int_equal(tctx, d1->color, d2->color, "color mismatch");
1876 torture_assert_int_equal(tctx, d1->duplex, d2->duplex, "duplex mismatch");
1877 torture_assert_int_equal(tctx, d1->yresolution, d2->yresolution, "yresolution mismatch");
1878 torture_assert_int_equal(tctx, d1->ttoption, d2->ttoption, "ttoption mismatch");
1879 torture_assert_int_equal(tctx, d1->collate, d2->collate, "collate mismatch");
1880 torture_assert_str_equal(tctx, d1->formname, d2->formname, "formname mismatch");
1881 torture_assert_int_equal(tctx, d1->logpixels, d2->logpixels, "logpixels mismatch");
1882 torture_assert_int_equal(tctx, d1->bitsperpel, d2->bitsperpel, "bitsperpel mismatch");
1883 torture_assert_int_equal(tctx, d1->pelswidth, d2->pelswidth, "pelswidth mismatch");
1884 torture_assert_int_equal(tctx, d1->pelsheight, d2->pelsheight, "pelsheight mismatch");
1885 torture_assert_int_equal(tctx, d1->displayflags, d2->displayflags, "displayflags mismatch");
1886 torture_assert_int_equal(tctx, d1->displayfrequency, d2->displayfrequency, "displayfrequency mismatch");
1887 torture_assert_int_equal(tctx, d1->icmmethod, d2->icmmethod, "icmmethod mismatch");
1888 torture_assert_int_equal(tctx, d1->icmintent, d2->icmintent, "icmintent mismatch");
1889 torture_assert_int_equal(tctx, d1->mediatype, d2->mediatype, "mediatype mismatch");
1890 torture_assert_int_equal(tctx, d1->dithertype, d2->dithertype, "dithertype mismatch");
1891 torture_assert_int_equal(tctx, d1->reserved1, d2->reserved1, "reserved1 mismatch");
1892 torture_assert_int_equal(tctx, d1->reserved2, d2->reserved2, "reserved2 mismatch");
1893 torture_assert_int_equal(tctx, d1->panningwidth, d2->panningwidth, "panningwidth mismatch");
1894 torture_assert_int_equal(tctx, d1->panningheight, d2->panningheight, "panningheight mismatch");
1895 torture_assert_data_blob_equal(tctx, d1->driverextra_data, d2->driverextra_data, "driverextra_data mismatch");
1896
1897 return true;
1898 }
1899
1900 static bool test_devicemode_full(struct torture_context *tctx,
1901 struct dcerpc_pipe *p,
1902 struct policy_handle *handle)
1903 {
1904 struct spoolss_SetPrinter s;
1905 struct spoolss_GetPrinter q;
1906 struct spoolss_GetPrinter q0;
1907 struct spoolss_SetPrinterInfoCtr info_ctr;
1908 struct spoolss_SetPrinterInfo8 info8;
1909 union spoolss_PrinterInfo info;
1910 struct spoolss_DevmodeContainer devmode_ctr;
1911 struct sec_desc_buf secdesc_ctr;
1912 uint32_t needed;
1913 bool ret = true;
1914 NTSTATUS status;
1915
1916 #define TEST_DEVMODE_INT_EXP(lvl1, field1, lvl2, field2, value, exp_value) do { \
1917 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
1918 q.in.level = lvl1; \
1919 TESTGETCALL(GetPrinter, q) \
1920 info_ctr.level = lvl1; \
1921 if (lvl1 == 2) {\
1922 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)&q.out.info->info ## lvl1; \
1923 } else if (lvl1 == 8) {\
1924 info_ctr.info.info ## lvl1 = &info8; \
1925 }\
1926 devmode_ctr.devmode = q.out.info->info ## lvl1.devmode; \
1927 devmode_ctr.devmode->field1 = value; \
1928 TESTSETCALL(SetPrinter, s) \
1929 TESTGETCALL(GetPrinter, q) \
1930 INT_EQUAL(q.out.info->info ## lvl1.devmode->field1, exp_value, field1); \
1931 q.in.level = lvl2; \
1932 TESTGETCALL(GetPrinter, q) \
1933 INT_EQUAL(q.out.info->info ## lvl2.devmode->field2, exp_value, field1); \
1934 } while (0)
1935
1936 #define TEST_DEVMODE_INT(lvl1, field1, lvl2, field2, value) do { \
1937 TEST_DEVMODE_INT_EXP(lvl1, field1, lvl2, field2, value, value); \
1938 } while (0)
1939
1940 ZERO_STRUCT(devmode_ctr);
1941 ZERO_STRUCT(secdesc_ctr);
1942 ZERO_STRUCT(info8);
1943
1944 s.in.handle = handle;
1945 s.in.command = 0;
1946 s.in.info_ctr = &info_ctr;
1947 s.in.devmode_ctr = &devmode_ctr;
1948 s.in.secdesc_ctr = &secdesc_ctr;
1949
1950 q.in.handle = handle;
1951 q.out.info = &info;
1952 q0 = q;
1953
1954 #if 0
1955 const char *devicename;/* [charset(UTF16)] */
1956 enum spoolss_DeviceModeSpecVersion specversion;
1957 uint16_t driverversion;
1958 uint16_t size;
1959 uint16_t __driverextra_length;/* [value(r->driverextra_data.length)] */
1960 uint32_t fields;
1961 #endif
1962
1963 TEST_DEVMODE_INT(8, orientation, 8, orientation, __LINE__);
1964 TEST_DEVMODE_INT(8, papersize, 8, papersize, __LINE__);
1965 TEST_DEVMODE_INT(8, paperlength, 8, paperlength, __LINE__);
1966 TEST_DEVMODE_INT(8, paperwidth, 8, paperwidth, __LINE__);
1967 TEST_DEVMODE_INT(8, scale, 8, scale, __LINE__);
1968 TEST_DEVMODE_INT(8, copies, 8, copies, __LINE__);
1969 TEST_DEVMODE_INT(8, defaultsource, 8, defaultsource, __LINE__);
1970 TEST_DEVMODE_INT(8, printquality, 8, printquality, __LINE__);
1971 TEST_DEVMODE_INT(8, color, 8, color, __LINE__);
1972 TEST_DEVMODE_INT(8, duplex, 8, duplex, __LINE__);
1973 TEST_DEVMODE_INT(8, yresolution, 8, yresolution, __LINE__);
1974 TEST_DEVMODE_INT(8, ttoption, 8, ttoption, __LINE__);
1975 TEST_DEVMODE_INT(8, collate, 8, collate, __LINE__);
1976 #if 0
1977 const char *formname;/* [charset(UTF16)] */
1978 #endif
1979 TEST_DEVMODE_INT(8, logpixels, 8, logpixels, __LINE__);
1980 TEST_DEVMODE_INT(8, bitsperpel, 8, bitsperpel, __LINE__);
1981 TEST_DEVMODE_INT(8, pelswidth, 8, pelswidth, __LINE__);
1982 TEST_DEVMODE_INT(8, pelsheight, 8, pelsheight, __LINE__);
1983 TEST_DEVMODE_INT(8, displayflags, 8, displayflags, __LINE__);
1984 TEST_DEVMODE_INT(8, displayfrequency, 8, displayfrequency, __LINE__);
1985 TEST_DEVMODE_INT(8, icmmethod, 8, icmmethod, __LINE__);
1986 TEST_DEVMODE_INT(8, icmintent, 8, icmintent, __LINE__);
1987 TEST_DEVMODE_INT(8, mediatype, 8, mediatype, __LINE__);
1988 TEST_DEVMODE_INT(8, dithertype, 8, dithertype, __LINE__);
1989 TEST_DEVMODE_INT(8, reserved1, 8, reserved1, __LINE__);
1990 TEST_DEVMODE_INT(8, reserved2, 8, reserved2, __LINE__);
1991 TEST_DEVMODE_INT(8, panningwidth, 8, panningwidth, __LINE__);
1992 TEST_DEVMODE_INT(8, panningheight, 8, panningheight, __LINE__);
1993
1994 return ret;
1995 }
1996
1997 static bool call_OpenPrinterEx(struct torture_context *tctx,
1998 struct dcerpc_pipe *p,
1999 const char *name,
2000 struct spoolss_DeviceMode *devmode,
2001 struct policy_handle *handle);
2002
2003 static bool test_ClosePrinter(struct torture_context *tctx,
2004 struct dcerpc_pipe *p,
2005 struct policy_handle *handle);
2006
2007 static bool test_PrinterInfo_DevModes(struct torture_context *tctx,
2008 struct dcerpc_pipe *p,
2009 struct policy_handle *handle,
2010 const char *name)
2011 {
2012 union spoolss_PrinterInfo info;
2013 struct spoolss_DeviceMode *devmode;
2014 struct spoolss_DeviceMode *devmode2;
2015 struct policy_handle handle_devmode;
2016
2017 /* simply compare level8 and level2 devmode */
2018
2019 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 8, &info), "");
2020
2021 devmode = info.info8.devmode;
2022
2023 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 2, &info), "");
2024
2025 devmode2 = info.info2.devmode;
2026
2027 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2028 "DM level 8 != DM level 2");
2029
2030
2031 /* set devicemode level 8 and see if it persists */
2032
2033 devmode->copies = 93;
2034 devmode->formname = talloc_strdup(tctx, "Legal");
2035
2036 torture_assert(tctx, test_devmode_set_level(tctx, p, handle, 8, devmode), "");
2037
2038 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 8, &info), "");
2039
2040 devmode2 = info.info8.devmode;
2041
2042 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2043 "modified DM level 8 != DM level 8 after DM has been set via level 8");
2044
2045 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 2, &info), "");
2046
2047 devmode2 = info.info2.devmode;
2048
2049 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2050 "modified DM level 8 != DM level 2");
2051
2052
2053 /* set devicemode level 2 and see if it persists */
2054
2055 devmode->copies = 39;
2056 devmode->formname = talloc_strdup(tctx, "Executive");
2057
2058 torture_assert(tctx, test_devmode_set_level(tctx, p, handle, 2, devmode), "");
2059
2060 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 8, &info), "");
2061
2062 devmode2 = info.info8.devmode;
2063
2064 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2065 "modified DM level 8 != DM level 8 after DM has been set via level 2");
2066
2067 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 2, &info), "");
2068
2069 devmode2 = info.info2.devmode;
2070
2071 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2072 "modified DM level 8 != DM level 2");
2073
2074
2075 /* check every single bit in public part of devicemode */
2076
2077 torture_assert(tctx, test_devicemode_full(tctx, p, handle),
2078 "failed to set every single devicemode component");
2079
2080
2081 /* change formname upon open and see if it persists in getprinter calls */
2082
2083 devmode->formname = talloc_strdup(tctx, "A4");
2084 devmode->copies = 42;
2085
2086 torture_assert(tctx, call_OpenPrinterEx(tctx, p, name, devmode, &handle_devmode),
2087 "failed to open printer handle");
2088
2089 torture_assert(tctx, test_GetPrinter_level(tctx, p, &handle_devmode, 8, &info), "");
2090
2091 devmode2 = info.info8.devmode;
2092
2093 if (strequal(devmode->devicename, devmode2->devicename)) {
2094 torture_comment(tctx, "devicenames are the same\n");
2095 } else {
2096 torture_comment(tctx, "devicename passed in for open: %s\n", devmode->devicename);
2097 torture_comment(tctx, "devicename after level 8 get: %s\n", devmode2->devicename);
2098 }
2099
2100 if (strequal(devmode->formname, devmode2->formname)) {
2101 torture_warning(tctx, "formname are the same\n");
2102 } else {
2103 torture_comment(tctx, "formname passed in for open: %s\n", devmode->formname);
2104 torture_comment(tctx, "formname after level 8 get: %s\n", devmode2->formname);
2105 }
2106
2107 if (devmode->copies == devmode2->copies) {
2108 torture_warning(tctx, "copies are the same\n");
2109 } else {
2110 torture_comment(tctx, "copies passed in for open: %d\n", devmode->copies);
2111 torture_comment(tctx, "copies after level 8 get: %d\n", devmode2->copies);
2112 }
2113
2114 torture_assert(tctx, test_GetPrinter_level(tctx, p, &handle_devmode, 2, &info), "");
2115
2116 devmode2 = info.info2.devmode;
2117
2118 if (strequal(devmode->devicename, devmode2->devicename)) {
2119 torture_comment(tctx, "devicenames are the same\n");
2120 } else {
2121 torture_comment(tctx, "devicename passed in for open: %s\n", devmode->devicename);
2122 torture_comment(tctx, "devicename after level 2 get: %s\n", devmode2->devicename);
2123 }
2124
2125 if (strequal(devmode->formname, devmode2->formname)) {
2126 torture_warning(tctx, "formname is the same\n");
2127 } else {
2128 torture_comment(tctx, "formname passed in for open: %s\n", devmode->formname);
2129 torture_comment(tctx, "formname after level 2 get: %s\n", devmode2->formname);
2130 }
2131
2132 if (devmode->copies == devmode2->copies) {
2133 torture_warning(tctx, "copies are the same\n");
2134 } else {
2135 torture_comment(tctx, "copies passed in for open: %d\n", devmode->copies);
2136 torture_comment(tctx, "copies after level 2 get: %d\n", devmode2->copies);
2137 }
2138
2139 test_ClosePrinter(tctx, p, &handle_devmode);
2140
2141 return true;
2142 }
2143
2144 /*
2145 * wrapper call that saves original devmode, runs tests, and restores devmode
2146 */
2147
2148 static bool test_PrinterInfo_DevMode(struct torture_context *tctx,
2149 struct dcerpc_pipe *p,
2150 struct policy_handle *handle,
2151 const char *name)
2152 {
2153 union spoolss_PrinterInfo info;
2154 struct spoolss_DeviceMode *devmode;
2155 bool ret = true;
2156
2157 torture_comment(tctx, "\nTesting Printer Devicemodes\n");
2158
2159 /* save original devmode */
2160
2161 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 8, &info),
2162 "failed to get initial global devicemode");
2163
2164 devmode = info.info8.devmode;
2165
2166 /* run tests */
2167
2168 ret = test_PrinterInfo_DevModes(tctx, p, handle, name);
2169
2170 /* restore original devmode */
2171
2172 torture_assert(tctx, test_devmode_set_level(tctx, p, handle, 8, devmode),
2173 "failed to restore initial global device mode");
2174
2175 torture_comment(tctx, "Printer Devicemodes test %s\n",
2176 ret ? "succeeded" : "failed");
2177
2178
2179 return ret;
2180 }
2181
2182 static bool test_ClosePrinter(struct torture_context *tctx,
2183 struct dcerpc_pipe *p,
2184 struct policy_handle *handle)
2185 {
2186 NTSTATUS status;
2187 struct spoolss_ClosePrinter r;
2188
2189 r.in.handle = handle;
2190 r.out.handle = handle;
2191
2192 torture_comment(tctx, "Testing ClosePrinter\n");
2193
2194 status = dcerpc_spoolss_ClosePrinter(p, tctx, &r);
2195 torture_assert_ntstatus_ok(tctx, status, "ClosePrinter failed");
2196 torture_assert_werr_ok(tctx, r.out.result, "ClosePrinter failed");
2197
2198 return true;
2199 }
2200
2201 static bool test_GetForm(struct torture_context *tctx,
2202 struct dcerpc_pipe *p,
2203 struct policy_handle *handle,
2204 const char *form_name,
2205 uint32_t level)
2206 {
2207 NTSTATUS status;
2208 struct spoolss_GetForm r;
2209 uint32_t needed;
2210
2211 r.in.handle = handle;
2212 r.in.form_name = form_name;
2213 r.in.level = level;
2214 r.in.buffer = NULL;
2215 r.in.offered = 0;
2216 r.out.needed = &needed;
2217
2218 torture_comment(tctx, "Testing GetForm level %d\n", r.in.level);
2219
2220 status = dcerpc_spoolss_GetForm(p, tctx, &r);
2221 torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
2222
2223 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2224 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
2225 data_blob_clear(&blob);
2226 r.in.buffer = &blob;
2227 r.in.offered = needed;
2228 status = dcerpc_spoolss_GetForm(p, tctx, &r);
2229 torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
2230
2231 torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
2232
2233 torture_assert(tctx, r.out.info, "No form info returned");
2234 }
2235
2236 torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
2237
2238 CHECK_NEEDED_SIZE_LEVEL(spoolss_FormInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
2239
2240 return true;
2241 }
2242
2243 static bool test_EnumForms(struct torture_context *tctx,
2244 struct dcerpc_pipe *p,
2245 struct policy_handle *handle, bool print_server)
2246 {
2247 NTSTATUS status;
2248 struct spoolss_EnumForms r;
2249 bool ret = true;
2250 uint32_t needed;
2251 uint32_t count;
2252 uint32_t levels[] = { 1, 2 };
2253 int i;
2254
2255 for (i=0; i<ARRAY_SIZE(levels); i++) {
2256
2257 union spoolss_FormInfo *info;
2258
2259 r.in.handle = handle;
2260 r.in.level = levels[i];
2261 r.in.buffer = NULL;
2262 r.in.offered = 0;
2263 r.out.needed = &needed;
2264 r.out.count = &count;
2265 r.out.info = &info;
2266
2267 torture_comment(tctx, "Testing EnumForms level %d\n", levels[i]);
2268
2269 status = dcerpc_spoolss_EnumForms(p, tctx, &r);
2270 torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
2271
2272 if ((r.in.level == 2) && (W_ERROR_EQUAL(r.out.result, WERR_UNKNOWN_LEVEL))) {
2273 break;
2274 }
2275
2276 if (print_server && W_ERROR_EQUAL(r.out.result, WERR_BADFID))
2277 torture_fail(tctx, "EnumForms on the PrintServer isn't supported by test server (NT4)");
2278
2279 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2280 int j;
2281 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
2282 data_blob_clear(&blob);
2283 r.in.buffer = &blob;
2284 r.in.offered = needed;
2285
2286 status = dcerpc_spoolss_EnumForms(p, tctx, &r);
2287
2288 torture_assert(tctx, info, "No forms returned");
2289
2290 for (j = 0; j < count; j++) {
2291 if (!print_server)
2292 ret &= test_GetForm(tctx, p, handle, info[j].info1.form_name, levels[i]);
2293 }
2294 }
2295
2296 torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
2297
2298 torture_assert_werr_ok(tctx, r.out.result, "EnumForms failed");
2299
2300 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumForms, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
2301 }
2302
2303 return true;
2304 }
2305
2306 static bool test_DeleteForm(struct torture_context *tctx,
2307 struct dcerpc_pipe *p,
2308 struct policy_handle *handle,
2309 const char *form_name)
2310 {
2311 NTSTATUS status;
2312 struct spoolss_DeleteForm r;
2313
2314 r.in.handle = handle;
2315 r.in.form_name = form_name;
2316
2317 status = dcerpc_spoolss_DeleteForm(p, tctx, &r);
2318
2319 torture_assert_ntstatus_ok(tctx, status, "DeleteForm failed");
2320
2321 torture_assert_werr_ok(tctx, r.out.result, "DeleteForm failed");
2322
2323 return true;
2324 }
2325
2326 static bool test_AddForm(struct torture_context *tctx,
2327 struct dcerpc_pipe *p,
2328 struct policy_handle *handle, bool print_server)
2329 {
2330 struct spoolss_AddForm r;
2331 struct spoolss_AddFormInfo1 addform;
2332 const char *form_name = "testform3";
2333 NTSTATUS status;
2334 bool ret = true;
2335
2336 r.in.handle = handle;
2337 r.in.level = 1;
2338 r.in.info.info1 = &addform;
2339 addform.flags = SPOOLSS_FORM_USER;
2340 addform.form_name = form_name;
2341 addform.size.width = 50;
2342 addform.size.height = 25;
2343 addform.area.left = 5;
2344 addform.area.top = 10;
2345 addform.area.right = 45;
2346 addform.area.bottom = 15;
2347
2348 status = dcerpc_spoolss_AddForm(p, tctx, &r);
2349
2350 torture_assert_ntstatus_ok(tctx, status, "AddForm failed");
2351
2352 torture_assert_werr_ok(tctx, r.out.result, "AddForm failed");
2353
2354 if (!print_server) ret &= test_GetForm(tctx, p, handle, form_name, 1);
2355
2356 {
2357 struct spoolss_SetForm sf;
2358 struct spoolss_AddFormInfo1 setform;
2359
2360 sf.in.handle = handle;
2361 sf.in.form_name = form_name;
2362 sf.in.level = 1;
2363 sf.in.info.info1= &setform;
2364 setform.flags = addform.flags;
2365 setform.form_name = addform.form_name;
2366 setform.size = addform.size;
2367 setform.area = addform.area;
2368
2369 setform.size.width = 1234;
2370
2371 status = dcerpc_spoolss_SetForm(p, tctx, &sf);
2372
2373 torture_assert_ntstatus_ok(tctx, status, "SetForm failed");
2374
2375 torture_assert_werr_ok(tctx, r.out.result, "SetForm failed");
2376 }
2377
2378 if (!print_server) ret &= test_GetForm(tctx, p, handle, form_name, 1);
2379
2380 {
2381 struct spoolss_EnumForms e;
2382 union spoolss_FormInfo *info;
2383 uint32_t needed;
2384 uint32_t count;
2385 bool found = false;
2386
2387 e.in.handle = handle;
2388 e.in.level = 1;
2389 e.in.buffer = NULL;
2390 e.in.offered = 0;
2391 e.out.needed = &needed;
2392 e.out.count = &count;
2393 e.out.info = &info;
2394
2395 torture_comment(tctx, "Testing EnumForms level 1\n");
2396
2397 status = dcerpc_spoolss_EnumForms(p, tctx, &e);
2398 torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
2399
2400 if (print_server && W_ERROR_EQUAL(e.out.result, WERR_BADFID))
2401 torture_fail(tctx, "EnumForms on the PrintServer isn't supported by test server (NT4)");
2402
2403 if (W_ERROR_EQUAL(e.out.result, WERR_INSUFFICIENT_BUFFER)) {
2404 int j;
2405 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
2406 data_blob_clear(&blob);
2407 e.in.buffer = &blob;
2408 e.in.offered = needed;
2409
2410 status = dcerpc_spoolss_EnumForms(p, tctx, &e);
2411
2412 torture_assert(tctx, info, "No forms returned");
2413
2414 for (j = 0; j < count; j++) {
2415 if (strequal(form_name, info[j].info1.form_name)) {
2416 found = true;
2417 break;
2418 }
2419 }
2420 }
2421 torture_assert(tctx, found, "Newly added form not found in enum call");
2422 }
2423
2424 if (!test_DeleteForm(tctx, p, handle, form_name)) {
2425 ret = false;
2426 }
2427
2428 return ret;
2429 }
2430
2431 static bool test_EnumPorts_old(struct torture_context *tctx,
2432 struct dcerpc_pipe *p)
2433 {
2434 NTSTATUS status;
2435 struct spoolss_EnumPorts r;
2436 uint32_t needed;
2437 uint32_t count;
2438 union spoolss_PortInfo *info;
2439
2440 r.in.servername = talloc_asprintf(tctx, "\\\\%s",
2441 dcerpc_server_name(p));
2442 r.in.level = 2;
2443 r.in.buffer = NULL;
2444 r.in.offered = 0;
2445 r.out.needed = &needed;
2446 r.out.count = &count;
2447 r.out.info = &info;
2448
2449 torture_comment(tctx, "Testing EnumPorts\n");
2450
2451 status = dcerpc_spoolss_EnumPorts(p, tctx, &r);
2452
2453 torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
2454
2455 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2456 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
2457 data_blob_clear(&blob);
2458 r.in.buffer = &blob;
2459 r.in.offered = needed;
2460
2461 status = dcerpc_spoolss_EnumPorts(p, tctx, &r);
2462 torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
2463 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
2464
2465 torture_assert(tctx, info, "No ports returned");
2466 }
2467
2468 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
2469
2470 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPorts, info, 2, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
2471
2472 return true;
2473 }
2474
2475 static bool test_AddPort(struct torture_context *tctx,
2476 struct dcerpc_pipe *p)
2477 {
2478 NTSTATUS status;
2479 struct spoolss_AddPort r;
2480
2481 r.in.server_name = talloc_asprintf(tctx, "\\\\%s",
2482 dcerpc_server_name(p));
2483 r.in.unknown = 0;
2484 r.in.monitor_name = "foo";
2485
2486 torture_comment(tctx, "Testing AddPort\n");
2487
2488 status = dcerpc_spoolss_AddPort(p, tctx, &r);
2489
2490 torture_assert_ntstatus_ok(tctx, status, "AddPort failed");
2491
2492 /* win2k3 returns WERR_NOT_SUPPORTED */
2493
2494 #if 0
2495
2496 if (!W_ERROR_IS_OK(r.out.result)) {
2497 printf("AddPort failed - %s\n", win_errstr(r.out.result));
2498 return false;
2499 }
2500
2501 #endif
2502
2503 return true;
2504 }
2505
2506 static bool test_GetJob(struct torture_context *tctx,
2507 struct dcerpc_pipe *p,
2508 struct policy_handle *handle, uint32_t job_id)
2509 {
2510 NTSTATUS status;
2511 struct spoolss_GetJob r;
2512 union spoolss_JobInfo info;
2513 uint32_t needed;
2514 uint32_t levels[] = {1, 2 /* 3, 4 */};
2515 uint32_t i;
2516
2517 r.in.handle = handle;
2518 r.in.job_id = job_id;
2519 r.in.level = 0;
2520 r.in.buffer = NULL;
2521 r.in.offered = 0;
2522 r.out.needed = &needed;
2523 r.out.info = &info;
2524
2525 torture_comment(tctx, "Testing GetJob level %d\n", r.in.level);
2526
2527 status = dcerpc_spoolss_GetJob(p, tctx, &r);
2528 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "Unexpected return code");
2529
2530 for (i = 0; i < ARRAY_SIZE(levels); i++) {
2531
2532 torture_comment(tctx, "Testing GetJob level %d\n", r.in.level);
2533
2534 needed = 0;
2535
2536 r.in.level = levels[i];
2537 r.in.offered = 0;
2538 r.in.buffer = NULL;
2539
2540 status = dcerpc_spoolss_GetJob(p, tctx, &r);
2541 torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
2542
2543 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2544 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
2545 data_blob_clear(&blob);
2546 r.in.buffer = &blob;
2547 r.in.offered = needed;
2548
2549 status = dcerpc_spoolss_GetJob(p, tctx, &r);
2550 torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
2551
2552 }
2553 torture_assert(tctx, r.out.info, "No job info returned");
2554 torture_assert_werr_ok(tctx, r.out.result, "GetJob failed");
2555
2556 CHECK_NEEDED_SIZE_LEVEL(spoolss_JobInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
2557 }
2558
2559 return true;
2560 }
2561
2562 static bool test_SetJob(struct torture_context *tctx,
2563 struct dcerpc_pipe *p,
2564 struct policy_handle *handle, uint32_t job_id,
2565 enum spoolss_JobControl command)
2566 {
2567 NTSTATUS status;
2568 struct spoolss_SetJob r;
2569
2570 r.in.handle = handle;
2571 r.in.job_id = job_id;
2572 r.in.ctr = NULL;
2573 r.in.command = command;
2574
2575 switch (command) {
2576 case SPOOLSS_JOB_CONTROL_PAUSE:
2577 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_PAUSE\n");
2578 break;
2579 case SPOOLSS_JOB_CONTROL_RESUME:
2580 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RESUME\n");
2581 break;
2582 case SPOOLSS_JOB_CONTROL_CANCEL:
2583 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_CANCEL\n");
2584 break;
2585 case SPOOLSS_JOB_CONTROL_RESTART:
2586 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RESTART\n");
2587 break;
2588 case SPOOLSS_JOB_CONTROL_DELETE:
2589 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_DELETE\n");
2590 break;
2591 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER:
2592 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER\n");
2593 break;
2594 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED:
2595 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED\n");
2596 break;
2597 case SPOOLSS_JOB_CONTROL_RETAIN:
2598 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RETAIN\n");
2599 break;
2600 case SPOOLSS_JOB_CONTROL_RELEASE:
2601 torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RELEASE\n");
2602 break;
2603 default:
2604 torture_comment(tctx, "Testing SetJob\n");
2605 break;
2606 }
2607
2608 status = dcerpc_spoolss_SetJob(p, tctx, &r);
2609 torture_assert_ntstatus_ok(tctx, status, "SetJob failed");
2610 torture_assert_werr_ok(tctx, r.out.result, "SetJob failed");
2611
2612 return true;
2613 }
2614
2615 static bool test_AddJob(struct torture_context *tctx,
2616 struct dcerpc_pipe *p,
2617 struct policy_handle *handle)
2618 {
2619 NTSTATUS status;
2620 struct spoolss_AddJob r;
2621 uint32_t needed;
2622
2623 r.in.level = 0;
2624 r.in.handle = handle;
2625 r.in.offered = 0;
2626 r.out.needed = &needed;
2627 r.in.buffer = r.out.buffer = NULL;
2628
2629 torture_comment(tctx, "Testing AddJob\n");
2630
2631 status = dcerpc_spoolss_AddJob(p, tctx, &r);
2632 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "AddJob failed");
2633
2634 r.in.level = 1;
2635
2636 status = dcerpc_spoolss_AddJob(p, tctx, &r);
2637 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM, "AddJob failed");
2638
2639 return true;
2640 }
2641
2642
2643 static bool test_EnumJobs(struct torture_context *tctx,
2644 struct dcerpc_pipe *p,
2645 struct policy_handle *handle)
2646 {
2647 NTSTATUS status;
2648 struct spoolss_EnumJobs r;
2649 uint32_t needed;
2650 uint32_t count;
2651 union spoolss_JobInfo *info;
2652
2653 r.in.handle = handle;
2654 r.in.firstjob = 0;
2655 r.in.numjobs = 0xffffffff;
2656 r.in.level = 1;
2657 r.in.buffer = NULL;
2658 r.in.offered = 0;
2659 r.out.needed = &needed;
2660 r.out.count = &count;
2661 r.out.info = &info;
2662
2663 torture_comment(tctx, "Testing EnumJobs\n");
2664
2665 status = dcerpc_spoolss_EnumJobs(p, tctx, &r);
2666
2667 torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
2668
2669 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2670 int j;
2671 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
2672 data_blob_clear(&blob);
2673 r.in.buffer = &blob;
2674 r.in.offered = needed;
2675
2676 status = dcerpc_spoolss_EnumJobs(p, tctx, &r);
2677
2678 torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
2679 torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
2680 torture_assert(tctx, info, "No jobs returned");
2681
2682 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumJobs, *r.out.info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
2683
2684 for (j = 0; j < count; j++) {
2685
2686 torture_assert(tctx, test_GetJob(tctx, p, handle, info[j].info1.job_id),
2687 "failed to call test_GetJob");
2688
2689 /* FIXME - gd */
2690 if (!torture_setting_bool(tctx, "samba3", false)) {
2691 test_SetJob(tctx, p, handle, info[j].info1.job_id, SPOOLSS_JOB_CONTROL_PAUSE);
2692 test_SetJob(tctx, p, handle, info[j].info1.job_id, SPOOLSS_JOB_CONTROL_RESUME);
2693 }
2694 }
2695
2696 } else {
2697 torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
2698 }
2699
2700 return true;
2701 }
2702
2703 static bool test_DoPrintTest(struct torture_context *tctx,
2704 struct dcerpc_pipe *p,
2705 struct policy_handle *handle)
2706 {
2707 bool ret = true;
2708 NTSTATUS status;
2709 struct spoolss_StartDocPrinter s;
2710 struct spoolss_DocumentInfo1 info1;
2711 struct spoolss_StartPagePrinter sp;
2712 struct spoolss_WritePrinter w;
2713 struct spoolss_EndPagePrinter ep;
2714 struct spoolss_EndDocPrinter e;
2715 int i;
2716 uint32_t job_id;
2717 uint32_t num_written;
2718
2719 torture_comment(tctx, "Testing StartDocPrinter\n");
2720
2721 s.in.handle = handle;
2722 s.in.level = 1;
2723 s.in.info.info1 = &info1;
2724 s.out.job_id = &job_id;
2725 info1.document_name = "TorturePrintJob";
2726 info1.output_file = NULL;
2727 info1.datatype = "RAW";
2728
2729 status = dcerpc_spoolss_StartDocPrinter(p, tctx, &s);
2730 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_StartDocPrinter failed");
2731 torture_assert_werr_ok(tctx, s.out.result, "StartDocPrinter failed");
2732
2733 for (i=1; i < 4; i++) {
2734 torture_comment(tctx, "Testing StartPagePrinter: Page[%d]\n", i);
2735
2736 sp.in.handle = handle;
2737
2738 status = dcerpc_spoolss_StartPagePrinter(p, tctx, &sp);
2739 torture_assert_ntstatus_ok(tctx, status,
2740 "dcerpc_spoolss_StartPagePrinter failed");
2741 torture_assert_werr_ok(tctx, sp.out.result, "StartPagePrinter failed");
2742
2743 torture_comment(tctx, "Testing WritePrinter: Page[%d]\n", i);
2744
2745 w.in.handle = handle;
2746 w.in.data = data_blob_string_const(talloc_asprintf(tctx,"TortureTestPage: %d\nData\n",i));
2747 w.out.num_written = &num_written;
2748
2749 status = dcerpc_spoolss_WritePrinter(p, tctx, &w);
2750 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_WritePrinter failed");
2751 torture_assert_werr_ok(tctx, w.out.result, "WritePrinter failed");
2752
2753 torture_comment(tctx, "Testing EndPagePrinter: Page[%d]\n", i);
2754
2755 ep.in.handle = handle;
2756
2757 status = dcerpc_spoolss_EndPagePrinter(p, tctx, &ep);
2758 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndPagePrinter failed");
2759 torture_assert_werr_ok(tctx, ep.out.result, "EndPagePrinter failed");
2760 }
2761
2762 torture_comment(tctx, "Testing EndDocPrinter\n");
2763
2764 e.in.handle = handle;
2765
2766 status = dcerpc_spoolss_EndDocPrinter(p, tctx, &e);
2767 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndDocPrinter failed");
2768 torture_assert_werr_ok(tctx, e.out.result, "EndDocPrinter failed");
2769
2770 ret &= test_AddJob(tctx, p, handle);
2771 ret &= test_EnumJobs(tctx, p, handle);
2772
2773 ret &= test_SetJob(tctx, p, handle, job_id, SPOOLSS_JOB_CONTROL_DELETE);
2774
2775 return ret;
2776 }
2777
2778 static bool test_PausePrinter(struct torture_context *tctx,
2779 struct dcerpc_pipe *p,
2780 struct policy_handle *handle)
2781 {
2782 NTSTATUS status;
2783 struct spoolss_SetPrinter r;
2784 struct spoolss_SetPrinterInfoCtr info_ctr;
2785 struct spoolss_DevmodeContainer devmode_ctr;
2786 struct sec_desc_buf secdesc_ctr;
2787
2788 info_ctr.level = 0;
2789 info_ctr.info.info0 = NULL;
2790
2791 ZERO_STRUCT(devmode_ctr);
2792 ZERO_STRUCT(secdesc_ctr);
2793
2794 r.in.handle = handle;
2795 r.in.info_ctr = &info_ctr;
2796 r.in.devmode_ctr = &devmode_ctr;
2797 r.in.secdesc_ctr = &secdesc_ctr;
2798 r.in.command = SPOOLSS_PRINTER_CONTROL_PAUSE;
2799
2800 torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_PAUSE\n");
2801
2802 status = dcerpc_spoolss_SetPrinter(p, tctx, &r);
2803
2804 torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
2805
2806 torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
2807
2808 return true;
2809 }
2810
2811 static bool test_ResumePrinter(struct torture_context *tctx,
2812 struct dcerpc_pipe *p,
2813 struct policy_handle *handle)
2814 {
2815 NTSTATUS status;
2816 struct spoolss_SetPrinter r;
2817 struct spoolss_SetPrinterInfoCtr info_ctr;
2818 struct spoolss_DevmodeContainer devmode_ctr;
2819 struct sec_desc_buf secdesc_ctr;
2820
2821 info_ctr.level = 0;
2822 info_ctr.info.info0 = NULL;
2823
2824 ZERO_STRUCT(devmode_ctr);
2825 ZERO_STRUCT(secdesc_ctr);
2826
2827 r.in.handle = handle;
2828 r.in.info_ctr = &info_ctr;
2829 r.in.devmode_ctr = &devmode_ctr;
2830 r.in.secdesc_ctr = &secdesc_ctr;
2831 r.in.command = SPOOLSS_PRINTER_CONTROL_RESUME;
2832
2833 torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_RESUME\n");
2834
2835 status = dcerpc_spoolss_SetPrinter(p, tctx, &r);
2836
2837 torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
2838
2839 torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
2840
2841 return true;
2842 }
2843
2844 static bool test_GetPrinterData(struct torture_context *tctx,
2845 struct dcerpc_pipe *p,
2846 struct policy_handle *handle,
2847 const char *value_name,
2848 enum winreg_Type *type_p,
2849 uint8_t **data_p,
2850 uint32_t *needed_p)
2851 {
2852 NTSTATUS status;
2853 struct spoolss_GetPrinterData r;
2854 uint32_t needed;
2855 enum winreg_Type type;
2856 union spoolss_PrinterData data;
2857
2858 r.in.handle = handle;
2859 r.in.value_name = value_name;
2860 r.in.offered = 0;
2861 r.out.needed = &needed;
2862 r.out.type = &type;
2863 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
2864
2865 torture_comment(tctx, "Testing GetPrinterData(%s)\n", r.in.value_name);
2866
2867 status = dcerpc_spoolss_GetPrinterData(p, tctx, &r);
2868 torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
2869
2870 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
2871 r.in.offered = needed;
2872 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
2873 status = dcerpc_spoolss_GetPrinterData(p, tctx, &r);
2874 torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
2875 }
2876
2877 torture_assert_werr_ok(tctx, r.out.result,
2878 talloc_asprintf(tctx, "GetPrinterData(%s) failed", r.in.value_name));
2879
2880 CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterData, &data, type, lp_iconv_convenience(tctx->lp_ctx), needed, 1);
2881
2882 if (type_p) {
2883 *type_p = type;
2884 }
2885
2886 if (data_p) {
2887 *data_p = r.out.data;
2888 }
2889
2890 if (needed_p) {
2891 *needed_p = needed;
2892 }
2893
2894 return true;
2895 }
2896
2897 static bool test_GetPrinterDataEx(struct torture_context *tctx,
2898 struct dcerpc_pipe *p,
2899 struct policy_handle *handle,
2900 const char *key_name,
2901 const char *value_name,
2902 enum winreg_Type *type_p,
2903 uint8_t **data_p,
2904 uint32_t *needed_p)
2905 {
2906 NTSTATUS status;
2907 struct spoolss_GetPrinterDataEx r;
2908 enum winreg_Type type;
2909 uint32_t needed;
2910 union spoolss_PrinterData data;
2911
2912 r.in.handle = handle;
2913 r.in.key_name = key_name;
2914 r.in.value_name = value_name;
2915 r.in.offered = 0;
2916 r.out.type = &type;
2917 r.out.needed = &needed;
2918 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
2919
2920 torture_comment(tctx, "Testing GetPrinterDataEx(%s - %s)\n",
2921 r.in.key_name, r.in.value_name);
2922
2923 status = dcerpc_spoolss_GetPrinterDataEx(p, tctx, &r);
2924 if (!NT_STATUS_IS_OK(status)) {
2925 if (NT_STATUS_EQUAL(status,NT_STATUS_NET_WRITE_FAULT) &&
2926 p->last_fault_code == DCERPC_FAULT_OP_RNG_ERROR) {
2927 torture_skip(tctx, "GetPrinterDataEx not supported by server\n");
2928 }
2929 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
2930 }
2931
2932 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
2933 r.in.offered = needed;
2934 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
2935 status = dcerpc_spoolss_GetPrinterDataEx(p, tctx, &r);
2936 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
2937 }
2938
2939 torture_assert_werr_ok(tctx, r.out.result,
2940 talloc_asprintf(tctx, "GetPrinterDataEx(%s - %s) failed", r.in.key_name, r.in.value_name));
2941
2942 CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterData, &data, type, lp_iconv_convenience(tctx->lp_ctx), needed, 1);
2943
2944 if (type_p) {
2945 *type_p = type;
2946 }
2947
2948 if (data_p) {
2949 *data_p = r.out.data;
2950 }
2951
2952 if (needed_p) {
2953 *needed_p = needed;
2954 }
2955
2956 return true;
2957 }
2958
2959 static bool test_GetPrinterData_list(struct torture_context *tctx,
2960 struct dcerpc_pipe *p,
2961 struct policy_handle *handle)
2962 {
2963 const char *list[] = {
2964 "W3SvcInstalled",
2965 "BeepEnabled",
2966 "EventLog",
2967 /* "NetPopup", not on w2k8 */
2968 /* "NetPopupToComputer", not on w2k8 */
2969 "MajorVersion",
2970 "MinorVersion",
2971 "DefaultSpoolDirectory",
2972 "Architecture",
2973 "DsPresent",
2974 "OSVersion",
2975 /* "OSVersionEx", not on s3 */
2976 "DNSMachineName"
2977 };
2978 int i;
2979
2980 for (i=0; i < ARRAY_SIZE(list); i++) {
2981 enum winreg_Type type, type_ex;
2982 uint8_t *data, *data_ex;
2983 uint32_t needed, needed_ex;
2984
2985 torture_assert(tctx, test_GetPrinterData(tctx, p, handle, list[i], &type, &data, &needed),
2986 talloc_asprintf(tctx, "GetPrinterData failed on %s\n", list[i]));
2987 torture_assert(tctx, test_GetPrinterDataEx(tctx, p, handle, "random_string", list[i], &type_ex, &data_ex, &needed_ex),
2988 talloc_asprintf(tctx, "GetPrinterDataEx failed on %s\n", list[i]));
2989 torture_assert_int_equal(tctx, type, type_ex, "type mismatch");
2990 torture_assert_int_equal(tctx, needed, needed_ex, "needed mismatch");
2991 torture_assert_mem_equal(tctx, data, data_ex, needed, "data mismatch");
2992 }
2993
2994 return true;
2995 }
2996
2997 static bool test_EnumPrinterData(struct torture_context *tctx, struct dcerpc_pipe *p,
2998 struct policy_handle *handle)
2999 {
3000 NTSTATUS status;
3001 struct spoolss_EnumPrinterData r;
3002
3003 ZERO_STRUCT(r);
3004 r.in.handle = handle;
3005 r.in.enum_index = 0;
3006
3007 do {
3008 uint32_t value_size = 0;
3009 uint32_t data_size = 0;
3010 enum winreg_Type type = 0;
3011
3012 r.in.value_offered = value_size;
3013 r.out.value_needed = &value_size;
3014 r.in.data_offered = data_size;
3015 r.out.data_needed = &data_size;
3016
3017 r.out.type = &type;
3018 r.out.data = talloc_zero_array(tctx, uint8_t, 0);
3019
3020 torture_comment(tctx, "Testing EnumPrinterData\n");
3021
3022 status = dcerpc_spoolss_EnumPrinterData(p, tctx, &r);
3023
3024 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterData failed");
3025 if (W_ERROR_EQUAL(r.out.result, WERR_NO_MORE_ITEMS)) {
3026 break;
3027 }
3028 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterData");
3029
3030 r.in.value_offered = value_size;
3031 r.out.value_name = talloc_zero_array(tctx, const char, value_size);
3032 r.in.data_offered = data_size;
3033 r.out.data = talloc_zero_array(tctx, uint8_t, data_size);
3034
3035 status = dcerpc_spoolss_EnumPrinterData(p, tctx, &r);
3036
3037 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterData failed");
3038 if (W_ERROR_EQUAL(r.out.result, WERR_NO_MORE_ITEMS)) {
3039 break;
3040 }
3041
3042 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterData failed");
3043
3044 torture_assert(tctx, test_GetPrinterData(tctx, p, handle, r.out.value_name, NULL, NULL, NULL),
3045 talloc_asprintf(tctx, "failed to call GetPrinterData for %s\n", r.out.value_name));
3046
3047 torture_assert(tctx, test_GetPrinterDataEx(tctx, p, handle, "PrinterDriverData", r.out.value_name, NULL, NULL, NULL),
3048 talloc_asprintf(tctx, "failed to call GetPrinterDataEx on PrinterDriverData for %s\n", r.out.value_name));
3049
3050 r.in.enum_index++;
3051
3052 } while (W_ERROR_IS_OK(r.out.result));
3053
3054 return true;
3055 }
3056
3057 static bool test_EnumPrinterDataEx(struct torture_context *tctx,
3058 struct dcerpc_pipe *p,
3059 struct policy_handle *handle,
3060 const char *key_name)
3061 {
3062 struct spoolss_EnumPrinterDataEx r;
3063 struct spoolss_PrinterEnumValues *info;
3064 uint32_t needed;
3065 uint32_t count;
3066
3067 r.in.handle = handle;
3068 r.in.key_name = key_name;
3069 r.in.offered = 0;
3070 r.out.needed = &needed;
3071 r.out.count = &count;
3072 r.out.info = &info;
3073
3074 torture_comment(tctx, "Testing EnumPrinterDataEx(%s)\n", key_name);
3075
3076 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &r),
3077 "EnumPrinterDataEx failed");
3078 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3079 r.in.offered = needed;
3080 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &r),
3081 "EnumPrinterDataEx failed");
3082 }
3083
3084 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDataEx failed");
3085
3086 CHECK_NEEDED_SIZE_ENUM(spoolss_EnumPrinterDataEx, info, count, lp_iconv_convenience(tctx->lp_ctx), needed, 1);
3087
3088 return true;
3089 }
3090
3091
3092 static bool test_DeletePrinterData(struct torture_context *tctx,
3093 struct dcerpc_pipe *p,
3094 struct policy_handle *handle,
3095 const char *value_name)
3096 {
3097 NTSTATUS status;
3098 struct spoolss_DeletePrinterData r;
3099
3100 r.in.handle = handle;
3101 r.in.value_name = value_name;
3102
3103 torture_comment(tctx, "Testing DeletePrinterData(%s)\n",
3104 r.in.value_name);
3105
3106 status = dcerpc_spoolss_DeletePrinterData(p, tctx, &r);
3107
3108 torture_assert_ntstatus_ok(tctx, status, "DeletePrinterData failed");
3109 torture_assert_werr_ok(tctx, r.out.result, "DeletePrinterData failed");
3110
3111 return true;
3112 }
3113
3114 static bool test_DeletePrinterDataEx(struct torture_context *tctx,
3115 struct dcerpc_pipe *p,
3116 struct policy_handle *handle,
3117 const char *key_name,
3118 const char *value_name)
3119 {
3120 struct spoolss_DeletePrinterDataEx r;
3121
3122 r.in.handle = handle;
3123 r.in.key_name = key_name;
3124 r.in.value_name = value_name;
3125
3126 torture_comment(tctx, "Testing DeletePrinterDataEx(%s - %s)\n",
3127 r.in.key_name, r.in.value_name);
3128
3129 torture_assert_ntstatus_ok(tctx,
3130 dcerpc_spoolss_DeletePrinterDataEx(p, tctx, &r),
3131 "DeletePrinterDataEx failed");
3132 torture_assert_werr_ok(tctx, r.out.result,
3133 "DeletePrinterDataEx failed");
3134
3135 return true;
3136 }
3137
3138 static bool test_DeletePrinterKey(struct torture_context *tctx,
3139 struct dcerpc_pipe *p,
3140 struct policy_handle *handle,
3141 const char *key_name)
3142 {
3143 struct spoolss_DeletePrinterKey r;
3144
3145 r.in.handle = handle;
3146 r.in.key_name = key_name;
3147
3148 torture_comment(tctx, "Testing DeletePrinterKey(%s)\n", r.in.key_name);
3149
3150 if (strequal(key_name, "") && !torture_setting_bool(tctx, "dangerous", false)) {
3151 torture_skip(tctx, "not wiping out printer registry - enable dangerous tests to use\n");
3152 return true;
3153 }
3154
3155 torture_assert_ntstatus_ok(tctx,
3156 dcerpc_spoolss_DeletePrinterKey(p, tctx, &r),
3157 "DeletePrinterKey failed");
3158 torture_assert_werr_ok(tctx, r.out.result,
3159 "DeletePrinterKey failed");
3160
3161 return true;
3162 }
3163
3164 static bool test_SetPrinterData(struct torture_context *tctx,
3165 struct dcerpc_pipe *p,
3166 struct policy_handle *handle)
3167 {
3168 NTSTATUS status;
3169 struct spoolss_SetPrinterData r;
3170 const char *values[] = {
3171 "spootyfoot",
3172 "spooty\\foot",
3173 #if 0
3174 /* FIXME: not working with s3 atm. */
3175 "spooty,foot",
3176 "spooty,fo,ot",
3177 #endif
3178 "spooty foot",
3179 #if 0
3180 /* FIXME: not working with s3 atm. */
3181 "spooty\\fo,ot",
3182 "spooty,fo\\ot"
3183 #endif
3184 };
3185 int i;
3186
3187 for (i=0; i < ARRAY_SIZE(values); i++) {
3188
3189 enum winreg_Type type;
3190 uint8_t *data;
3191 DATA_BLOB blob;
3192 uint32_t needed;
3193
3194 torture_assert(tctx,
3195 reg_string_to_val(tctx, lp_iconv_convenience(tctx->lp_ctx),
3196 "REG_SZ", "dog", &r.in.type, &blob), "");
3197
3198 r.in.handle = handle;
3199 r.in.value_name = values[i];
3200 r.in.data = blob.data;
3201 r.in.offered = blob.length;
3202
3203 torture_comment(tctx, "Testing SetPrinterData(%s)\n",
3204 r.in.value_name);
3205
3206 status = dcerpc_spoolss_SetPrinterData(p, tctx, &r);
3207
3208 torture_assert_ntstatus_ok(tctx, status, "SetPrinterData failed");
3209 torture_assert_werr_ok(tctx, r.out.result, "SetPrinterData failed");
3210
3211 if (!test_GetPrinterData(tctx, p, handle, r.in.value_name, &type, &data, &needed)) {
3212 return false;
3213 }
3214
3215 torture_assert_int_equal(tctx, r.in.type, type, "type mismatch");
3216 torture_assert_int_equal(tctx, r.in.offered, needed, "size mismatch");
3217 torture_assert_mem_equal(tctx, blob.data, data, needed, "buffer mismatch");
3218
3219 if (!test_DeletePrinterData(tctx, p, handle, r.in.value_name)) {
3220 return false;
3221 }
3222 }
3223
3224 return true;
3225 }
3226
3227 static bool test_EnumPrinterKey(struct torture_context *tctx,
3228 struct dcerpc_pipe *p,
3229 struct policy_handle *handle,
3230 const char *key_name,
3231 const char ***array);
3232
3233 static bool test_SetPrinterDataEx(struct torture_context *tctx,
3234 struct dcerpc_pipe *p,
3235 struct policy_handle *handle,
3236 const char *key_name,
3237 const char *value_name,
3238 enum winreg_Type type,
3239 uint8_t *data,
3240 uint32_t offered)
3241 {
3242 NTSTATUS status;
3243 struct spoolss_SetPrinterDataEx r;
3244
3245 r.in.handle = handle;
3246 r.in.key_name = key_name;
3247 r.in.value_name = value_name;
3248 r.in.type = type;
3249 r.in.data = data;
3250 r.in.offered = offered;
3251
3252 torture_comment(tctx, "Testing SetPrinterDataEx(%s - %s) type: %s, offered: 0x%08x\n",
3253 r.in.key_name, r.in.value_name, str_regtype(r.in.type), r.in.offered);
3254
3255 status = dcerpc_spoolss_SetPrinterDataEx(p, tctx, &r);
3256
3257 torture_assert_ntstatus_ok(tctx, status, "SetPrinterDataEx failed");
3258 torture_assert_werr_ok(tctx, r.out.result, "SetPrinterDataEx failed");
3259
3260 return true;
3261 }
3262
3263 #define TOP_LEVEL_PRINTER_KEY "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Print\\Printers"
3264
3265 static bool test_winreg_OpenHKLM(struct torture_context *tctx,
3266 struct dcerpc_pipe *p,
3267 struct policy_handle *handle)
3268 {
3269 struct winreg_OpenHKLM r;
3270
3271 r.in.system_name = NULL;
3272 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
3273 r.out.handle = handle;
3274
3275 torture_comment(tctx, "Testing winreg_OpenHKLM\n");
3276
3277 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_OpenHKLM(p, tctx, &r), "OpenHKLM failed");
3278 torture_assert_werr_ok(tctx, r.out.result, "OpenHKLM failed");
3279
3280 return true;
3281 }
3282
3283 static void init_winreg_String(struct winreg_String *name, const char *s)
3284 {
3285 name->name = s;
3286 if (s) {
3287 name->name_len = 2 * (strlen_m(s) + 1);
3288 name->name_size = name->name_len;
3289 } else {
3290 name->name_len = 0;
3291 name->name_size = 0;
3292 }
3293 }
3294
3295 static bool test_winreg_OpenKey(struct torture_context *tctx,
3296 struct dcerpc_pipe *p,
3297 struct policy_handle *hive_handle,
3298 const char *keyname,
3299 struct policy_handle *key_handle)
3300 {
3301 struct winreg_OpenKey r;
3302
3303 r.in.parent_handle = hive_handle;
3304 init_winreg_String(&r.in.keyname, keyname);
3305 r.in.unknown = 0x00000000;
3306 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
3307 r.out.handle = key_handle;
3308
3309 torture_comment(tctx, "Testing winreg_OpenKey(%s)\n", keyname);
3310
3311 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_OpenKey(p, tctx, &r), "OpenKey failed");
3312 torture_assert_werr_ok(tctx, r.out.result, "OpenKey failed");
3313
3314 return true;
3315 }
3316
3317 static bool test_winreg_CloseKey(struct torture_context *tctx,
3318 struct dcerpc_pipe *p,
3319 struct policy_handle *handle)
3320 {
3321 struct winreg_CloseKey r;
3322
3323 r.in.handle = handle;
3324 r.out.handle = handle;
3325
3326 torture_comment(tctx, "Testing winreg_CloseKey\n");
3327
3328 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_CloseKey(p, tctx, &r), "CloseKey failed");
3329 torture_assert_werr_ok(tctx, r.out.result, "CloseKey failed");
3330
3331 return true;
3332 }
3333
3334 static bool test_winreg_QueryValue(struct torture_context *tctx,
3335 struct dcerpc_pipe *p,
3336 struct policy_handle *handle,
3337 const char *value_name,
3338 enum winreg_Type *type_p,
3339 uint32_t *data_size_p,
3340 uint32_t *data_length_p,
3341 uint8_t **data_p)
3342 {
3343 struct winreg_QueryValue r;
3344 enum winreg_Type type = REG_NONE;
3345 uint32_t data_size = 0;
3346 uint32_t data_length = 0;
3347 struct winreg_String valuename;
3348
3349 init_winreg_String(&valuename, value_name);
3350
3351 r.in.handle = handle;
3352 r.in.value_name = &valuename;
3353 r.in.type = &type;
3354 r.in.data_size = &data_size;
3355 r.in.data_length = &data_length;
3356 r.out.type = &type;
3357 r.out.data = talloc_zero_array(tctx, uint8_t, *r.in.data_size);
3358 r.out.data_size = &data_size;
3359 r.out.data_length = &data_length;
3360
3361 torture_comment(tctx, "Testing winreg_QueryValue(%s)\n", value_name);
3362
3363 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue(p, tctx, &r), "QueryValue failed");
3364 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3365 *r.in.data_size = *r.out.data_size;
3366 r.out.data = talloc_zero_array(tctx, uint8_t, *r.in.data_size);
3367 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue(p, tctx, &r), "QueryValue failed");
3368 }
3369 torture_assert_werr_ok(tctx, r.out.result, "QueryValue failed");
3370
3371 if (type_p) {
3372 *type_p = *r.out.type;
3373 }
3374 if (data_size_p) {
3375 *data_size_p = *r.out.data_size;
3376 }
3377 if (data_length_p) {
3378 *data_length_p = *r.out.data_length;
3379 }
3380 if (data_p) {
3381 *data_p = r.out.data;
3382 }
3383
3384 return true;
3385 }
3386
3387 static bool test_SetPrinterDataEx_matrix(struct torture_context *tctx,
3388 struct dcerpc_pipe *p,
3389 struct policy_handle *handle,
3390 const char *printername,
3391 struct dcerpc_pipe *winreg_pipe,
3392 struct policy_handle *hive_handle)
3393 {
3394 const char *value_name = "dog";
3395 const char *keys[] = {
3396 "torturedataex",
3397 "torture data ex",
3398 #if 0
3399 /* FIXME: not working with s3 atm. */
3400 "torturedataex_with_subkey\\subkey",
3401 "torturedataex_with_subkey\\subkey:0",
3402 "torturedataex_with_subkey\\subkey:1",
3403 "torturedataex_with_subkey\\subkey\\subsubkey",
3404 "torturedataex_with_subkey\\subkey\\subsubkey:0",
3405 "torturedataex_with_subkey\\subkey\\subsubkey:1",
3406 #endif
3407 "torture,data",
3408 #if 0
3409 /* FIXME: not working with s3 atm. */
3410
3411 "torture,data,ex",
3412 "torture,data\\ex",
3413 "torture\\data,ex"
3414 #endif
3415 };
3416 enum winreg_Type types[] = {
3417 REG_SZ,
3418 REG_DWORD,
3419 REG_BINARY
3420 };
3421 const char *str = "abcdefghijklmnopqrstuvwxzy";
3422 int i, t, s;
3423
3424
3425 for (i=0; i < ARRAY_SIZE(keys); i++) {
3426 for (t=0; t < ARRAY_SIZE(types); t++) {
3427 for (s=0; s < strlen(str); s++) {
3428
3429 char *c;
3430 const char *key;
3431 enum winreg_Type type;
3432 const char *string = talloc_strndup(tctx, str, s);
3433 DATA_BLOB blob = data_blob_string_const(string);
3434 const char **subkeys;
3435 DATA_BLOB data;
3436 uint8_t *data_out;
3437 uint32_t needed, offered = 0;
3438
3439 switch (types[t]) {
3440 case REG_BINARY:
3441 case REG_DWORD:
3442 data = blob;
3443 offered = blob.length;
3444 break;
3445 case REG_SZ:
3446 torture_assert(tctx,
3447 reg_string_to_val(tctx, lp_iconv_convenience(tctx->lp_ctx),
3448 "REG_SZ", string, &type, &data), "");
3449 offered = data.length;
3450 /*strlen_m_term(data.string)*2;*/
3451 break;
3452 default:
3453 torture_fail(tctx, talloc_asprintf(tctx, "type %d untested\n", types[t]));
3454 }
3455
3456 torture_assert(tctx,
3457 test_SetPrinterDataEx(tctx, p, handle, keys[i], value_name, types[t], data.data, offered),
3458 "failed to call SetPrinterDataEx");
3459
3460 if (!test_GetPrinterDataEx(tctx, p, handle, keys[i], value_name, &type, &data_out, &needed)) {
3461 return false;
3462 }
3463 torture_assert_int_equal(tctx, types[t], type, "type mismatch");
3464 torture_assert_int_equal(tctx, needed, offered, "size mismatch");
3465 torture_assert_mem_equal(tctx, data_out, data.data, offered, "buffer mismatch");
3466
3467 if (winreg_pipe && hive_handle) {
3468 const char *printer_key;
3469 struct policy_handle key_handle;
3470 enum winreg_Type w_type;
3471 uint32_t w_size, w_length;
3472 uint8_t *w_data;
3473
3474 printer_key = talloc_asprintf(tctx, "%s\\%s\\%s",
3475 TOP_LEVEL_PRINTER_KEY, printername, keys[i]);
3476
3477 torture_assert(tctx, test_winreg_OpenKey(tctx, winreg_pipe, hive_handle, printer_key, &key_handle), "");
3478
3479 torture_assert(tctx,
3480 test_winreg_QueryValue(tctx, winreg_pipe, &key_handle, value_name, &w_type, &w_size, &w_length, &w_data), "");
3481
3482 test_winreg_CloseKey(tctx, winreg_pipe, &key_handle);
3483
3484 torture_assert_int_equal(tctx, w_type, types[t], "winreg type mismatch");
3485 torture_assert_int_equal(tctx, w_size, offered, "winreg size mismatch");
3486 torture_assert_mem_equal(tctx, w_data, data.data, offered, "winreg buffer mismatch");
3487 }
3488
3489 key = talloc_strdup(tctx, keys[i]);
3490
3491 if (!test_EnumPrinterDataEx(tctx, p, handle, keys[i])) {
3492 return false;
3493 }
3494
3495 if (!test_DeletePrinterDataEx(tctx, p, handle, keys[i], value_name)) {
3496 return false;
3497 }
3498
3499 c = strchr(key, '\\');
3500 if (c) {
3501 int i;
3502
3503 /* we have subkeys */
3504
3505 *c = 0;
3506
3507 if (!test_EnumPrinterKey(tctx, p, handle, key, &subkeys)) {
3508 return false;
3509 }
3510
3511 for (i=0; subkeys && subkeys[i]; i++) {
3512
3513 const char *current_key = talloc_asprintf(tctx, "%s\\%s", key, subkeys[i]);
3514
3515 if (!test_DeletePrinterKey(tctx, p, handle, current_key)) {
3516 return false;
3517 }
3518 }
3519
3520 if (!test_DeletePrinterKey(tctx, p, handle, key)) {
3521 return false;
3522 }
3523
3524 } else {
3525 if (!test_DeletePrinterKey(tctx, p, handle, key)) {
3526 return false;
3527 }
3528 }
3529 }
3530 }
3531 }
3532
3533 return true;
3534 }
3535
3536 static bool test_PrinterData_winreg(struct torture_context *tctx,
3537 struct dcerpc_pipe *p,
3538 struct policy_handle *handle,
3539 const char *printer_name)
3540 {
3541 struct dcerpc_pipe *p2;
3542 bool ret = true;
3543 struct policy_handle hive_handle;
3544
3545 torture_assert_ntstatus_ok(tctx,
3546 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
3547 "could not open winreg pipe");
3548
3549 torture_assert(tctx, test_winreg_OpenHKLM(tctx, p2, &hive_handle), "");
3550
3551 ret = test_SetPrinterDataEx_matrix(tctx, p, handle, printer_name, p2, &hive_handle);
3552
3553 test_winreg_CloseKey(tctx, p2, &hive_handle);
3554
3555 talloc_free(p2);
3556
3557 return ret;
3558 }
3559
3560 static bool test_GetChangeID_PrinterData(struct torture_context *tctx,
3561 struct dcerpc_pipe *p,
3562 struct policy_handle *handle,
3563 uint32_t *change_id)
3564 {
3565 enum winreg_Type type;
3566 uint8_t *data;
3567 uint32_t needed;
3568
3569 torture_assert(tctx,
3570 test_GetPrinterData(tctx, p, handle, "ChangeID", &type, &data, &needed),
3571 "failed to call GetPrinterData");
3572
3573 torture_assert(tctx, type == REG_DWORD, "unexpected type");
3574 torture_assert_int_equal(tctx, needed, 4, "unexpected size");
3575
3576 *change_id = IVAL(data, 0);
3577
3578 return true;
3579 }
3580
3581 static bool test_GetChangeID_PrinterDataEx(struct torture_context *tctx,
3582 struct dcerpc_pipe *p,
3583 struct policy_handle *handle,
3584 uint32_t *change_id)
3585 {
3586 enum winreg_Type type;
3587 uint8_t *data;
3588 uint32_t needed;
3589
3590 torture_assert(tctx,
3591 test_GetPrinterDataEx(tctx, p, handle, "PrinterDriverData", "ChangeID", &type, &data, &needed),
3592 "failed to call GetPrinterData");
3593
3594 torture_assert(tctx, type == REG_DWORD, "unexpected type");
3595 torture_assert_int_equal(tctx, needed, 4, "unexpected size");
3596
3597 *change_id = IVAL(data, 0);
3598
3599 return true;
3600 }
3601
3602 static bool test_GetChangeID_PrinterInfo(struct torture_context *tctx,
3603 struct dcerpc_pipe *p,
3604 struct policy_handle *handle,
3605 uint32_t *change_id)
3606 {
3607 union spoolss_PrinterInfo info;
3608
3609 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 0, &info),
3610 "failed to query Printer level 0");
3611
3612 *change_id = info.info0.change_id;
3613
3614 return true;
3615 }
3616
3617 static bool test_ChangeID(struct torture_context *tctx,
3618 struct dcerpc_pipe *p,
3619 struct policy_handle *handle)
3620 {
3621 uint32_t change_id, change_id_ex, change_id_info;
3622 uint32_t change_id2, change_id_ex2, change_id_info2;
3623 union spoolss_PrinterInfo info;
3624 const char *comment;
3625
3626
3627 torture_comment(tctx, "Testing ChangeID: id change test #1\n");
3628
3629 torture_assert(tctx, test_GetChangeID_PrinterData(tctx, p, handle, &change_id),
3630 "failed to query for ChangeID");
3631 torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
3632 "failed to query for ChangeID");
3633 torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, p, handle, &change_id_info),
3634 "failed to query for ChangeID");
3635
3636 torture_assert_int_equal(tctx, change_id, change_id_ex,
3637 "change_ids should all be equal");
3638 torture_assert_int_equal(tctx, change_id_ex, change_id_info,
3639 "change_ids should all be equal");
3640
3641
3642 torture_comment(tctx, "Testing ChangeID: id change test #2\n");
3643
3644 torture_assert(tctx, test_GetChangeID_PrinterData(tctx, p, handle, &change_id),
3645 "failed to query for ChangeID");
3646 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 2, &info),
3647 "failed to query Printer level 2");
3648 torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
3649 "failed to query for ChangeID");
3650 torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, p, handle, &change_id_info),
3651 "failed to query for ChangeID");
3652 torture_assert_int_equal(tctx, change_id, change_id_ex,
3653 "change_id should not have changed");
3654 torture_assert_int_equal(tctx, change_id_ex, change_id_info,
3655 "change_id should not have changed");
3656
3657
3658 torture_comment(tctx, "Testing ChangeID: id change test #3\n");
3659
3660 torture_assert(tctx, test_GetChangeID_PrinterData(tctx, p, handle, &change_id),
3661 "failed to query for ChangeID");
3662 torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
3663 "failed to query for ChangeID");
3664 torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, p, handle, &change_id_info),
3665 "failed to query for ChangeID");
3666 torture_assert(tctx, test_GetPrinter_level(tctx, p, handle, 2, &info),
3667 "failed to query Printer level 2");
3668 comment = talloc_strdup(tctx, info.info2.comment);
3669
3670 {
3671 struct spoolss_SetPrinterInfoCtr info_ctr;
3672 struct spoolss_DevmodeContainer devmode_ctr;
3673 struct sec_desc_buf secdesc_ctr;
3674 struct spoolss_SetPrinterInfo2 info2;
3675
3676 ZERO_STRUCT(info_ctr);
3677 ZERO_STRUCT(devmode_ctr);
3678 ZERO_STRUCT(secdesc_ctr);
3679
3680 info2.servername = info.info2.servername;
3681 info2.printername = info.info2.printername;
3682 info2.sharename = info.info2.sharename;
3683 info2.portname = info.info2.portname;
3684 info2.drivername = info.info2.drivername;
3685 info2.comment = "torture_comment";
3686 info2.location = info.info2.location;
3687 info2.devmode_ptr = 0;
3688 info2.sepfile = info.info2.sepfile;
3689 info2.printprocessor = info.info2.printprocessor;
3690 info2.datatype = info.info2.datatype;
3691 info2.parameters = info.info2.parameters;
3692 info2.secdesc_ptr = 0;
3693 info2.attributes = info.info2.attributes;
3694 info2.priority = info.info2.priority;
3695 info2.defaultpriority = info.info2.defaultpriority;
3696 info2.starttime = info.info2.starttime;
3697 info2.untiltime = info.info2.untiltime;
3698 info2.status = info.info2.status;
3699 info2.cjobs = info.info2.cjobs;
3700 info2.averageppm = info.info2.averageppm;
3701
3702 info_ctr.level = 2;
3703 info_ctr.info.info2 = &info2;
3704
3705 torture_assert(tctx, test_SetPrinter(tctx, p, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
3706 "failed to call SetPrinter");
3707
3708 info2.comment = comment;
3709
3710 torture_assert(tctx, test_SetPrinter(tctx, p, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
3711 "failed to call SetPrinter");
3712
3713 }
3714
3715 torture_assert(tctx, test_GetChangeID_PrinterData(tctx, p, handle, &change_id2),
3716 "failed to query for ChangeID");
3717 torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex2),
3718 "failed to query for ChangeID");
3719 torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, p, handle, &change_id_info2),
3720 "failed to query for ChangeID");
3721
3722 torture_assert_int_equal(tctx, change_id2, change_id_ex2,
3723 "change_ids should all be equal");
3724 torture_assert_int_equal(tctx, change_id_ex2, change_id_info2,
3725 "change_ids should all be equal");
3726
3727 torture_assert(tctx, (change_id < change_id2),
3728 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
3729 change_id2, change_id));
3730 torture_assert(tctx, (change_id_ex < change_id_ex2),
3731 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
3732 change_id_ex2, change_id_ex));
3733 torture_assert(tctx, (change_id_info < change_id_info2),
3734 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
3735 change_id_info2, change_id_info));
3736
3737 return true;
3738 }
3739
3740 static bool test_SecondaryClosePrinter(struct torture_context *tctx,
3741 struct dcerpc_pipe *p,
3742 struct policy_handle *handle)
3743 {
3744 NTSTATUS status;
3745 struct dcerpc_binding *b;
3746 struct dcerpc_pipe *p2;
3747 struct spoolss_ClosePrinter cp;
3748
3749 /* only makes sense on SMB */
3750 if (p->conn->transport.transport != NCACN_NP) {
3751 return true;
3752 }
3753
3754 torture_comment(tctx, "testing close on secondary pipe\n");
3755
3756 status = dcerpc_parse_binding(tctx, p->conn->binding_string, &b);
3757 torture_assert_ntstatus_ok(tctx, status, "Failed to parse dcerpc binding");
3758
3759 status = dcerpc_secondary_connection(p, &p2, b);
3760 torture_assert_ntstatus_ok(tctx, status, "Failed to create secondary connection");
3761
3762 status = dcerpc_bind_auth_none(p2, &ndr_table_spoolss);
3763 torture_assert_ntstatus_ok(tctx, status, "Failed to create bind on secondary connection");
3764
3765 cp.in.handle = handle;
3766 cp.out.handle = handle;
3767
3768 status = dcerpc_spoolss_ClosePrinter(p2, tctx, &cp);
3769 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_NET_WRITE_FAULT,
3770 "ERROR: Allowed close on secondary connection");
3771
3772 torture_assert_int_equal(tctx, p2->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
3773 "Unexpected fault code");
3774
3775 talloc_free(p2);
3776
3777 return true;
3778 }
3779
3780 static bool test_OpenPrinter_badname(struct torture_context *tctx,
3781 struct dcerpc_pipe *p, const char *name)
3782 {
3783 NTSTATUS status;
3784 struct spoolss_OpenPrinter op;
3785 struct spoolss_OpenPrinterEx opEx;
3786 struct policy_handle handle;
3787 bool ret = true;
3788
3789 op.in.printername = name;
3790 op.in.datatype = NULL;
3791 op.in.devmode_ctr.devmode= NULL;
3792 op.in.access_mask = 0;
3793 op.out.handle = &handle;
3794
3795 torture_comment(tctx, "\nTesting OpenPrinter(%s) with bad name\n", op.in.printername);
3796
3797 status = dcerpc_spoolss_OpenPrinter(p, tctx, &op);
3798 torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
3799 if (!W_ERROR_EQUAL(WERR_INVALID_PRINTER_NAME,op.out.result)) {
3800 torture_comment(tctx, "OpenPrinter(%s) unexpected result[%s] should be WERR_INVALID_PRINTER_NAME\n",
3801 name, win_errstr(op.out.result));
3802 }
3803
3804 if (W_ERROR_IS_OK(op.out.result)) {
3805 ret &=test_ClosePrinter(tctx, p, &handle);
3806 }
3807
3808 opEx.in.printername = name;
3809 opEx.in.datatype = NULL;
3810 opEx.in.devmode_ctr.devmode = NULL;
3811 opEx.in.access_mask = 0;
3812 opEx.in.level = 1;
3813 opEx.in.userlevel.level1 = NULL;
3814 opEx.out.handle = &handle;
3815
3816 torture_comment(tctx, "Testing OpenPrinterEx(%s) with bad name\n", opEx.in.printername);
3817
3818 status = dcerpc_spoolss_OpenPrinterEx(p, tctx, &opEx);
3819 torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
3820 if (!W_ERROR_EQUAL(WERR_INVALID_PARAM,opEx.out.result)) {
3821 torture_comment(tctx, "OpenPrinterEx(%s) unexpected result[%s] should be WERR_INVALID_PARAM\n",
3822 name, win_errstr(opEx.out.result));
3823 }
3824
3825 if (W_ERROR_IS_OK(opEx.out.result)) {
3826 ret &=test_ClosePrinter(tctx, p, &handle);
3827 }
3828
3829 return ret;
3830 }
3831
3832 static bool test_OpenPrinter(struct torture_context *tctx,
3833 struct dcerpc_pipe *p,
3834 const char *name,
3835 const char *environment)
3836 {
3837 NTSTATUS status;
3838 struct spoolss_OpenPrinter r;
3839 struct policy_handle handle;
3840 bool ret = true;
3841
3842 r.in.printername = talloc_asprintf(tctx, "\\\\%s\\%s", dcerpc_server_name(p), name);
3843 r.in.datatype = NULL;
3844 r.in.devmode_ctr.devmode= NULL;
3845 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
3846 r.out.handle = &handle;
3847
3848 torture_comment(tctx, "Testing OpenPrinter(%s)\n", r.in.printername);
3849
3850 status = dcerpc_spoolss_OpenPrinter(p, tctx, &r);
3851
3852 torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
3853
3854 torture_assert_werr_ok(tctx, r.out.result, "OpenPrinter failed");
3855
3856 if (!test_GetPrinter(tctx, p, &handle, environment)) {
3857 ret = false;
3858 }
3859
3860 if (!torture_setting_bool(tctx, "samba3", false)) {
3861 if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
3862 ret = false;
3863 }
3864 }
3865
3866 if (!test_ClosePrinter(tctx, p, &handle)) {
3867 ret = false;
3868 }
3869
3870 return ret;
3871 }
3872
3873 static bool call_OpenPrinterEx(struct torture_context *tctx,
3874 struct dcerpc_pipe *p,
3875 const char *name,
3876 struct spoolss_DeviceMode *devmode,
3877 struct policy_handle *handle)
3878 {
3879 struct spoolss_OpenPrinterEx r;
3880 struct spoolss_UserLevel1 userlevel1;
3881 NTSTATUS status;
3882
3883 if (name && name[0]) {
3884 r.in.printername = talloc_asprintf(tctx, "\\\\%s\\%s",
3885 dcerpc_server_name(p), name);
3886 } else {
3887 r.in.printername = talloc_asprintf(tctx, "\\\\%s",
3888 dcerpc_server_name(p));
3889 }
3890
3891 r.in.datatype = NULL;
3892 r.in.devmode_ctr.devmode= devmode;
3893 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
3894 r.in.level = 1;
3895 r.in.userlevel.level1 = &userlevel1;
3896 r.out.handle = handle;
3897
3898 userlevel1.size = 1234;
3899 userlevel1.client = "hello";
3900 userlevel1.user = "spottyfoot!";
3901 userlevel1.build = 1;
3902 userlevel1.major = 2;
3903 userlevel1.minor = 3;
3904 userlevel1.processor = 4;
3905
3906 torture_comment(tctx, "Testing OpenPrinterEx(%s)\n", r.in.printername);
3907
3908 status = dcerpc_spoolss_OpenPrinterEx(p, tctx, &r);
3909
3910 torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
3911
3912 torture_assert_werr_ok(tctx, r.out.result, "OpenPrinterEx failed");
3913
3914 return true;
3915 }
3916
3917 static bool test_OpenPrinterEx(struct torture_context *tctx,
3918 struct dcerpc_pipe *p,
3919 const char *name,
3920 const char *environment)
3921 {
3922 struct policy_handle handle;
3923 bool ret = true;
3924
3925 if (!call_OpenPrinterEx(tctx, p, name, NULL, &handle)) {
3926 return false;
3927 }
3928
3929 if (!test_PrinterInfo_SD(tctx, p, &handle)) {
3930 ret = false;
3931 }
3932
3933 if (!test_GetPrinter(tctx, p, &handle, environment)) {
3934 ret = false;
3935 }
3936
3937 if (!test_EnumForms(tctx, p, &handle, false)) {
3938 ret = false;
3939 }
3940
3941 if (!test_AddForm(tctx, p, &handle, false)) {
3942 ret = false;
3943 }
3944
3945 if (!test_EnumPrinterData(tctx, p, &handle)) {
3946 ret = false;
3947 }
3948
3949 if (!test_EnumPrinterDataEx(tctx, p, &handle, "PrinterDriverData")) {
3950 ret = false;
3951 }
3952
3953 if (!test_printer_keys(tctx, p, &handle)) {
3954 ret = false;
3955 }
3956
3957 if (!test_PausePrinter(tctx, p, &handle)) {
3958 ret = false;
3959 }
3960
3961 if (!test_DoPrintTest(tctx, p, &handle)) {
3962 ret = false;
3963 }
3964
3965 if (!test_ResumePrinter(tctx, p, &handle)) {
3966 ret = false;
3967 }
3968
3969 if (!test_SetPrinterData(tctx, p, &handle)) {
3970 ret = false;
3971 }
3972
3973 if (!test_SetPrinterDataEx_matrix(tctx, p, &handle, name, NULL, NULL)) {
3974 ret = false;
3975 }
3976
3977 if (!torture_setting_bool(tctx, "samba3", false)) {
3978 if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
3979 ret = false;
3980 }
3981 }
3982
3983 if (!test_ClosePrinter(tctx, p, &handle)) {
3984 ret = false;
3985 }
3986
3987 return ret;
3988 }
3989
3990 static bool test_EnumPrinters_old(struct torture_context *tctx,
3991 struct dcerpc_pipe *p,
3992 const char *environment)
3993 {
3994 struct spoolss_EnumPrinters r;
3995 NTSTATUS status;
3996 uint16_t levels[] = {1, 2, 4, 5};
3997 int i;
3998 bool ret = true;
3999
4000 for (i=0;i<ARRAY_SIZE(levels);i++) {
4001 union spoolss_PrinterInfo *info;
4002 int j;
4003 uint32_t needed;
4004 uint32_t count;
4005
4006 r.in.flags = PRINTER_ENUM_LOCAL;
4007 r.in.server = "";
4008 r.in.level = levels[i];
4009 r.in.buffer = NULL;
4010 r.in.offered = 0;
4011 r.out.needed = &needed;
4012 r.out.count = &count;
4013 r.out.info = &info;
4014
4015 torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
4016
4017 status = dcerpc_spoolss_EnumPrinters(p, tctx, &r);
4018 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
4019
4020 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
4021 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
4022 data_blob_clear(&blob);
4023 r.in.buffer = &blob;
4024 r.in.offered = needed;
4025 status = dcerpc_spoolss_EnumPrinters(p, tctx, &r);
4026 }
4027
4028 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
4029
4030 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
4031
4032 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
4033
4034 if (!info) {
4035 torture_comment(tctx, "No printers returned\n");
4036 return true;
4037 }
4038
4039 for (j=0;j<count;j++) {
4040 if (r.in.level == 1) {
4041 char *unc = talloc_strdup(tctx, info[j].info1.name);
4042 char *slash, *name;
4043 name = unc;
4044 if (unc[0] == '\\' && unc[1] == '\\') {
4045 unc +=2;
4046 }
4047 slash = strchr(unc, '\\');
4048 if (slash) {
4049 slash++;
4050 name = slash;
4051 }
4052 if (!test_OpenPrinter(tctx, p, name, environment)) {
4053 ret = false;
4054 }
4055 if (!test_OpenPrinterEx(tctx, p, name, environment)) {
4056 ret = false;
4057 }
4058 }
4059 }
4060 }
4061
4062 return ret;
4063 }
4064
4065 static bool test_GetPrinterDriver(struct torture_context *tctx,
4066 struct dcerpc_pipe *p,
4067 struct policy_handle *handle,
4068 const char *driver_name)
4069 {
4070 struct spoolss_GetPrinterDriver r;
4071 uint32_t needed;
4072
4073 r.in.handle = handle;
4074 r.in.architecture = "W32X86";
4075 r.in.level = 1;
4076 r.in.buffer = NULL;
4077 r.in.offered = 0;
4078 r.out.needed = &needed;
4079
4080 torture_comment(tctx, "Testing GetPrinterDriver level %d\n", r.in.level);
4081
4082 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver(p, tctx, &r),
4083 "failed to call GetPrinterDriver");
4084 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
4085 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
4086 data_blob_clear(&blob);
4087 r.in.buffer = &blob;
4088 r.in.offered = needed;
4089 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver(p, tctx, &r),
4090 "failed to call GetPrinterDriver");
4091 }
4092
4093 torture_assert_werr_ok(tctx, r.out.result,
4094 "failed to call GetPrinterDriver");
4095
4096 CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
4097
4098 return true;
4099 }
4100
4101 static bool test_GetPrinterDriver2(struct torture_context *tctx,
4102 struct dcerpc_pipe *p,
4103 struct policy_handle *handle,
4104 const char *driver_name,
4105 const char *architecture)
4106 {
4107 struct spoolss_GetPrinterDriver2 r;
4108 uint16_t levels[] = {1, 2, 3, 4, 5, 6, 8, 101 };
4109 uint32_t needed;
4110 uint32_t server_major_version;
4111 uint32_t server_minor_version;
4112 int i;
4113
4114 r.in.handle = handle;
4115 r.in.architecture = architecture;
4116 r.in.client_major_version = 3;
4117 r.in.client_minor_version = 0;
4118 r.out.needed = &needed;
4119 r.out.server_major_version = &server_major_version;
4120 r.out.server_minor_version = &server_minor_version;
4121
4122 for (i=0;i<ARRAY_SIZE(levels);i++) {
4123
4124 r.in.buffer = NULL;
4125 r.in.offered = 0;
4126 r.in.level = levels[i];
4127
4128 torture_comment(tctx, "Testing GetPrinterDriver2(%s) level %d\n",
4129 driver_name, r.in.level);
4130
4131 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver2(p, tctx, &r),
4132 "failed to call GetPrinterDriver2");
4133 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
4134 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
4135 data_blob_clear(&blob);
4136 r.in.buffer = &blob;
4137 r.in.offered = needed;
4138 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver2(p, tctx, &r),
4139 "failed to call GetPrinterDriver2");
4140 }
4141
4142 if (W_ERROR_EQUAL(r.out.result, WERR_INVALID_LEVEL)) {
4143 switch (r.in.level) {
4144 case 101:
4145 case 8:
4146 continue;
4147 default:
4148 break;
4149 }
4150 }
4151
4152 torture_assert_werr_ok(tctx, r.out.result,
4153 "failed to call GetPrinterDriver2");
4154
4155 CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
4156 }
4157
4158 return true;
4159 }
4160
4161 static bool test_EnumPrinterDrivers_old(struct torture_context *tctx,
4162 struct dcerpc_pipe *p,
4163 const char *environment)
4164 {
4165 struct spoolss_EnumPrinterDrivers r;
4166 NTSTATUS status;
4167 uint16_t levels[] = {1, 2, 3, 4, 5, 6};
4168 int i;
4169
4170 for (i=0;i<ARRAY_SIZE(levels);i++) {
4171
4172 uint32_t needed;
4173 uint32_t count;
4174 union spoolss_DriverInfo *info;
4175
4176 r.in.server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
4177 r.in.environment = environment;
4178 r.in.level = levels[i];
4179 r.in.buffer = NULL;
4180 r.in.offered = 0;
4181 r.out.needed = &needed;
4182 r.out.count = &count;
4183 r.out.info = &info;
4184
4185 torture_comment(tctx, "Testing EnumPrinterDrivers level %u\n", r.in.level);
4186
4187 status = dcerpc_spoolss_EnumPrinterDrivers(p, tctx, &r);
4188
4189 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDrivers failed");
4190
4191 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
4192 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
4193 data_blob_clear(&blob);
4194 r.in.buffer = &blob;
4195 r.in.offered = needed;
4196 status = dcerpc_spoolss_EnumPrinterDrivers(p, tctx, &r);
4197 }
4198
4199 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDrivers failed");
4200
4201 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDrivers failed");
4202
4203 if (!info) {
4204 torture_comment(tctx, "No printer drivers returned\n");
4205 break;
4206 }
4207
4208 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinterDrivers, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
4209 }
4210
4211 return true;
4212 }
4213
4214 static bool test_DeletePrinter(struct torture_context *tctx,
4215 struct dcerpc_pipe *p,
4216 struct policy_handle *handle)
4217 {
4218 struct spoolss_DeletePrinter r;
4219
4220 torture_comment(tctx, "Testing DeletePrinter\n");
4221
4222 r.in.handle = handle;
4223
4224 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_DeletePrinter(p, tctx, &r),
4225 "failed to delete printer");
4226 torture_assert_werr_ok(tctx, r.out.result,
4227 "failed to delete printer");
4228
4229 return true;
4230 }
4231
4232 static bool test_EnumPrinters_findname(struct torture_context *tctx,
4233 struct dcerpc_pipe *p,
4234 uint32_t flags,
4235 uint32_t level,
4236 const char *name,
4237 bool *found)
4238 {
4239 struct spoolss_EnumPrinters e;
4240 uint32_t count;
4241 union spoolss_PrinterInfo *info;
4242 uint32_t needed;
4243 int i;
4244
4245 *found = false;
4246
4247 e.in.flags = flags;
4248 e.in.server = NULL;
4249 e.in.level = level;
4250 e.in.buffer = NULL;
4251 e.in.offered = 0;
4252 e.out.count = &count;
4253 e.out.info = &info;
4254 e.out.needed = &needed;
4255
4256 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters(p, tctx, &e),
4257 "failed to enum printers");
4258
4259 if (W_ERROR_EQUAL(e.out.result, WERR_INSUFFICIENT_BUFFER)) {
4260 DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
4261 data_blob_clear(&blob);
4262 e.in.buffer = &blob;
4263 e.in.offered = needed;
4264
4265 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters(p, tctx, &e),
4266 "failed to enum printers");
4267 }
4268
4269 torture_assert_werr_ok(tctx, e.out.result,
4270 "failed to enum printers");
4271
4272 for (i=0; i < count; i++) {
4273
4274 const char *current = NULL;
4275 const char *p;
4276
4277 switch (level) {
4278 case 1:
4279 current = info[i].info1.name;
4280 break;
4281 }
4282
4283 if (strequal(current, name)) {
4284 *found = true;
4285 break;
4286 }
4287
4288 p = strrchr(current, '\\');
4289 if (p) {
4290 if (!e.in.server) {
4291 torture_warning(tctx,
4292 "server returns printername %s incl. servername although we did not set servername", current);
4293 }
4294 p++;
4295 if (strequal(p, name)) {
4296 *found = true;
4297 break;
4298 }
4299 }
4300 }
4301
4302 return true;
4303 }
4304
4305 static bool test_AddPrinter_wellknown(struct torture_context *tctx,
4306 struct dcerpc_pipe *p,
4307 const char *printername,
4308 bool ex)
4309 {
4310 WERROR result;
4311 struct spoolss_AddPrinter r;
4312 struct spoolss_AddPrinterEx rex;
4313 struct spoolss_SetPrinterInfoCtr info_ctr;
4314 struct spoolss_SetPrinterInfo1 info1;
4315 struct spoolss_DevmodeContainer devmode_ctr;
4316 struct sec_desc_buf secdesc_ctr;
4317 struct spoolss_UserLevelCtr userlevel_ctr;
4318 struct policy_handle handle;
4319 bool found = false;
4320
4321 ZERO_STRUCT(devmode_ctr);
4322 ZERO_STRUCT(secdesc_ctr);
4323 ZERO_STRUCT(userlevel_ctr);
4324 ZERO_STRUCT(info1);
4325
4326 torture_comment(tctx, "Testing AddPrinter%s level 1\n", ex ? "Ex":"");
4327
4328 /* try to add printer to wellknown printer list (level 1) */
4329
4330 userlevel_ctr.level = 1;
4331
4332 info_ctr.info.info1 = &info1;
4333 info_ctr.level = 1;
4334
4335 rex.in.server = NULL;
4336 rex.in.info_ctr = &info_ctr;
4337 rex.in.devmode_ctr = &devmode_ctr;
4338 rex.in.secdesc_ctr = &secdesc_ctr;
4339 rex.in.userlevel_ctr = &userlevel_ctr;
4340 rex.out.handle = &handle;
4341
4342 r.in.server = NULL;
4343 r.in.info_ctr = &info_ctr;
4344 r.in.devmode_ctr = &devmode_ctr;
4345 r.in.secdesc_ctr = &secdesc_ctr;
4346 r.out.handle = &handle;
4347
4348 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
4349 dcerpc_spoolss_AddPrinter(p, tctx, &r),
4350 "failed to add printer");
4351 result = ex ? rex.out.result : r.out.result;
4352 torture_assert_werr_equal(tctx, result, WERR_INVALID_PRINTER_NAME,
4353 "unexpected result code");
4354
4355 info1.name = printername;
4356 info1.flags = PRINTER_ATTRIBUTE_SHARED;
4357
4358 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
4359 dcerpc_spoolss_AddPrinter(p, tctx, &r),
4360 "failed to add printer");
4361 result = ex ? rex.out.result : r.out.result;
4362 torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
4363 "unexpected result code");
4364
4365 /* bizarre protocol, WERR_PRINTER_ALREADY_EXISTS means success here,
4366 better do a real check to see the printer is really there */
4367
4368 torture_assert(tctx, test_EnumPrinters_findname(tctx, p,
4369 PRINTER_ENUM_NETWORK, 1,
4370 printername,
4371 &found),
4372 "failed to enum printers");
4373
4374 torture_assert(tctx, found, "failed to find newly added printer");
4375
4376 info1.flags = 0;
4377
4378 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
4379 dcerpc_spoolss_AddPrinter(p, tctx, &r),
4380 "failed to add printer");
4381 result = ex ? rex.out.result : r.out.result;
4382 torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
4383 "unexpected result code");
4384
4385 /* bizarre protocol, WERR_PRINTER_ALREADY_EXISTS means success here,
4386 better do a real check to see the printer has really been removed
4387 from the well known printer list */
4388
4389 found = false;
4390
4391 torture_assert(tctx, test_EnumPrinters_findname(tctx, p,
4392 PRINTER_ENUM_NETWORK, 1,
4393 printername,
4394 &found),
4395 "failed to enum printers");
4396 #if 0
4397 torture_assert(tctx, !found, "printer still in well known printer list");
4398 #endif
4399 return true;
4400 }
4401
4402 static bool test_AddPrinter_normal(struct torture_context *tctx,
4403 struct dcerpc_pipe *p,
4404 struct policy_handle *handle_p,
4405 const char *printername,
4406 const char *drivername,
4407 const char *portname,
4408 bool ex)
4409 {
4410 WERROR result;
4411 struct spoolss_AddPrinter r;
4412 struct spoolss_AddPrinterEx rex;
4413 struct spoolss_SetPrinterInfoCtr info_ctr;
4414 struct spoolss_SetPrinterInfo2 info2;
4415 struct spoolss_DevmodeContainer devmode_ctr;
4416 struct sec_desc_buf secdesc_ctr;
4417 struct spoolss_UserLevelCtr userlevel_ctr;
4418 struct policy_handle handle;
4419 bool found = false;
4420 bool existing_printer_deleted = false;
4421
4422 ZERO_STRUCT(devmode_ctr);
4423 ZERO_STRUCT(secdesc_ctr);
4424 ZERO_STRUCT(userlevel_ctr);
4425
4426 torture_comment(tctx, "Testing AddPrinter%s level 2\n", ex ? "Ex":"");
4427
4428 userlevel_ctr.level = 1;
4429
4430 rex.in.server = NULL;
4431 rex.in.info_ctr = &info_ctr;
4432 rex.in.devmode_ctr = &devmode_ctr;
4433 rex.in.secdesc_ctr = &secdesc_ctr;
4434 rex.in.userlevel_ctr = &userlevel_ctr;
4435 rex.out.handle = &handle;
4436
4437 r.in.server = NULL;
4438 r.in.info_ctr = &info_ctr;
4439 r.in.devmode_ctr = &devmode_ctr;
4440 r.in.secdesc_ctr = &secdesc_ctr;
4441 r.out.handle = &handle;
4442
4443 again:
4444
4445 /* try to add printer to printer list (level 2) */
4446
4447 ZERO_STRUCT(info2);
4448
4449 info_ctr.info.info2 = &info2;
4450 info_ctr.level = 2;
4451
4452 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
4453 dcerpc_spoolss_AddPrinter(p, tctx, &r),
4454 "failed to add printer");
4455 result = ex ? rex.out.result : r.out.result;
4456 torture_assert_werr_equal(tctx, result, WERR_INVALID_PRINTER_NAME,
4457 "unexpected result code");
4458
4459 info2.printername = printername;
4460
4461 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
4462 dcerpc_spoolss_AddPrinter(p, tctx, &r),
4463 "failed to add printer");
4464 result = ex ? rex.out.result : r.out.result;
4465
4466 if (W_ERROR_EQUAL(result, WERR_PRINTER_ALREADY_EXISTS)) {
4467 struct policy_handle printer_handle;
4468
4469 if (existing_printer_deleted) {
4470 torture_fail(tctx, "already deleted printer still existing?");
4471 }
4472
4473 torture_assert(tctx, call_OpenPrinterEx(tctx, p, printername, NULL, &printer_handle),
4474 "failed to open printer handle");
4475
4476 torture_assert(tctx, test_DeletePrinter(tctx, p, &printer_handle),
4477 "failed to delete printer");
4478
4479 torture_assert(tctx, test_ClosePrinter(tctx, p, &printer_handle),
4480 "failed to close server handle");
4481
4482 existing_printer_deleted = true;
4483
4484 goto again;
4485 }
4486
4487 torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PORT,
4488 "unexpected result code");
4489
4490 info2.portname = portname;
4491
4492 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
4493 dcerpc_spoolss_AddPrinter(p, tctx, &r),
4494 "failed to add printer");
4495 result = ex ? rex.out.result : r.out.result;
4496 torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PRINTER_DRIVER,
4497 "unexpected result code");
4498
4499 info2.drivername = drivername;
4500
4501 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
4502 dcerpc_spoolss_AddPrinter(p, tctx, &r),
4503 "failed to add printer");
4504 result = ex ? rex.out.result : r.out.result;
4505
4506 /* w2k8r2 allows to add printer w/o defining printprocessor */
4507
4508 if (!W_ERROR_IS_OK(result)) {
4509 torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PRINTPROCESSOR,
4510 "unexpected result code");
4511
4512 info2.printprocessor = "winprint";
4513
4514 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
4515 dcerpc_spoolss_AddPrinter(p, tctx, &r),
4516 "failed to add printer");
4517 result = ex ? rex.out.result : r.out.result;
4518 torture_assert_werr_ok(tctx, result,
4519 "failed to add printer");
4520 }
4521
4522 *handle_p = handle;
4523
4524 /* we are paranoid, really check if the printer is there now */
4525
4526 torture_assert(tctx, test_EnumPrinters_findname(tctx, p,
4527 PRINTER_ENUM_LOCAL, 1,
4528 printername,
4529 &found),
4530 "failed to enum printers");
4531 torture_assert(tctx, found, "failed to find newly added printer");
4532
4533 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx(p, tctx, &rex) :
4534 dcerpc_spoolss_AddPrinter(p, tctx, &r),
4535 "failed to add printer");
4536 result = ex ? rex.out.result : r.out.result;
4537 torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
4538 "unexpected result code");
4539
4540 return true;
4541 }
4542
4543 static bool test_AddPrinterEx(struct torture_context *tctx,
4544 struct dcerpc_pipe *p,
4545 struct policy_handle *handle_p,
4546 const char *printername,
4547 const char *drivername,
4548 const char *portname)
4549 {
4550 bool ret = true;
4551
4552 if (!torture_setting_bool(tctx, "samba3", false)) {
4553 if (!test_AddPrinter_wellknown(tctx, p, TORTURE_WELLKNOWN_PRINTER_EX, true)) {
4554 torture_comment(tctx, "failed to add printer to well known list\n");
4555 ret = false;
4556 }
4557 }
4558
4559 if (!test_AddPrinter_normal(tctx, p, handle_p,
4560 printername, drivername, portname,
4561 true)) {
4562 torture_comment(tctx, "failed to add printer to printer list\n");
4563 ret = false;
4564 }
4565
4566 return ret;
4567 }
4568
4569 static bool test_AddPrinter(struct torture_context *tctx,
4570 struct dcerpc_pipe *p,
4571 struct policy_handle *handle_p,
4572 const char *printername,
4573 const char *drivername,
4574 const char *portname)
4575 {
4576 bool ret = true;
4577
4578 if (!torture_setting_bool(tctx, "samba3", false)) {
4579 if (!test_AddPrinter_wellknown(tctx, p, TORTURE_WELLKNOWN_PRINTER, false)) {
4580 torture_comment(tctx, "failed to add printer to well known list\n");
4581 ret = false;
4582 }
4583 }
4584
4585 if (!test_AddPrinter_normal(tctx, p, handle_p,
4586 printername, drivername, portname,
4587 false)) {
4588 torture_comment(tctx, "failed to add printer to printer list\n");
4589 ret = false;
4590 }
4591
4592 return ret;
4593 }
4594
4595 static bool test_printer_info(struct torture_context *tctx,
4596 struct dcerpc_pipe *p,
4597 struct policy_handle *handle)
4598 {
4599 bool ret = true;
4600
4601 if (torture_setting_bool(tctx, "samba3", false)) {
4602 torture_skip(tctx, "skipping printer info cross tests against samba 3");
4603 }
4604
4605 if (!test_PrinterInfo(tctx, p, handle)) {
4606 ret = false;
4607 }
4608
4609 if (!test_SetPrinter_errors(tctx, p, handle)) {
4610 ret = false;
4611 }
4612
4613 return ret;
4614 }
4615
4616 static bool test_EnumPrinterKey(struct torture_context *tctx,
4617 struct dcerpc_pipe *p,
4618 struct policy_handle *handle,
4619 const char *key_name,
4620 const char ***array)
4621 {
4622 struct spoolss_EnumPrinterKey r;
4623 uint32_t needed = 0;
4624 union spoolss_KeyNames key_buffer;
4625 int32_t offered[] = { 0, 1, 2, 3, 4, 5, -1, -2, -3, -4, -5, 256, 512, 1024, 2048 };
4626 uint32_t _ndr_size;
4627 int i;
4628
4629 r.in.handle = handle;
4630 r.in.key_name = key_name;
4631 r.out.key_buffer = &key_buffer;
4632 r.out.needed = &needed;
4633 r.out._ndr_size = &_ndr_size;
4634
4635 for (i=0; i < ARRAY_SIZE(offered); i++) {
4636
4637 if (offered[i] < 0 && needed) {
4638 if (needed <= 4) {
4639 continue;
4640 }
4641 r.in.offered = needed + offered[i];
4642 } else {
4643 r.in.offered = offered[i];
4644 }
4645
4646 ZERO_STRUCT(key_buffer);
4647
4648 torture_comment(tctx, "Testing EnumPrinterKey(%s) with %d offered\n", r.in.key_name, r.in.offered);
4649
4650 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterKey(p, tctx, &r),
4651 "failed to call EnumPrinterKey");
4652 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
4653
4654 torture_assert(tctx, (_ndr_size == r.in.offered/2),
4655 talloc_asprintf(tctx, "EnumPrinterKey size mismatch, _ndr_size %d (expected %d)",
4656 _ndr_size, r.in.offered/2));
4657
4658 r.in.offered = needed;
4659 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterKey(p, tctx, &r),
4660 "failed to call EnumPrinterKey");
4661 }
4662
4663 if (offered[i] > 0) {
4664 torture_assert_werr_ok(tctx, r.out.result,
4665 "failed to call EnumPrinterKey");
4666 }
4667
4668 torture_assert(tctx, (_ndr_size == r.in.offered/2),
4669 talloc_asprintf(tctx, "EnumPrinterKey size mismatch, _ndr_size %d (expected %d)",
4670 _ndr_size, r.in.offered/2));
4671
4672 torture_assert(tctx, (*r.out.needed <= r.in.offered),
4673 talloc_asprintf(tctx, "EnumPrinterKey size mismatch: needed %d is not <= offered %d", *r.out.needed, r.in.offered));
4674
4675 torture_assert(tctx, (*r.out.needed <= _ndr_size * 2),
4676 talloc_asprintf(tctx, "EnumPrinterKey size mismatch: needed %d is not <= _ndr_size %d * 2", *r.out.needed, _ndr_size));
4677
4678 if (key_buffer.string_array) {
4679 uint32_t calc_needed = 0;
4680 int s;
4681 for (s=0; key_buffer.string_array[s]; s++) {
4682 calc_needed += strlen_m_term(key_buffer.string_array[s])*2;
4683 }
4684 if (!key_buffer.string_array[0]) {
4685 calc_needed += 2;
4686 }
4687 calc_needed += 2;
4688
4689 torture_assert_int_equal(tctx, *r.out.needed, calc_needed,
4690 "EnumPrinterKey unexpected size");
4691 }
4692 }
4693
4694 if (array) {
4695 *array = key_buffer.string_array;
4696 }
4697
4698 return true;
4699 }
4700
4701 bool test_printer_keys(struct torture_context *tctx,
4702 struct dcerpc_pipe *p,
4703 struct policy_handle *handle)
4704 {
4705 const char **key_array = NULL;
4706 int i;
4707
4708 torture_comment(tctx, "\nTesting Printer Keys\n");
4709
4710 torture_assert(tctx, test_EnumPrinterKey(tctx, p, handle, "", &key_array),
4711 "failed to call test_EnumPrinterKey");
4712
4713 for (i=0; key_array && key_array[i]; i++) {
4714 torture_assert(tctx, test_EnumPrinterKey(tctx, p, handle, key_array[i], NULL),
4715 "failed to call test_EnumPrinterKey");
4716 }
4717 for (i=0; key_array && key_array[i]; i++) {
4718 torture_assert(tctx, test_EnumPrinterDataEx(tctx, p, handle, key_array[i]),
4719 "failed to call test_EnumPrinterDataEx");
4720 }
4721
4722 return true;
4723 }
4724
4725 static bool test_one_printer(struct torture_context *tctx,
4726 struct dcerpc_pipe *p,
4727 struct policy_handle *handle,
4728 const char *name)
4729 {
4730 bool ret = true;
4731
4732 if (!test_printer_info(tctx, p, handle)) {
4733 ret = false;
4734 }
4735
4736 if (!test_PrinterInfo_SD(tctx, p, handle)) {
4737 ret = false;
4738 }
4739
4740 if (!test_PrinterInfo_DevMode(tctx, p, handle, name)) {
4741 ret = false;
4742 }
4743
4744 if (!test_ChangeID(tctx, p, handle)) {
4745 ret = false;
4746 }
4747
4748 if (!test_printer_keys(tctx, p, handle)) {
4749 ret = false;
4750 }
4751
4752 if (!test_SetPrinterDataEx_matrix(tctx, p, handle, name, NULL, NULL)) {
4753 ret = false;
4754 }
4755
4756 if (!test_PrinterData_winreg(tctx, p, handle, name)) {
4757 ret = false;
4758 }
4759
4760 return ret;
4761 }
4762
4763 static bool test_printer(struct torture_context *tctx,
4764 struct dcerpc_pipe *p)
4765 {
4766 bool ret = true;
4767 struct policy_handle handle[2];
4768 bool found = false;
4769 const char *drivername = "Microsoft XPS Document Writer";
4770 const char *portname = "LPT1:";
4771
4772 /* test printer created via AddPrinter */
4773
4774 if (!test_AddPrinter(tctx, p, &handle[0], TORTURE_PRINTER, drivername, portname)) {
4775 return false;
4776 }
4777
4778 if (!test_one_printer(tctx, p, &handle[0], TORTURE_PRINTER)) {
4779 ret = false;
4780 }
4781
4782 if (!test_DeletePrinter(tctx, p, &handle[0])) {
4783 ret = false;
4784 }
4785
4786 if (!test_EnumPrinters_findname(tctx, p, PRINTER_ENUM_LOCAL, 1,
4787 TORTURE_PRINTER, &found)) {
4788 ret = false;
4789 }
4790
4791 torture_assert(tctx, !found, "deleted printer still there");
4792
4793 /* test printer created via AddPrinterEx */
4794
4795 if (!test_AddPrinterEx(tctx, p, &handle[1], TORTURE_PRINTER_EX, drivername, portname)) {
4796 return false;
4797 }
4798
4799 if (!test_one_printer(tctx, p, &handle[1], TORTURE_PRINTER_EX)) {
4800 ret = false;
4801 }
4802
4803 if (!test_DeletePrinter(tctx, p, &handle[1])) {
4804 ret = false;
4805 }
4806
4807 if (!test_EnumPrinters_findname(tctx, p, PRINTER_ENUM_LOCAL, 1,
4808 TORTURE_PRINTER_EX, &found)) {
4809 ret = false;
4810 }
4811
4812 torture_assert(tctx, !found, "deleted printer still there");
4813
4814 return ret;
4815 }
4816
4817 static bool test_architecture_buffer(struct torture_context *tctx,
4818 struct dcerpc_pipe *p)
4819 {
4820 struct spoolss_OpenPrinterEx r;
4821 struct spoolss_UserLevel1 u1;
4822 struct policy_handle handle;
4823 uint32_t architectures[] = {
4824 PROCESSOR_ARCHITECTURE_INTEL,
4825 PROCESSOR_ARCHITECTURE_IA64,
4826 PROCESSOR_ARCHITECTURE_AMD64
4827 };
4828 uint32_t needed[3];
4829 int i;
4830
4831 for (i=0; i < ARRAY_SIZE(architectures); i++) {
4832
4833 torture_comment(tctx, "Testing OpenPrinterEx with architecture %d\n", architectures[i]);
4834
4835 u1.size = 0;
4836 u1.client = NULL;
4837 u1.user = NULL;
4838 u1.build = 0;
4839 u1.major = 3;
4840 u1.minor = 0;
4841 u1.processor = architectures[i];
4842
4843 r.in.printername = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
4844 r.in.datatype = NULL;
4845 r.in.devmode_ctr.devmode= NULL;
4846 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
4847 r.in.level = 1;
4848 r.in.userlevel.level1 = &u1;
4849 r.out.handle = &handle;
4850
4851 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_OpenPrinterEx(p, tctx, &r), "");
4852 torture_assert_werr_ok(tctx, r.out.result, "");
4853
4854 {
4855 struct spoolss_EnumPrinters e;
4856 uint32_t count;
4857 union spoolss_PrinterInfo *info;
4858
4859 e.in.flags = PRINTER_ENUM_LOCAL;
4860 e.in.server = NULL;
4861 e.in.level = 2;
4862 e.in.buffer = NULL;
4863 e.in.offered = 0;
4864 e.out.count = &count;
4865 e.out.info = &info;
4866 e.out.needed = &needed[i];
4867
4868 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters(p, tctx, &e), "");
4869 #if 0
4870 torture_comment(tctx, "needed was %d\n", needed[i]);
4871 #endif
4872 }
4873
4874 torture_assert(tctx, test_ClosePrinter(tctx, p, &handle), "");
4875 }
4876
4877 for (i=1; i < ARRAY_SIZE(architectures); i++) {
4878 if (needed[i-1] != needed[i]) {
4879 torture_fail(tctx,
4880 talloc_asprintf(tctx, "needed size %d for architecture %d != needed size %d for architecture %d\n",
4881 needed[i-1], architectures[i-1], needed[i], architectures[i]));
4882 }
4883 }
4884
4885 return true;
4886 }
4887
4888 bool torture_rpc_spoolss(struct torture_context *torture)
4889 {
4890 NTSTATUS status;
4891 struct dcerpc_pipe *p;
4892 bool ret = true;
4893 struct test_spoolss_context *ctx;
4894 const char *environment = SPOOLSS_ARCHITECTURE_NT_X86;
4895
4896 status = torture_rpc_connection(torture, &p, &ndr_table_spoolss);
4897 if (!NT_STATUS_IS_OK(status)) {
4898 return false;
4899 }
4900
4901 ctx = talloc_zero(torture, struct test_spoolss_context);
4902
4903 ret &= test_OpenPrinter_server(torture, p, &ctx->server_handle);
4904 ret &= test_GetPrinterData_list(torture, p, &ctx->server_handle);
4905 ret &= test_EnumForms(torture, p, &ctx->server_handle, true);
4906 ret &= test_AddForm(torture, p, &ctx->server_handle, true);
4907 ret &= test_EnumPorts(torture, p, ctx);
4908 ret &= test_GetPrinterDriverDirectory(torture, p, ctx, environment);
4909 ret &= test_GetPrintProcessorDirectory(torture, p, ctx, environment);
4910 ret &= test_EnumPrinterDrivers(torture, p, ctx, environment);
4911 ret &= test_EnumPrinterDrivers(torture, p, ctx, SPOOLSS_ARCHITECTURE_ALL);
4912 ret &= test_EnumMonitors(torture, p, ctx);
4913 ret &= test_EnumPrintProcessors(torture, p, ctx, environment);
4914 ret &= test_EnumPrintProcDataTypes(torture, p, ctx);
4915 ret &= test_EnumPrinters(torture, p, ctx);
4916 ret &= test_OpenPrinter_badname(torture, p, "__INVALID_PRINTER__");
4917 ret &= test_OpenPrinter_badname(torture, p, "\\\\__INVALID_HOST__");
4918 ret &= test_OpenPrinter_badname(torture, p, "");
4919 ret &= test_OpenPrinter_badname(torture, p, "\\\\\\");
4920 ret &= test_OpenPrinter_badname(torture, p, "\\\\\\__INVALID_PRINTER__");
4921 ret &= test_OpenPrinter_badname(torture, p, talloc_asprintf(torture, "\\\\%s\\", dcerpc_server_name(p)));
4922 ret &= test_OpenPrinter_badname(torture, p,
4923 talloc_asprintf(torture, "\\\\%s\\__INVALID_PRINTER__", dcerpc_server_name(p)));
4924
4925
4926 ret &= test_AddPort(torture, p);
4927 ret &= test_EnumPorts_old(torture, p);
4928 ret &= test_EnumPrinters_old(torture, p, environment);
4929 ret &= test_EnumPrinterDrivers_old(torture, p, environment);
4930 ret &= test_architecture_buffer(torture, p);
4931
4932 return ret;
4933 }
4934
4935 struct torture_suite *torture_rpc_spoolss_printer(TALLOC_CTX *mem_ctx)
4936 {
4937 struct torture_suite *suite = torture_suite_create(mem_ctx, "SPOOLSS-PRINTER");
4938
4939 struct torture_rpc_tcase *tcase = torture_suite_add_rpc_iface_tcase(suite,
4940 "printer", &ndr_table_spoolss);
4941
4942 torture_rpc_tcase_add_test(tcase, "printer", test_printer);
4943
4944 return suite;
4945 }