?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4-smbtorture: skip driverName and printerName DsSpooler tests for now.
[Samba/ekacnet.git] / source4 / torture / rpc / spoolss.c
blob07b799416f1b68f6174ba3b7e8c85efb1e2ca3b7
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/torture_rpc.h"
33 #include "param/param.h"
34 #include "lib/registry/registry.h"
35 #include "libcli/libcli.h"
36 #include "libcli/raw/raw_proto.h"
37 #include "libcli/resolve/resolve.h"
38 #include "lib/cmdline/popt_common.h"
39 #include "system/filesys.h"
40
41 #define TORTURE_WELLKNOWN_PRINTER "torture_wkn_printer"
42 #define TORTURE_PRINTER "torture_printer"
43 #define TORTURE_WELLKNOWN_PRINTER_EX "torture_wkn_printer_ex"
44 #define TORTURE_PRINTER_EX "torture_printer_ex"
45 #define TORTURE_DRIVER "torture_driver"
46 #define TORTURE_DRIVER_EX "torture_driver_ex"
47
48 #define TOP_LEVEL_PRINT_KEY "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Print"
49 #define TOP_LEVEL_PRINT_PRINTERS_KEY TOP_LEVEL_PRINT_KEY "\\Printers"
50 #define TOP_LEVEL_CONTROL_KEY "SYSTEM\\CurrentControlSet\\Control\\Print"
51 #define TOP_LEVEL_CONTROL_FORMS_KEY TOP_LEVEL_CONTROL_KEY "\\Forms"
52 #define TOP_LEVEL_CONTROL_PRINTERS_KEY TOP_LEVEL_CONTROL_KEY "\\Printers"
53 #define TOP_LEVEL_CONTROL_ENVIRONMENTS_KEY TOP_LEVEL_CONTROL_KEY "\\Environments"
54
55 struct test_spoolss_context {
56 /* print server handle */
57 struct policy_handle server_handle;
58
59 /* for EnumPorts */
60 uint32_t port_count[3];
61 union spoolss_PortInfo *ports[3];
62
63 /* for EnumPrinterDrivers */
64 uint32_t driver_count[8];
65 union spoolss_DriverInfo *drivers[8];
66
67 /* for EnumMonitors */
68 uint32_t monitor_count[3];
69 union spoolss_MonitorInfo *monitors[3];
70
71 /* for EnumPrintProcessors */
72 uint32_t print_processor_count[2];
73 union spoolss_PrintProcessorInfo *print_processors[2];
74
75 /* for EnumPrinters */
76 uint32_t printer_count[6];
77 union spoolss_PrinterInfo *printers[6];
78 };
79
80 struct torture_driver_context {
81 struct {
82 const char *driver_directory;
83 const char *environment;
84 } local;
85 struct {
86 const char *driver_directory;
87 const char *environment;
88 } remote;
89 struct spoolss_AddDriverInfo8 info8;
90 bool ex;
91 };
92
93 struct torture_printer_context {
94 struct spoolss_SetPrinterInfo2 info2;
95 struct torture_driver_context driver;
96 bool ex;
97 bool wellknown;
98 bool added_driver;
99 bool have_driver;
100 struct spoolss_DeviceMode *devmode;
101 };
102
103 static bool upload_printer_driver(struct torture_context *tctx,
104 const char *server_name,
105 struct torture_driver_context *d);
106 static bool remove_printer_driver(struct torture_context *tctx,
107 const char *server_name,
108 struct torture_driver_context *d);
109 static bool fillup_printserver_info(struct torture_context *tctx,
110 struct dcerpc_pipe *p,
111 struct torture_driver_context *d);
112 static bool test_AddPrinterDriver_args_level_3(struct torture_context *tctx,
113 struct dcerpc_binding_handle *b,
114 const char *server_name,
115 struct spoolss_AddDriverInfo8 *r,
116 uint32_t flags,
117 bool ex);
118
119 #define COMPARE_STRING(tctx, c,r,e) \
120 torture_assert_str_equal(tctx, c.e, r.e, "invalid value")
121
122 /* not every compiler supports __typeof__() */
123 #if (__GNUC__ >= 3)
124 #define _CHECK_FIELD_SIZE(c,r,e,type) do {\
125 if (sizeof(__typeof__(c.e)) != sizeof(type)) { \
126 torture_fail(tctx, #c "." #e "field is not " #type "\n"); \
127 }\
128 if (sizeof(__typeof__(r.e)) != sizeof(type)) { \
129 torture_fail(tctx, #r "." #e "field is not " #type "\n"); \
130 }\
131 } while(0)
132 #else
133 #define _CHECK_FIELD_SIZE(c,r,e,type) do {} while(0)
134 #endif
135
136 #define COMPARE_UINT32(tctx, c, r, e) do {\
137 _CHECK_FIELD_SIZE(c, r, e, uint32_t); \
138 torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
139 } while(0)
140
141 #define COMPARE_UINT64(tctx, c, r, e) do {\
142 _CHECK_FIELD_SIZE(c, r, e, uint64_t); \
143 torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
144 } while(0)
145
146
147 #define COMPARE_NTTIME(tctx, c, r, e) do {\
148 _CHECK_FIELD_SIZE(c, r, e, NTTIME); \
149 torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
150 } while(0)
151
152 #define COMPARE_STRING_ARRAY(tctx, c,r,e) do {\
153 int __i; \
154 if (!c.e && !r.e) { \
155 break; \
156 } \
157 if (c.e && !r.e) { \
158 torture_fail(tctx, #r "." #e " field is NULL and " #c "." #e " is not\n"); \
159 } \
160 if (!c.e && r.e) { \
161 torture_fail(tctx, #c "." #e " field is NULL and " #r "." #e " is not\n"); \
162 } \
163 for (__i=0;c.e[__i] != NULL; __i++) { \
164 torture_assert_str_equal(tctx, c.e[__i], r.e[__i], "invalid value"); \
165 } \
166 } while(0)
167
168 #define CHECK_ALIGN(size, n) do {\
169 if (size % n) {\
170 torture_warning(tctx, "%d is *NOT* %d byte aligned, should be %d",\
171 size, n, size + n - (size % n));\
172 }\
173 } while(0)
174
175 #define DO_ROUND(size, n) (((size)+((n)-1)) & ~((n)-1))
176
177 #define CHECK_NEEDED_SIZE_ENUM_LEVEL(fn, info, level, count, needed, align) do { \
178 if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
179 uint32_t size = ndr_size_##fn##_info(tctx, level, count, info);\
180 uint32_t round_size = DO_ROUND(size, align);\
181 if (round_size != needed) {\
182 torture_warning(tctx, __location__": "#fn" level %d (count: %d) got unexpected needed size: %d, we calculated: %d", level, count, needed, round_size);\
183 CHECK_ALIGN(size, align);\
184 }\
185 }\
186 } while(0)
187
188 #define CHECK_NEEDED_SIZE_ENUM(fn, info, count, needed, align) do { \
189 if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
190 uint32_t size = ndr_size_##fn##_info(tctx, count, info);\
191 uint32_t round_size = DO_ROUND(size, align);\
192 if (round_size != needed) {\
193 torture_warning(tctx, __location__": "#fn" (count: %d) got unexpected needed size: %d, we calculated: %d", count, needed, round_size);\
194 CHECK_ALIGN(size, align);\
195 }\
196 }\
197 } while(0)
198
199 #define CHECK_NEEDED_SIZE_LEVEL(fn, info, level, needed, align) do { \
200 if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
201 uint32_t size = ndr_size_##fn(info, level, 0);\
202 uint32_t round_size = DO_ROUND(size, align);\
203 if (round_size != needed) {\
204 torture_warning(tctx, __location__": "#fn" level %d got unexpected needed size: %d, we calculated: %d", level, needed, round_size);\
205 CHECK_ALIGN(size, align);\
206 }\
207 }\
208 } while(0)
209
210 static bool PrinterInfo_to_SetPrinterInfo(struct torture_context *tctx,
211 const union spoolss_PrinterInfo *i,
212 uint32_t level,
213 union spoolss_SetPrinterInfo *s)
214 {
215 switch (level) {
216 case 0:
217 s->info0 = talloc(tctx, struct spoolss_SetPrinterInfo0);
218 break;
219 case 2:
220 s->info2 = talloc(tctx, struct spoolss_SetPrinterInfo2);
221 s->info2->servername = i->info2.servername;
222 s->info2->printername = i->info2.printername;
223 s->info2->sharename = i->info2.sharename;
224 s->info2->portname = i->info2.portname;
225 s->info2->drivername = i->info2.drivername;
226 s->info2->comment = i->info2.comment;
227 s->info2->location = i->info2.location;
228 s->info2->devmode_ptr = 0;
229 s->info2->sepfile = i->info2.sepfile;
230 s->info2->printprocessor = i->info2.printprocessor;
231 s->info2->datatype = i->info2.datatype;
232 s->info2->parameters = i->info2.parameters;
233 s->info2->secdesc_ptr = 0;
234 s->info2->attributes = i->info2.attributes;
235 s->info2->priority = i->info2.priority;
236 s->info2->defaultpriority = i->info2.defaultpriority;
237 s->info2->starttime = i->info2.starttime;
238 s->info2->untiltime = i->info2.untiltime;
239 s->info2->status = i->info2.status;
240 s->info2->cjobs = i->info2.cjobs;
241 s->info2->averageppm = i->info2.averageppm;
242 break;
243 case 3:
244 case 4:
245 case 5:
246 case 6:
247 case 7:
248 case 8:
249 case 9:
250 default:
251 return false;
252 }
253
254 return true;
255 }
256
257 static bool test_OpenPrinter_server(struct torture_context *tctx,
258 struct dcerpc_pipe *p,
259 struct policy_handle *server_handle)
260 {
261 NTSTATUS status;
262 struct spoolss_OpenPrinter op;
263 struct dcerpc_binding_handle *b = p->binding_handle;
264
265 op.in.printername = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
266 op.in.datatype = NULL;
267 op.in.devmode_ctr.devmode= NULL;
268 op.in.access_mask = 0;
269 op.out.handle = server_handle;
270
271 torture_comment(tctx, "Testing OpenPrinter(%s)\n", op.in.printername);
272
273 status = dcerpc_spoolss_OpenPrinter_r(b, tctx, &op);
274 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_OpenPrinter failed");
275 torture_assert_werr_ok(tctx, op.out.result, "dcerpc_spoolss_OpenPrinter failed");
276
277 return true;
278 }
279
280 static bool test_EnumPorts(struct torture_context *tctx,
281 struct dcerpc_binding_handle *b,
282 struct test_spoolss_context *ctx)
283 {
284 NTSTATUS status;
285 struct spoolss_EnumPorts r;
286 uint16_t levels[] = { 1, 2 };
287 int i, j;
288
289 for (i=0;i<ARRAY_SIZE(levels);i++) {
290 int level = levels[i];
291 DATA_BLOB blob;
292 uint32_t needed;
293 uint32_t count;
294 union spoolss_PortInfo *info;
295
296 r.in.servername = "";
297 r.in.level = level;
298 r.in.buffer = NULL;
299 r.in.offered = 0;
300 r.out.needed = &needed;
301 r.out.count = &count;
302 r.out.info = &info;
303
304 torture_comment(tctx, "Testing EnumPorts level %u\n", r.in.level);
305
306 status = dcerpc_spoolss_EnumPorts_r(b, ctx, &r);
307 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
308 if (W_ERROR_IS_OK(r.out.result)) {
309 /* TODO: do some more checks here */
310 continue;
311 }
312 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
313 "EnumPorts unexpected return code");
314
315 blob = data_blob_talloc_zero(ctx, needed);
316 r.in.buffer = &blob;
317 r.in.offered = needed;
318
319 status = dcerpc_spoolss_EnumPorts_r(b, ctx, &r);
320 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
321
322 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
323
324 torture_assert(tctx, info, "EnumPorts returned no info");
325
326 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPorts, info, r.in.level, count, needed, 4);
327
328 ctx->port_count[level] = count;
329 ctx->ports[level] = info;
330 }
331
332 for (i=1;i<ARRAY_SIZE(levels);i++) {
333 int level = levels[i];
334 int old_level = levels[i-1];
335 torture_assert_int_equal(tctx, ctx->port_count[level], ctx->port_count[old_level],
336 "EnumPorts invalid value");
337 }
338 /* if the array sizes are not the same we would maybe segfault in the following code */
339
340 for (i=0;i<ARRAY_SIZE(levels);i++) {
341 int level = levels[i];
342 for (j=0;j<ctx->port_count[level];j++) {
343 union spoolss_PortInfo *cur = &ctx->ports[level][j];
344 union spoolss_PortInfo *ref = &ctx->ports[2][j];
345 switch (level) {
346 case 1:
347 COMPARE_STRING(tctx, cur->info1, ref->info2, port_name);
348 break;
349 case 2:
350 /* level 2 is our reference, and it makes no sense to compare it to itself */
351 break;
352 }
353 }
354 }
355
356 return true;
357 }
358
359 static bool test_GetPrintProcessorDirectory(struct torture_context *tctx,
360 struct dcerpc_pipe *p,
361 const char *environment)
362 {
363 NTSTATUS status;
364 struct dcerpc_binding_handle *b = p->binding_handle;
365 struct spoolss_GetPrintProcessorDirectory r;
366 struct {
367 uint16_t level;
368 const char *server;
369 } levels[] = {{
370 .level = 1,
371 .server = NULL
372 },{
373 .level = 1,
374 .server = ""
375 },{
376 .level = 78,
377 .server = ""
378 },{
379 .level = 1,
380 .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
381 },{
382 .level = 1024,
383 .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
384 }
385 };
386 int i;
387 uint32_t needed;
388
389 for (i=0;i<ARRAY_SIZE(levels);i++) {
390 int level = levels[i].level;
391 DATA_BLOB blob;
392
393 r.in.server = levels[i].server;
394 r.in.environment = environment;
395 r.in.level = level;
396 r.in.buffer = NULL;
397 r.in.offered = 0;
398 r.out.needed = &needed;
399
400 torture_comment(tctx, "Testing GetPrintProcessorDirectory level %u\n", r.in.level);
401
402 status = dcerpc_spoolss_GetPrintProcessorDirectory_r(b, tctx, &r);
403 torture_assert_ntstatus_ok(tctx, status,
404 "dcerpc_spoolss_GetPrintProcessorDirectory failed");
405 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
406 "GetPrintProcessorDirectory unexpected return code");
407
408 blob = data_blob_talloc_zero(tctx, needed);
409 r.in.buffer = &blob;
410 r.in.offered = needed;
411
412 status = dcerpc_spoolss_GetPrintProcessorDirectory_r(b, tctx, &r);
413 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrintProcessorDirectory failed");
414
415 torture_assert_werr_ok(tctx, r.out.result, "GetPrintProcessorDirectory failed");
416
417 CHECK_NEEDED_SIZE_LEVEL(spoolss_PrintProcessorDirectoryInfo, r.out.info, r.in.level, needed, 2);
418 }
419
420 return true;
421 }
422
423
424 static bool test_GetPrinterDriverDirectory(struct torture_context *tctx,
425 struct dcerpc_pipe *p,
426 const char *environment)
427 {
428 NTSTATUS status;
429 struct dcerpc_binding_handle *b = p->binding_handle;
430 struct spoolss_GetPrinterDriverDirectory r;
431 struct {
432 uint16_t level;
433 const char *server;
434 } levels[] = {{
435 .level = 1,
436 .server = NULL
437 },{
438 .level = 1,
439 .server = ""
440 },{
441 .level = 78,
442 .server = ""
443 },{
444 .level = 1,
445 .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
446 },{
447 .level = 1024,
448 .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
449 }
450 };
451 int i;
452 uint32_t needed;
453
454 for (i=0;i<ARRAY_SIZE(levels);i++) {
455 int level = levels[i].level;
456 DATA_BLOB blob;
457
458 r.in.server = levels[i].server;
459 r.in.environment = environment;
460 r.in.level = level;
461 r.in.buffer = NULL;
462 r.in.offered = 0;
463 r.out.needed = &needed;
464
465 torture_comment(tctx, "Testing GetPrinterDriverDirectory level %u\n", r.in.level);
466
467 status = dcerpc_spoolss_GetPrinterDriverDirectory_r(b, tctx, &r);
468 torture_assert_ntstatus_ok(tctx, status,
469 "dcerpc_spoolss_GetPrinterDriverDirectory failed");
470 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
471 "GetPrinterDriverDirectory unexpected return code");
472
473 blob = data_blob_talloc_zero(tctx, needed);
474 r.in.buffer = &blob;
475 r.in.offered = needed;
476
477 status = dcerpc_spoolss_GetPrinterDriverDirectory_r(b, tctx, &r);
478 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrinterDriverDirectory failed");
479
480 torture_assert_werr_ok(tctx, r.out.result, "GetPrinterDriverDirectory failed");
481
482 CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverDirectoryInfo, r.out.info, r.in.level, needed, 2);
483 }
484
485 return true;
486 }
487
488 static bool test_EnumPrinterDrivers_args(struct torture_context *tctx,
489 struct dcerpc_binding_handle *b,
490 const char *server_name,
491 const char *environment,
492 uint32_t level,
493 uint32_t *count_p,
494 union spoolss_DriverInfo **info_p)
495 {
496 struct spoolss_EnumPrinterDrivers r;
497 uint32_t needed;
498 uint32_t count;
499 union spoolss_DriverInfo *info;
500
501 r.in.server = server_name;
502 r.in.environment = environment;
503 r.in.level = level;
504 r.in.buffer = NULL;
505 r.in.offered = 0;
506 r.out.needed = &needed;
507 r.out.count = &count;
508 r.out.info = &info;
509
510 torture_comment(tctx, "Testing EnumPrinterDrivers(%s) level %u\n",
511 r.in.environment, r.in.level);
512
513 torture_assert_ntstatus_ok(tctx,
514 dcerpc_spoolss_EnumPrinterDrivers_r(b, tctx, &r),
515 "EnumPrinterDrivers failed");
516 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
517 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
518 r.in.buffer = &blob;
519 r.in.offered = needed;
520
521 torture_assert_ntstatus_ok(tctx,
522 dcerpc_spoolss_EnumPrinterDrivers_r(b, tctx, &r),
523 "EnumPrinterDrivers failed");
524 }
525
526 torture_assert_werr_ok(tctx, r.out.result,
527 "EnumPrinterDrivers failed");
528
529 if (count_p) {
530 *count_p = count;
531 }
532 if (info_p) {
533 *info_p = info;
534 }
535
536 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinterDrivers, info, r.in.level, count, needed, 4);
537
538 return true;
539
540 }
541
542 static bool test_EnumPrinterDrivers_findone(struct torture_context *tctx,
543 struct dcerpc_binding_handle *b,
544 const char *server_name,
545 const char *environment,
546 uint32_t level,
547 const char *driver_name)
548 {
549 uint32_t count;
550 union spoolss_DriverInfo *info;
551 int i;
552
553 torture_assert(tctx,
554 test_EnumPrinterDrivers_args(tctx, b, server_name, environment, level, &count, &info),
555 "failed to enumerate printer drivers");
556
557 for (i=0; i < count; i++) {
558 const char *driver_name_ret;
559 switch (level) {
560 case 1:
561 driver_name_ret = info[i].info1.driver_name;
562 break;
563 case 2:
564 driver_name_ret = info[i].info2.driver_name;
565 break;
566 case 3:
567 driver_name_ret = info[i].info3.driver_name;
568 break;
569 case 4:
570 driver_name_ret = info[i].info4.driver_name;
571 break;
572 case 5:
573 driver_name_ret = info[i].info5.driver_name;
574 break;
575 case 6:
576 driver_name_ret = info[i].info6.driver_name;
577 break;
578 case 7:
579 driver_name_ret = info[i].info7.driver_name;
580 break;
581 case 8:
582 driver_name_ret = info[i].info8.driver_name;
583 break;
584 default:
585 break;
586 }
587 if (strequal(driver_name, driver_name_ret)) {
588 return true;
589 }
590 }
591
592 return false;
593 }
594
595 static bool test_EnumPrinterDrivers(struct torture_context *tctx,
596 struct dcerpc_pipe *p,
597 struct test_spoolss_context *ctx,
598 const char *architecture)
599 {
600 struct dcerpc_binding_handle *b = p->binding_handle;
601 uint16_t levels[] = { 1, 2, 3, 4, 5, 6, 8 };
602 int i, j;
603
604 /* FIXME: gd, come back and fix "" as server, and handle
605 * priority of returned error codes in torture test and samba 3
606 * server */
607 const char *server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
608
609 for (i=0;i<ARRAY_SIZE(levels);i++) {
610 int level = levels[i];
611 uint32_t count;
612 union spoolss_DriverInfo *info;
613
614 torture_assert(tctx,
615 test_EnumPrinterDrivers_args(tctx, b, server_name, architecture, level, &count, &info),
616 "failed to enumerate drivers");
617
618 ctx->driver_count[level] = count;
619 ctx->drivers[level] = info;
620 }
621
622 for (i=1;i<ARRAY_SIZE(levels);i++) {
623 int level = levels[i];
624 int old_level = levels[i-1];
625
626 torture_assert_int_equal(tctx, ctx->driver_count[level], ctx->driver_count[old_level],
627 "EnumPrinterDrivers invalid value");
628 }
629
630 for (i=0;i<ARRAY_SIZE(levels);i++) {
631 int level = levels[i];
632
633 for (j=0;j<ctx->driver_count[level];j++) {
634 union spoolss_DriverInfo *cur = &ctx->drivers[level][j];
635 union spoolss_DriverInfo *ref = &ctx->drivers[8][j];
636
637 switch (level) {
638 case 1:
639 COMPARE_STRING(tctx, cur->info1, ref->info8, driver_name);
640 break;
641 case 2:
642 COMPARE_UINT32(tctx, cur->info2, ref->info8, version);
643 COMPARE_STRING(tctx, cur->info2, ref->info8, driver_name);
644 COMPARE_STRING(tctx, cur->info2, ref->info8, architecture);
645 COMPARE_STRING(tctx, cur->info2, ref->info8, driver_path);
646 COMPARE_STRING(tctx, cur->info2, ref->info8, data_file);
647 COMPARE_STRING(tctx, cur->info2, ref->info8, config_file);
648 break;
649 case 3:
650 COMPARE_UINT32(tctx, cur->info3, ref->info8, version);
651 COMPARE_STRING(tctx, cur->info3, ref->info8, driver_name);
652 COMPARE_STRING(tctx, cur->info3, ref->info8, architecture);
653 COMPARE_STRING(tctx, cur->info3, ref->info8, driver_path);
654 COMPARE_STRING(tctx, cur->info3, ref->info8, data_file);
655 COMPARE_STRING(tctx, cur->info3, ref->info8, config_file);
656 COMPARE_STRING(tctx, cur->info3, ref->info8, help_file);
657 COMPARE_STRING_ARRAY(tctx, cur->info3, ref->info8, dependent_files);
658 COMPARE_STRING(tctx, cur->info3, ref->info8, monitor_name);
659 COMPARE_STRING(tctx, cur->info3, ref->info8, default_datatype);
660 break;
661 case 4:
662 COMPARE_UINT32(tctx, cur->info4, ref->info8, version);
663 COMPARE_STRING(tctx, cur->info4, ref->info8, driver_name);
664 COMPARE_STRING(tctx, cur->info4, ref->info8, architecture);
665 COMPARE_STRING(tctx, cur->info4, ref->info8, driver_path);
666 COMPARE_STRING(tctx, cur->info4, ref->info8, data_file);
667 COMPARE_STRING(tctx, cur->info4, ref->info8, config_file);
668 COMPARE_STRING(tctx, cur->info4, ref->info8, help_file);
669 COMPARE_STRING_ARRAY(tctx, cur->info4, ref->info8, dependent_files);
670 COMPARE_STRING(tctx, cur->info4, ref->info8, monitor_name);
671 COMPARE_STRING(tctx, cur->info4, ref->info8, default_datatype);
672 COMPARE_STRING_ARRAY(tctx, cur->info4, ref->info8, previous_names);
673 break;
674 case 5:
675 COMPARE_UINT32(tctx, cur->info5, ref->info8, version);
676 COMPARE_STRING(tctx, cur->info5, ref->info8, driver_name);
677 COMPARE_STRING(tctx, cur->info5, ref->info8, architecture);
678 COMPARE_STRING(tctx, cur->info5, ref->info8, driver_path);
679 COMPARE_STRING(tctx, cur->info5, ref->info8, data_file);
680 COMPARE_STRING(tctx, cur->info5, ref->info8, config_file);
681 /*COMPARE_UINT32(tctx, cur->info5, ref->info8, driver_attributes);*/
682 /*COMPARE_UINT32(tctx, cur->info5, ref->info8, config_version);*/
683 /*TODO: ! COMPARE_UINT32(tctx, cur->info5, ref->info8, driver_version); */
684 break;
685 case 6:
686 COMPARE_UINT32(tctx, cur->info6, ref->info8, version);
687 COMPARE_STRING(tctx, cur->info6, ref->info8, driver_name);
688 COMPARE_STRING(tctx, cur->info6, ref->info8, architecture);
689 COMPARE_STRING(tctx, cur->info6, ref->info8, driver_path);
690 COMPARE_STRING(tctx, cur->info6, ref->info8, data_file);
691 COMPARE_STRING(tctx, cur->info6, ref->info8, config_file);
692 COMPARE_STRING(tctx, cur->info6, ref->info8, help_file);
693 COMPARE_STRING_ARRAY(tctx, cur->info6, ref->info8, dependent_files);
694 COMPARE_STRING(tctx, cur->info6, ref->info8, monitor_name);
695 COMPARE_STRING(tctx, cur->info6, ref->info8, default_datatype);
696 COMPARE_STRING_ARRAY(tctx, cur->info6, ref->info8, previous_names);
697 COMPARE_NTTIME(tctx, cur->info6, ref->info8, driver_date);
698 COMPARE_UINT64(tctx, cur->info6, ref->info8, driver_version);
699 COMPARE_STRING(tctx, cur->info6, ref->info8, manufacturer_name);
700 COMPARE_STRING(tctx, cur->info6, ref->info8, manufacturer_url);
701 COMPARE_STRING(tctx, cur->info6, ref->info8, hardware_id);
702 COMPARE_STRING(tctx, cur->info6, ref->info8, provider);
703 break;
704 case 8:
705 /* level 8 is our reference, and it makes no sense to compare it to itself */
706 break;
707 }
708 }
709 }
710
711 return true;
712 }
713
714 static bool test_EnumMonitors(struct torture_context *tctx,
715 struct dcerpc_binding_handle *b,
716 struct test_spoolss_context *ctx)
717 {
718 NTSTATUS status;
719 struct spoolss_EnumMonitors r;
720 uint16_t levels[] = { 1, 2 };
721 int i, j;
722
723 for (i=0;i<ARRAY_SIZE(levels);i++) {
724 int level = levels[i];
725 DATA_BLOB blob;
726 uint32_t needed;
727 uint32_t count;
728 union spoolss_MonitorInfo *info;
729
730 r.in.servername = "";
731 r.in.level = level;
732 r.in.buffer = NULL;
733 r.in.offered = 0;
734 r.out.needed = &needed;
735 r.out.count = &count;
736 r.out.info = &info;
737
738 torture_comment(tctx, "Testing EnumMonitors level %u\n", r.in.level);
739
740 status = dcerpc_spoolss_EnumMonitors_r(b, ctx, &r);
741 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
742 if (W_ERROR_IS_OK(r.out.result)) {
743 /* TODO: do some more checks here */
744 continue;
745 }
746 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
747 "EnumMonitors failed");
748
749 blob = data_blob_talloc_zero(ctx, needed);
750 r.in.buffer = &blob;
751 r.in.offered = needed;
752
753 status = dcerpc_spoolss_EnumMonitors_r(b, ctx, &r);
754 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
755
756 torture_assert_werr_ok(tctx, r.out.result, "EnumMonitors failed");
757
758 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumMonitors, info, r.in.level, count, needed, 4);
759
760 ctx->monitor_count[level] = count;
761 ctx->monitors[level] = info;
762 }
763
764 for (i=1;i<ARRAY_SIZE(levels);i++) {
765 int level = levels[i];
766 int old_level = levels[i-1];
767 torture_assert_int_equal(tctx, ctx->monitor_count[level], ctx->monitor_count[old_level],
768 "EnumMonitors invalid value");
769 }
770
771 for (i=0;i<ARRAY_SIZE(levels);i++) {
772 int level = levels[i];
773 for (j=0;j<ctx->monitor_count[level];j++) {
774 union spoolss_MonitorInfo *cur = &ctx->monitors[level][j];
775 union spoolss_MonitorInfo *ref = &ctx->monitors[2][j];
776 switch (level) {
777 case 1:
778 COMPARE_STRING(tctx, cur->info1, ref->info2, monitor_name);
779 break;
780 case 2:
781 /* level 2 is our reference, and it makes no sense to compare it to itself */
782 break;
783 }
784 }
785 }
786
787 return true;
788 }
789
790 static bool test_EnumPrintProcessors(struct torture_context *tctx,
791 struct dcerpc_binding_handle *b,
792 struct test_spoolss_context *ctx,
793 const char *environment)
794 {
795 NTSTATUS status;
796 struct spoolss_EnumPrintProcessors r;
797 uint16_t levels[] = { 1 };
798 int i, j;
799
800 for (i=0;i<ARRAY_SIZE(levels);i++) {
801 int level = levels[i];
802 DATA_BLOB blob;
803 uint32_t needed;
804 uint32_t count;
805 union spoolss_PrintProcessorInfo *info;
806
807 r.in.servername = "";
808 r.in.environment = environment;
809 r.in.level = level;
810 r.in.buffer = NULL;
811 r.in.offered = 0;
812 r.out.needed = &needed;
813 r.out.count = &count;
814 r.out.info = &info;
815
816 torture_comment(tctx, "Testing EnumPrintProcessors level %u\n", r.in.level);
817
818 status = dcerpc_spoolss_EnumPrintProcessors_r(b, ctx, &r);
819 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcessors failed");
820 if (W_ERROR_IS_OK(r.out.result)) {
821 /* TODO: do some more checks here */
822 continue;
823 }
824 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
825 "EnumPrintProcessors unexpected return code");
826
827 blob = data_blob_talloc_zero(ctx, needed);
828 r.in.buffer = &blob;
829 r.in.offered = needed;
830
831 status = dcerpc_spoolss_EnumPrintProcessors_r(b, ctx, &r);
832 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcessors failed");
833
834 torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcessors failed");
835
836 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcessors, info, r.in.level, count, needed, 4);
837
838 ctx->print_processor_count[level] = count;
839 ctx->print_processors[level] = info;
840 }
841
842 for (i=1;i<ARRAY_SIZE(levels);i++) {
843 int level = levels[i];
844 int old_level = levels[i-1];
845 torture_assert_int_equal(tctx, ctx->print_processor_count[level], ctx->print_processor_count[old_level],
846 "EnumPrintProcessors failed");
847 }
848
849 for (i=0;i<ARRAY_SIZE(levels);i++) {
850 int level = levels[i];
851 for (j=0;j<ctx->print_processor_count[level];j++) {
852 #if 0
853 union spoolss_PrintProcessorInfo *cur = &ctx->print_processors[level][j];
854 union spoolss_PrintProcessorInfo *ref = &ctx->print_processors[1][j];
855 #endif
856 switch (level) {
857 case 1:
858 /* level 1 is our reference, and it makes no sense to compare it to itself */
859 break;
860 }
861 }
862 }
863
864 return true;
865 }
866
867 static bool test_EnumPrintProcDataTypes(struct torture_context *tctx,
868 struct dcerpc_binding_handle *b)
869 {
870 NTSTATUS status;
871 struct spoolss_EnumPrintProcDataTypes r;
872 uint16_t levels[] = { 1 };
873 int i;
874
875 for (i=0;i<ARRAY_SIZE(levels);i++) {
876 int level = levels[i];
877 DATA_BLOB blob;
878 uint32_t needed;
879 uint32_t count;
880 union spoolss_PrintProcDataTypesInfo *info;
881
882 r.in.servername = "";
883 r.in.print_processor_name = "winprint";
884 r.in.level = level;
885 r.in.buffer = NULL;
886 r.in.offered = 0;
887 r.out.needed = &needed;
888 r.out.count = &count;
889 r.out.info = &info;
890
891 torture_comment(tctx, "Testing EnumPrintProcDataTypes level %u\n", r.in.level);
892
893 status = dcerpc_spoolss_EnumPrintProcDataTypes_r(b, tctx, &r);
894 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcDataType failed");
895 if (W_ERROR_IS_OK(r.out.result)) {
896 /* TODO: do some more checks here */
897 continue;
898 }
899 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
900 "EnumPrintProcDataTypes unexpected return code");
901
902 blob = data_blob_talloc_zero(tctx, needed);
903 r.in.buffer = &blob;
904 r.in.offered = needed;
905
906 status = dcerpc_spoolss_EnumPrintProcDataTypes_r(b, tctx, &r);
907 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcDataTypes failed");
908
909 torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcDataTypes failed");
910
911 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcDataTypes, info, r.in.level, count, needed, 4);
912
913 }
914
915 return true;
916 }
917
918
919 static bool test_EnumPrinters(struct torture_context *tctx,
920 struct dcerpc_binding_handle *b,
921 struct test_spoolss_context *ctx)
922 {
923 struct spoolss_EnumPrinters r;
924 NTSTATUS status;
925 uint16_t levels[] = { 0, 1, 2, 4, 5 };
926 int i, j;
927
928 for (i=0;i<ARRAY_SIZE(levels);i++) {
929 int level = levels[i];
930 DATA_BLOB blob;
931 uint32_t needed;
932 uint32_t count;
933 union spoolss_PrinterInfo *info;
934
935 r.in.flags = PRINTER_ENUM_LOCAL;
936 r.in.server = "";
937 r.in.level = level;
938 r.in.buffer = NULL;
939 r.in.offered = 0;
940 r.out.needed = &needed;
941 r.out.count = &count;
942 r.out.info = &info;
943
944 torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
945
946 status = dcerpc_spoolss_EnumPrinters_r(b, ctx, &r);
947 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
948 if (W_ERROR_IS_OK(r.out.result)) {
949 /* TODO: do some more checks here */
950 continue;
951 }
952 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
953 "EnumPrinters unexpected return code");
954
955 blob = data_blob_talloc_zero(ctx, needed);
956 r.in.buffer = &blob;
957 r.in.offered = needed;
958
959 status = dcerpc_spoolss_EnumPrinters_r(b, ctx, &r);
960 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
961
962 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
963
964 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, needed, 4);
965
966 ctx->printer_count[level] = count;
967 ctx->printers[level] = info;
968 }
969
970 for (i=1;i<ARRAY_SIZE(levels);i++) {
971 int level = levels[i];
972 int old_level = levels[i-1];
973 torture_assert_int_equal(tctx, ctx->printer_count[level], ctx->printer_count[old_level],
974 "EnumPrinters invalid value");
975 }
976
977 for (i=0;i<ARRAY_SIZE(levels);i++) {
978 int level = levels[i];
979 for (j=0;j<ctx->printer_count[level];j++) {
980 union spoolss_PrinterInfo *cur = &ctx->printers[level][j];
981 union spoolss_PrinterInfo *ref = &ctx->printers[2][j];
982 switch (level) {
983 case 0:
984 COMPARE_STRING(tctx, cur->info0, ref->info2, printername);
985 COMPARE_STRING(tctx, cur->info0, ref->info2, servername);
986 COMPARE_UINT32(tctx, cur->info0, ref->info2, cjobs);
987 /*COMPARE_UINT32(tctx, cur->info0, ref->info2, total_jobs);
988 COMPARE_UINT32(tctx, cur->info0, ref->info2, total_bytes);
989 COMPARE_SPOOLSS_TIME(cur->info0, ref->info2, spoolss_Time time);
990 COMPARE_UINT32(tctx, cur->info0, ref->info2, global_counter);
991 COMPARE_UINT32(tctx, cur->info0, ref->info2, total_pages);
992 COMPARE_UINT32(tctx, cur->info0, ref->info2, version);
993 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown10);
994 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown11);
995 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown12);
996 COMPARE_UINT32(tctx, cur->info0, ref->info2, session_counter);
997 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown14);
998 COMPARE_UINT32(tctx, cur->info0, ref->info2, printer_errors);
999 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown16);
1000 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown17);
1001 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown18);
1002 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown19);
1003 COMPARE_UINT32(tctx, cur->info0, ref->info2, change_id);
1004 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown21);*/
1005 COMPARE_UINT32(tctx, cur->info0, ref->info2, status);
1006 /*COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown23);
1007 COMPARE_UINT32(tctx, cur->info0, ref->info2, c_setprinter);
1008 COMPARE_UINT16(cur->info0, ref->info2, unknown25);
1009 COMPARE_UINT16(cur->info0, ref->info2, unknown26);
1010 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown27);
1011 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown28);
1012 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown29);*/
1013 break;
1014 case 1:
1015 /*COMPARE_UINT32(tctx, cur->info1, ref->info2, flags);*/
1016 /*COMPARE_STRING(tctx, cur->info1, ref->info2, name);*/
1017 /*COMPARE_STRING(tctx, cur->info1, ref->info2, description);*/
1018 COMPARE_STRING(tctx, cur->info1, ref->info2, comment);
1019 break;
1020 case 2:
1021 /* level 2 is our reference, and it makes no sense to compare it to itself */
1022 break;
1023 case 4:
1024 COMPARE_STRING(tctx, cur->info4, ref->info2, printername);
1025 COMPARE_STRING(tctx, cur->info4, ref->info2, servername);
1026 COMPARE_UINT32(tctx, cur->info4, ref->info2, attributes);
1027 break;
1028 case 5:
1029 COMPARE_STRING(tctx, cur->info5, ref->info2, printername);
1030 COMPARE_STRING(tctx, cur->info5, ref->info2, portname);
1031 COMPARE_UINT32(tctx, cur->info5, ref->info2, attributes);
1032 /*COMPARE_UINT32(tctx, cur->info5, ref->info2, device_not_selected_timeout);
1033 COMPARE_UINT32(tctx, cur->info5, ref->info2, transmission_retry_timeout);*/
1034 break;
1035 }
1036 }
1037 }
1038
1039 /* TODO:
1040 * - verify that the port of a printer was in the list returned by EnumPorts
1041 */
1042
1043 return true;
1044 }
1045
1046 static bool test_GetPrinterDriver2(struct torture_context *tctx,
1047 struct dcerpc_binding_handle *b,
1048 struct policy_handle *handle,
1049 const char *driver_name,
1050 const char *environment);
1051
1052 bool test_GetPrinter_level(struct torture_context *tctx,
1053 struct dcerpc_binding_handle *b,
1054 struct policy_handle *handle,
1055 uint32_t level,
1056 union spoolss_PrinterInfo *info)
1057 {
1058 struct spoolss_GetPrinter r;
1059 uint32_t needed;
1060
1061 r.in.handle = handle;
1062 r.in.level = level;
1063 r.in.buffer = NULL;
1064 r.in.offered = 0;
1065 r.out.needed = &needed;
1066
1067 torture_comment(tctx, "Testing GetPrinter level %u\n", r.in.level);
1068
1069 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinter_r(b, tctx, &r),
1070 "GetPrinter failed");
1071
1072 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
1073 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
1074 r.in.buffer = &blob;
1075 r.in.offered = needed;
1076
1077 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinter_r(b, tctx, &r),
1078 "GetPrinter failed");
1079 }
1080
1081 torture_assert_werr_ok(tctx, r.out.result, "GetPrinter failed");
1082
1083 CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterInfo, r.out.info, r.in.level, needed, 4);
1084
1085 if (info && r.out.info) {
1086 *info = *r.out.info;
1087 }
1088
1089 return true;
1090 }
1091
1092
1093 static bool test_GetPrinter(struct torture_context *tctx,
1094 struct dcerpc_binding_handle *b,
1095 struct policy_handle *handle,
1096 const char *environment)
1097 {
1098 uint32_t levels[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
1099 int i;
1100
1101 for (i=0;i<ARRAY_SIZE(levels);i++) {
1102
1103 union spoolss_PrinterInfo info;
1104
1105 ZERO_STRUCT(info);
1106
1107 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, levels[i], &info),
1108 "failed to call GetPrinter");
1109
1110 if ((levels[i] == 2) && info.info2.drivername && strlen(info.info2.drivername)) {
1111 torture_assert(tctx,
1112 test_GetPrinterDriver2(tctx, b, handle, info.info2.drivername, environment),
1113 "failed to call test_GetPrinterDriver2");
1114 }
1115 }
1116
1117 return true;
1118 }
1119
1120 static bool test_SetPrinter(struct torture_context *tctx,
1121 struct dcerpc_binding_handle *b,
1122 struct policy_handle *handle,
1123 struct spoolss_SetPrinterInfoCtr *info_ctr,
1124 struct spoolss_DevmodeContainer *devmode_ctr,
1125 struct sec_desc_buf *secdesc_ctr,
1126 enum spoolss_PrinterControl command)
1127 {
1128 struct spoolss_SetPrinter r;
1129
1130 r.in.handle = handle;
1131 r.in.info_ctr = info_ctr;
1132 r.in.devmode_ctr = devmode_ctr;
1133 r.in.secdesc_ctr = secdesc_ctr;
1134 r.in.command = command;
1135
1136 torture_comment(tctx, "Testing SetPrinter level %d\n", r.in.info_ctr->level);
1137
1138 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r),
1139 "failed to call SetPrinter");
1140 torture_assert_werr_ok(tctx, r.out.result,
1141 "failed to call SetPrinter");
1142
1143 return true;
1144 }
1145
1146 static bool test_SetPrinter_errors(struct torture_context *tctx,
1147 struct dcerpc_binding_handle *b,
1148 struct policy_handle *handle)
1149 {
1150 struct spoolss_SetPrinter r;
1151 uint16_t levels[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
1152 int i;
1153
1154 struct spoolss_SetPrinterInfoCtr info_ctr;
1155 struct spoolss_DevmodeContainer devmode_ctr;
1156 struct sec_desc_buf secdesc_ctr;
1157
1158 info_ctr.level = 0;
1159 info_ctr.info.info0 = NULL;
1160
1161 ZERO_STRUCT(devmode_ctr);
1162 ZERO_STRUCT(secdesc_ctr);
1163
1164 r.in.handle = handle;
1165 r.in.info_ctr = &info_ctr;
1166 r.in.devmode_ctr = &devmode_ctr;
1167 r.in.secdesc_ctr = &secdesc_ctr;
1168 r.in.command = 0;
1169
1170 torture_comment(tctx, "Testing SetPrinter all zero\n");
1171
1172 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r),
1173 "failed to call SetPrinter");
1174 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
1175 "failed to call SetPrinter");
1176
1177 again:
1178 for (i=0; i < ARRAY_SIZE(levels); i++) {
1179
1180 struct spoolss_SetPrinterInfo0 info0;
1181 struct spoolss_SetPrinterInfo1 info1;
1182 struct spoolss_SetPrinterInfo2 info2;
1183 struct spoolss_SetPrinterInfo3 info3;
1184 struct spoolss_SetPrinterInfo4 info4;
1185 struct spoolss_SetPrinterInfo5 info5;
1186 struct spoolss_SetPrinterInfo6 info6;
1187 struct spoolss_SetPrinterInfo7 info7;
1188 struct spoolss_SetPrinterInfo8 info8;
1189 struct spoolss_SetPrinterInfo9 info9;
1190
1191
1192 info_ctr.level = levels[i];
1193 switch (levels[i]) {
1194 case 0:
1195 ZERO_STRUCT(info0);
1196 info_ctr.info.info0 = &info0;
1197 break;
1198 case 1:
1199 ZERO_STRUCT(info1);
1200 info_ctr.info.info1 = &info1;
1201 break;
1202 case 2:
1203 ZERO_STRUCT(info2);
1204 info_ctr.info.info2 = &info2;
1205 break;
1206 case 3:
1207 ZERO_STRUCT(info3);
1208 info_ctr.info.info3 = &info3;
1209 break;
1210 case 4:
1211 ZERO_STRUCT(info4);
1212 info_ctr.info.info4 = &info4;
1213 break;
1214 case 5:
1215 ZERO_STRUCT(info5);
1216 info_ctr.info.info5 = &info5;
1217 break;
1218 case 6:
1219 ZERO_STRUCT(info6);
1220 info_ctr.info.info6 = &info6;
1221 break;
1222 case 7:
1223 ZERO_STRUCT(info7);
1224 info_ctr.info.info7 = &info7;
1225 break;
1226 case 8:
1227 ZERO_STRUCT(info8);
1228 info_ctr.info.info8 = &info8;
1229 break;
1230 case 9:
1231 ZERO_STRUCT(info9);
1232 info_ctr.info.info9 = &info9;
1233 break;
1234 }
1235
1236 torture_comment(tctx, "Testing SetPrinter level %d, command %d\n",
1237 info_ctr.level, r.in.command);
1238
1239 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r),
1240 "failed to call SetPrinter");
1241
1242 switch (r.in.command) {
1243 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: /* 0 */
1244 /* is ignored for all levels other then 0 */
1245 if (info_ctr.level > 0) {
1246 /* ignored then */
1247 break;
1248 }
1249 case SPOOLSS_PRINTER_CONTROL_PAUSE: /* 1 */
1250 case SPOOLSS_PRINTER_CONTROL_RESUME: /* 2 */
1251 case SPOOLSS_PRINTER_CONTROL_PURGE: /* 3 */
1252 if (info_ctr.level > 0) {
1253 /* is invalid for all levels other then 0 */
1254 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PRINTER_COMMAND,
1255 "unexpected error code returned");
1256 continue;
1257 } else {
1258 torture_assert_werr_ok(tctx, r.out.result,
1259 "failed to call SetPrinter with non 0 command");
1260 continue;
1261 }
1262 break;
1263
1264 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: /* 4 */
1265 /* FIXME: gd needs further investigation */
1266 default:
1267 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PRINTER_COMMAND,
1268 "unexpected error code returned");
1269 continue;
1270 }
1271
1272 switch (info_ctr.level) {
1273 case 1:
1274 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
1275 "unexpected error code returned");
1276 break;
1277 case 2:
1278 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_PRINTER_DRIVER,
1279 "unexpected error code returned");
1280 break;
1281 case 3:
1282 case 4:
1283 case 5:
1284 case 7:
1285 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
1286 "unexpected error code returned");
1287 break;
1288 case 9:
1289 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1290 "unexpected error code returned");
1291 break;
1292 default:
1293 torture_assert_werr_ok(tctx, r.out.result,
1294 "failed to call SetPrinter");
1295 break;
1296 }
1297 }
1298
1299 if (r.in.command < 5) {
1300 r.in.command++;
1301 goto again;
1302 }
1303
1304 return true;
1305 }
1306
1307 static void clear_info2(struct spoolss_SetPrinterInfoCtr *r)
1308 {
1309 if ((r->level == 2) && (r->info.info2)) {
1310 r->info.info2->secdesc_ptr = 0;
1311 r->info.info2->devmode_ptr = 0;
1312 }
1313 }
1314
1315 static bool test_PrinterInfo(struct torture_context *tctx,
1316 struct dcerpc_binding_handle *b,
1317 struct policy_handle *handle)
1318 {
1319 NTSTATUS status;
1320 struct spoolss_SetPrinter s;
1321 struct spoolss_GetPrinter q;
1322 struct spoolss_GetPrinter q0;
1323 struct spoolss_SetPrinterInfoCtr info_ctr;
1324 union spoolss_PrinterInfo info;
1325 struct spoolss_DevmodeContainer devmode_ctr;
1326 struct sec_desc_buf secdesc_ctr;
1327 uint32_t needed;
1328 bool ret = true;
1329 int i;
1330
1331 uint32_t status_list[] = {
1332 /* these do not stick
1333 PRINTER_STATUS_PAUSED,
1334 PRINTER_STATUS_ERROR,
1335 PRINTER_STATUS_PENDING_DELETION, */
1336 PRINTER_STATUS_PAPER_JAM,
1337 PRINTER_STATUS_PAPER_OUT,
1338 PRINTER_STATUS_MANUAL_FEED,
1339 PRINTER_STATUS_PAPER_PROBLEM,
1340 PRINTER_STATUS_OFFLINE,
1341 PRINTER_STATUS_IO_ACTIVE,
1342 PRINTER_STATUS_BUSY,
1343 PRINTER_STATUS_PRINTING,
1344 PRINTER_STATUS_OUTPUT_BIN_FULL,
1345 PRINTER_STATUS_NOT_AVAILABLE,
1346 PRINTER_STATUS_WAITING,
1347 PRINTER_STATUS_PROCESSING,
1348 PRINTER_STATUS_INITIALIZING,
1349 PRINTER_STATUS_WARMING_UP,
1350 PRINTER_STATUS_TONER_LOW,
1351 PRINTER_STATUS_NO_TONER,
1352 PRINTER_STATUS_PAGE_PUNT,
1353 PRINTER_STATUS_USER_INTERVENTION,
1354 PRINTER_STATUS_OUT_OF_MEMORY,
1355 PRINTER_STATUS_DOOR_OPEN,
1356 PRINTER_STATUS_SERVER_UNKNOWN,
1357 PRINTER_STATUS_POWER_SAVE,
1358 /* these do not stick
1359 0x02000000,
1360 0x04000000,
1361 0x08000000,
1362 0x10000000,
1363 0x20000000,
1364 0x40000000,
1365 0x80000000 */
1366 };
1367 uint32_t default_attribute = PRINTER_ATTRIBUTE_LOCAL;
1368 uint32_t attribute_list[] = {
1369 PRINTER_ATTRIBUTE_QUEUED,
1370 /* fails with WERR_INVALID_DATATYPE:
1371 PRINTER_ATTRIBUTE_DIRECT, */
1372 /* does not stick
1373 PRINTER_ATTRIBUTE_DEFAULT, */
1374 PRINTER_ATTRIBUTE_SHARED,
1375 /* does not stick
1376 PRINTER_ATTRIBUTE_NETWORK, */
1377 PRINTER_ATTRIBUTE_HIDDEN,
1378 PRINTER_ATTRIBUTE_LOCAL,
1379 PRINTER_ATTRIBUTE_ENABLE_DEVQ,
1380 PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS,
1381 PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST,
1382 PRINTER_ATTRIBUTE_WORK_OFFLINE,
1383 /* does not stick
1384 PRINTER_ATTRIBUTE_ENABLE_BIDI, */
1385 /* fails with WERR_INVALID_DATATYPE:
1386 PRINTER_ATTRIBUTE_RAW_ONLY, */
1387 /* these do not stick
1388 PRINTER_ATTRIBUTE_PUBLISHED,
1389 PRINTER_ATTRIBUTE_FAX,
1390 PRINTER_ATTRIBUTE_TS,
1391 0x00010000,
1392 0x00020000,
1393 0x00040000,
1394 0x00080000,
1395 0x00100000,
1396 0x00200000,
1397 0x00400000,
1398 0x00800000,
1399 0x01000000,
1400 0x02000000,
1401 0x04000000,
1402 0x08000000,
1403 0x10000000,
1404 0x20000000,
1405 0x40000000,
1406 0x80000000 */
1407 };
1408
1409 ZERO_STRUCT(devmode_ctr);
1410 ZERO_STRUCT(secdesc_ctr);
1411
1412 s.in.handle = handle;
1413 s.in.command = 0;
1414 s.in.info_ctr = &info_ctr;
1415 s.in.devmode_ctr = &devmode_ctr;
1416 s.in.secdesc_ctr = &secdesc_ctr;
1417
1418 q.in.handle = handle;
1419 q.out.info = &info;
1420 q0 = q;
1421
1422 #define TESTGETCALL(call, r) \
1423 r.in.buffer = NULL; \
1424 r.in.offered = 0;\
1425 r.out.needed = &needed; \
1426 status = dcerpc_spoolss_ ##call## _r(b, tctx, &r); \
1427 if (!NT_STATUS_IS_OK(status)) { \
1428 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1429 r.in.level, nt_errstr(status), __location__); \
1430 ret = false; \
1431 break; \
1432 }\
1433 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {\
1434 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed); \
1435 r.in.buffer = &blob; \
1436 r.in.offered = needed; \
1437 }\
1438 status = dcerpc_spoolss_ ##call## _r(b, tctx, &r); \
1439 if (!NT_STATUS_IS_OK(status)) { \
1440 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1441 r.in.level, nt_errstr(status), __location__); \
1442 ret = false; \
1443 break; \
1444 } \
1445 if (!W_ERROR_IS_OK(r.out.result)) { \
1446 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1447 r.in.level, win_errstr(r.out.result), __location__); \
1448 ret = false; \
1449 break; \
1450 }
1451
1452
1453 #define TESTSETCALL_EXP(call, r, err) \
1454 clear_info2(&info_ctr);\
1455 status = dcerpc_spoolss_ ##call## _r(b, tctx, &r); \
1456 if (!NT_STATUS_IS_OK(status)) { \
1457 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1458 r.in.info_ctr->level, nt_errstr(status), __location__); \
1459 ret = false; \
1460 break; \
1461 } \
1462 if (!W_ERROR_IS_OK(err)) { \
1463 if (!W_ERROR_EQUAL(err, r.out.result)) { \
1464 torture_comment(tctx, #call " level %u failed - %s, expected %s (%s)\n", \
1465 r.in.info_ctr->level, win_errstr(r.out.result), win_errstr(err), __location__); \
1466 ret = false; \
1467 } \
1468 break; \
1469 } \
1470 if (!W_ERROR_IS_OK(r.out.result)) { \
1471 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1472 r.in.info_ctr->level, win_errstr(r.out.result), __location__); \
1473 ret = false; \
1474 break; \
1475 }
1476
1477 #define TESTSETCALL(call, r) \
1478 TESTSETCALL_EXP(call, r, WERR_OK)
1479
1480 #define STRING_EQUAL(s1, s2, field) \
1481 if ((s1 && !s2) || (s2 && !s1) || strcmp(s1, s2)) { \
1482 torture_comment(tctx, "Failed to set %s to '%s' (%s)\n", \
1483 #field, s2, __location__); \
1484 ret = false; \
1485 break; \
1486 }
1487
1488 #define MEM_EQUAL(s1, s2, length, field) \
1489 if ((s1 && !s2) || (s2 && !s1) || memcmp(s1, s2, length)) { \
1490 torture_comment(tctx, "Failed to set %s to '%s' (%s)\n", \
1491 #field, (const char *)s2, __location__); \
1492 ret = false; \
1493 break; \
1494 }
1495
1496 #define INT_EQUAL(i1, i2, field) \
1497 if (i1 != i2) { \
1498 torture_comment(tctx, "Failed to set %s to 0x%llx - got 0x%llx (%s)\n", \
1499 #field, (unsigned long long)i2, (unsigned long long)i1, __location__); \
1500 ret = false; \
1501 break; \
1502 }
1503
1504 #define SD_EQUAL(sd1, sd2, field) \
1505 if (!security_descriptor_equal(sd1, sd2)) { \
1506 torture_comment(tctx, "Failed to set %s (%s)\n", \
1507 #field, __location__); \
1508 ret = false; \
1509 break; \
1510 }
1511
1512 #define TEST_PRINTERINFO_STRING_EXP_ERR(lvl1, field1, lvl2, field2, value, err) do { \
1513 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
1514 q.in.level = lvl1; \
1515 TESTGETCALL(GetPrinter, q) \
1516 info_ctr.level = lvl1; \
1517 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
1518 info_ctr.info.info ## lvl1->field1 = value;\
1519 TESTSETCALL_EXP(SetPrinter, s, err) \
1520 info_ctr.info.info ## lvl1->field1 = ""; \
1521 TESTGETCALL(GetPrinter, q) \
1522 info_ctr.info.info ## lvl1->field1 = value; \
1523 STRING_EQUAL(info_ctr.info.info ## lvl1->field1, value, field1); \
1524 q.in.level = lvl2; \
1525 TESTGETCALL(GetPrinter, q) \
1526 info_ctr.info.info ## lvl2 = (struct spoolss_SetPrinterInfo ## lvl2 *)(void *)&q.out.info->info ## lvl2; \
1527 STRING_EQUAL(info_ctr.info.info ## lvl2->field2, value, field2); \
1528 } while (0)
1529
1530 #define TEST_PRINTERINFO_STRING(lvl1, field1, lvl2, field2, value) do { \
1531 TEST_PRINTERINFO_STRING_EXP_ERR(lvl1, field1, lvl2, field2, value, WERR_OK); \
1532 } while (0);
1533
1534 #define TEST_PRINTERINFO_INT_EXP(lvl1, field1, lvl2, field2, value, exp_value) do { \
1535 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
1536 q.in.level = lvl1; \
1537 TESTGETCALL(GetPrinter, q) \
1538 info_ctr.level = lvl1; \
1539 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
1540 info_ctr.info.info ## lvl1->field1 = value; \
1541 TESTSETCALL(SetPrinter, s) \
1542 info_ctr.info.info ## lvl1->field1 = 0; \
1543 TESTGETCALL(GetPrinter, q) \
1544 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
1545 INT_EQUAL(info_ctr.info.info ## lvl1->field1, exp_value, field1); \
1546 q.in.level = lvl2; \
1547 TESTGETCALL(GetPrinter, q) \
1548 info_ctr.info.info ## lvl2 = (struct spoolss_SetPrinterInfo ## lvl2 *)(void *)&q.out.info->info ## lvl2; \
1549 INT_EQUAL(info_ctr.info.info ## lvl2->field2, exp_value, field1); \
1550 } while (0)
1551
1552 #define TEST_PRINTERINFO_INT(lvl1, field1, lvl2, field2, value) do { \
1553 TEST_PRINTERINFO_INT_EXP(lvl1, field1, lvl2, field2, value, value); \
1554 } while (0)
1555
1556 q0.in.level = 0;
1557 do { TESTGETCALL(GetPrinter, q0) } while (0);
1558
1559 TEST_PRINTERINFO_STRING(2, comment, 1, comment, "xx2-1 comment");
1560 TEST_PRINTERINFO_STRING(2, comment, 2, comment, "xx2-2 comment");
1561
1562 /* level 0 printername does not stick */
1563 /* TEST_PRINTERINFO_STRING(2, printername, 0, printername, "xx2-0 printer"); */
1564 TEST_PRINTERINFO_STRING(2, printername, 1, name, "xx2-1 printer");
1565 TEST_PRINTERINFO_STRING(2, printername, 2, printername, "xx2-2 printer");
1566 TEST_PRINTERINFO_STRING(2, printername, 4, printername, "xx2-4 printer");
1567 TEST_PRINTERINFO_STRING(2, printername, 5, printername, "xx2-5 printer");
1568 /* TEST_PRINTERINFO_STRING(4, printername, 0, printername, "xx4-0 printer"); */
1569 TEST_PRINTERINFO_STRING(4, printername, 1, name, "xx4-1 printer");
1570 TEST_PRINTERINFO_STRING(4, printername, 2, printername, "xx4-2 printer");
1571 TEST_PRINTERINFO_STRING(4, printername, 4, printername, "xx4-4 printer");
1572 TEST_PRINTERINFO_STRING(4, printername, 5, printername, "xx4-5 printer");
1573 /* TEST_PRINTERINFO_STRING(5, printername, 0, printername, "xx5-0 printer"); */
1574 TEST_PRINTERINFO_STRING(5, printername, 1, name, "xx5-1 printer");
1575 TEST_PRINTERINFO_STRING(5, printername, 2, printername, "xx5-2 printer");
1576 TEST_PRINTERINFO_STRING(5, printername, 4, printername, "xx5-4 printer");
1577 TEST_PRINTERINFO_STRING(5, printername, 5, printername, "xx5-5 printer");
1578
1579 /* servername can be set but does not stick
1580 TEST_PRINTERINFO_STRING(2, servername, 0, servername, "xx2-0 servername");
1581 TEST_PRINTERINFO_STRING(2, servername, 2, servername, "xx2-2 servername");
1582 TEST_PRINTERINFO_STRING(2, servername, 4, servername, "xx2-4 servername");
1583 */
1584
1585 /* passing an invalid port will result in WERR_UNKNOWN_PORT */
1586 TEST_PRINTERINFO_STRING_EXP_ERR(2, portname, 2, portname, "xx2-2 portname", WERR_UNKNOWN_PORT);
1587 TEST_PRINTERINFO_STRING_EXP_ERR(2, portname, 5, portname, "xx2-5 portname", WERR_UNKNOWN_PORT);
1588 TEST_PRINTERINFO_STRING_EXP_ERR(5, portname, 2, portname, "xx5-2 portname", WERR_UNKNOWN_PORT);
1589 TEST_PRINTERINFO_STRING_EXP_ERR(5, portname, 5, portname, "xx5-5 portname", WERR_UNKNOWN_PORT);
1590
1591 TEST_PRINTERINFO_STRING(2, sharename, 2, sharename, "xx2-2 sharename");
1592 /* passing an invalid driver will result in WERR_UNKNOWN_PRINTER_DRIVER */
1593 TEST_PRINTERINFO_STRING_EXP_ERR(2, drivername, 2, drivername, "xx2-2 drivername", WERR_UNKNOWN_PRINTER_DRIVER);
1594 TEST_PRINTERINFO_STRING(2, location, 2, location, "xx2-2 location");
1595 /* passing an invalid sepfile will result in WERR_INVALID_SEPARATOR_FILE */
1596 TEST_PRINTERINFO_STRING_EXP_ERR(2, sepfile, 2, sepfile, "xx2-2 sepfile", WERR_INVALID_SEPARATOR_FILE);
1597 /* passing an invalid printprocessor will result in WERR_UNKNOWN_PRINTPROCESSOR */
1598 TEST_PRINTERINFO_STRING_EXP_ERR(2, printprocessor, 2, printprocessor, "xx2-2 printprocessor", WERR_UNKNOWN_PRINTPROCESSOR);
1599 TEST_PRINTERINFO_STRING(2, datatype, 2, datatype, "xx2-2 datatype");
1600 TEST_PRINTERINFO_STRING(2, parameters, 2, parameters, "xx2-2 parameters");
1601
1602 for (i=0; i < ARRAY_SIZE(attribute_list); i++) {
1603 /* TEST_PRINTERINFO_INT_EXP(2, attributes, 1, flags,
1604 attribute_list[i],
1605 (attribute_list[i] | default_attribute)
1606 ); */
1607 TEST_PRINTERINFO_INT_EXP(2, attributes, 2, attributes,
1608 attribute_list[i],
1609 (attribute_list[i] | default_attribute)
1610 );
1611 TEST_PRINTERINFO_INT_EXP(2, attributes, 4, attributes,
1612 attribute_list[i],
1613 (attribute_list[i] | default_attribute)
1614 );
1615 TEST_PRINTERINFO_INT_EXP(2, attributes, 5, attributes,
1616 attribute_list[i],
1617 (attribute_list[i] | default_attribute)
1618 );
1619 /* TEST_PRINTERINFO_INT_EXP(4, attributes, 1, flags,
1620 attribute_list[i],
1621 (attribute_list[i] | default_attribute)
1622 ); */
1623 TEST_PRINTERINFO_INT_EXP(4, attributes, 2, attributes,
1624 attribute_list[i],
1625 (attribute_list[i] | default_attribute)
1626 );
1627 TEST_PRINTERINFO_INT_EXP(4, attributes, 4, attributes,
1628 attribute_list[i],
1629 (attribute_list[i] | default_attribute)
1630 );
1631 TEST_PRINTERINFO_INT_EXP(4, attributes, 5, attributes,
1632 attribute_list[i],
1633 (attribute_list[i] | default_attribute)
1634 );
1635 /* TEST_PRINTERINFO_INT_EXP(5, attributes, 1, flags,
1636 attribute_list[i],
1637 (attribute_list[i] | default_attribute)
1638 ); */
1639 TEST_PRINTERINFO_INT_EXP(5, attributes, 2, attributes,
1640 attribute_list[i],
1641 (attribute_list[i] | default_attribute)
1642 );
1643 TEST_PRINTERINFO_INT_EXP(5, attributes, 4, attributes,
1644 attribute_list[i],
1645 (attribute_list[i] | default_attribute)
1646 );
1647 TEST_PRINTERINFO_INT_EXP(5, attributes, 5, attributes,
1648 attribute_list[i],
1649 (attribute_list[i] | default_attribute)
1650 );
1651 }
1652
1653 for (i=0; i < ARRAY_SIZE(status_list); i++) {
1654 /* level 2 sets do not stick
1655 TEST_PRINTERINFO_INT(2, status, 0, status, status_list[i]);
1656 TEST_PRINTERINFO_INT(2, status, 2, status, status_list[i]);
1657 TEST_PRINTERINFO_INT(2, status, 6, status, status_list[i]); */
1658 TEST_PRINTERINFO_INT(6, status, 0, status, status_list[i]);
1659 TEST_PRINTERINFO_INT(6, status, 2, status, status_list[i]);
1660 TEST_PRINTERINFO_INT(6, status, 6, status, status_list[i]);
1661 }
1662
1663 /* priorities need to be between 0 and 99
1664 passing an invalid priority will result in WERR_INVALID_PRIORITY */
1665 TEST_PRINTERINFO_INT(2, priority, 2, priority, 0);
1666 TEST_PRINTERINFO_INT(2, priority, 2, priority, 1);
1667 TEST_PRINTERINFO_INT(2, priority, 2, priority, 99);
1668 /* TEST_PRINTERINFO_INT(2, priority, 2, priority, 100); */
1669 TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 0);
1670 TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 1);
1671 TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 99);
1672 /* TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 100); */
1673
1674 TEST_PRINTERINFO_INT(2, starttime, 2, starttime, __LINE__);
1675 TEST_PRINTERINFO_INT(2, untiltime, 2, untiltime, __LINE__);
1676
1677 /* does not stick
1678 TEST_PRINTERINFO_INT(2, cjobs, 2, cjobs, __LINE__);
1679 TEST_PRINTERINFO_INT(2, averageppm, 2, averageppm, __LINE__); */
1680
1681 /* does not stick
1682 TEST_PRINTERINFO_INT(5, device_not_selected_timeout, 5, device_not_selected_timeout, __LINE__);
1683 TEST_PRINTERINFO_INT(5, transmission_retry_timeout, 5, transmission_retry_timeout, __LINE__); */
1684
1685 /* FIXME: gd also test devmode and secdesc behavior */
1686
1687 {
1688 /* verify composition of level 1 description field */
1689 const char *description;
1690 const char *tmp;
1691
1692 q0.in.level = 1;
1693 do { TESTGETCALL(GetPrinter, q0) } while (0);
1694
1695 description = talloc_strdup(tctx, q0.out.info->info1.description);
1696
1697 q0.in.level = 2;
1698 do { TESTGETCALL(GetPrinter, q0) } while (0);
1699
1700 tmp = talloc_asprintf(tctx, "%s,%s,%s",
1701 q0.out.info->info2.printername,
1702 q0.out.info->info2.drivername,
1703 q0.out.info->info2.location);
1704
1705 do { STRING_EQUAL(description, tmp, "description")} while (0);
1706 }
1707
1708 return ret;
1709 }
1710
1711 #define torture_assert_sid_equal(torture_ctx,got,expected,cmt)\
1712 do { struct dom_sid *__got = (got), *__expected = (expected); \
1713 if (!dom_sid_equal(__got, __expected)) { \
1714 torture_result(torture_ctx, TORTURE_FAIL, \
1715 __location__": "#got" was %s, expected %s: %s", \
1716 dom_sid_string(torture_ctx, __got), dom_sid_string(torture_ctx, __expected), cmt); \
1717 return false; \
1718 } \
1719 } while(0)
1720
1721 static bool test_security_descriptor_equal(struct torture_context *tctx,
1722 const struct security_descriptor *sd1,
1723 const struct security_descriptor *sd2)
1724 {
1725 if (sd1 == sd2) {
1726 return true;
1727 }
1728
1729 if (!sd1 || !sd2) {
1730 torture_comment(tctx, "%s\n", __location__);
1731 return false;
1732 }
1733
1734 torture_assert_int_equal(tctx, sd1->revision, sd2->revision, "revision mismatch");
1735 torture_assert_int_equal(tctx, sd1->type, sd2->type, "type mismatch");
1736
1737 torture_assert_sid_equal(tctx, sd1->owner_sid, sd2->owner_sid, "owner mismatch");
1738 torture_assert_sid_equal(tctx, sd1->group_sid, sd2->group_sid, "group mismatch");
1739
1740 if (!security_acl_equal(sd1->sacl, sd2->sacl)) {
1741 torture_comment(tctx, "%s: sacl mismatch\n", __location__);
1742 NDR_PRINT_DEBUG(security_acl, sd1->sacl);
1743 NDR_PRINT_DEBUG(security_acl, sd2->sacl);
1744 return false;
1745 }
1746 if (!security_acl_equal(sd1->dacl, sd2->dacl)) {
1747 torture_comment(tctx, "%s: dacl mismatch\n", __location__);
1748 NDR_PRINT_DEBUG(security_acl, sd1->dacl);
1749 NDR_PRINT_DEBUG(security_acl, sd2->dacl);
1750 return false;
1751 }
1752
1753 return true;
1754 }
1755
1756 static bool test_sd_set_level(struct torture_context *tctx,
1757 struct dcerpc_binding_handle *b,
1758 struct policy_handle *handle,
1759 uint32_t level,
1760 struct security_descriptor *sd)
1761 {
1762 struct spoolss_SetPrinterInfoCtr info_ctr;
1763 struct spoolss_DevmodeContainer devmode_ctr;
1764 struct sec_desc_buf secdesc_ctr;
1765 union spoolss_SetPrinterInfo sinfo;
1766
1767 ZERO_STRUCT(devmode_ctr);
1768 ZERO_STRUCT(secdesc_ctr);
1769
1770 switch (level) {
1771 case 2: {
1772 union spoolss_PrinterInfo info;
1773 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1774 torture_assert(tctx, PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
1775
1776 info_ctr.level = 2;
1777 info_ctr.info = sinfo;
1778
1779 break;
1780 }
1781 case 3: {
1782 struct spoolss_SetPrinterInfo3 info3;
1783
1784 info3.sec_desc_ptr = 0;
1785
1786 info_ctr.level = 3;
1787 info_ctr.info.info3 = &info3;
1788
1789 break;
1790 }
1791 default:
1792 return false;
1793 }
1794
1795 secdesc_ctr.sd = sd;
1796
1797 torture_assert(tctx,
1798 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0), "");
1799
1800 return true;
1801 }
1802
1803 static bool test_PrinterInfo_SDs(struct torture_context *tctx,
1804 struct dcerpc_binding_handle *b,
1805 struct policy_handle *handle)
1806 {
1807 union spoolss_PrinterInfo info;
1808 struct security_descriptor *sd1, *sd2;
1809 int i;
1810
1811 /* just compare level 2 and level 3 */
1812
1813 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1814
1815 sd1 = info.info2.secdesc;
1816
1817 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 3, &info), "");
1818
1819 sd2 = info.info3.secdesc;
1820
1821 torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1822 "SD level 2 != SD level 3");
1823
1824
1825 /* query level 2, set level 2, query level 2 */
1826
1827 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1828
1829 sd1 = info.info2.secdesc;
1830
1831 torture_assert(tctx, test_sd_set_level(tctx, b, handle, 2, sd1), "");
1832
1833 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1834
1835 sd2 = info.info2.secdesc;
1836 if (sd1->type & SEC_DESC_DACL_DEFAULTED) {
1837 torture_comment(tctx, "removing SEC_DESC_DACL_DEFAULTED\n");
1838 sd1->type &= ~SEC_DESC_DACL_DEFAULTED;
1839 }
1840
1841 torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1842 "SD level 2 != SD level 2 after SD has been set via level 2");
1843
1844
1845 /* query level 2, set level 3, query level 2 */
1846
1847 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1848
1849 sd1 = info.info2.secdesc;
1850
1851 torture_assert(tctx, test_sd_set_level(tctx, b, handle, 3, sd1), "");
1852
1853 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1854
1855 sd2 = info.info2.secdesc;
1856
1857 torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1858 "SD level 2 != SD level 2 after SD has been set via level 3");
1859
1860 /* set modified sd level 3, query level 2 */
1861
1862 for (i=0; i < 93; i++) {
1863 struct security_ace a;
1864 const char *sid_string = talloc_asprintf(tctx, "S-1-5-32-9999%i", i);
1865 a.type = SEC_ACE_TYPE_ACCESS_ALLOWED;
1866 a.flags = 0;
1867 a.size = 0; /* autogenerated */
1868 a.access_mask = 0;
1869 a.trustee = *dom_sid_parse_talloc(tctx, sid_string);
1870 torture_assert_ntstatus_ok(tctx, security_descriptor_dacl_add(sd1, &a), "");
1871 }
1872
1873 torture_assert(tctx, test_sd_set_level(tctx, b, handle, 3, sd1), "");
1874
1875 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1876 sd2 = info.info2.secdesc;
1877
1878 if (sd1->type & SEC_DESC_DACL_DEFAULTED) {
1879 torture_comment(tctx, "removing SEC_DESC_DACL_DEFAULTED\n");
1880 sd1->type &= ~SEC_DESC_DACL_DEFAULTED;
1881 }
1882
1883 torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1884 "modified SD level 2 != SD level 2 after SD has been set via level 3");
1885
1886
1887 return true;
1888 }
1889
1890 /*
1891 * wrapper call that saves original sd, runs tests, and restores sd
1892 */
1893
1894 static bool test_PrinterInfo_SD(struct torture_context *tctx,
1895 struct dcerpc_binding_handle *b,
1896 struct policy_handle *handle)
1897 {
1898 union spoolss_PrinterInfo info;
1899 struct security_descriptor *sd;
1900 bool ret = true;
1901
1902 torture_comment(tctx, "Testing Printer Security Descriptors\n");
1903
1904 /* save original sd */
1905
1906 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info),
1907 "failed to get initial security descriptor");
1908
1909 sd = security_descriptor_copy(tctx, info.info2.secdesc);
1910
1911 /* run tests */
1912
1913 ret = test_PrinterInfo_SDs(tctx, b, handle);
1914
1915 /* restore original sd */
1916
1917 torture_assert(tctx, test_sd_set_level(tctx, b, handle, 3, sd),
1918 "failed to restore initial security descriptor");
1919
1920 torture_comment(tctx, "Printer Security Descriptors test %s\n\n",
1921 ret ? "succeeded" : "failed");
1922
1923
1924 return ret;
1925 }
1926
1927 static bool test_devmode_set_level(struct torture_context *tctx,
1928 struct dcerpc_binding_handle *b,
1929 struct policy_handle *handle,
1930 uint32_t level,
1931 struct spoolss_DeviceMode *devmode)
1932 {
1933 struct spoolss_SetPrinterInfoCtr info_ctr;
1934 struct spoolss_DevmodeContainer devmode_ctr;
1935 struct sec_desc_buf secdesc_ctr;
1936 union spoolss_SetPrinterInfo sinfo;
1937
1938 ZERO_STRUCT(devmode_ctr);
1939 ZERO_STRUCT(secdesc_ctr);
1940
1941 switch (level) {
1942 case 2: {
1943 union spoolss_PrinterInfo info;
1944 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1945 torture_assert(tctx, PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
1946
1947 info_ctr.level = 2;
1948 info_ctr.info = sinfo;
1949
1950 break;
1951 }
1952 case 8: {
1953 struct spoolss_SetPrinterInfo8 info8;
1954
1955 info8.devmode_ptr = 0;
1956
1957 info_ctr.level = 8;
1958 info_ctr.info.info8 = &info8;
1959
1960 break;
1961 }
1962 default:
1963 return false;
1964 }
1965
1966 devmode_ctr.devmode = devmode;
1967
1968 torture_assert(tctx,
1969 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0), "");
1970
1971 return true;
1972 }
1973
1974
1975 static bool test_devicemode_equal(struct torture_context *tctx,
1976 const struct spoolss_DeviceMode *d1,
1977 const struct spoolss_DeviceMode *d2)
1978 {
1979 if (d1 == d2) {
1980 return true;
1981 }
1982
1983 if (!d1 || !d2) {
1984 torture_comment(tctx, "%s\n", __location__);
1985 return false;
1986 }
1987 torture_assert_str_equal(tctx, d1->devicename, d2->devicename, "devicename mismatch");
1988 torture_assert_int_equal(tctx, d1->specversion, d2->specversion, "specversion mismatch");
1989 torture_assert_int_equal(tctx, d1->driverversion, d2->driverversion, "driverversion mismatch");
1990 torture_assert_int_equal(tctx, d1->size, d2->size, "size mismatch");
1991 torture_assert_int_equal(tctx, d1->__driverextra_length, d2->__driverextra_length, "__driverextra_length mismatch");
1992 torture_assert_int_equal(tctx, d1->fields, d2->fields, "fields mismatch");
1993 torture_assert_int_equal(tctx, d1->orientation, d2->orientation, "orientation mismatch");
1994 torture_assert_int_equal(tctx, d1->papersize, d2->papersize, "papersize mismatch");
1995 torture_assert_int_equal(tctx, d1->paperlength, d2->paperlength, "paperlength mismatch");
1996 torture_assert_int_equal(tctx, d1->paperwidth, d2->paperwidth, "paperwidth mismatch");
1997 torture_assert_int_equal(tctx, d1->scale, d2->scale, "scale mismatch");
1998 torture_assert_int_equal(tctx, d1->copies, d2->copies, "copies mismatch");
1999 torture_assert_int_equal(tctx, d1->defaultsource, d2->defaultsource, "defaultsource mismatch");
2000 torture_assert_int_equal(tctx, d1->printquality, d2->printquality, "printquality mismatch");
2001 torture_assert_int_equal(tctx, d1->color, d2->color, "color mismatch");
2002 torture_assert_int_equal(tctx, d1->duplex, d2->duplex, "duplex mismatch");
2003 torture_assert_int_equal(tctx, d1->yresolution, d2->yresolution, "yresolution mismatch");
2004 torture_assert_int_equal(tctx, d1->ttoption, d2->ttoption, "ttoption mismatch");
2005 torture_assert_int_equal(tctx, d1->collate, d2->collate, "collate mismatch");
2006 torture_assert_str_equal(tctx, d1->formname, d2->formname, "formname mismatch");
2007 torture_assert_int_equal(tctx, d1->logpixels, d2->logpixels, "logpixels mismatch");
2008 torture_assert_int_equal(tctx, d1->bitsperpel, d2->bitsperpel, "bitsperpel mismatch");
2009 torture_assert_int_equal(tctx, d1->pelswidth, d2->pelswidth, "pelswidth mismatch");
2010 torture_assert_int_equal(tctx, d1->pelsheight, d2->pelsheight, "pelsheight mismatch");
2011 torture_assert_int_equal(tctx, d1->displayflags, d2->displayflags, "displayflags mismatch");
2012 torture_assert_int_equal(tctx, d1->displayfrequency, d2->displayfrequency, "displayfrequency mismatch");
2013 torture_assert_int_equal(tctx, d1->icmmethod, d2->icmmethod, "icmmethod mismatch");
2014 torture_assert_int_equal(tctx, d1->icmintent, d2->icmintent, "icmintent mismatch");
2015 torture_assert_int_equal(tctx, d1->mediatype, d2->mediatype, "mediatype mismatch");
2016 torture_assert_int_equal(tctx, d1->dithertype, d2->dithertype, "dithertype mismatch");
2017 torture_assert_int_equal(tctx, d1->reserved1, d2->reserved1, "reserved1 mismatch");
2018 torture_assert_int_equal(tctx, d1->reserved2, d2->reserved2, "reserved2 mismatch");
2019 torture_assert_int_equal(tctx, d1->panningwidth, d2->panningwidth, "panningwidth mismatch");
2020 torture_assert_int_equal(tctx, d1->panningheight, d2->panningheight, "panningheight mismatch");
2021 torture_assert_data_blob_equal(tctx, d1->driverextra_data, d2->driverextra_data, "driverextra_data mismatch");
2022
2023 return true;
2024 }
2025
2026 static bool test_devicemode_full(struct torture_context *tctx,
2027 struct dcerpc_binding_handle *b,
2028 struct policy_handle *handle)
2029 {
2030 struct spoolss_SetPrinter s;
2031 struct spoolss_GetPrinter q;
2032 struct spoolss_GetPrinter q0;
2033 struct spoolss_SetPrinterInfoCtr info_ctr;
2034 struct spoolss_SetPrinterInfo8 info8;
2035 union spoolss_PrinterInfo info;
2036 struct spoolss_DevmodeContainer devmode_ctr;
2037 struct sec_desc_buf secdesc_ctr;
2038 uint32_t needed;
2039 bool ret = true;
2040 NTSTATUS status;
2041
2042 #define TEST_DEVMODE_INT_EXP(lvl1, field1, lvl2, field2, value, exp_value) do { \
2043 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
2044 q.in.level = lvl1; \
2045 TESTGETCALL(GetPrinter, q) \
2046 info_ctr.level = lvl1; \
2047 if (lvl1 == 2) {\
2048 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
2049 } else if (lvl1 == 8) {\
2050 info_ctr.info.info ## lvl1 = &info8; \
2051 }\
2052 devmode_ctr.devmode = q.out.info->info ## lvl1.devmode; \
2053 devmode_ctr.devmode->field1 = value; \
2054 TESTSETCALL(SetPrinter, s) \
2055 TESTGETCALL(GetPrinter, q) \
2056 INT_EQUAL(q.out.info->info ## lvl1.devmode->field1, exp_value, field1); \
2057 q.in.level = lvl2; \
2058 TESTGETCALL(GetPrinter, q) \
2059 INT_EQUAL(q.out.info->info ## lvl2.devmode->field2, exp_value, field1); \
2060 } while (0)
2061
2062 #define TEST_DEVMODE_INT(lvl1, field1, lvl2, field2, value) do { \
2063 TEST_DEVMODE_INT_EXP(lvl1, field1, lvl2, field2, value, value); \
2064 } while (0)
2065
2066 ZERO_STRUCT(devmode_ctr);
2067 ZERO_STRUCT(secdesc_ctr);
2068 ZERO_STRUCT(info8);
2069
2070 s.in.handle = handle;
2071 s.in.command = 0;
2072 s.in.info_ctr = &info_ctr;
2073 s.in.devmode_ctr = &devmode_ctr;
2074 s.in.secdesc_ctr = &secdesc_ctr;
2075
2076 q.in.handle = handle;
2077 q.out.info = &info;
2078 q0 = q;
2079
2080 #if 0
2081 const char *devicename;/* [charset(UTF16)] */
2082 enum spoolss_DeviceModeSpecVersion specversion;
2083 uint16_t driverversion;
2084 uint16_t size;
2085 uint16_t __driverextra_length;/* [value(r->driverextra_data.length)] */
2086 uint32_t fields;
2087 #endif
2088
2089 TEST_DEVMODE_INT(8, orientation, 8, orientation, __LINE__);
2090 TEST_DEVMODE_INT(8, papersize, 8, papersize, __LINE__);
2091 TEST_DEVMODE_INT(8, paperlength, 8, paperlength, __LINE__);
2092 TEST_DEVMODE_INT(8, paperwidth, 8, paperwidth, __LINE__);
2093 TEST_DEVMODE_INT(8, scale, 8, scale, __LINE__);
2094 TEST_DEVMODE_INT(8, copies, 8, copies, __LINE__);
2095 TEST_DEVMODE_INT(8, defaultsource, 8, defaultsource, __LINE__);
2096 TEST_DEVMODE_INT(8, printquality, 8, printquality, __LINE__);
2097 TEST_DEVMODE_INT(8, color, 8, color, __LINE__);
2098 TEST_DEVMODE_INT(8, duplex, 8, duplex, __LINE__);
2099 TEST_DEVMODE_INT(8, yresolution, 8, yresolution, __LINE__);
2100 TEST_DEVMODE_INT(8, ttoption, 8, ttoption, __LINE__);
2101 TEST_DEVMODE_INT(8, collate, 8, collate, __LINE__);
2102 #if 0
2103 const char *formname;/* [charset(UTF16)] */
2104 #endif
2105 TEST_DEVMODE_INT(8, logpixels, 8, logpixels, __LINE__);
2106 TEST_DEVMODE_INT(8, bitsperpel, 8, bitsperpel, __LINE__);
2107 TEST_DEVMODE_INT(8, pelswidth, 8, pelswidth, __LINE__);
2108 TEST_DEVMODE_INT(8, pelsheight, 8, pelsheight, __LINE__);
2109 TEST_DEVMODE_INT(8, displayflags, 8, displayflags, __LINE__);
2110 TEST_DEVMODE_INT(8, displayfrequency, 8, displayfrequency, __LINE__);
2111 TEST_DEVMODE_INT(8, icmmethod, 8, icmmethod, __LINE__);
2112 TEST_DEVMODE_INT(8, icmintent, 8, icmintent, __LINE__);
2113 TEST_DEVMODE_INT(8, mediatype, 8, mediatype, __LINE__);
2114 TEST_DEVMODE_INT(8, dithertype, 8, dithertype, __LINE__);
2115 TEST_DEVMODE_INT(8, reserved1, 8, reserved1, __LINE__);
2116 TEST_DEVMODE_INT(8, reserved2, 8, reserved2, __LINE__);
2117 TEST_DEVMODE_INT(8, panningwidth, 8, panningwidth, __LINE__);
2118 TEST_DEVMODE_INT(8, panningheight, 8, panningheight, __LINE__);
2119
2120 return ret;
2121 }
2122
2123 static bool call_OpenPrinterEx(struct torture_context *tctx,
2124 struct dcerpc_pipe *p,
2125 const char *name,
2126 struct spoolss_DeviceMode *devmode,
2127 struct policy_handle *handle);
2128
2129 static bool test_ClosePrinter(struct torture_context *tctx,
2130 struct dcerpc_binding_handle *b,
2131 struct policy_handle *handle);
2132
2133 static bool test_PrinterInfo_DevModes(struct torture_context *tctx,
2134 struct dcerpc_pipe *p,
2135 struct policy_handle *handle,
2136 const char *name)
2137 {
2138 union spoolss_PrinterInfo info;
2139 struct spoolss_DeviceMode *devmode;
2140 struct spoolss_DeviceMode *devmode2;
2141 struct policy_handle handle_devmode;
2142 struct dcerpc_binding_handle *b = p->binding_handle;
2143
2144 /* simply compare level8 and level2 devmode */
2145
2146 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info), "");
2147
2148 devmode = info.info8.devmode;
2149
2150 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
2151
2152 devmode2 = info.info2.devmode;
2153
2154 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2155 "DM level 8 != DM level 2");
2156
2157
2158 /* set devicemode level 8 and see if it persists */
2159
2160 devmode->copies = 93;
2161 devmode->formname = talloc_strdup(tctx, "Legal");
2162
2163 torture_assert(tctx, test_devmode_set_level(tctx, b, handle, 8, devmode), "");
2164
2165 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info), "");
2166
2167 devmode2 = info.info8.devmode;
2168
2169 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2170 "modified DM level 8 != DM level 8 after DM has been set via level 8");
2171
2172 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
2173
2174 devmode2 = info.info2.devmode;
2175
2176 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2177 "modified DM level 8 != DM level 2");
2178
2179
2180 /* set devicemode level 2 and see if it persists */
2181
2182 devmode->copies = 39;
2183 devmode->formname = talloc_strdup(tctx, "Executive");
2184
2185 torture_assert(tctx, test_devmode_set_level(tctx, b, handle, 2, devmode), "");
2186
2187 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info), "");
2188
2189 devmode2 = info.info8.devmode;
2190
2191 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2192 "modified DM level 8 != DM level 8 after DM has been set via level 2");
2193
2194 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
2195
2196 devmode2 = info.info2.devmode;
2197
2198 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2199 "modified DM level 8 != DM level 2");
2200
2201
2202 /* check every single bit in public part of devicemode */
2203
2204 torture_assert(tctx, test_devicemode_full(tctx, b, handle),
2205 "failed to set every single devicemode component");
2206
2207
2208 /* change formname upon open and see if it persists in getprinter calls */
2209
2210 devmode->formname = talloc_strdup(tctx, "A4");
2211 devmode->copies = 42;
2212
2213 torture_assert(tctx, call_OpenPrinterEx(tctx, p, name, devmode, &handle_devmode),
2214 "failed to open printer handle");
2215
2216 torture_assert(tctx, test_GetPrinter_level(tctx, b, &handle_devmode, 8, &info), "");
2217
2218 devmode2 = info.info8.devmode;
2219
2220 if (strequal(devmode->devicename, devmode2->devicename)) {
2221 torture_warning(tctx, "devicenames are the same\n");
2222 } else {
2223 torture_comment(tctx, "devicename passed in for open: %s\n", devmode->devicename);
2224 torture_comment(tctx, "devicename after level 8 get: %s\n", devmode2->devicename);
2225 }
2226
2227 if (strequal(devmode->formname, devmode2->formname)) {
2228 torture_warning(tctx, "formname are the same\n");
2229 } else {
2230 torture_comment(tctx, "formname passed in for open: %s\n", devmode->formname);
2231 torture_comment(tctx, "formname after level 8 get: %s\n", devmode2->formname);
2232 }
2233
2234 if (devmode->copies == devmode2->copies) {
2235 torture_warning(tctx, "copies are the same\n");
2236 } else {
2237 torture_comment(tctx, "copies passed in for open: %d\n", devmode->copies);
2238 torture_comment(tctx, "copies after level 8 get: %d\n", devmode2->copies);
2239 }
2240
2241 torture_assert(tctx, test_GetPrinter_level(tctx, b, &handle_devmode, 2, &info), "");
2242
2243 devmode2 = info.info2.devmode;
2244
2245 if (strequal(devmode->devicename, devmode2->devicename)) {
2246 torture_warning(tctx, "devicenames are the same\n");
2247 } else {
2248 torture_comment(tctx, "devicename passed in for open: %s\n", devmode->devicename);
2249 torture_comment(tctx, "devicename after level 2 get: %s\n", devmode2->devicename);
2250 }
2251
2252 if (strequal(devmode->formname, devmode2->formname)) {
2253 torture_warning(tctx, "formname is the same\n");
2254 } else {
2255 torture_comment(tctx, "formname passed in for open: %s\n", devmode->formname);
2256 torture_comment(tctx, "formname after level 2 get: %s\n", devmode2->formname);
2257 }
2258
2259 if (devmode->copies == devmode2->copies) {
2260 torture_warning(tctx, "copies are the same\n");
2261 } else {
2262 torture_comment(tctx, "copies passed in for open: %d\n", devmode->copies);
2263 torture_comment(tctx, "copies after level 2 get: %d\n", devmode2->copies);
2264 }
2265
2266 test_ClosePrinter(tctx, b, &handle_devmode);
2267
2268 return true;
2269 }
2270
2271 /*
2272 * wrapper call that saves original devmode, runs tests, and restores devmode
2273 */
2274
2275 static bool test_PrinterInfo_DevMode(struct torture_context *tctx,
2276 struct dcerpc_pipe *p,
2277 struct policy_handle *handle,
2278 const char *name,
2279 struct spoolss_DeviceMode *addprinter_devmode)
2280 {
2281 union spoolss_PrinterInfo info;
2282 struct spoolss_DeviceMode *devmode;
2283 bool ret = true;
2284 struct dcerpc_binding_handle *b = p->binding_handle;
2285
2286 torture_comment(tctx, "Testing Printer Devicemodes\n");
2287
2288 /* save original devmode */
2289
2290 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info),
2291 "failed to get initial global devicemode");
2292
2293 devmode = info.info8.devmode;
2294
2295 if (addprinter_devmode) {
2296 if (!test_devicemode_equal(tctx, devmode, addprinter_devmode)) {
2297 torture_warning(tctx, "current global DM is != DM provided in addprinter");
2298 }
2299 }
2300
2301 /* run tests */
2302
2303 ret = test_PrinterInfo_DevModes(tctx, p, handle, name);
2304
2305 /* restore original devmode */
2306
2307 torture_assert(tctx, test_devmode_set_level(tctx, b, handle, 8, devmode),
2308 "failed to restore initial global device mode");
2309
2310 torture_comment(tctx, "Printer Devicemodes test %s\n\n",
2311 ret ? "succeeded" : "failed");
2312
2313
2314 return ret;
2315 }
2316
2317 static bool test_ClosePrinter(struct torture_context *tctx,
2318 struct dcerpc_binding_handle *b,
2319 struct policy_handle *handle)
2320 {
2321 NTSTATUS status;
2322 struct spoolss_ClosePrinter r;
2323
2324 r.in.handle = handle;
2325 r.out.handle = handle;
2326
2327 torture_comment(tctx, "Testing ClosePrinter\n");
2328
2329 status = dcerpc_spoolss_ClosePrinter_r(b, tctx, &r);
2330 torture_assert_ntstatus_ok(tctx, status, "ClosePrinter failed");
2331 torture_assert_werr_ok(tctx, r.out.result, "ClosePrinter failed");
2332
2333 return true;
2334 }
2335
2336 static bool test_GetForm_args(struct torture_context *tctx,
2337 struct dcerpc_binding_handle *b,
2338 struct policy_handle *handle,
2339 const char *form_name,
2340 uint32_t level,
2341 union spoolss_FormInfo *info_p)
2342 {
2343 NTSTATUS status;
2344 struct spoolss_GetForm r;
2345 uint32_t needed;
2346
2347 r.in.handle = handle;
2348 r.in.form_name = form_name;
2349 r.in.level = level;
2350 r.in.buffer = NULL;
2351 r.in.offered = 0;
2352 r.out.needed = &needed;
2353
2354 torture_comment(tctx, "Testing GetForm(%s) level %d\n", form_name, r.in.level);
2355
2356 status = dcerpc_spoolss_GetForm_r(b, tctx, &r);
2357 torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
2358
2359 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2360 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2361 r.in.buffer = &blob;
2362 r.in.offered = needed;
2363 status = dcerpc_spoolss_GetForm_r(b, tctx, &r);
2364 torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
2365
2366 torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
2367
2368 torture_assert(tctx, r.out.info, "No form info returned");
2369 }
2370
2371 torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
2372
2373 CHECK_NEEDED_SIZE_LEVEL(spoolss_FormInfo, r.out.info, r.in.level, needed, 4);
2374
2375 if (info_p) {
2376 *info_p = *r.out.info;
2377 }
2378
2379 return true;
2380 }
2381
2382 static bool test_GetForm(struct torture_context *tctx,
2383 struct dcerpc_binding_handle *b,
2384 struct policy_handle *handle,
2385 const char *form_name,
2386 uint32_t level)
2387 {
2388 return test_GetForm_args(tctx, b, handle, form_name, level, NULL);
2389 }
2390
2391 static bool test_EnumForms(struct torture_context *tctx,
2392 struct dcerpc_binding_handle *b,
2393 struct policy_handle *handle,
2394 bool print_server,
2395 uint32_t level,
2396 uint32_t *count_p,
2397 union spoolss_FormInfo **info_p)
2398 {
2399 struct spoolss_EnumForms r;
2400 uint32_t needed;
2401 uint32_t count;
2402 union spoolss_FormInfo *info;
2403
2404 r.in.handle = handle;
2405 r.in.level = level;
2406 r.in.buffer = NULL;
2407 r.in.offered = 0;
2408 r.out.needed = &needed;
2409 r.out.count = &count;
2410 r.out.info = &info;
2411
2412 torture_comment(tctx, "Testing EnumForms level %d\n", r.in.level);
2413
2414 torture_assert_ntstatus_ok(tctx,
2415 dcerpc_spoolss_EnumForms_r(b, tctx, &r),
2416 "EnumForms failed");
2417
2418 if ((r.in.level == 2) && (W_ERROR_EQUAL(r.out.result, WERR_UNKNOWN_LEVEL))) {
2419 torture_skip(tctx, "EnumForms level 2 not supported");
2420 }
2421
2422 if (print_server && W_ERROR_EQUAL(r.out.result, WERR_BADFID)) {
2423 torture_fail(tctx, "EnumForms on the PrintServer isn't supported by test server (NT4)");
2424 }
2425
2426 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2427 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2428 r.in.buffer = &blob;
2429 r.in.offered = needed;
2430
2431 torture_assert_ntstatus_ok(tctx,
2432 dcerpc_spoolss_EnumForms_r(b, tctx, &r),
2433 "EnumForms failed");
2434
2435 torture_assert(tctx, info, "No forms returned");
2436 }
2437
2438 torture_assert_werr_ok(tctx, r.out.result, "EnumForms failed");
2439
2440 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumForms, info, r.in.level, count, needed, 4);
2441
2442 if (info_p) {
2443 *info_p = info;
2444 }
2445 if (count_p) {
2446 *count_p = count;
2447 }
2448
2449 return true;
2450 }
2451
2452 static bool test_EnumForms_all(struct torture_context *tctx,
2453 struct dcerpc_binding_handle *b,
2454 struct policy_handle *handle,
2455 bool print_server)
2456 {
2457 uint32_t levels[] = { 1, 2 };
2458 int i, j;
2459
2460 for (i=0; i<ARRAY_SIZE(levels); i++) {
2461
2462 uint32_t count = 0;
2463 union spoolss_FormInfo *info = NULL;
2464
2465 torture_assert(tctx,
2466 test_EnumForms(tctx, b, handle, print_server, levels[i], &count, &info),
2467 "failed to enum forms");
2468
2469 for (j = 0; j < count; j++) {
2470 if (!print_server) {
2471 torture_assert(tctx,
2472 test_GetForm(tctx, b, handle, info[j].info1.form_name, levels[i]),
2473 "failed to get form");
2474 }
2475 }
2476 }
2477
2478 return true;
2479 }
2480
2481 static bool test_EnumForms_find_one(struct torture_context *tctx,
2482 struct dcerpc_binding_handle *b,
2483 struct policy_handle *handle,
2484 bool print_server,
2485 const char *form_name)
2486 {
2487 union spoolss_FormInfo *info;
2488 uint32_t count;
2489 bool found = false;
2490 int i;
2491
2492 torture_assert(tctx,
2493 test_EnumForms(tctx, b, handle, print_server, 1, &count, &info),
2494 "failed to enumerate forms");
2495
2496 for (i=0; i<count; i++) {
2497 if (strequal(form_name, info[i].info1.form_name)) {
2498 found = true;
2499 break;
2500 }
2501 }
2502
2503 return found;
2504 }
2505
2506 static bool test_DeleteForm(struct torture_context *tctx,
2507 struct dcerpc_binding_handle *b,
2508 struct policy_handle *handle,
2509 const char *form_name,
2510 WERROR expected_result)
2511 {
2512 struct spoolss_DeleteForm r;
2513
2514 r.in.handle = handle;
2515 r.in.form_name = form_name;
2516
2517 torture_comment(tctx, "Testing DeleteForm(%s)\n", form_name);
2518
2519 torture_assert_ntstatus_ok(tctx,
2520 dcerpc_spoolss_DeleteForm_r(b, tctx, &r),
2521 "DeleteForm failed");
2522 torture_assert_werr_equal(tctx, r.out.result, expected_result,
2523 "DeleteForm gave unexpected result");
2524 if (W_ERROR_IS_OK(r.out.result)) {
2525 torture_assert_ntstatus_ok(tctx,
2526 dcerpc_spoolss_DeleteForm_r(b, tctx, &r),
2527 "2nd DeleteForm failed");
2528 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_FORM_NAME,
2529 "2nd DeleteForm failed");
2530 }
2531
2532 return true;
2533 }
2534
2535 static bool test_AddForm(struct torture_context *tctx,
2536 struct dcerpc_binding_handle *b,
2537 struct policy_handle *handle,
2538 uint32_t level,
2539 union spoolss_AddFormInfo *info,
2540 WERROR expected_result)
2541 {
2542 struct spoolss_AddForm r;
2543
2544 if (level != 1) {
2545 torture_skip(tctx, "only level 1 supported");
2546 }
2547
2548 r.in.handle = handle;
2549 r.in.level = level;
2550 r.in.info = *info;
2551
2552 torture_comment(tctx, "Testing AddForm(%s) level %d, type %d\n",
2553 r.in.info.info1->form_name, r.in.level,
2554 r.in.info.info1->flags);
2555
2556 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_AddForm_r(b, tctx, &r),
2557 "AddForm failed");
2558 torture_assert_werr_equal(tctx, r.out.result, expected_result,
2559 "AddForm gave unexpected result");
2560
2561 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_AddForm_r(b, tctx, &r),
2562 "2nd AddForm failed");
2563 if (W_ERROR_EQUAL(expected_result, WERR_INVALID_PARAM)) {
2564 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
2565 "2nd AddForm gave unexpected result");
2566 } else {
2567 torture_assert_werr_equal(tctx, r.out.result, WERR_FILE_EXISTS,
2568 "2nd AddForm gave unexpected result");
2569 }
2570
2571 return true;
2572 }
2573
2574 static bool test_SetForm(struct torture_context *tctx,
2575 struct dcerpc_binding_handle *b,
2576 struct policy_handle *handle,
2577 const char *form_name,
2578 uint32_t level,
2579 union spoolss_AddFormInfo *info)
2580 {
2581 struct spoolss_SetForm r;
2582
2583 r.in.handle = handle;
2584 r.in.form_name = form_name;
2585 r.in.level = level;
2586 r.in.info = *info;
2587
2588 torture_comment(tctx, "Testing SetForm(%s) level %d\n",
2589 form_name, r.in.level);
2590
2591 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetForm_r(b, tctx, &r),
2592 "SetForm failed");
2593
2594 torture_assert_werr_ok(tctx, r.out.result,
2595 "SetForm failed");
2596
2597 return true;
2598 }
2599
2600 static bool test_GetForm_winreg(struct torture_context *tctx,
2601 struct dcerpc_binding_handle *b,
2602 struct policy_handle *handle,
2603 const char *key_name,
2604 const char *form_name,
2605 enum winreg_Type *w_type,
2606 uint32_t *w_size,
2607 uint32_t *w_length,
2608 uint8_t **w_data);
2609
2610 static bool test_Forms_args(struct torture_context *tctx,
2611 struct dcerpc_binding_handle *b,
2612 struct policy_handle *handle,
2613 bool print_server,
2614 const char *printer_name,
2615 struct dcerpc_binding_handle *winreg_handle,
2616 struct policy_handle *hive_handle,
2617 const char *form_name,
2618 struct spoolss_AddFormInfo1 *info1,
2619 WERROR expected_add_result,
2620 WERROR expected_delete_result)
2621 {
2622 union spoolss_FormInfo info;
2623 union spoolss_AddFormInfo add_info;
2624
2625 enum winreg_Type w_type;
2626 uint32_t w_size;
2627 uint32_t w_length;
2628 uint8_t *w_data;
2629
2630 add_info.info1 = info1;
2631
2632 torture_assert(tctx,
2633 test_AddForm(tctx, b, handle, 1, &add_info, expected_add_result),
2634 "failed to add form");
2635
2636 if (winreg_handle && hive_handle && W_ERROR_IS_OK(expected_add_result)) {
2637
2638 torture_assert(tctx,
2639 test_GetForm_winreg(tctx, winreg_handle, hive_handle, TOP_LEVEL_CONTROL_FORMS_KEY, form_name, &w_type, &w_size, &w_length, &w_data),
2640 "failed to get form via winreg");
2641
2642 torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");
2643 torture_assert_int_equal(tctx, w_size, 0x20, "unexpected size");
2644 torture_assert_int_equal(tctx, w_length, 0x20, "unexpected length");
2645 torture_assert_mem_equal(tctx, &w_data[0], &add_info.info1->size.width, 4, "width mismatch");
2646 torture_assert_mem_equal(tctx, &w_data[4], &add_info.info1->size.height, 4, "height mismatch");
2647 torture_assert_mem_equal(tctx, &w_data[8], &add_info.info1->area.left, 4, "left mismatch");
2648 torture_assert_mem_equal(tctx, &w_data[12], &add_info.info1->area.top, 4, "top mismatch");
2649 torture_assert_mem_equal(tctx, &w_data[16], &add_info.info1->area.right, 4, "right mismatch");
2650 torture_assert_mem_equal(tctx, &w_data[20], &add_info.info1->area.bottom, 4, "bottom mismatch");
2651 /* skip index here */
2652 torture_assert_mem_equal(tctx, &w_data[28], &add_info.info1->flags, 4, "flags mismatch");
2653 }
2654
2655 if (!print_server && W_ERROR_IS_OK(expected_add_result)) {
2656 torture_assert(tctx,
2657 test_GetForm_args(tctx, b, handle, form_name, 1, &info),
2658 "failed to get added form");
2659
2660 torture_assert_int_equal(tctx, info.info1.size.width, add_info.info1->size.width, "width mismatch");
2661 torture_assert_int_equal(tctx, info.info1.size.height, add_info.info1->size.height, "height mismatch");
2662 torture_assert_int_equal(tctx, info.info1.area.left, add_info.info1->area.left, "left mismatch");
2663 torture_assert_int_equal(tctx, info.info1.area.top, add_info.info1->area.top, "top mismatch");
2664 torture_assert_int_equal(tctx, info.info1.area.right, add_info.info1->area.right, "right mismatch");
2665 torture_assert_int_equal(tctx, info.info1.area.bottom, add_info.info1->area.bottom, "bottom mismatch");
2666 torture_assert_int_equal(tctx, info.info1.flags, add_info.info1->flags, "flags mismatch");
2667
2668 if (winreg_handle && hive_handle) {
2669 torture_assert_mem_equal(tctx, &w_data[0], &info.info1.size.width, 4, "width mismatch");
2670 torture_assert_mem_equal(tctx, &w_data[4], &info.info1.size.height, 4, "height mismatch");
2671 torture_assert_mem_equal(tctx, &w_data[8], &info.info1.area.left, 4, "left mismatch");
2672 torture_assert_mem_equal(tctx, &w_data[12], &info.info1.area.top, 4, "top mismatch");
2673 torture_assert_mem_equal(tctx, &w_data[16], &info.info1.area.right, 4, "right mismatch");
2674 torture_assert_mem_equal(tctx, &w_data[20], &info.info1.area.bottom, 4, "bottom mismatch");
2675 /* skip index here */
2676 torture_assert_mem_equal(tctx, &w_data[28], &info.info1.flags, 4, "flags mismatch");
2677 }
2678
2679 add_info.info1->size.width = 1234;
2680
2681 torture_assert(tctx,
2682 test_SetForm(tctx, b, handle, form_name, 1, &add_info),
2683 "failed to set form");
2684 torture_assert(tctx,
2685 test_GetForm_args(tctx, b, handle, form_name, 1, &info),
2686 "failed to get setted form");
2687
2688 torture_assert_int_equal(tctx, info.info1.size.width, add_info.info1->size.width, "width mismatch");
2689 }
2690
2691 if (!W_ERROR_EQUAL(expected_add_result, WERR_INVALID_PARAM)) {
2692 torture_assert(tctx,
2693 test_EnumForms_find_one(tctx, b, handle, print_server, form_name),
2694 "Newly added form not found in enum call");
2695 }
2696
2697 torture_assert(tctx,
2698 test_DeleteForm(tctx, b, handle, form_name, expected_delete_result),
2699 "failed to delete form");
2700
2701 return true;
2702 }
2703
2704 static bool test_Forms(struct torture_context *tctx,
2705 struct dcerpc_binding_handle *b,
2706 struct policy_handle *handle,
2707 bool print_server,
2708 const char *printer_name,
2709 struct dcerpc_binding_handle *winreg_handle,
2710 struct policy_handle *hive_handle)
2711 {
2712 const struct spoolss_FormSize size = {
2713 .width = 50,
2714 .height = 25
2715 };
2716 const struct spoolss_FormArea area = {
2717 .left = 5,
2718 .top = 10,
2719 .right = 45,
2720 .bottom = 15
2721 };
2722 int i;
2723
2724 struct {
2725 struct spoolss_AddFormInfo1 info1;
2726 WERROR expected_add_result;
2727 WERROR expected_delete_result;
2728 } forms[] = {
2729 {
2730 .info1 = {
2731 .flags = SPOOLSS_FORM_USER,
2732 .form_name = "testform_user",
2733 .size = size,
2734 .area = area,
2735 },
2736 .expected_add_result = WERR_OK,
2737 .expected_delete_result = WERR_OK
2738 },
2739 /*
2740 weird, we can add a builtin form but we can never remove it
2741 again - gd
2742
2743 {
2744 .info1 = {
2745 .flags = SPOOLSS_FORM_BUILTIN,
2746 .form_name = "testform_builtin",
2747 .size = size,
2748 .area = area,
2749 },
2750 .expected_add_result = WERR_OK,
2751 .expected_delete_result = WERR_INVALID_PARAM,
2752 },
2753 */
2754 {
2755 .info1 = {
2756 .flags = SPOOLSS_FORM_PRINTER,
2757 .form_name = "testform_printer",
2758 .size = size,
2759 .area = area,
2760 },
2761 .expected_add_result = WERR_OK,
2762 .expected_delete_result = WERR_OK
2763 },
2764 {
2765 .info1 = {
2766 .flags = SPOOLSS_FORM_USER,
2767 .form_name = "Letter",
2768 .size = size,
2769 .area = area,
2770 },
2771 .expected_add_result = WERR_FILE_EXISTS,
2772 .expected_delete_result = WERR_INVALID_PARAM
2773 },
2774 {
2775 .info1 = {
2776 .flags = SPOOLSS_FORM_BUILTIN,
2777 .form_name = "Letter",
2778 .size = size,
2779 .area = area,
2780 },
2781 .expected_add_result = WERR_FILE_EXISTS,
2782 .expected_delete_result = WERR_INVALID_PARAM
2783 },
2784 {
2785 .info1 = {
2786 .flags = SPOOLSS_FORM_PRINTER,
2787 .form_name = "Letter",
2788 .size = size,
2789 .area = area,
2790 },
2791 .expected_add_result = WERR_FILE_EXISTS,
2792 .expected_delete_result = WERR_INVALID_PARAM
2793 },
2794 {
2795 .info1 = {
2796 .flags = 12345,
2797 .form_name = "invalid_flags",
2798 .size = size,
2799 .area = area,
2800 },
2801 .expected_add_result = WERR_INVALID_PARAM,
2802 .expected_delete_result = WERR_INVALID_FORM_NAME
2803 }
2804
2805 };
2806
2807 for (i=0; i < ARRAY_SIZE(forms); i++) {
2808 torture_assert(tctx,
2809 test_Forms_args(tctx, b, handle, print_server, printer_name,
2810 winreg_handle, hive_handle,
2811 forms[i].info1.form_name,
2812 &forms[i].info1,
2813 forms[i].expected_add_result,
2814 forms[i].expected_delete_result),
2815 talloc_asprintf(tctx, "failed to test form '%s'", forms[i].info1.form_name));
2816 }
2817
2818 return true;
2819 }
2820
2821 static bool test_EnumPorts_old(struct torture_context *tctx,
2822 struct dcerpc_pipe *p)
2823 {
2824 NTSTATUS status;
2825 struct spoolss_EnumPorts r;
2826 uint32_t needed;
2827 uint32_t count;
2828 union spoolss_PortInfo *info;
2829 struct dcerpc_binding_handle *b = p->binding_handle;
2830
2831 r.in.servername = talloc_asprintf(tctx, "\\\\%s",
2832 dcerpc_server_name(p));
2833 r.in.level = 2;
2834 r.in.buffer = NULL;
2835 r.in.offered = 0;
2836 r.out.needed = &needed;
2837 r.out.count = &count;
2838 r.out.info = &info;
2839
2840 torture_comment(tctx, "Testing EnumPorts\n");
2841
2842 status = dcerpc_spoolss_EnumPorts_r(b, tctx, &r);
2843
2844 torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
2845
2846 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2847 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2848 r.in.buffer = &blob;
2849 r.in.offered = needed;
2850
2851 status = dcerpc_spoolss_EnumPorts_r(b, tctx, &r);
2852 torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
2853 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
2854
2855 torture_assert(tctx, info, "No ports returned");
2856 }
2857
2858 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
2859
2860 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPorts, info, 2, count, needed, 4);
2861
2862 return true;
2863 }
2864
2865 static bool test_AddPort(struct torture_context *tctx,
2866 struct dcerpc_pipe *p)
2867 {
2868 NTSTATUS status;
2869 struct spoolss_AddPort r;
2870 struct dcerpc_binding_handle *b = p->binding_handle;
2871
2872 r.in.server_name = talloc_asprintf(tctx, "\\\\%s",
2873 dcerpc_server_name(p));
2874 r.in.unknown = 0;
2875 r.in.monitor_name = "foo";
2876
2877 torture_comment(tctx, "Testing AddPort\n");
2878
2879 status = dcerpc_spoolss_AddPort_r(b, tctx, &r);
2880
2881 torture_assert_ntstatus_ok(tctx, status, "AddPort failed");
2882
2883 /* win2k3 returns WERR_NOT_SUPPORTED */
2884
2885 #if 0
2886
2887 if (!W_ERROR_IS_OK(r.out.result)) {
2888 printf("AddPort failed - %s\n", win_errstr(r.out.result));
2889 return false;
2890 }
2891
2892 #endif
2893
2894 return true;
2895 }
2896
2897 static bool test_GetJob_args(struct torture_context *tctx,
2898 struct dcerpc_binding_handle *b,
2899 struct policy_handle *handle,
2900 uint32_t job_id,
2901 uint32_t level,
2902 union spoolss_JobInfo *info_p)
2903 {
2904 NTSTATUS status;
2905 struct spoolss_GetJob r;
2906 union spoolss_JobInfo info;
2907 uint32_t needed;
2908
2909 r.in.handle = handle;
2910 r.in.job_id = job_id;
2911 r.in.level = level;
2912 r.in.buffer = NULL;
2913 r.in.offered = 0;
2914 r.out.needed = &needed;
2915 r.out.info = &info;
2916
2917 torture_comment(tctx, "Testing GetJob(%d), level %d\n", job_id, r.in.level);
2918
2919 status = dcerpc_spoolss_GetJob_r(b, tctx, &r);
2920 torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
2921 if (level == 0) {
2922 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "Unexpected return code");
2923 }
2924
2925 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2926 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2927 r.in.buffer = &blob;
2928 r.in.offered = needed;
2929
2930 status = dcerpc_spoolss_GetJob_r(b, tctx, &r);
2931 torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
2932 }
2933
2934 torture_assert_werr_ok(tctx, r.out.result, "GetJob failed");
2935 torture_assert(tctx, r.out.info, "No job info returned");
2936
2937 CHECK_NEEDED_SIZE_LEVEL(spoolss_JobInfo, r.out.info, r.in.level, needed, 4);
2938
2939 if (info_p) {
2940 *info_p = *r.out.info;
2941 }
2942
2943 return true;
2944 }
2945
2946 static bool test_GetJob(struct torture_context *tctx,
2947 struct dcerpc_binding_handle *b,
2948 struct policy_handle *handle,
2949 uint32_t job_id)
2950 {
2951 uint32_t levels[] = {0, 1, 2 /* 3, 4 */};
2952 uint32_t i;
2953
2954 for (i=0; i < ARRAY_SIZE(levels); i++) {
2955 torture_assert(tctx,
2956 test_GetJob_args(tctx, b, handle, job_id, levels[i], NULL),
2957 "GetJob failed");
2958 }
2959
2960 return true;
2961 }
2962
2963 static bool test_SetJob(struct torture_context *tctx,
2964 struct dcerpc_binding_handle *b,
2965 struct policy_handle *handle,
2966 uint32_t job_id,
2967 struct spoolss_JobInfoContainer *ctr,
2968 enum spoolss_JobControl command)
2969 {
2970 NTSTATUS status;
2971 struct spoolss_SetJob r;
2972
2973 r.in.handle = handle;
2974 r.in.job_id = job_id;
2975 r.in.ctr = ctr;
2976 r.in.command = command;
2977
2978 switch (command) {
2979 case SPOOLSS_JOB_CONTROL_PAUSE:
2980 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_PAUSE\n", job_id);
2981 break;
2982 case SPOOLSS_JOB_CONTROL_RESUME:
2983 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RESUME\n", job_id);
2984 break;
2985 case SPOOLSS_JOB_CONTROL_CANCEL:
2986 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_CANCEL\n", job_id);
2987 break;
2988 case SPOOLSS_JOB_CONTROL_RESTART:
2989 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RESTART\n", job_id);
2990 break;
2991 case SPOOLSS_JOB_CONTROL_DELETE:
2992 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_DELETE\n", job_id);
2993 break;
2994 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER:
2995 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER\n", job_id);
2996 break;
2997 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED:
2998 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED\n", job_id);
2999 break;
3000 case SPOOLSS_JOB_CONTROL_RETAIN:
3001 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RETAIN\n", job_id);
3002 break;
3003 case SPOOLSS_JOB_CONTROL_RELEASE:
3004 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RELEASE\n", job_id);
3005 break;
3006 default:
3007 torture_comment(tctx, "Testing SetJob(%d)\n", job_id);
3008 break;
3009 }
3010
3011 status = dcerpc_spoolss_SetJob_r(b, tctx, &r);
3012 torture_assert_ntstatus_ok(tctx, status, "SetJob failed");
3013 torture_assert_werr_ok(tctx, r.out.result, "SetJob failed");
3014
3015 return true;
3016 }
3017
3018 static bool test_AddJob(struct torture_context *tctx,
3019 struct dcerpc_binding_handle *b,
3020 struct policy_handle *handle)
3021 {
3022 NTSTATUS status;
3023 struct spoolss_AddJob r;
3024 uint32_t needed;
3025
3026 r.in.level = 0;
3027 r.in.handle = handle;
3028 r.in.offered = 0;
3029 r.out.needed = &needed;
3030 r.in.buffer = r.out.buffer = NULL;
3031
3032 torture_comment(tctx, "Testing AddJob\n");
3033
3034 status = dcerpc_spoolss_AddJob_r(b, tctx, &r);
3035 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "AddJob failed");
3036
3037 r.in.level = 1;
3038
3039 status = dcerpc_spoolss_AddJob_r(b, tctx, &r);
3040 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM, "AddJob failed");
3041
3042 return true;
3043 }
3044
3045
3046 static bool test_EnumJobs_args(struct torture_context *tctx,
3047 struct dcerpc_binding_handle *b,
3048 struct policy_handle *handle,
3049 uint32_t level,
3050 uint32_t *count_p,
3051 union spoolss_JobInfo **info_p)
3052 {
3053 NTSTATUS status;
3054 struct spoolss_EnumJobs r;
3055 uint32_t needed;
3056 uint32_t count;
3057 union spoolss_JobInfo *info;
3058
3059 r.in.handle = handle;
3060 r.in.firstjob = 0;
3061 r.in.numjobs = 0xffffffff;
3062 r.in.level = level;
3063 r.in.buffer = NULL;
3064 r.in.offered = 0;
3065 r.out.needed = &needed;
3066 r.out.count = &count;
3067 r.out.info = &info;
3068
3069 torture_comment(tctx, "Testing EnumJobs level %d\n", level);
3070
3071 status = dcerpc_spoolss_EnumJobs_r(b, tctx, &r);
3072
3073 torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
3074
3075 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
3076 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
3077 r.in.buffer = &blob;
3078 r.in.offered = needed;
3079
3080 status = dcerpc_spoolss_EnumJobs_r(b, tctx, &r);
3081
3082 torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
3083 torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
3084 torture_assert(tctx, info, "No jobs returned");
3085
3086 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumJobs, *r.out.info, r.in.level, count, needed, 4);
3087
3088 } else {
3089 torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
3090 }
3091
3092 if (count_p) {
3093 *count_p = count;
3094 }
3095 if (info_p) {
3096 *info_p = info;
3097 }
3098
3099 return true;
3100 }
3101
3102 static bool test_DoPrintTest_add_one_job(struct torture_context *tctx,
3103 struct dcerpc_binding_handle *b,
3104 struct policy_handle *handle,
3105 uint32_t *job_id)
3106 {
3107 NTSTATUS status;
3108 struct spoolss_StartDocPrinter s;
3109 struct spoolss_DocumentInfo1 info1;
3110 struct spoolss_StartPagePrinter sp;
3111 struct spoolss_WritePrinter w;
3112 struct spoolss_EndPagePrinter ep;
3113 struct spoolss_EndDocPrinter e;
3114 int i;
3115 uint32_t num_written;
3116
3117 torture_comment(tctx, "Testing StartDocPrinter\n");
3118
3119 s.in.handle = handle;
3120 s.in.level = 1;
3121 s.in.info.info1 = &info1;
3122 s.out.job_id = job_id;
3123 info1.document_name = "TorturePrintJob";
3124 info1.output_file = NULL;
3125 info1.datatype = "RAW";
3126
3127 status = dcerpc_spoolss_StartDocPrinter_r(b, tctx, &s);
3128 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_StartDocPrinter failed");
3129 torture_assert_werr_ok(tctx, s.out.result, "StartDocPrinter failed");
3130
3131 for (i=1; i < 4; i++) {
3132 torture_comment(tctx, "Testing StartPagePrinter: Page[%d], JobId[%d]\n", i, *job_id);
3133
3134 sp.in.handle = handle;
3135
3136 status = dcerpc_spoolss_StartPagePrinter_r(b, tctx, &sp);
3137 torture_assert_ntstatus_ok(tctx, status,
3138 "dcerpc_spoolss_StartPagePrinter failed");
3139 torture_assert_werr_ok(tctx, sp.out.result, "StartPagePrinter failed");
3140
3141 torture_comment(tctx, "Testing WritePrinter: Page[%d], JobId[%d]\n", i, *job_id);
3142
3143 w.in.handle = handle;
3144 w.in.data = data_blob_string_const(talloc_asprintf(tctx,"TortureTestPage: %d\nData\n",i));
3145 w.out.num_written = &num_written;
3146
3147 status = dcerpc_spoolss_WritePrinter_r(b, tctx, &w);
3148 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_WritePrinter failed");
3149 torture_assert_werr_ok(tctx, w.out.result, "WritePrinter failed");
3150
3151 torture_comment(tctx, "Testing EndPagePrinter: Page[%d], JobId[%d]\n", i, *job_id);
3152
3153 ep.in.handle = handle;
3154
3155 status = dcerpc_spoolss_EndPagePrinter_r(b, tctx, &ep);
3156 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndPagePrinter failed");
3157 torture_assert_werr_ok(tctx, ep.out.result, "EndPagePrinter failed");
3158 }
3159
3160 torture_comment(tctx, "Testing EndDocPrinter: JobId[%d]\n", *job_id);
3161
3162 e.in.handle = handle;
3163
3164 status = dcerpc_spoolss_EndDocPrinter_r(b, tctx, &e);
3165 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndDocPrinter failed");
3166 torture_assert_werr_ok(tctx, e.out.result, "EndDocPrinter failed");
3167
3168 return true;
3169 }
3170
3171 static bool test_DoPrintTest_check_jobs(struct torture_context *tctx,
3172 struct dcerpc_binding_handle *b,
3173 struct policy_handle *handle,
3174 uint32_t num_jobs,
3175 uint32_t *job_ids)
3176 {
3177 uint32_t count;
3178 union spoolss_JobInfo *info = NULL;
3179 int i;
3180
3181 torture_assert(tctx,
3182 test_AddJob(tctx, b, handle),
3183 "AddJob failed");
3184
3185 torture_assert(tctx,
3186 test_EnumJobs_args(tctx, b, handle, 1, &count, &info),
3187 "EnumJobs level 1 failed");
3188
3189 torture_assert_int_equal(tctx, count, num_jobs, "unexpected number of jobs in queue");
3190
3191 for (i=0; i < num_jobs; i++) {
3192 union spoolss_JobInfo ginfo;
3193 const char *document_name;
3194 const char *new_document_name = "any_other_docname";
3195 struct spoolss_JobInfoContainer ctr;
3196 struct spoolss_SetJobInfo1 info1;
3197
3198 torture_assert_int_equal(tctx, info[i].info1.job_id, job_ids[i], "job id mismatch");
3199
3200 torture_assert(tctx,
3201 test_GetJob_args(tctx, b, handle, info[i].info1.job_id, 1, &ginfo),
3202 "failed to call test_GetJob");
3203
3204 torture_assert_int_equal(tctx, ginfo.info1.job_id, info[i].info1.job_id, "job id mismatch");
3205
3206 document_name = ginfo.info1.document_name;
3207
3208 info1.job_id = ginfo.info1.job_id;
3209 info1.printer_name = ginfo.info1.printer_name;
3210 info1.server_name = ginfo.info1.server_name;
3211 info1.user_name = ginfo.info1.user_name;
3212 info1.document_name = new_document_name;
3213 info1.data_type = ginfo.info1.data_type;
3214 info1.text_status = ginfo.info1.text_status;
3215 info1.status = ginfo.info1.status;
3216 info1.priority = ginfo.info1.priority;
3217 info1.position = ginfo.info1.position;
3218 info1.total_pages = ginfo.info1.total_pages;
3219 info1.pages_printed = ginfo.info1.pages_printed;
3220 info1.submitted = ginfo.info1.submitted;
3221
3222 ctr.level = 1;
3223 ctr.info.info1 = &info1;
3224
3225 torture_assert(tctx,
3226 test_SetJob(tctx, b, handle, info[i].info1.job_id, &ctr, 0),
3227 "failed to call test_SetJob level 1");
3228
3229 torture_assert(tctx,
3230 test_GetJob_args(tctx, b, handle, info[i].info1.job_id, 1, &ginfo),
3231 "failed to call test_GetJob");
3232
3233 if (strequal(ginfo.info1.document_name, document_name)) {
3234 torture_warning(tctx,
3235 talloc_asprintf(tctx, "document_name did *NOT* change from '%s' to '%s'\n",
3236 document_name, new_document_name));
3237 }
3238 }
3239
3240 for (i=0; i < num_jobs; i++) {
3241 if (!test_SetJob(tctx, b, handle, info[i].info1.job_id, NULL, SPOOLSS_JOB_CONTROL_PAUSE)) {
3242 torture_warning(tctx, "failed to pause printjob\n");
3243 }
3244 if (!test_SetJob(tctx, b, handle, info[i].info1.job_id, NULL, SPOOLSS_JOB_CONTROL_RESUME)) {
3245 torture_warning(tctx, "failed to resume printjob\n");
3246 }
3247 }
3248
3249 return true;
3250 }
3251
3252 static bool test_DoPrintTest(struct torture_context *tctx,
3253 struct dcerpc_binding_handle *b,
3254 struct policy_handle *handle)
3255 {
3256 bool ret = true;
3257 uint32_t num_jobs = 8;
3258 uint32_t *job_ids;
3259 int i;
3260
3261 torture_comment(tctx, "Testing real print operations\n");
3262
3263 job_ids = talloc_zero_array(tctx, uint32_t, num_jobs);
3264
3265 for (i=0; i < num_jobs; i++) {
3266 ret &= test_DoPrintTest_add_one_job(tctx, b, handle, &job_ids[i]);
3267 }
3268
3269 for (i=0; i < num_jobs; i++) {
3270 ret &= test_SetJob(tctx, b, handle, job_ids[i], NULL, SPOOLSS_JOB_CONTROL_DELETE);
3271 }
3272
3273 if (ret == true) {
3274 torture_comment(tctx, "real print operations test succeeded\n\n");
3275 }
3276
3277 return ret;
3278 }
3279
3280 static bool test_DoPrintTest_extended(struct torture_context *tctx,
3281 struct dcerpc_binding_handle *b,
3282 struct policy_handle *handle)
3283 {
3284 bool ret = true;
3285 uint32_t num_jobs = 8;
3286 uint32_t *job_ids;
3287 int i;
3288 torture_comment(tctx, "Testing real print operations (extended)\n");
3289
3290 job_ids = talloc_zero_array(tctx, uint32_t, num_jobs);
3291
3292 for (i=0; i < num_jobs; i++) {
3293 ret &= test_DoPrintTest_add_one_job(tctx, b, handle, &job_ids[i]);
3294 }
3295
3296 ret &= test_DoPrintTest_check_jobs(tctx, b, handle, num_jobs, job_ids);
3297
3298 for (i=0; i < num_jobs; i++) {
3299 ret &= test_SetJob(tctx, b, handle, job_ids[i], NULL, SPOOLSS_JOB_CONTROL_DELETE);
3300 }
3301
3302 if (ret == true) {
3303 torture_comment(tctx, "real print operations (extended) test succeeded\n\n");
3304 }
3305
3306 return ret;
3307 }
3308
3309 static bool test_PausePrinter(struct torture_context *tctx,
3310 struct dcerpc_binding_handle *b,
3311 struct policy_handle *handle)
3312 {
3313 NTSTATUS status;
3314 struct spoolss_SetPrinter r;
3315 struct spoolss_SetPrinterInfoCtr info_ctr;
3316 struct spoolss_DevmodeContainer devmode_ctr;
3317 struct sec_desc_buf secdesc_ctr;
3318
3319 info_ctr.level = 0;
3320 info_ctr.info.info0 = NULL;
3321
3322 ZERO_STRUCT(devmode_ctr);
3323 ZERO_STRUCT(secdesc_ctr);
3324
3325 r.in.handle = handle;
3326 r.in.info_ctr = &info_ctr;
3327 r.in.devmode_ctr = &devmode_ctr;
3328 r.in.secdesc_ctr = &secdesc_ctr;
3329 r.in.command = SPOOLSS_PRINTER_CONTROL_PAUSE;
3330
3331 torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_PAUSE\n");
3332
3333 status = dcerpc_spoolss_SetPrinter_r(b, tctx, &r);
3334
3335 torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
3336
3337 torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
3338
3339 return true;
3340 }
3341
3342 static bool test_ResumePrinter(struct torture_context *tctx,
3343 struct dcerpc_binding_handle *b,
3344 struct policy_handle *handle)
3345 {
3346 NTSTATUS status;
3347 struct spoolss_SetPrinter r;
3348 struct spoolss_SetPrinterInfoCtr info_ctr;
3349 struct spoolss_DevmodeContainer devmode_ctr;
3350 struct sec_desc_buf secdesc_ctr;
3351
3352 info_ctr.level = 0;
3353 info_ctr.info.info0 = NULL;
3354
3355 ZERO_STRUCT(devmode_ctr);
3356 ZERO_STRUCT(secdesc_ctr);
3357
3358 r.in.handle = handle;
3359 r.in.info_ctr = &info_ctr;
3360 r.in.devmode_ctr = &devmode_ctr;
3361 r.in.secdesc_ctr = &secdesc_ctr;
3362 r.in.command = SPOOLSS_PRINTER_CONTROL_RESUME;
3363
3364 torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_RESUME\n");
3365
3366 status = dcerpc_spoolss_SetPrinter_r(b, tctx, &r);
3367
3368 torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
3369
3370 torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
3371
3372 return true;
3373 }
3374
3375 static bool test_GetPrinterData(struct torture_context *tctx,
3376 struct dcerpc_binding_handle *b,
3377 struct policy_handle *handle,
3378 const char *value_name,
3379 enum winreg_Type *type_p,
3380 uint8_t **data_p,
3381 uint32_t *needed_p)
3382 {
3383 NTSTATUS status;
3384 struct spoolss_GetPrinterData r;
3385 uint32_t needed;
3386 enum winreg_Type type;
3387 union spoolss_PrinterData data;
3388
3389 r.in.handle = handle;
3390 r.in.value_name = value_name;
3391 r.in.offered = 0;
3392 r.out.needed = &needed;
3393 r.out.type = &type;
3394 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3395
3396 torture_comment(tctx, "Testing GetPrinterData(%s)\n", r.in.value_name);
3397
3398 status = dcerpc_spoolss_GetPrinterData_r(b, tctx, &r);
3399 torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
3400
3401 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3402 r.in.offered = needed;
3403 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3404 status = dcerpc_spoolss_GetPrinterData_r(b, tctx, &r);
3405 torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
3406 }
3407
3408 torture_assert_werr_ok(tctx, r.out.result,
3409 talloc_asprintf(tctx, "GetPrinterData(%s) failed", r.in.value_name));
3410
3411 CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterData, &data, type, needed, 1);
3412
3413 if (type_p) {
3414 *type_p = type;
3415 }
3416
3417 if (data_p) {
3418 *data_p = r.out.data;
3419 }
3420
3421 if (needed_p) {
3422 *needed_p = needed;
3423 }
3424
3425 return true;
3426 }
3427
3428 static bool test_GetPrinterDataEx(struct torture_context *tctx,
3429 struct dcerpc_pipe *p,
3430 struct policy_handle *handle,
3431 const char *key_name,
3432 const char *value_name,
3433 enum winreg_Type *type_p,
3434 uint8_t **data_p,
3435 uint32_t *needed_p)
3436 {
3437 NTSTATUS status;
3438 struct spoolss_GetPrinterDataEx r;
3439 enum winreg_Type type;
3440 uint32_t needed;
3441 union spoolss_PrinterData data;
3442 struct dcerpc_binding_handle *b = p->binding_handle;
3443
3444 r.in.handle = handle;
3445 r.in.key_name = key_name;
3446 r.in.value_name = value_name;
3447 r.in.offered = 0;
3448 r.out.type = &type;
3449 r.out.needed = &needed;
3450 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3451
3452 torture_comment(tctx, "Testing GetPrinterDataEx(%s - %s)\n",
3453 r.in.key_name, r.in.value_name);
3454
3455 status = dcerpc_spoolss_GetPrinterDataEx_r(b, tctx, &r);
3456 if (!NT_STATUS_IS_OK(status)) {
3457 if (NT_STATUS_EQUAL(status, NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE)) {
3458 torture_skip(tctx, "GetPrinterDataEx not supported by server\n");
3459 }
3460 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
3461 }
3462
3463 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3464 r.in.offered = needed;
3465 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3466 status = dcerpc_spoolss_GetPrinterDataEx_r(b, tctx, &r);
3467 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
3468 }
3469
3470 torture_assert_werr_ok(tctx, r.out.result,
3471 talloc_asprintf(tctx, "GetPrinterDataEx(%s - %s) failed", r.in.key_name, r.in.value_name));
3472
3473 CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterData, &data, type, needed, 1);
3474
3475 if (type_p) {
3476 *type_p = type;
3477 }
3478
3479 if (data_p) {
3480 *data_p = r.out.data;
3481 }
3482
3483 if (needed_p) {
3484 *needed_p = needed;
3485 }
3486
3487 return true;
3488 }
3489
3490 static bool test_get_environment(struct torture_context *tctx,
3491 struct dcerpc_binding_handle *b,
3492 struct policy_handle *handle,
3493 const char **architecture)
3494 {
3495 DATA_BLOB blob;
3496 enum winreg_Type type;
3497 uint8_t *data;
3498 uint32_t needed;
3499
3500 torture_assert(tctx,
3501 test_GetPrinterData(tctx, b, handle, "Architecture", &type, &data, &needed),
3502 "failed to get Architecture");
3503
3504 torture_assert_int_equal(tctx, type, REG_SZ, "unexpected type");
3505
3506 blob = data_blob_const(data, needed);
3507 *architecture = reg_val_data_string(tctx, REG_SZ, blob);
3508
3509 return true;
3510 }
3511
3512 static bool test_GetPrinterData_list(struct torture_context *tctx,
3513 struct dcerpc_pipe *p,
3514 struct policy_handle *handle,
3515 const char **architecture)
3516 {
3517 struct dcerpc_binding_handle *b = p->binding_handle;
3518 const char *list[] = {
3519 "W3SvcInstalled",
3520 "BeepEnabled",
3521 "EventLog",
3522 /* "NetPopup", not on w2k8 */
3523 /* "NetPopupToComputer", not on w2k8 */
3524 "MajorVersion",
3525 "MinorVersion",
3526 "DefaultSpoolDirectory",
3527 "Architecture",
3528 "DsPresent",
3529 "OSVersion",
3530 /* "OSVersionEx", not on s3 */
3531 "DNSMachineName"
3532 };
3533 int i;
3534
3535 for (i=0; i < ARRAY_SIZE(list); i++) {
3536 enum winreg_Type type, type_ex;
3537 uint8_t *data, *data_ex;
3538 uint32_t needed, needed_ex;
3539
3540 torture_assert(tctx, test_GetPrinterData(tctx, b, handle, list[i], &type, &data, &needed),
3541 talloc_asprintf(tctx, "GetPrinterData failed on %s\n", list[i]));
3542 torture_assert(tctx, test_GetPrinterDataEx(tctx, p, handle, "random_string", list[i], &type_ex, &data_ex, &needed_ex),
3543 talloc_asprintf(tctx, "GetPrinterDataEx failed on %s\n", list[i]));
3544 torture_assert_int_equal(tctx, type, type_ex, "type mismatch");
3545 torture_assert_int_equal(tctx, needed, needed_ex, "needed mismatch");
3546 torture_assert_mem_equal(tctx, data, data_ex, needed, "data mismatch");
3547
3548 if (strequal(list[i], "Architecture")) {
3549 if (architecture) {
3550 DATA_BLOB blob = data_blob_const(data, needed);
3551 *architecture = reg_val_data_string(tctx, REG_SZ, blob);
3552 }
3553 }
3554 }
3555
3556 return true;
3557 }
3558
3559 static bool test_EnumPrinterData(struct torture_context *tctx,
3560 struct dcerpc_pipe *p,
3561 struct policy_handle *handle,
3562 uint32_t enum_index,
3563 uint32_t value_offered,
3564 uint32_t data_offered,
3565 enum winreg_Type *type_p,
3566 uint32_t *value_needed_p,
3567 uint32_t *data_needed_p,
3568 const char **value_name_p,
3569 uint8_t **data_p,
3570 WERROR *result_p)
3571 {
3572 struct spoolss_EnumPrinterData r;
3573 uint32_t data_needed;
3574 uint32_t value_needed;
3575 enum winreg_Type type;
3576 struct dcerpc_binding_handle *b = p->binding_handle;
3577
3578 r.in.handle = handle;
3579 r.in.enum_index = enum_index;
3580 r.in.value_offered = value_offered;
3581 r.in.data_offered = data_offered;
3582 r.out.data_needed = &data_needed;
3583 r.out.value_needed = &value_needed;
3584 r.out.type = &type;
3585 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.data_offered);
3586 r.out.value_name = talloc_zero_array(tctx, const char, r.in.value_offered);
3587
3588 torture_comment(tctx, "Testing EnumPrinterData(%d)\n", enum_index);
3589
3590 torture_assert_ntstatus_ok(tctx,
3591 dcerpc_spoolss_EnumPrinterData_r(b, tctx, &r),
3592 "EnumPrinterData failed");
3593
3594 if (type_p) {
3595 *type_p = type;
3596 }
3597 if (value_needed_p) {
3598 *value_needed_p = value_needed;
3599 }
3600 if (data_needed_p) {
3601 *data_needed_p = data_needed;
3602 }
3603 if (value_name_p) {
3604 *value_name_p = r.out.value_name;
3605 }
3606 if (data_p) {
3607 *data_p = r.out.data;
3608 }
3609 if (result_p) {
3610 *result_p = r.out.result;
3611 }
3612
3613 return true;
3614 }
3615
3616
3617 static bool test_EnumPrinterData_all(struct torture_context *tctx,
3618 struct dcerpc_pipe *p,
3619 struct policy_handle *handle)
3620 {
3621 uint32_t enum_index = 0;
3622 enum winreg_Type type;
3623 uint32_t value_needed;
3624 uint32_t data_needed;
3625 uint8_t *data;
3626 const char *value_name;
3627 WERROR result;
3628
3629 torture_comment(tctx, "Testing EnumPrinterData\n");
3630
3631 do {
3632 torture_assert(tctx,
3633 test_EnumPrinterData(tctx, p, handle, enum_index, 0, 0,
3634 &type, &value_needed, &data_needed,
3635 &value_name, &data, &result),
3636 "EnumPrinterData failed");
3637
3638 if (W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS)) {
3639 break;
3640 }
3641
3642 torture_assert(tctx,
3643 test_EnumPrinterData(tctx, p, handle, enum_index, value_needed, data_needed,
3644 &type, &value_needed, &data_needed,
3645 &value_name, &data, &result),
3646 "EnumPrinterData failed");
3647
3648 if (W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS)) {
3649 break;
3650 }
3651
3652 enum_index++;
3653
3654 } while (W_ERROR_IS_OK(result));
3655
3656 torture_comment(tctx, "EnumPrinterData test succeeded\n");
3657
3658 return true;
3659 }
3660
3661 static bool test_EnumPrinterDataEx(struct torture_context *tctx,
3662 struct dcerpc_binding_handle *b,
3663 struct policy_handle *handle,
3664 const char *key_name,
3665 uint32_t *count_p,
3666 struct spoolss_PrinterEnumValues **info_p)
3667 {
3668 struct spoolss_EnumPrinterDataEx r;
3669 struct spoolss_PrinterEnumValues *info;
3670 uint32_t needed;
3671 uint32_t count;
3672
3673 r.in.handle = handle;
3674 r.in.key_name = key_name;
3675 r.in.offered = 0;
3676 r.out.needed = &needed;
3677 r.out.count = &count;
3678 r.out.info = &info;
3679
3680 torture_comment(tctx, "Testing EnumPrinterDataEx(%s)\n", key_name);
3681
3682 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterDataEx_r(b, tctx, &r),
3683 "EnumPrinterDataEx failed");
3684 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3685 r.in.offered = needed;
3686 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterDataEx_r(b, tctx, &r),
3687 "EnumPrinterDataEx failed");
3688 }
3689
3690 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDataEx failed");
3691
3692 CHECK_NEEDED_SIZE_ENUM(spoolss_EnumPrinterDataEx, info, count, needed, 1);
3693
3694 if (count_p) {
3695 *count_p = count;
3696 }
3697 if (info_p) {
3698 *info_p = info;
3699 }
3700
3701 return true;
3702 }
3703
3704 static bool test_SetPrinterData(struct torture_context *tctx,
3705 struct dcerpc_binding_handle *b,
3706 struct policy_handle *handle,
3707 const char *value_name,
3708 enum winreg_Type type,
3709 uint8_t *data,
3710 uint32_t offered);
3711 static bool test_DeletePrinterData(struct torture_context *tctx,
3712 struct dcerpc_binding_handle *b,
3713 struct policy_handle *handle,
3714 const char *value_name);
3715
3716 static bool test_EnumPrinterData_consistency(struct torture_context *tctx,
3717 struct dcerpc_pipe *p,
3718 struct policy_handle *handle)
3719 {
3720 uint32_t count;
3721 struct spoolss_PrinterEnumValues *info;
3722 int i;
3723 uint32_t value_needed, data_needed;
3724 uint32_t value_offered, data_offered;
3725 WERROR result;
3726 struct dcerpc_binding_handle *b = p->binding_handle;
3727
3728 enum winreg_Type type;
3729 DATA_BLOB blob;
3730
3731 torture_comment(tctx, "Testing EnumPrinterData vs EnumPrinterDataEx consistency\n");
3732
3733 torture_assert(tctx, push_reg_sz(tctx, &blob, "torture_data1"), "");
3734 type = REG_SZ;
3735
3736 torture_assert(tctx,
3737 test_SetPrinterData(tctx, b, handle, "torture_value1", type, blob.data, blob.length),
3738 "SetPrinterData failed");
3739
3740 blob = data_blob_string_const("torture_data2");
3741
3742 torture_assert(tctx,
3743 test_SetPrinterData(tctx, b, handle, "torture_value2", REG_BINARY, blob.data, blob.length),
3744 "SetPrinterData failed");
3745
3746 blob = data_blob_talloc(tctx, NULL, 4);
3747 SIVAL(blob.data, 0, 0x11223344);
3748
3749 torture_assert(tctx,
3750 test_SetPrinterData(tctx, b, handle, "torture_value3", type, blob.data, blob.length),
3751 "SetPrinterData failed");
3752
3753 torture_assert(tctx,
3754 test_EnumPrinterDataEx(tctx, b, handle, "PrinterDriverData", &count, &info),
3755 "failed to call EnumPrinterDataEx");
3756
3757 /* get the max sizes for value and data */
3758
3759 torture_assert(tctx,
3760 test_EnumPrinterData(tctx, p, handle, 0, 0, 0,
3761 NULL, &value_needed, &data_needed,
3762 NULL, NULL, &result),
3763 "EnumPrinterData failed");
3764 torture_assert_werr_ok(tctx, result, "unexpected result");
3765
3766 /* check if the reply from the EnumPrinterData really matches max values */
3767
3768 for (i=0; i < count; i++) {
3769 if (info[i].value_name_len > value_needed) {
3770 torture_fail(tctx,
3771 talloc_asprintf(tctx,
3772 "EnumPrinterDataEx gave a reply with value length %d which is larger then expected max value length %d from EnumPrinterData",
3773 info[i].value_name_len, value_needed));
3774 }
3775 if (info[i].data_length > data_needed) {
3776 torture_fail(tctx,
3777 talloc_asprintf(tctx,
3778 "EnumPrinterDataEx gave a reply with data length %d which is larger then expected max data length %d from EnumPrinterData",
3779 info[i].data_length, data_needed));
3780 }
3781 }
3782
3783 /* assuming that both EnumPrinterData and EnumPrinterDataEx do either
3784 * sort or not sort the replies by value name, we should be able to do
3785 * the following entry comparison */
3786
3787 data_offered = data_needed;
3788 value_offered = value_needed;
3789
3790 for (i=0; i < count; i++) {
3791
3792 const char *value_name;
3793 uint8_t *data;
3794
3795 torture_assert(tctx,
3796 test_EnumPrinterData(tctx, p, handle, i, value_offered, data_offered,
3797 &type, &value_needed, &data_needed,
3798 &value_name, &data, &result),
3799 "EnumPrinterData failed");
3800
3801 if (i -1 == count) {
3802 torture_assert_werr_equal(tctx, result, WERR_NO_MORE_ITEMS,
3803 "unexpected result");
3804 break;
3805 } else {
3806 torture_assert_werr_ok(tctx, result, "unexpected result");
3807 }
3808
3809 torture_assert_int_equal(tctx, type, info[i].type, "type mismatch");
3810 torture_assert_int_equal(tctx, value_needed, info[i].value_name_len, "value name length mismatch");
3811 torture_assert_str_equal(tctx, value_name, info[i].value_name, "value name mismatch");
3812 torture_assert_int_equal(tctx, data_needed, info[i].data_length, "data length mismatch");
3813 torture_assert_mem_equal(tctx, data, info[i].data->data, info[i].data_length, "data mismatch");
3814 }
3815
3816 torture_assert(tctx,
3817 test_DeletePrinterData(tctx, b, handle, "torture_value1"),
3818 "DeletePrinterData failed");
3819 torture_assert(tctx,
3820 test_DeletePrinterData(tctx, b, handle, "torture_value2"),
3821 "DeletePrinterData failed");
3822 torture_assert(tctx,
3823 test_DeletePrinterData(tctx, b, handle, "torture_value3"),
3824 "DeletePrinterData failed");
3825
3826 torture_comment(tctx, "EnumPrinterData vs EnumPrinterDataEx consistency test succeeded\n\n");
3827
3828 return true;
3829 }
3830
3831 static bool test_DeletePrinterData(struct torture_context *tctx,
3832 struct dcerpc_binding_handle *b,
3833 struct policy_handle *handle,
3834 const char *value_name)
3835 {
3836 NTSTATUS status;
3837 struct spoolss_DeletePrinterData r;
3838
3839 r.in.handle = handle;
3840 r.in.value_name = value_name;
3841
3842 torture_comment(tctx, "Testing DeletePrinterData(%s)\n",
3843 r.in.value_name);
3844
3845 status = dcerpc_spoolss_DeletePrinterData_r(b, tctx, &r);
3846
3847 torture_assert_ntstatus_ok(tctx, status, "DeletePrinterData failed");
3848 torture_assert_werr_ok(tctx, r.out.result, "DeletePrinterData failed");
3849
3850 return true;
3851 }
3852
3853 static bool test_DeletePrinterDataEx(struct torture_context *tctx,
3854 struct dcerpc_binding_handle *b,
3855 struct policy_handle *handle,
3856 const char *key_name,
3857 const char *value_name)
3858 {
3859 struct spoolss_DeletePrinterDataEx r;
3860
3861 r.in.handle = handle;
3862 r.in.key_name = key_name;
3863 r.in.value_name = value_name;
3864
3865 torture_comment(tctx, "Testing DeletePrinterDataEx(%s - %s)\n",
3866 r.in.key_name, r.in.value_name);
3867
3868 torture_assert_ntstatus_ok(tctx,
3869 dcerpc_spoolss_DeletePrinterDataEx_r(b, tctx, &r),
3870 "DeletePrinterDataEx failed");
3871 torture_assert_werr_ok(tctx, r.out.result,
3872 "DeletePrinterDataEx failed");
3873
3874 return true;
3875 }
3876
3877 static bool test_DeletePrinterKey(struct torture_context *tctx,
3878 struct dcerpc_binding_handle *b,
3879 struct policy_handle *handle,
3880 const char *key_name)
3881 {
3882 struct spoolss_DeletePrinterKey r;
3883
3884 r.in.handle = handle;
3885 r.in.key_name = key_name;
3886
3887 torture_comment(tctx, "Testing DeletePrinterKey(%s)\n", r.in.key_name);
3888
3889 if (strequal(key_name, "") && !torture_setting_bool(tctx, "dangerous", false)) {
3890 torture_skip(tctx, "not wiping out printer registry - enable dangerous tests to use\n");
3891 return true;
3892 }
3893
3894 torture_assert_ntstatus_ok(tctx,
3895 dcerpc_spoolss_DeletePrinterKey_r(b, tctx, &r),
3896 "DeletePrinterKey failed");
3897 torture_assert_werr_ok(tctx, r.out.result,
3898 "DeletePrinterKey failed");
3899
3900 return true;
3901 }
3902
3903 static bool test_winreg_OpenHKLM(struct torture_context *tctx,
3904 struct dcerpc_binding_handle *b,
3905 struct policy_handle *handle)
3906 {
3907 struct winreg_OpenHKLM r;
3908
3909 r.in.system_name = NULL;
3910 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
3911 r.out.handle = handle;
3912
3913 torture_comment(tctx, "Testing winreg_OpenHKLM\n");
3914
3915 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_OpenHKLM_r(b, tctx, &r), "OpenHKLM failed");
3916 torture_assert_werr_ok(tctx, r.out.result, "OpenHKLM failed");
3917
3918 return true;
3919 }
3920
3921 static void init_winreg_String(struct winreg_String *name, const char *s)
3922 {
3923 name->name = s;
3924 if (s) {
3925 name->name_len = 2 * (strlen_m(s) + 1);
3926 name->name_size = name->name_len;
3927 } else {
3928 name->name_len = 0;
3929 name->name_size = 0;
3930 }
3931 }
3932
3933 static bool test_winreg_OpenKey_opts(struct torture_context *tctx,
3934 struct dcerpc_binding_handle *b,
3935 struct policy_handle *hive_handle,
3936 const char *keyname,
3937 uint32_t options,
3938 struct policy_handle *key_handle)
3939 {
3940 struct winreg_OpenKey r;
3941
3942 r.in.parent_handle = hive_handle;
3943 init_winreg_String(&r.in.keyname, keyname);
3944 r.in.options = options;
3945 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
3946 r.out.handle = key_handle;
3947
3948 torture_comment(tctx, "Testing winreg_OpenKey(%s)\n", keyname);
3949
3950 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_OpenKey_r(b, tctx, &r), "OpenKey failed");
3951 torture_assert_werr_ok(tctx, r.out.result, "OpenKey failed");
3952
3953 return true;
3954 }
3955
3956 static bool test_winreg_OpenKey(struct torture_context *tctx,
3957 struct dcerpc_binding_handle *b,
3958 struct policy_handle *hive_handle,
3959 const char *keyname,
3960 struct policy_handle *key_handle)
3961 {
3962 return test_winreg_OpenKey_opts(tctx, b, hive_handle, keyname,
3963 REG_OPTION_NON_VOLATILE, key_handle);
3964 }
3965
3966 static bool test_winreg_CloseKey(struct torture_context *tctx,
3967 struct dcerpc_binding_handle *b,
3968 struct policy_handle *handle)
3969 {
3970 struct winreg_CloseKey r;
3971
3972 r.in.handle = handle;
3973 r.out.handle = handle;
3974
3975 torture_comment(tctx, "Testing winreg_CloseKey\n");
3976
3977 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_CloseKey_r(b, tctx, &r), "CloseKey failed");
3978 torture_assert_werr_ok(tctx, r.out.result, "CloseKey failed");
3979
3980 return true;
3981 }
3982
3983 bool test_winreg_QueryValue(struct torture_context *tctx,
3984 struct dcerpc_binding_handle *b,
3985 struct policy_handle *handle,
3986 const char *value_name,
3987 enum winreg_Type *type_p,
3988 uint32_t *data_size_p,
3989 uint32_t *data_length_p,
3990 uint8_t **data_p)
3991 {
3992 struct winreg_QueryValue r;
3993 enum winreg_Type type = REG_NONE;
3994 uint32_t data_size = 0;
3995 uint32_t data_length = 0;
3996 struct winreg_String valuename;
3997 uint8_t *data = NULL;
3998
3999 init_winreg_String(&valuename, value_name);
4000
4001 data = talloc_zero_array(tctx, uint8_t, 0);
4002
4003 r.in.handle = handle;
4004 r.in.value_name = &valuename;
4005 r.in.type = &type;
4006 r.in.data_size = &data_size;
4007 r.in.data_length = &data_length;
4008 r.in.data = data;
4009 r.out.type = &type;
4010 r.out.data = data;
4011 r.out.data_size = &data_size;
4012 r.out.data_length = &data_length;
4013
4014 torture_comment(tctx, "Testing winreg_QueryValue(%s)\n", value_name);
4015
4016 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue_r(b, tctx, &r), "QueryValue failed");
4017 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
4018 *r.in.data_size = *r.out.data_size;
4019 data = talloc_zero_array(tctx, uint8_t, *r.in.data_size);
4020 r.in.data = data;
4021 r.out.data = data;
4022 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue_r(b, tctx, &r), "QueryValue failed");
4023 }
4024 torture_assert_werr_ok(tctx, r.out.result, "QueryValue failed");
4025
4026 if (type_p) {
4027 *type_p = *r.out.type;
4028 }
4029 if (data_size_p) {
4030 *data_size_p = *r.out.data_size;
4031 }
4032 if (data_length_p) {
4033 *data_length_p = *r.out.data_length;
4034 }
4035 if (data_p) {
4036 *data_p = r.out.data;
4037 }
4038
4039 return true;
4040 }
4041
4042 static bool test_winreg_query_printerdata(struct torture_context *tctx,
4043 struct dcerpc_binding_handle *b,
4044 struct policy_handle *handle,
4045 const char *printer_name,
4046 const char *key_name,
4047 const char *value_name,
4048 enum winreg_Type *w_type,
4049 uint32_t *w_size,
4050 uint32_t *w_length,
4051 uint8_t **w_data)
4052 {
4053 const char *printer_key;
4054 struct policy_handle key_handle;
4055
4056 printer_key = talloc_asprintf(tctx, "%s\\%s\\%s",
4057 TOP_LEVEL_PRINT_PRINTERS_KEY, printer_name, key_name);
4058
4059 torture_assert(tctx,
4060 test_winreg_OpenKey(tctx, b, handle, printer_key, &key_handle), "");
4061
4062 torture_assert(tctx,
4063 test_winreg_QueryValue(tctx, b, &key_handle, value_name, w_type, w_size, w_length, w_data), "");
4064
4065 torture_assert(tctx,
4066 test_winreg_CloseKey(tctx, b, &key_handle), "");
4067
4068 return true;
4069 }
4070
4071 static bool test_GetForm_winreg(struct torture_context *tctx,
4072 struct dcerpc_binding_handle *b,
4073 struct policy_handle *handle,
4074 const char *key_name,
4075 const char *form_name,
4076 enum winreg_Type *w_type,
4077 uint32_t *w_size,
4078 uint32_t *w_length,
4079 uint8_t **w_data)
4080 {
4081 struct policy_handle key_handle;
4082
4083 torture_assert(tctx,
4084 test_winreg_OpenKey(tctx, b, handle, key_name, &key_handle), "");
4085
4086 torture_assert(tctx,
4087 test_winreg_QueryValue(tctx, b, &key_handle, form_name, w_type, w_size, w_length, w_data), "");
4088
4089 torture_assert(tctx,
4090 test_winreg_CloseKey(tctx, b, &key_handle), "");
4091
4092 return true;
4093 }
4094
4095 static bool test_winreg_symbolic_link(struct torture_context *tctx,
4096 struct dcerpc_binding_handle *b,
4097 struct policy_handle *handle,
4098 const char *symlink_keyname,
4099 const char *symlink_destination)
4100 {
4101 /* check if the first key is a symlink to the second key */
4102
4103 enum winreg_Type w_type;
4104 uint32_t w_size;
4105 uint32_t w_length;
4106 uint8_t *w_data;
4107 struct policy_handle key_handle;
4108 DATA_BLOB blob;
4109 const char *str;
4110
4111 if (torture_setting_bool(tctx, "samba3", false)) {
4112 torture_skip(tctx, "skip winreg symlink test against samba");
4113 }
4114
4115 torture_assert(tctx,
4116 test_winreg_OpenKey_opts(tctx, b, handle, symlink_keyname, REG_OPTION_OPEN_LINK, &key_handle),
4117 "failed to open key link");
4118
4119 torture_assert(tctx,
4120 test_winreg_QueryValue(tctx, b, &key_handle,
4121 "SymbolicLinkValue",
4122 &w_type, &w_size, &w_length, &w_data),
4123 "failed to query for 'SymbolicLinkValue' attribute");
4124
4125 torture_assert_int_equal(tctx, w_type, REG_LINK, "unexpected type");
4126
4127 blob = data_blob(w_data, w_size);
4128 str = reg_val_data_string(tctx, REG_SZ, blob);
4129
4130 torture_assert_str_equal(tctx, str, symlink_destination, "unexpected symlink target string");
4131
4132 torture_assert(tctx,
4133 test_winreg_CloseKey(tctx, b, &key_handle),
4134 "failed to close key link");
4135
4136 return true;
4137 }
4138
4139 static const char *strip_unc(const char *unc)
4140 {
4141 char *name;
4142
4143 if (!unc) {
4144 return NULL;
4145 }
4146
4147 if (unc[0] == '\\' && unc[1] == '\\') {
4148 unc +=2;
4149 }
4150
4151 name = strchr(unc, '\\');
4152 if (name) {
4153 return name+1;
4154 }
4155
4156 return unc;
4157 }
4158
4159 static bool test_GetPrinterInfo_winreg(struct torture_context *tctx,
4160 struct dcerpc_binding_handle *b,
4161 struct policy_handle *handle,
4162 const char *printer_name,
4163 struct dcerpc_binding_handle *winreg_handle,
4164 struct policy_handle *hive_handle)
4165 {
4166 union spoolss_PrinterInfo info;
4167 const char *keys[] = {
4168 TOP_LEVEL_CONTROL_PRINTERS_KEY,
4169 TOP_LEVEL_PRINT_PRINTERS_KEY
4170 };
4171 int i;
4172 const char *printername, *sharename;
4173
4174 torture_comment(tctx, "Testing Printer Info and winreg consistency\n");
4175
4176 torture_assert(tctx,
4177 test_GetPrinter_level(tctx, b, handle, 2, &info),
4178 "failed to get printer info level 2");
4179
4180 printername = strip_unc(info.info2.printername);
4181 sharename = strip_unc(info.info2.sharename);
4182
4183 #define test_sz(wname, iname) \
4184 do {\
4185 DATA_BLOB blob;\
4186 const char *str;\
4187 enum winreg_Type w_type;\
4188 uint32_t w_size;\
4189 uint32_t w_length;\
4190 uint8_t *w_data;\
4191 torture_assert(tctx,\
4192 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4193 &w_type, &w_size, &w_length, &w_data),\
4194 "failed to query winreg");\
4195 torture_assert_int_equal(tctx, w_type, REG_SZ, "unexpected type");\
4196 blob = data_blob(w_data, w_size);\
4197 str = reg_val_data_string(tctx, REG_SZ, blob);\
4198 if (w_size == 2 && iname == NULL) {\
4199 /*torture_comment(tctx, "%s: \"\", %s: (null)\n", #wname, #iname);\ */\
4200 } else {\
4201 torture_assert_str_equal(tctx, str, iname,\
4202 talloc_asprintf(tctx, "%s - %s mismatch", #wname, #iname));\
4203 }\
4204 } while(0);
4205
4206 #define test_dword(wname, iname) \
4207 do {\
4208 uint32_t value;\
4209 enum winreg_Type w_type;\
4210 uint32_t w_size;\
4211 uint32_t w_length;\
4212 uint8_t *w_data;\
4213 torture_assert(tctx,\
4214 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4215 &w_type, &w_size, &w_length, &w_data),\
4216 "failed to query winreg");\
4217 torture_assert_int_equal(tctx, w_type, REG_DWORD, "unexpected type");\
4218 torture_assert_int_equal(tctx, w_size, 4, "unexpected size");\
4219 torture_assert_int_equal(tctx, w_length, 4, "unexpected length");\
4220 value = IVAL(w_data, 0);\
4221 torture_assert_int_equal(tctx, value, iname,\
4222 talloc_asprintf(tctx, "%s - %s mismatch", #wname, #iname));\
4223 } while(0);
4224
4225 #define test_dm(wname, iname) \
4226 do {\
4227 DATA_BLOB blob;\
4228 struct spoolss_DeviceMode dm;\
4229 enum ndr_err_code ndr_err;\
4230 enum winreg_Type w_type;\
4231 uint32_t w_size;\
4232 uint32_t w_length;\
4233 uint8_t *w_data;\
4234 torture_assert(tctx,\
4235 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4236 &w_type, &w_size, &w_length, &w_data),\
4237 "failed to query winreg");\
4238 torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");\
4239 blob = data_blob(w_data, w_size);\
4240 ndr_err = ndr_pull_struct_blob(&blob, tctx, &dm,\
4241 (ndr_pull_flags_fn_t)ndr_pull_spoolss_DeviceMode);\
4242 torture_assert_ndr_success(tctx, ndr_err, "failed to unmarshall dm");\
4243 torture_assert(tctx, test_devicemode_equal(tctx, &dm, iname),\
4244 "dm unequal");\
4245 } while(0);
4246
4247 #define test_sd(wname, iname) \
4248 do {\
4249 DATA_BLOB blob;\
4250 struct security_descriptor sd;\
4251 enum ndr_err_code ndr_err;\
4252 enum winreg_Type w_type;\
4253 uint32_t w_size;\
4254 uint32_t w_length;\
4255 uint8_t *w_data;\
4256 torture_assert(tctx,\
4257 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4258 &w_type, &w_size, &w_length, &w_data),\
4259 "failed to query winreg");\
4260 torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");\
4261 blob = data_blob(w_data, w_size);\
4262 ndr_err = ndr_pull_struct_blob(&blob, tctx, &sd,\
4263 (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);\
4264 torture_assert_ndr_success(tctx, ndr_err, "failed to unmarshall sd");\
4265 torture_assert(tctx, test_security_descriptor_equal(tctx, &sd, iname),\
4266 "sd unequal");\
4267 } while(0);
4268
4269 #define test_multi_sz(wname, iname) \
4270 do {\
4271 DATA_BLOB blob;\
4272 const char **array;\
4273 enum winreg_Type w_type;\
4274 uint32_t w_size;\
4275 uint32_t w_length;\
4276 uint8_t *w_data;\
4277 int i;\
4278 torture_assert(tctx,\
4279 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4280 &w_type, &w_size, &w_length, &w_data),\
4281 "failed to query winreg");\
4282 torture_assert_int_equal(tctx, w_type, REG_MULTI_SZ, "unexpected type");\
4283 blob = data_blob(w_data, w_size);\
4284 torture_assert(tctx, \
4285 pull_reg_multi_sz(tctx, &blob, &array),\
4286 "failed to pull multi sz");\
4287 for (i=0; array[i] != NULL; i++) {\
4288 torture_assert_str_equal(tctx, array[i], iname[i],\
4289 talloc_asprintf(tctx, "%s - %s mismatch", #wname, iname[i]));\
4290 }\
4291 } while(0);
4292
4293
4294 if (!test_winreg_symbolic_link(tctx, winreg_handle, hive_handle,
4295 TOP_LEVEL_CONTROL_PRINTERS_KEY,
4296 "\\Registry\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Print\\Printers"))
4297 {
4298 torture_warning(tctx, "failed to check for winreg symlink");
4299 }
4300
4301
4302 for (i=0; i < ARRAY_SIZE(keys); i++) {
4303
4304 const char *printer_key;
4305 struct policy_handle key_handle;
4306
4307 printer_key = talloc_asprintf(tctx, "%s\\%s",
4308 keys[i], printer_name);
4309
4310 torture_assert(tctx,
4311 test_winreg_OpenKey(tctx, winreg_handle, hive_handle, printer_key, &key_handle), "");
4312
4313 test_sz("Name", printername);
4314 test_sz("Share Name", sharename);
4315 test_sz("Port", info.info2.portname);
4316 test_sz("Printer Driver", info.info2.drivername);
4317 test_sz("Description", info.info2.comment);
4318 test_sz("Location", info.info2.location);
4319 test_sz("Separator File", info.info2.sepfile);
4320 test_sz("Print Processor", info.info2.printprocessor);
4321 test_sz("Datatype", info.info2.datatype);
4322 test_sz("Parameters", info.info2.parameters);
4323 /* winreg: 0, spoolss not */
4324 /* test_dword("Attributes", info.info2.attributes); */
4325 test_dword("Priority", info.info2.priority);
4326 test_dword("Default Priority", info.info2.defaultpriority);
4327 /* winreg: 60, spoolss: 0 */
4328 /* test_dword("StartTime", info.info2.starttime); */
4329 /* test_dword("UntilTime", info.info2.untiltime); */
4330 /* winreg != spoolss */
4331 /* test_dword("Status", info.info2.status); */
4332 test_dm("Default DevMode", info.info2.devmode);
4333 test_sd("Security", info.info2.secdesc);
4334
4335 torture_assert(tctx,
4336 test_winreg_CloseKey(tctx, winreg_handle, &key_handle), "");
4337 }
4338
4339 #undef test_dm
4340 #undef test_sd
4341
4342 torture_comment(tctx, "Printer Info and winreg consistency test succeeded\n\n");
4343
4344 return true;
4345 }
4346
4347 static bool test_GetPrinterDriver2_level(struct torture_context *tctx,
4348 struct dcerpc_binding_handle *b,
4349 struct policy_handle *handle,
4350 const char *driver_name,
4351 const char *architecture,
4352 uint32_t level,
4353 uint32_t client_major_version,
4354 uint32_t client_minor_version,
4355 union spoolss_DriverInfo *info_p,
4356 WERROR *result);
4357
4358 static const char *strip_path(const char *path)
4359 {
4360 char *p;
4361
4362 if (path == NULL) {
4363 return NULL;
4364 }
4365
4366 p = strrchr(path, '\\');
4367 if (p) {
4368 return p+1;
4369 }
4370
4371 return path;
4372 }
4373
4374 static const char **strip_paths(const char **path_array)
4375 {
4376 int i;
4377
4378 if (path_array == NULL) {
4379 return NULL;
4380 }
4381
4382 for (i=0; path_array[i] != NULL; i++) {
4383 path_array[i] = strip_path(path_array[i]);
4384 }
4385
4386 return path_array;
4387 }
4388
4389 static const char *driver_winreg_date(TALLOC_CTX *mem_ctx, NTTIME nt)
4390 {
4391 time_t t;
4392 struct tm *tm;
4393 t = nt_time_to_unix(nt);
4394 tm = localtime(&t);
4395
4396 return talloc_asprintf(mem_ctx, "%02d/%02d/%04d",
4397 tm->tm_mon + 1, tm->tm_mday, tm->tm_year + 1900);
4398 }
4399
4400 static const char *driver_winreg_version(TALLOC_CTX *mem_ctx, uint64_t v)
4401 {
4402 return talloc_asprintf(mem_ctx, "%u.%u.%u.%u",
4403 (unsigned)((v >> 48) & 0xFFFF),
4404 (unsigned)((v >> 32) & 0xFFFF),
4405 (unsigned)((v >> 16) & 0xFFFF),
4406 (unsigned)(v & 0xFFFF));
4407 }
4408
4409 static bool test_GetDriverInfo_winreg(struct torture_context *tctx,
4410 struct dcerpc_binding_handle *b,
4411 struct policy_handle *handle,
4412 const char *printer_name,
4413 const char *driver_name,
4414 const char *environment,
4415 struct dcerpc_binding_handle *winreg_handle,
4416 struct policy_handle *hive_handle)
4417 {
4418 WERROR result;
4419 union spoolss_DriverInfo info;
4420 const char *driver_key;
4421 struct policy_handle key_handle;
4422
4423 const char *driver_path;
4424 const char *data_file;
4425 const char *config_file;
4426 const char *help_file;
4427 const char **dependent_files;
4428
4429 const char *driver_date;
4430 const char *inbox_driver_date;
4431
4432 const char *driver_version;
4433 const char *inbox_driver_version;
4434
4435 torture_comment(tctx, "Testing Driver Info and winreg consistency\n");
4436
4437 driver_key = talloc_asprintf(tctx, "%s\\%s\\Drivers\\Version-%d\\%s",
4438 TOP_LEVEL_CONTROL_ENVIRONMENTS_KEY,
4439 environment,
4440 3,
4441 driver_name);
4442
4443 torture_assert(tctx,
4444 test_winreg_OpenKey(tctx, winreg_handle, hive_handle, driver_key, &key_handle),
4445 "failed to open driver key");
4446
4447 if (torture_setting_bool(tctx, "samba3", false)) {
4448 goto try_level3;
4449 }
4450
4451 torture_assert(tctx,
4452 test_GetPrinterDriver2_level(tctx, b, handle, driver_name, environment, 8, 3, 0, &info, &result),
4453 "failed to get driver info level 8");
4454
4455 if (W_ERROR_EQUAL(result, WERR_INVALID_LEVEL)) {
4456 goto try_level6;
4457 }
4458
4459 driver_path = strip_path(info.info8.driver_path);
4460 data_file = strip_path(info.info8.data_file);
4461 config_file = strip_path(info.info8.config_file);
4462 help_file = strip_path(info.info8.help_file);
4463 dependent_files = strip_paths(info.info8.dependent_files);
4464
4465 driver_date = driver_winreg_date(tctx, info.info8.driver_date);
4466 inbox_driver_date = driver_winreg_date(tctx, info.info8.min_inbox_driver_ver_date);
4467
4468 driver_version = driver_winreg_version(tctx, info.info8.driver_version);
4469 inbox_driver_version = driver_winreg_version(tctx, info.info8.min_inbox_driver_ver_version);
4470
4471 test_sz("Configuration File", config_file);
4472 test_sz("Data File", data_file);
4473 test_sz("Datatype", info.info8.default_datatype);
4474 test_sz("Driver", driver_path);
4475 test_sz("DriverDate", driver_date);
4476 test_sz("DriverVersion", driver_version);
4477 test_sz("HardwareID", info.info8.hardware_id);
4478 test_sz("Help File", help_file);
4479 test_sz("InfPath", info.info8.inf_path);
4480 test_sz("Manufacturer", info.info8.manufacturer_name);
4481 test_sz("MinInboxDriverVerDate", inbox_driver_date);
4482 test_sz("MinInboxDriverVerVersion", inbox_driver_version);
4483 test_sz("Monitor", info.info8.monitor_name);
4484 test_sz("OEM URL", info.info8.manufacturer_url);
4485 test_sz("Print Processor", info.info8.print_processor);
4486 test_sz("Provider", info.info8.provider);
4487 test_sz("VendorSetup", info.info8.vendor_setup);
4488 test_multi_sz("ColorProfiles", info.info8.color_profiles);
4489 test_multi_sz("Dependent Files", dependent_files);
4490 test_multi_sz("CoreDependencies", info.info8.core_driver_dependencies);
4491 test_multi_sz("Previous Names", info.info8.previous_names);
4492 /* test_dword("Attributes", ?); */
4493 test_dword("PrinterDriverAttributes", info.info8.printer_driver_attributes);
4494 test_dword("Version", info.info8.version);
4495 /* test_dword("TempDir", ?); */
4496
4497 try_level6:
4498
4499 torture_assert(tctx,
4500 test_GetPrinterDriver2_level(tctx, b, handle, driver_name, environment, 6, 3, 0, &info, &result),
4501 "failed to get driver info level 6");
4502
4503 driver_path = strip_path(info.info6.driver_path);
4504 data_file = strip_path(info.info6.data_file);
4505 config_file = strip_path(info.info6.config_file);
4506 help_file = strip_path(info.info6.help_file);
4507 dependent_files = strip_paths(info.info6.dependent_files);
4508
4509 driver_date = driver_winreg_date(tctx, info.info6.driver_date);
4510
4511 driver_version = driver_winreg_version(tctx, info.info6.driver_version);
4512
4513 test_sz("Configuration File", config_file);
4514 test_sz("Data File", data_file);
4515 test_sz("Datatype", info.info6.default_datatype);
4516 test_sz("Driver", driver_path);
4517 test_sz("DriverDate", driver_date);
4518 test_sz("DriverVersion", driver_version);
4519 test_sz("HardwareID", info.info6.hardware_id);
4520 test_sz("Help File", help_file);
4521 test_sz("Manufacturer", info.info6.manufacturer_name);
4522 test_sz("Monitor", info.info6.monitor_name);
4523 test_sz("OEM URL", info.info6.manufacturer_url);
4524 test_sz("Provider", info.info6.provider);
4525 test_multi_sz("Dependent Files", dependent_files);
4526 test_multi_sz("Previous Names", info.info6.previous_names);
4527 /* test_dword("Attributes", ?); */
4528 test_dword("Version", info.info6.version);
4529 /* test_dword("TempDir", ?); */
4530
4531 try_level3:
4532
4533 torture_assert(tctx,
4534 test_GetPrinterDriver2_level(tctx, b, handle, driver_name, environment, 3, 3, 0, &info, &result),
4535 "failed to get driver info level 3");
4536
4537 driver_path = strip_path(info.info3.driver_path);
4538 data_file = strip_path(info.info3.data_file);
4539 config_file = strip_path(info.info3.config_file);
4540 help_file = strip_path(info.info3.help_file);
4541 dependent_files = strip_paths(info.info3.dependent_files);
4542
4543 test_sz("Configuration File", config_file);
4544 test_sz("Data File", data_file);
4545 test_sz("Datatype", info.info3.default_datatype);
4546 test_sz("Driver", driver_path);
4547 test_sz("Help File", help_file);
4548 test_sz("Monitor", info.info3.monitor_name);
4549 test_multi_sz("Dependent Files", dependent_files);
4550 /* test_dword("Attributes", ?); */
4551 test_dword("Version", info.info3.version);
4552 /* test_dword("TempDir", ?); */
4553
4554
4555 torture_assert(tctx,
4556 test_winreg_CloseKey(tctx, winreg_handle, &key_handle), "");
4557
4558 torture_comment(tctx, "Driver Info and winreg consistency test succeeded\n\n");
4559
4560 return true;
4561 }
4562
4563 #undef test_sz
4564 #undef test_dword
4565
4566 static bool test_SetPrinterData(struct torture_context *tctx,
4567 struct dcerpc_binding_handle *b,
4568 struct policy_handle *handle,
4569 const char *value_name,
4570 enum winreg_Type type,
4571 uint8_t *data,
4572 uint32_t offered)
4573 {
4574 struct spoolss_SetPrinterData r;
4575
4576 r.in.handle = handle;
4577 r.in.value_name = value_name;
4578 r.in.type = type;
4579 r.in.data = data;
4580 r.in.offered = offered;
4581
4582 torture_comment(tctx, "Testing SetPrinterData(%s)\n",
4583 r.in.value_name);
4584
4585 torture_assert_ntstatus_ok(tctx,
4586 dcerpc_spoolss_SetPrinterData_r(b, tctx, &r),
4587 "SetPrinterData failed");
4588 torture_assert_werr_ok(tctx, r.out.result,
4589 "SetPrinterData failed");
4590
4591 return true;
4592 }
4593
4594 static bool test_SetPrinterData_matrix(struct torture_context *tctx,
4595 struct dcerpc_binding_handle *b,
4596 struct policy_handle *handle,
4597 const char *printer_name,
4598 struct dcerpc_binding_handle *winreg_handle,
4599 struct policy_handle *hive_handle)
4600 {
4601 const char *values[] = {
4602 "spootyfoot",
4603 "spooty\\foot",
4604 #if 0
4605 /* FIXME: not working with s3 atm. */
4606 "spooty,foot",
4607 "spooty,fo,ot",
4608 #endif
4609 "spooty foot",
4610 #if 0
4611 /* FIXME: not working with s3 atm. */
4612 "spooty\\fo,ot",
4613 "spooty,fo\\ot"
4614 #endif
4615 };
4616 int i;
4617
4618 for (i=0; i < ARRAY_SIZE(values); i++) {
4619
4620 enum winreg_Type type;
4621 DATA_BLOB blob;
4622 uint8_t *data;
4623 uint32_t needed;
4624
4625 torture_assert(tctx, push_reg_sz(tctx, &blob, "dog"), "");
4626 type = REG_SZ;
4627
4628 torture_assert(tctx,
4629 test_SetPrinterData(tctx, b, handle, values[i], REG_SZ, blob.data, blob.length),
4630 "SetPrinterData failed");
4631
4632 torture_assert(tctx,
4633 test_GetPrinterData(tctx, b, handle, values[i], &type, &data, &needed),
4634 "GetPrinterData failed");
4635
4636 torture_assert_int_equal(tctx, type, REG_SZ, "type mismatch");
4637 torture_assert_int_equal(tctx, needed, blob.length, "size mismatch");
4638 torture_assert_mem_equal(tctx, data, blob.data, blob.length, "buffer mismatch");
4639
4640 if (winreg_handle && hive_handle) {
4641
4642 enum winreg_Type w_type;
4643 uint32_t w_size;
4644 uint32_t w_length;
4645 uint8_t *w_data;
4646
4647 torture_assert(tctx,
4648 test_winreg_query_printerdata(tctx, winreg_handle, hive_handle,
4649 printer_name, "PrinterDriverData", values[i],
4650 &w_type, &w_size, &w_length, &w_data), "");
4651
4652 torture_assert_int_equal(tctx, w_type, REG_SZ, "winreg type mismatch");
4653 torture_assert_int_equal(tctx, w_size, blob.length, "winreg size mismatch");
4654 torture_assert_int_equal(tctx, w_length, blob.length, "winreg length mismatch");
4655 torture_assert_mem_equal(tctx, w_data, blob.data, blob.length, "winreg buffer mismatch");
4656 }
4657
4658 torture_assert(tctx,
4659 test_DeletePrinterData(tctx, b, handle, values[i]),
4660 "DeletePrinterData failed");
4661 }
4662
4663 return true;
4664 }
4665
4666
4667 static bool test_EnumPrinterKey(struct torture_context *tctx,
4668 struct dcerpc_binding_handle *b,
4669 struct policy_handle *handle,
4670 const char *key_name,
4671 const char ***array);
4672
4673 static bool test_SetPrinterDataEx(struct torture_context *tctx,
4674 struct dcerpc_binding_handle *b,
4675 struct policy_handle *handle,
4676 const char *key_name,
4677 const char *value_name,
4678 enum winreg_Type type,
4679 uint8_t *data,
4680 uint32_t offered)
4681 {
4682 NTSTATUS status;
4683 struct spoolss_SetPrinterDataEx r;
4684
4685 r.in.handle = handle;
4686 r.in.key_name = key_name;
4687 r.in.value_name = value_name;
4688 r.in.type = type;
4689 r.in.data = data;
4690 r.in.offered = offered;
4691
4692 torture_comment(tctx, "Testing SetPrinterDataEx(%s - %s) type: %s, offered: 0x%08x\n",
4693 r.in.key_name, r.in.value_name, str_regtype(r.in.type), r.in.offered);
4694
4695 status = dcerpc_spoolss_SetPrinterDataEx_r(b, tctx, &r);
4696
4697 torture_assert_ntstatus_ok(tctx, status, "SetPrinterDataEx failed");
4698 torture_assert_werr_ok(tctx, r.out.result, "SetPrinterDataEx failed");
4699
4700 return true;
4701 }
4702
4703 static bool test_SetPrinterDataEx_matrix(struct torture_context *tctx,
4704 struct dcerpc_pipe *p,
4705 struct policy_handle *handle,
4706 const char *printername,
4707 struct dcerpc_binding_handle *winreg_handle,
4708 struct policy_handle *hive_handle)
4709 {
4710 struct dcerpc_binding_handle *b = p->binding_handle;
4711 const char *value_name = "dog";
4712 const char *keys[] = {
4713 "torturedataex",
4714 "torture data ex",
4715 #if 0
4716 /* FIXME: not working with s3 atm. */
4717 "torturedataex_with_subkey\\subkey",
4718 "torturedataex_with_subkey\\subkey:0",
4719 "torturedataex_with_subkey\\subkey:1",
4720 "torturedataex_with_subkey\\subkey\\subsubkey",
4721 "torturedataex_with_subkey\\subkey\\subsubkey:0",
4722 "torturedataex_with_subkey\\subkey\\subsubkey:1",
4723 #endif
4724 "torture,data",
4725 #if 0
4726 /* FIXME: not working with s3 atm. */
4727
4728 "torture,data,ex",
4729 "torture,data\\ex",
4730 "torture\\data,ex"
4731 #endif
4732 };
4733 enum winreg_Type types[] = {
4734 REG_SZ,
4735 REG_MULTI_SZ,
4736 REG_DWORD,
4737 REG_BINARY
4738 };
4739 const char *str = "abcdefghijklmnopqrstuvwxzy";
4740 int i, t, s;
4741
4742
4743 for (i=0; i < ARRAY_SIZE(keys); i++) {
4744 for (t=0; t < ARRAY_SIZE(types); t++) {
4745 for (s=0; s < strlen(str); s++) {
4746
4747 char *c;
4748 const char *key;
4749 enum winreg_Type type;
4750 const char *string = talloc_strndup(tctx, str, s);
4751 const char *array[2];
4752 DATA_BLOB blob = data_blob_string_const(string);
4753 const char **subkeys;
4754 DATA_BLOB data;
4755 uint8_t *data_out;
4756 uint32_t needed, offered = 0;
4757 uint32_t ecount;
4758 struct spoolss_PrinterEnumValues *einfo;
4759
4760 array[0] = talloc_strdup(tctx, string);
4761 array[1] = NULL;
4762
4763 if (types[t] == REG_DWORD) {
4764 s = 0xffff;
4765 }
4766
4767 if (torture_setting_bool(tctx, "samba3", false)) {
4768 if ((types[t] == REG_MULTI_SZ) && s == 0) {
4769 torture_warning(tctx, "samba3 does not handle 4 byte emtpy REG_MULTI_SZ buffers");
4770 continue;
4771 }
4772 }
4773
4774 switch (types[t]) {
4775 case REG_BINARY:
4776 data = blob;
4777 offered = blob.length;
4778 break;
4779 case REG_DWORD:
4780 data = data_blob_talloc(tctx, NULL, 4);
4781 SIVAL(data.data, 0, 0x12345678);
4782 offered = 4;
4783 break;
4784 case REG_SZ:
4785 torture_assert(tctx, push_reg_sz(tctx, &data, string), "");
4786 type = REG_SZ;
4787 offered = data.length;
4788 /*strlen_m_term(data.string)*2;*/
4789 break;
4790 case REG_MULTI_SZ:
4791 torture_assert(tctx, push_reg_multi_sz(tctx, &data, array), "");
4792 type = REG_MULTI_SZ;
4793 offered = data.length;
4794 break;
4795 default:
4796 torture_fail(tctx, talloc_asprintf(tctx, "type %d untested\n", types[t]));
4797 }
4798
4799 torture_assert(tctx,
4800 test_SetPrinterDataEx(tctx, b, handle, keys[i], value_name, types[t], data.data, offered),
4801 "failed to call SetPrinterDataEx");
4802
4803 torture_assert(tctx,
4804 test_GetPrinterDataEx(tctx, p, handle, keys[i], value_name, &type, &data_out, &needed),
4805 "failed to call GetPrinterDataEx");
4806
4807 torture_assert(tctx,
4808 test_EnumPrinterDataEx(tctx, b, handle, keys[i], &ecount, &einfo),
4809 "failed to call EnumPrinterDataEx");
4810
4811 torture_assert_int_equal(tctx, types[t], type, "type mismatch");
4812 torture_assert_int_equal(tctx, needed, offered, "size mismatch");
4813 torture_assert_mem_equal(tctx, data_out, data.data, offered, "buffer mismatch");
4814
4815 torture_assert_int_equal(tctx, ecount, 1, "unexpected enum count");
4816 torture_assert_str_equal(tctx, einfo[0].value_name, value_name, "value_name mismatch");
4817 torture_assert_int_equal(tctx, einfo[0].value_name_len, strlen_m_term(value_name)*2, "unexpected value_name_len");
4818 torture_assert_int_equal(tctx, einfo[0].type, types[t], "type mismatch");
4819 torture_assert_int_equal(tctx, einfo[0].data_length, offered, "size mismatch");
4820 if (einfo[0].data_length > 0) {
4821 torture_assert_mem_equal(tctx, einfo[0].data->data, data.data, offered, "buffer mismatch");
4822 }
4823
4824 if (winreg_handle && hive_handle) {
4825 enum winreg_Type w_type;
4826 uint32_t w_size;
4827 uint32_t w_length;
4828 uint8_t *w_data;
4829
4830 torture_assert(tctx,
4831 test_winreg_query_printerdata(tctx, winreg_handle, hive_handle,
4832 printername, keys[i], value_name,
4833 &w_type, &w_size, &w_length, &w_data), "");
4834
4835 torture_assert_int_equal(tctx, w_type, types[t], "winreg type mismatch");
4836 torture_assert_int_equal(tctx, w_size, offered, "winreg size mismatch");
4837 torture_assert_int_equal(tctx, w_length, offered, "winreg length mismatch");
4838 torture_assert_mem_equal(tctx, w_data, data.data, offered, "winreg buffer mismatch");
4839 }
4840
4841 key = talloc_strdup(tctx, keys[i]);
4842
4843 if (!test_DeletePrinterDataEx(tctx, b, handle, keys[i], value_name)) {
4844 return false;
4845 }
4846
4847 c = strchr(key, '\\');
4848 if (c) {
4849 int k;
4850
4851 /* we have subkeys */
4852
4853 *c = 0;
4854
4855 if (!test_EnumPrinterKey(tctx, b, handle, key, &subkeys)) {
4856 return false;
4857 }
4858
4859 for (k=0; subkeys && subkeys[k]; k++) {
4860
4861 const char *current_key = talloc_asprintf(tctx, "%s\\%s", key, subkeys[k]);
4862
4863 if (!test_DeletePrinterKey(tctx, b, handle, current_key)) {
4864 return false;
4865 }
4866 }
4867
4868 if (!test_DeletePrinterKey(tctx, b, handle, key)) {
4869 return false;
4870 }
4871
4872 } else {
4873 if (!test_DeletePrinterKey(tctx, b, handle, key)) {
4874 return false;
4875 }
4876 }
4877 }
4878 }
4879 }
4880
4881 return true;
4882 }
4883
4884 static bool test_PrinterData_winreg(struct torture_context *tctx,
4885 struct dcerpc_pipe *p,
4886 struct policy_handle *handle,
4887 const char *printer_name)
4888 {
4889 struct dcerpc_binding_handle *b = p->binding_handle;
4890 struct dcerpc_pipe *p2;
4891 bool ret = true;
4892 struct policy_handle hive_handle;
4893 struct dcerpc_binding_handle *b2;
4894
4895 torture_assert_ntstatus_ok(tctx,
4896 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
4897 "could not open winreg pipe");
4898 b2 = p2->binding_handle;
4899
4900 torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
4901
4902 ret &= test_SetPrinterData_matrix(tctx, b, handle, printer_name, b2, &hive_handle);
4903 ret &= test_SetPrinterDataEx_matrix(tctx, p, handle, printer_name, b2, &hive_handle);
4904
4905 test_winreg_CloseKey(tctx, b2, &hive_handle);
4906
4907 talloc_free(p2);
4908
4909 return ret;
4910 }
4911
4912 static bool test_Forms_winreg(struct torture_context *tctx,
4913 struct dcerpc_binding_handle *b,
4914 struct policy_handle *handle,
4915 bool print_server,
4916 const char *printer_name)
4917 {
4918 struct dcerpc_pipe *p2;
4919 bool ret = true;
4920 struct policy_handle hive_handle;
4921 struct dcerpc_binding_handle *b2;
4922
4923 torture_assert_ntstatus_ok(tctx,
4924 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
4925 "could not open winreg pipe");
4926 b2 = p2->binding_handle;
4927
4928 torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
4929
4930 ret = test_Forms(tctx, b, handle, print_server, printer_name, b2, &hive_handle);
4931
4932 test_winreg_CloseKey(tctx, b2, &hive_handle);
4933
4934 talloc_free(p2);
4935
4936 return ret;
4937 }
4938
4939 static bool test_PrinterInfo_winreg(struct torture_context *tctx,
4940 struct dcerpc_pipe *p,
4941 struct policy_handle *handle,
4942 const char *printer_name)
4943 {
4944 struct dcerpc_binding_handle *b = p->binding_handle;
4945 struct dcerpc_pipe *p2;
4946 bool ret = true;
4947 struct policy_handle hive_handle;
4948 struct dcerpc_binding_handle *b2;
4949
4950 torture_assert_ntstatus_ok(tctx,
4951 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
4952 "could not open winreg pipe");
4953 b2 = p2->binding_handle;
4954
4955 torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
4956
4957 ret = test_GetPrinterInfo_winreg(tctx, b, handle, printer_name, b2, &hive_handle);
4958
4959 test_winreg_CloseKey(tctx, b2, &hive_handle);
4960
4961 talloc_free(p2);
4962
4963 return ret;
4964 }
4965
4966 static bool test_DriverInfo_winreg(struct torture_context *tctx,
4967 struct dcerpc_pipe *p,
4968 struct policy_handle *handle,
4969 const char *printer_name,
4970 const char *driver_name,
4971 const char *environment)
4972 {
4973 struct dcerpc_binding_handle *b = p->binding_handle;
4974 struct dcerpc_pipe *p2;
4975 bool ret = true;
4976 struct policy_handle hive_handle;
4977 struct dcerpc_binding_handle *b2;
4978
4979 torture_assert_ntstatus_ok(tctx,
4980 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
4981 "could not open winreg pipe");
4982 b2 = p2->binding_handle;
4983
4984 torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
4985
4986 ret = test_GetDriverInfo_winreg(tctx, b, handle, printer_name, driver_name, environment, b2, &hive_handle);
4987
4988 test_winreg_CloseKey(tctx, b2, &hive_handle);
4989
4990 talloc_free(p2);
4991
4992 return ret;
4993 }
4994
4995 static bool test_PrinterData_DsSpooler(struct torture_context *tctx,
4996 struct dcerpc_pipe *p,
4997 struct policy_handle *handle,
4998 const char *printer_name)
4999 {
5000 struct spoolss_SetPrinterInfoCtr info_ctr;
5001 struct spoolss_DevmodeContainer devmode_ctr;
5002 struct sec_desc_buf secdesc_ctr;
5003 union spoolss_SetPrinterInfo sinfo;
5004 union spoolss_PrinterInfo info;
5005 struct dcerpc_binding_handle *b = p->binding_handle;
5006 const char *pname;
5007
5008 ZERO_STRUCT(info_ctr);
5009 ZERO_STRUCT(devmode_ctr);
5010 ZERO_STRUCT(secdesc_ctr);
5011
5012 torture_comment(tctx, "Testing DsSpooler <-> SetPrinter relations\n");
5013
5014 torture_assert(tctx,
5015 test_GetPrinter_level(tctx, b, handle, 2, &info),
5016 "failed to query Printer level 2");
5017
5018 torture_assert(tctx,
5019 PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo),
5020 "failed to convert");
5021
5022 info_ctr.level = 2;
5023 info_ctr.info = sinfo;
5024
5025 #define TEST_SZ(wname, iname) \
5026 do {\
5027 enum winreg_Type type;\
5028 uint8_t *data;\
5029 uint32_t needed;\
5030 DATA_BLOB blob;\
5031 const char *str;\
5032 torture_assert(tctx,\
5033 test_GetPrinterDataEx(tctx, p, handle, "DsSpooler", wname, &type, &data, &needed),\
5034 "failed to query");\
5035 torture_assert_int_equal(tctx, type, REG_SZ, "unexpected type");\
5036 blob = data_blob_const(data, needed);\
5037 torture_assert(tctx,\
5038 pull_reg_sz(tctx, &blob, &str),\
5039 "failed to pull REG_SZ");\
5040 torture_assert_str_equal(tctx, str, iname, "unexpected result");\
5041 } while(0);
5042
5043
5044 #define TEST_SET_SZ(wname, iname, val) \
5045 do {\
5046 enum winreg_Type type;\
5047 uint8_t *data;\
5048 uint32_t needed;\
5049 DATA_BLOB blob;\
5050 const char *str;\
5051 sinfo.info2->iname = val;\
5052 torture_assert(tctx,\
5053 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),\
5054 "failed to call SetPrinter");\
5055 torture_assert(tctx,\
5056 test_GetPrinterDataEx(tctx, p, handle, "DsSpooler", wname, &type, &data, &needed),\
5057 "failed to query");\
5058 torture_assert_int_equal(tctx, type, REG_SZ, "unexpected type");\
5059 blob = data_blob_const(data, needed);\
5060 torture_assert(tctx,\
5061 pull_reg_sz(tctx, &blob, &str),\
5062 "failed to pull REG_SZ");\
5063 torture_assert_str_equal(tctx, str, val, "unexpected result");\
5064 } while(0);
5065
5066 #define TEST_SET_DWORD(wname, iname, val) \
5067 do {\
5068 enum winreg_Type type;\
5069 uint8_t *data;\
5070 uint32_t needed;\
5071 uint32_t value;\
5072 sinfo.info2->iname = val;\
5073 torture_assert(tctx,\
5074 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),\
5075 "failed to call SetPrinter");\
5076 torture_assert(tctx,\
5077 test_GetPrinterDataEx(tctx, p, handle, "DsSpooler", wname, &type, &data, &needed),\
5078 "failed to query");\
5079 torture_assert_int_equal(tctx, type, REG_DWORD, "unexpected type");\
5080 torture_assert_int_equal(tctx, needed, 4, "unexpected length");\
5081 value = IVAL(data, 0); \
5082 torture_assert_int_equal(tctx, value, val, "unexpected result");\
5083 } while(0);
5084
5085 TEST_SET_SZ("description", comment, "newval");
5086 TEST_SET_SZ("location", location, "newval");
5087 /* TEST_SET_DWORD("priority", priority, 25); */
5088
5089 torture_assert(tctx,
5090 test_GetPrinter_level(tctx, b, handle, 2, &info),
5091 "failed to query Printer level 2");
5092
5093 TEST_SZ("description", info.info2.comment);
5094 /* TEST_SZ("driverName", info.info2.drivername); */
5095 TEST_SZ("location", info.info2.location);
5096
5097 pname = strrchr(info.info2.printername, '\\');
5098 if (pname == NULL) {
5099 pname = info.info2.printername;
5100 } else {
5101 pname++;
5102 }
5103 /* TEST_SZ("printerName", pname); */
5104 /* TEST_SZ("printSeparatorFile", info.info2.sepfile); */
5105 /* TEST_SZ("printShareName", info.info2.sharename); */
5106
5107 /* FIXME gd: complete the list */
5108
5109 #undef TEST_SZ
5110 #undef TEST_SET_SZ
5111 #undef TEST_DWORD
5112
5113 torture_comment(tctx, "DsSpooler <-> SetPrinter relations test succeeded\n\n");
5114
5115 return true;
5116 }
5117
5118 static bool test_GetChangeID_PrinterData(struct torture_context *tctx,
5119 struct dcerpc_binding_handle *b,
5120 struct policy_handle *handle,
5121 uint32_t *change_id)
5122 {
5123 enum winreg_Type type;
5124 uint8_t *data;
5125 uint32_t needed;
5126
5127 torture_assert(tctx,
5128 test_GetPrinterData(tctx, b, handle, "ChangeID", &type, &data, &needed),
5129 "failed to call GetPrinterData");
5130
5131 torture_assert(tctx, type == REG_DWORD, "unexpected type");
5132 torture_assert_int_equal(tctx, needed, 4, "unexpected size");
5133
5134 *change_id = IVAL(data, 0);
5135
5136 return true;
5137 }
5138
5139 static bool test_GetChangeID_PrinterDataEx(struct torture_context *tctx,
5140 struct dcerpc_pipe *p,
5141 struct policy_handle *handle,
5142 uint32_t *change_id)
5143 {
5144 enum winreg_Type type;
5145 uint8_t *data;
5146 uint32_t needed;
5147
5148 torture_assert(tctx,
5149 test_GetPrinterDataEx(tctx, p, handle, "PrinterDriverData", "ChangeID", &type, &data, &needed),
5150 "failed to call GetPrinterData");
5151
5152 torture_assert(tctx, type == REG_DWORD, "unexpected type");
5153 torture_assert_int_equal(tctx, needed, 4, "unexpected size");
5154
5155 *change_id = IVAL(data, 0);
5156
5157 return true;
5158 }
5159
5160 static bool test_GetChangeID_PrinterInfo(struct torture_context *tctx,
5161 struct dcerpc_binding_handle *b,
5162 struct policy_handle *handle,
5163 uint32_t *change_id)
5164 {
5165 union spoolss_PrinterInfo info;
5166
5167 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 0, &info),
5168 "failed to query Printer level 0");
5169
5170 *change_id = info.info0.change_id;
5171
5172 return true;
5173 }
5174
5175 static bool test_ChangeID(struct torture_context *tctx,
5176 struct dcerpc_pipe *p,
5177 struct policy_handle *handle)
5178 {
5179 uint32_t change_id, change_id_ex, change_id_info;
5180 uint32_t change_id2, change_id_ex2, change_id_info2;
5181 union spoolss_PrinterInfo info;
5182 const char *comment;
5183 struct dcerpc_binding_handle *b = p->binding_handle;
5184
5185 torture_comment(tctx, "Testing ChangeID: id change test #1\n");
5186
5187 torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id),
5188 "failed to query for ChangeID");
5189 torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
5190 "failed to query for ChangeID");
5191 torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info),
5192 "failed to query for ChangeID");
5193
5194 torture_assert_int_equal(tctx, change_id, change_id_ex,
5195 "change_ids should all be equal");
5196 torture_assert_int_equal(tctx, change_id_ex, change_id_info,
5197 "change_ids should all be equal");
5198
5199
5200 torture_comment(tctx, "Testing ChangeID: id change test #2\n");
5201
5202 torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id),
5203 "failed to query for ChangeID");
5204 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info),
5205 "failed to query Printer level 2");
5206 torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
5207 "failed to query for ChangeID");
5208 torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info),
5209 "failed to query for ChangeID");
5210 torture_assert_int_equal(tctx, change_id, change_id_ex,
5211 "change_id should not have changed");
5212 torture_assert_int_equal(tctx, change_id_ex, change_id_info,
5213 "change_id should not have changed");
5214
5215
5216 torture_comment(tctx, "Testing ChangeID: id change test #3\n");
5217
5218 torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id),
5219 "failed to query for ChangeID");
5220 torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
5221 "failed to query for ChangeID");
5222 torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info),
5223 "failed to query for ChangeID");
5224 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info),
5225 "failed to query Printer level 2");
5226 comment = talloc_strdup(tctx, info.info2.comment);
5227
5228 {
5229 struct spoolss_SetPrinterInfoCtr info_ctr;
5230 struct spoolss_DevmodeContainer devmode_ctr;
5231 struct sec_desc_buf secdesc_ctr;
5232 union spoolss_SetPrinterInfo sinfo;
5233
5234 ZERO_STRUCT(info_ctr);
5235 ZERO_STRUCT(devmode_ctr);
5236 ZERO_STRUCT(secdesc_ctr);
5237
5238
5239 torture_assert(tctx, PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
5240 sinfo.info2->comment = "torture_comment";
5241
5242 info_ctr.level = 2;
5243 info_ctr.info = sinfo;
5244
5245 torture_assert(tctx, test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
5246 "failed to call SetPrinter");
5247
5248 sinfo.info2->comment = comment;
5249
5250 torture_assert(tctx, test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
5251 "failed to call SetPrinter");
5252
5253 }
5254
5255 torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id2),
5256 "failed to query for ChangeID");
5257 torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex2),
5258 "failed to query for ChangeID");
5259 torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info2),
5260 "failed to query for ChangeID");
5261
5262 torture_assert_int_equal(tctx, change_id2, change_id_ex2,
5263 "change_ids should all be equal");
5264 torture_assert_int_equal(tctx, change_id_ex2, change_id_info2,
5265 "change_ids should all be equal");
5266
5267 torture_assert(tctx, (change_id < change_id2),
5268 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
5269 change_id2, change_id));
5270 torture_assert(tctx, (change_id_ex < change_id_ex2),
5271 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
5272 change_id_ex2, change_id_ex));
5273 torture_assert(tctx, (change_id_info < change_id_info2),
5274 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
5275 change_id_info2, change_id_info));
5276
5277 torture_comment(tctx, "ChangeID tests succeeded\n\n");
5278
5279 return true;
5280 }
5281
5282 static bool test_SecondaryClosePrinter(struct torture_context *tctx,
5283 struct dcerpc_pipe *p,
5284 struct policy_handle *handle)
5285 {
5286 NTSTATUS status;
5287 struct dcerpc_binding *b;
5288 struct dcerpc_pipe *p2;
5289 struct spoolss_ClosePrinter cp;
5290
5291 /* only makes sense on SMB */
5292 if (p->conn->transport.transport != NCACN_NP) {
5293 return true;
5294 }
5295
5296 torture_comment(tctx, "Testing close on secondary pipe\n");
5297
5298 status = dcerpc_parse_binding(tctx, p->conn->binding_string, &b);
5299 torture_assert_ntstatus_ok(tctx, status, "Failed to parse dcerpc binding");
5300
5301 status = dcerpc_secondary_connection(p, &p2, b);
5302 torture_assert_ntstatus_ok(tctx, status, "Failed to create secondary connection");
5303
5304 status = dcerpc_bind_auth_none(p2, &ndr_table_spoolss);
5305 torture_assert_ntstatus_ok(tctx, status, "Failed to create bind on secondary connection");
5306
5307 cp.in.handle = handle;
5308 cp.out.handle = handle;
5309
5310 status = dcerpc_spoolss_ClosePrinter_r(p2->binding_handle, tctx, &cp);
5311 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_RPC_SS_CONTEXT_MISMATCH,
5312 "ERROR: Allowed close on secondary connection");
5313
5314 talloc_free(p2);
5315
5316 return true;
5317 }
5318
5319 static bool test_OpenPrinter_badname(struct torture_context *tctx,
5320 struct dcerpc_binding_handle *b, const char *name)
5321 {
5322 NTSTATUS status;
5323 struct spoolss_OpenPrinter op;
5324 struct spoolss_OpenPrinterEx opEx;
5325 struct policy_handle handle;
5326 bool ret = true;
5327
5328 op.in.printername = name;
5329 op.in.datatype = NULL;
5330 op.in.devmode_ctr.devmode= NULL;
5331 op.in.access_mask = 0;
5332 op.out.handle = &handle;
5333
5334 torture_comment(tctx, "Testing OpenPrinter(%s) with bad name\n", op.in.printername);
5335
5336 status = dcerpc_spoolss_OpenPrinter_r(b, tctx, &op);
5337 torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
5338 torture_assert_werr_equal(tctx, op.out.result, WERR_INVALID_PRINTER_NAME,
5339 "unexpected result");
5340
5341 if (W_ERROR_IS_OK(op.out.result)) {
5342 ret &=test_ClosePrinter(tctx, b, &handle);
5343 }
5344
5345 opEx.in.printername = name;
5346 opEx.in.datatype = NULL;
5347 opEx.in.devmode_ctr.devmode = NULL;
5348 opEx.in.access_mask = 0;
5349 opEx.in.level = 1;
5350 opEx.in.userlevel.level1 = NULL;
5351 opEx.out.handle = &handle;
5352
5353 torture_comment(tctx, "Testing OpenPrinterEx(%s) with bad name\n", opEx.in.printername);
5354
5355 status = dcerpc_spoolss_OpenPrinterEx_r(b, tctx, &opEx);
5356 torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
5357 torture_assert_werr_equal(tctx, opEx.out.result, WERR_INVALID_PARAM,
5358 "unexpected result");
5359
5360 if (W_ERROR_IS_OK(opEx.out.result)) {
5361 ret &=test_ClosePrinter(tctx, b, &handle);
5362 }
5363
5364 return ret;
5365 }
5366
5367 static bool test_OpenPrinter_badname_list(struct torture_context *tctx,
5368 struct dcerpc_binding_handle *b,
5369 const char *server_name)
5370 {
5371 const char *badnames[] = {
5372 "__INVALID_PRINTER__",
5373 "\\\\__INVALID_HOST__",
5374 "",
5375 "\\\\\\",
5376 "\\\\\\__INVALID_PRINTER__"
5377 };
5378 const char *badname;
5379 int i;
5380
5381 for (i=0; i < ARRAY_SIZE(badnames); i++) {
5382 torture_assert(tctx,
5383 test_OpenPrinter_badname(tctx, b, badnames[i]),
5384 "");
5385 }
5386
5387 badname = talloc_asprintf(tctx, "\\\\%s\\", server_name);
5388 torture_assert(tctx,
5389 test_OpenPrinter_badname(tctx, b, badname),
5390 "");
5391
5392 badname = talloc_asprintf(tctx, "\\\\%s\\__INVALID_PRINTER__", server_name);
5393 torture_assert(tctx,
5394 test_OpenPrinter_badname(tctx, b, badname),
5395 "");
5396
5397 return true;
5398 }
5399
5400 static bool test_OpenPrinter(struct torture_context *tctx,
5401 struct dcerpc_pipe *p,
5402 const char *name,
5403 const char *environment)
5404 {
5405 NTSTATUS status;
5406 struct spoolss_OpenPrinter r;
5407 struct policy_handle handle;
5408 bool ret = true;
5409 struct dcerpc_binding_handle *b = p->binding_handle;
5410
5411 r.in.printername = talloc_asprintf(tctx, "\\\\%s\\%s", dcerpc_server_name(p), name);
5412 r.in.datatype = NULL;
5413 r.in.devmode_ctr.devmode= NULL;
5414 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
5415 r.out.handle = &handle;
5416
5417 torture_comment(tctx, "Testing OpenPrinter(%s)\n", r.in.printername);
5418
5419 status = dcerpc_spoolss_OpenPrinter_r(b, tctx, &r);
5420
5421 torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
5422
5423 torture_assert_werr_ok(tctx, r.out.result, "OpenPrinter failed");
5424
5425 if (!test_GetPrinter(tctx, b, &handle, environment)) {
5426 ret = false;
5427 }
5428
5429 if (!torture_setting_bool(tctx, "samba3", false)) {
5430 if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
5431 ret = false;
5432 }
5433 }
5434
5435 if (!test_ClosePrinter(tctx, b, &handle)) {
5436 ret = false;
5437 }
5438
5439 return ret;
5440 }
5441
5442 static bool call_OpenPrinterEx(struct torture_context *tctx,
5443 struct dcerpc_pipe *p,
5444 const char *name,
5445 struct spoolss_DeviceMode *devmode,
5446 struct policy_handle *handle)
5447 {
5448 struct spoolss_OpenPrinterEx r;
5449 struct spoolss_UserLevel1 userlevel1;
5450 NTSTATUS status;
5451 struct dcerpc_binding_handle *b = p->binding_handle;
5452
5453 if (name && name[0]) {
5454 r.in.printername = talloc_asprintf(tctx, "\\\\%s\\%s",
5455 dcerpc_server_name(p), name);
5456 } else {
5457 r.in.printername = talloc_asprintf(tctx, "\\\\%s",
5458 dcerpc_server_name(p));
5459 }
5460
5461 r.in.datatype = NULL;
5462 r.in.devmode_ctr.devmode= devmode;
5463 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
5464 r.in.level = 1;
5465 r.in.userlevel.level1 = &userlevel1;
5466 r.out.handle = handle;
5467
5468 userlevel1.size = 1234;
5469 userlevel1.client = "hello";
5470 userlevel1.user = "spottyfoot!";
5471 userlevel1.build = 1;
5472 userlevel1.major = 2;
5473 userlevel1.minor = 3;
5474 userlevel1.processor = 4;
5475
5476 torture_comment(tctx, "Testing OpenPrinterEx(%s)\n", r.in.printername);
5477
5478 status = dcerpc_spoolss_OpenPrinterEx_r(b, tctx, &r);
5479
5480 torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
5481
5482 torture_assert_werr_ok(tctx, r.out.result, "OpenPrinterEx failed");
5483
5484 return true;
5485 }
5486
5487 static bool test_printer_rename(struct torture_context *tctx,
5488 struct dcerpc_pipe *p,
5489 struct policy_handle *handle,
5490 const char *name)
5491 {
5492 bool ret = true;
5493 union spoolss_PrinterInfo info;
5494 union spoolss_SetPrinterInfo sinfo;
5495 struct spoolss_SetPrinterInfoCtr info_ctr;
5496 struct spoolss_DevmodeContainer devmode_ctr;
5497 struct sec_desc_buf secdesc_ctr;
5498 const char *printer_name;
5499 const char *printer_name_orig;
5500 const char *printer_name_new = "SAMBA smbtorture Test Printer (Copy 2)";
5501 struct policy_handle new_handle;
5502 const char *q;
5503 struct dcerpc_binding_handle *b = p->binding_handle;
5504
5505 ZERO_STRUCT(devmode_ctr);
5506 ZERO_STRUCT(secdesc_ctr);
5507
5508 torture_comment(tctx, "Testing Printer rename operations\n");
5509
5510 torture_assert(tctx,
5511 test_GetPrinter_level(tctx, b, handle, 2, &info),
5512 "failed to call GetPrinter level 2");
5513
5514 printer_name_orig = talloc_strdup(tctx, info.info2.printername);
5515
5516 q = strrchr(info.info2.printername, '\\');
5517 if (q) {
5518 torture_warning(tctx,
5519 "server returns printername %s incl. servername although we did not set servername", info.info2.printername);
5520 }
5521
5522 torture_assert(tctx,
5523 PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
5524
5525 sinfo.info2->printername = printer_name_new;
5526
5527 info_ctr.level = 2;
5528 info_ctr.info = sinfo;
5529
5530 torture_assert(tctx,
5531 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
5532 "failed to call SetPrinter level 2");
5533
5534 torture_assert(tctx,
5535 test_GetPrinter_level(tctx, b, handle, 2, &info),
5536 "failed to call GetPrinter level 2");
5537
5538 printer_name = talloc_strdup(tctx, info.info2.printername);
5539
5540 q = strrchr(info.info2.printername, '\\');
5541 if (q) {
5542 torture_warning(tctx,
5543 "server returns printername %s incl. servername although we did not set servername", info.info2.printername);
5544 q++;
5545 printer_name = q;
5546 }
5547
5548 torture_assert_str_equal(tctx, printer_name, printer_name_new,
5549 "new printer name was not set");
5550
5551 /* samba currently cannot fully rename printers */
5552 if (!torture_setting_bool(tctx, "samba3", false)) {
5553 torture_assert(tctx,
5554 test_OpenPrinter_badname(tctx, b, printer_name_orig),
5555 "still can open printer with oldname after rename");
5556 } else {
5557 torture_warning(tctx, "*not* checking for open with oldname after rename for samba3");
5558 }
5559
5560 torture_assert(tctx,
5561 call_OpenPrinterEx(tctx, p, printer_name_new, NULL, &new_handle),
5562 "failed to open printer with new name");
5563
5564 torture_assert(tctx,
5565 test_GetPrinter_level(tctx, b, &new_handle, 2, &info),
5566 "failed to call GetPrinter level 2");
5567
5568 /* FIXME: we openend with servername! */
5569 printer_name = talloc_asprintf(tctx, "\\\\%s\\%s",
5570 dcerpc_server_name(p), printer_name_new);
5571
5572 torture_assert_str_equal(tctx, info.info2.printername, printer_name,
5573 "new printer name was not set");
5574
5575 torture_assert(tctx,
5576 test_ClosePrinter(tctx, b, &new_handle),
5577 "failed to close printer");
5578
5579 torture_comment(tctx, "Printer rename operations test succeeded\n\n");
5580
5581 return ret;
5582 }
5583
5584
5585 static bool test_OpenPrinterEx(struct torture_context *tctx,
5586 struct dcerpc_pipe *p,
5587 const char *name,
5588 const char *environment)
5589 {
5590 struct policy_handle handle;
5591 bool ret = true;
5592 struct dcerpc_binding_handle *b = p->binding_handle;
5593
5594 if (!call_OpenPrinterEx(tctx, p, name, NULL, &handle)) {
5595 return false;
5596 }
5597
5598 if (!test_PrinterInfo_SD(tctx, b, &handle)) {
5599 ret = false;
5600 }
5601
5602 if (!test_GetPrinter(tctx, b, &handle, environment)) {
5603 ret = false;
5604 }
5605
5606 if (!test_EnumForms_all(tctx, b, &handle, false)) {
5607 ret = false;
5608 }
5609
5610 if (!test_Forms(tctx, b, &handle, false, name, NULL, NULL)) {
5611 ret = false;
5612 }
5613
5614 if (!test_Forms_winreg(tctx, b, &handle, false, name)) {
5615 ret = false;
5616 }
5617
5618 if (!test_EnumPrinterData_all(tctx, p, &handle)) {
5619 ret = false;
5620 }
5621
5622 if (!test_EnumPrinterDataEx(tctx, b, &handle, "PrinterDriverData", NULL, NULL)) {
5623 ret = false;
5624 }
5625
5626 if (!test_EnumPrinterData_consistency(tctx, p, &handle)) {
5627 ret = false;
5628 }
5629
5630 if (!test_printer_keys(tctx, b, &handle)) {
5631 ret = false;
5632 }
5633
5634 if (!test_PausePrinter(tctx, b, &handle)) {
5635 ret = false;
5636 }
5637
5638 if (!test_DoPrintTest(tctx, b, &handle)) {
5639 ret = false;
5640 }
5641
5642 if (!test_ResumePrinter(tctx, b, &handle)) {
5643 ret = false;
5644 }
5645
5646 if (!test_SetPrinterData_matrix(tctx, b, &handle, name, NULL, NULL)) {
5647 ret = false;
5648 }
5649
5650 if (!test_SetPrinterDataEx_matrix(tctx, p, &handle, name, NULL, NULL)) {
5651 ret = false;
5652 }
5653
5654 if (!torture_setting_bool(tctx, "samba3", false)) {
5655 if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
5656 ret = false;
5657 }
5658 }
5659
5660 if (!test_ClosePrinter(tctx, b, &handle)) {
5661 ret = false;
5662 }
5663
5664 return ret;
5665 }
5666
5667 static bool test_EnumPrinters_old(struct torture_context *tctx,
5668 struct dcerpc_pipe *p,
5669 const char *environment)
5670 {
5671 struct spoolss_EnumPrinters r;
5672 NTSTATUS status;
5673 uint16_t levels[] = {1, 2, 4, 5};
5674 int i;
5675 bool ret = true;
5676 struct dcerpc_binding_handle *b = p->binding_handle;
5677
5678 for (i=0;i<ARRAY_SIZE(levels);i++) {
5679 union spoolss_PrinterInfo *info;
5680 int j;
5681 uint32_t needed;
5682 uint32_t count;
5683
5684 r.in.flags = PRINTER_ENUM_LOCAL;
5685 r.in.server = "";
5686 r.in.level = levels[i];
5687 r.in.buffer = NULL;
5688 r.in.offered = 0;
5689 r.out.needed = &needed;
5690 r.out.count = &count;
5691 r.out.info = &info;
5692
5693 torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
5694
5695 status = dcerpc_spoolss_EnumPrinters_r(b, tctx, &r);
5696 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
5697
5698 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
5699 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
5700 r.in.buffer = &blob;
5701 r.in.offered = needed;
5702 status = dcerpc_spoolss_EnumPrinters_r(b, tctx, &r);
5703 }
5704
5705 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
5706
5707 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
5708
5709 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, needed, 4);
5710
5711 if (!info) {
5712 torture_comment(tctx, "No printers returned\n");
5713 return true;
5714 }
5715
5716 for (j=0;j<count;j++) {
5717 if (r.in.level == 1) {
5718 char *unc = talloc_strdup(tctx, info[j].info1.name);
5719 char *slash, *name;
5720 name = unc;
5721 if (unc[0] == '\\' && unc[1] == '\\') {
5722 unc +=2;
5723 }
5724 slash = strchr(unc, '\\');
5725 if (slash) {
5726 slash++;
5727 name = slash;
5728 }
5729 if (!test_OpenPrinter(tctx, p, name, environment)) {
5730 ret = false;
5731 }
5732 if (!test_OpenPrinterEx(tctx, p, name, environment)) {
5733 ret = false;
5734 }
5735 }
5736 }
5737 }
5738
5739 return ret;
5740 }
5741
5742 static bool test_GetPrinterDriver(struct torture_context *tctx,
5743 struct dcerpc_binding_handle *b,
5744 struct policy_handle *handle,
5745 const char *driver_name)
5746 {
5747 struct spoolss_GetPrinterDriver r;
5748 uint32_t needed;
5749
5750 r.in.handle = handle;
5751 r.in.architecture = "W32X86";
5752 r.in.level = 1;
5753 r.in.buffer = NULL;
5754 r.in.offered = 0;
5755 r.out.needed = &needed;
5756
5757 torture_comment(tctx, "Testing GetPrinterDriver level %d\n", r.in.level);
5758
5759 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver_r(b, tctx, &r),
5760 "failed to call GetPrinterDriver");
5761 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
5762 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
5763 r.in.buffer = &blob;
5764 r.in.offered = needed;
5765 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver_r(b, tctx, &r),
5766 "failed to call GetPrinterDriver");
5767 }
5768
5769 torture_assert_werr_ok(tctx, r.out.result,
5770 "failed to call GetPrinterDriver");
5771
5772 CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverInfo, r.out.info, r.in.level, needed, 4);
5773
5774 return true;
5775 }
5776
5777 static bool test_GetPrinterDriver2_level(struct torture_context *tctx,
5778 struct dcerpc_binding_handle *b,
5779 struct policy_handle *handle,
5780 const char *driver_name,
5781 const char *architecture,
5782 uint32_t level,
5783 uint32_t client_major_version,
5784 uint32_t client_minor_version,
5785 union spoolss_DriverInfo *info_p,
5786 WERROR *result_p)
5787
5788 {
5789 struct spoolss_GetPrinterDriver2 r;
5790 uint32_t needed;
5791 uint32_t server_major_version;
5792 uint32_t server_minor_version;
5793
5794 r.in.handle = handle;
5795 r.in.architecture = architecture;
5796 r.in.client_major_version = client_major_version;
5797 r.in.client_minor_version = client_minor_version;
5798 r.in.buffer = NULL;
5799 r.in.offered = 0;
5800 r.in.level = level;
5801 r.out.needed = &needed;
5802 r.out.server_major_version = &server_major_version;
5803 r.out.server_minor_version = &server_minor_version;
5804
5805 torture_comment(tctx, "Testing GetPrinterDriver2(%s) level %d\n",
5806 driver_name, r.in.level);
5807
5808 torture_assert_ntstatus_ok(tctx,
5809 dcerpc_spoolss_GetPrinterDriver2_r(b, tctx, &r),
5810 "failed to call GetPrinterDriver2");
5811 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
5812 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
5813 r.in.buffer = &blob;
5814 r.in.offered = needed;
5815 torture_assert_ntstatus_ok(tctx,
5816 dcerpc_spoolss_GetPrinterDriver2_r(b, tctx, &r),
5817 "failed to call GetPrinterDriver2");
5818 }
5819
5820 if (result_p) {
5821 *result_p = r.out.result;
5822 }
5823
5824 if (W_ERROR_EQUAL(r.out.result, WERR_INVALID_LEVEL)) {
5825 switch (r.in.level) {
5826 case 101:
5827 case 8:
5828 torture_comment(tctx,
5829 "level %d not implemented, not considering as an error\n",
5830 r.in.level);
5831 return true;
5832 default:
5833 break;
5834 }
5835 }
5836
5837 torture_assert_werr_ok(tctx, r.out.result,
5838 "failed to call GetPrinterDriver2");
5839
5840 CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverInfo, r.out.info, r.in.level, needed, 4);
5841
5842 if (info_p) {
5843 *info_p = *r.out.info;
5844 }
5845
5846 return true;
5847 }
5848
5849 static bool test_GetPrinterDriver2(struct torture_context *tctx,
5850 struct dcerpc_binding_handle *b,
5851 struct policy_handle *handle,
5852 const char *driver_name,
5853 const char *architecture)
5854 {
5855 uint16_t levels[] = {1, 2, 3, 4, 5, 6, 8, 101 };
5856 int i;
5857
5858
5859 for (i=0;i<ARRAY_SIZE(levels);i++) {
5860
5861 torture_assert(tctx,
5862 test_GetPrinterDriver2_level(tctx, b, handle, driver_name, architecture, levels[i], 3, 0, NULL, NULL),
5863 "");
5864 }
5865
5866 return true;
5867 }
5868
5869 static bool test_EnumPrinterDrivers_old(struct torture_context *tctx,
5870 struct dcerpc_pipe *p,
5871 const char *environment)
5872 {
5873 uint16_t levels[] = {1, 2, 3, 4, 5, 6};
5874 int i;
5875 struct dcerpc_binding_handle *b = p->binding_handle;
5876 const char *server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
5877
5878 for (i=0;i<ARRAY_SIZE(levels);i++) {
5879
5880 uint32_t count;
5881 union spoolss_DriverInfo *info;
5882
5883 torture_assert(tctx,
5884 test_EnumPrinterDrivers_args(tctx, b, server_name, environment, levels[i], &count, &info),
5885 "failed to enumerate drivers");
5886
5887 if (!info) {
5888 torture_comment(tctx, "No printer drivers returned\n");
5889 break;
5890 }
5891 }
5892
5893 return true;
5894 }
5895
5896 static bool test_DeletePrinter(struct torture_context *tctx,
5897 struct dcerpc_binding_handle *b,
5898 struct policy_handle *handle)
5899 {
5900 struct spoolss_DeletePrinter r;
5901
5902 torture_comment(tctx, "Testing DeletePrinter\n");
5903
5904 r.in.handle = handle;
5905
5906 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_DeletePrinter_r(b, tctx, &r),
5907 "failed to delete printer");
5908 torture_assert_werr_ok(tctx, r.out.result,
5909 "failed to delete printer");
5910
5911 return true;
5912 }
5913
5914 static bool test_EnumPrinters_findname(struct torture_context *tctx,
5915 struct dcerpc_binding_handle *b,
5916 uint32_t flags,
5917 uint32_t level,
5918 const char *name,
5919 bool *found)
5920 {
5921 struct spoolss_EnumPrinters e;
5922 uint32_t count;
5923 union spoolss_PrinterInfo *info;
5924 uint32_t needed;
5925 int i;
5926
5927 *found = false;
5928
5929 e.in.flags = flags;
5930 e.in.server = NULL;
5931 e.in.level = level;
5932 e.in.buffer = NULL;
5933 e.in.offered = 0;
5934 e.out.count = &count;
5935 e.out.info = &info;
5936 e.out.needed = &needed;
5937
5938 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters_r(b, tctx, &e),
5939 "failed to enum printers");
5940
5941 if (W_ERROR_EQUAL(e.out.result, WERR_INSUFFICIENT_BUFFER)) {
5942 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
5943 e.in.buffer = &blob;
5944 e.in.offered = needed;
5945
5946 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters_r(b, tctx, &e),
5947 "failed to enum printers");
5948 }
5949
5950 torture_assert_werr_ok(tctx, e.out.result,
5951 "failed to enum printers");
5952
5953 for (i=0; i < count; i++) {
5954
5955 const char *current = NULL;
5956 const char *q;
5957
5958 switch (level) {
5959 case 1:
5960 current = info[i].info1.name;
5961 break;
5962 }
5963
5964 if (strequal(current, name)) {
5965 *found = true;
5966 break;
5967 }
5968
5969 q = strrchr(current, '\\');
5970 if (q) {
5971 if (!e.in.server) {
5972 torture_warning(tctx,
5973 "server returns printername %s incl. servername although we did not set servername", current);
5974 }
5975 q++;
5976 if (strequal(q, name)) {
5977 *found = true;
5978 break;
5979 }
5980 }
5981 }
5982
5983 return true;
5984 }
5985
5986 static bool test_AddPrinter_wellknown(struct torture_context *tctx,
5987 struct dcerpc_pipe *p,
5988 const char *printername,
5989 bool ex)
5990 {
5991 WERROR result;
5992 struct spoolss_AddPrinter r;
5993 struct spoolss_AddPrinterEx rex;
5994 struct spoolss_SetPrinterInfoCtr info_ctr;
5995 struct spoolss_SetPrinterInfo1 info1;
5996 struct spoolss_DevmodeContainer devmode_ctr;
5997 struct sec_desc_buf secdesc_ctr;
5998 struct spoolss_UserLevelCtr userlevel_ctr;
5999 struct policy_handle handle;
6000 bool found = false;
6001 struct dcerpc_binding_handle *b = p->binding_handle;
6002
6003 ZERO_STRUCT(devmode_ctr);
6004 ZERO_STRUCT(secdesc_ctr);
6005 ZERO_STRUCT(userlevel_ctr);
6006 ZERO_STRUCT(info1);
6007
6008 torture_comment(tctx, "Testing AddPrinter%s(%s) level 1\n",
6009 ex ? "Ex":"", printername);
6010
6011 /* try to add printer to wellknown printer list (level 1) */
6012
6013 userlevel_ctr.level = 1;
6014
6015 info_ctr.info.info1 = &info1;
6016 info_ctr.level = 1;
6017
6018 rex.in.server = NULL;
6019 rex.in.info_ctr = &info_ctr;
6020 rex.in.devmode_ctr = &devmode_ctr;
6021 rex.in.secdesc_ctr = &secdesc_ctr;
6022 rex.in.userlevel_ctr = &userlevel_ctr;
6023 rex.out.handle = &handle;
6024
6025 r.in.server = NULL;
6026 r.in.info_ctr = &info_ctr;
6027 r.in.devmode_ctr = &devmode_ctr;
6028 r.in.secdesc_ctr = &secdesc_ctr;
6029 r.out.handle = &handle;
6030
6031 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6032 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6033 "failed to add printer");
6034 result = ex ? rex.out.result : r.out.result;
6035 torture_assert_werr_equal(tctx, result, WERR_INVALID_PRINTER_NAME,
6036 "unexpected result code");
6037
6038 info1.name = printername;
6039 info1.flags = PRINTER_ATTRIBUTE_SHARED;
6040
6041 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6042 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6043 "failed to add printer");
6044 result = ex ? rex.out.result : r.out.result;
6045 torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
6046 "unexpected result code");
6047
6048 /* bizarre protocol, WERR_PRINTER_ALREADY_EXISTS means success here,
6049 better do a real check to see the printer is really there */
6050
6051 torture_assert(tctx, test_EnumPrinters_findname(tctx, b,
6052 PRINTER_ENUM_NETWORK, 1,
6053 printername,
6054 &found),
6055 "failed to enum printers");
6056
6057 torture_assert(tctx, found, "failed to find newly added printer");
6058
6059 info1.flags = 0;
6060
6061 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6062 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6063 "failed to add printer");
6064 result = ex ? rex.out.result : r.out.result;
6065 torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
6066 "unexpected result code");
6067
6068 /* bizarre protocol, WERR_PRINTER_ALREADY_EXISTS means success here,
6069 better do a real check to see the printer has really been removed
6070 from the well known printer list */
6071
6072 found = false;
6073
6074 torture_assert(tctx, test_EnumPrinters_findname(tctx, b,
6075 PRINTER_ENUM_NETWORK, 1,
6076 printername,
6077 &found),
6078 "failed to enum printers");
6079 #if 0
6080 torture_assert(tctx, !found, "printer still in well known printer list");
6081 #endif
6082 return true;
6083 }
6084
6085 static bool test_AddPrinter_normal(struct torture_context *tctx,
6086 struct dcerpc_pipe *p,
6087 struct policy_handle *handle_p,
6088 const char *printername,
6089 const char *drivername,
6090 const char *portname,
6091 struct spoolss_DeviceMode *devmode,
6092 bool ex)
6093 {
6094 WERROR result;
6095 struct spoolss_AddPrinter r;
6096 struct spoolss_AddPrinterEx rex;
6097 struct spoolss_SetPrinterInfoCtr info_ctr;
6098 struct spoolss_SetPrinterInfo2 info2;
6099 struct spoolss_DevmodeContainer devmode_ctr;
6100 struct sec_desc_buf secdesc_ctr;
6101 struct spoolss_UserLevelCtr userlevel_ctr;
6102 struct policy_handle handle;
6103 bool found = false;
6104 bool existing_printer_deleted = false;
6105 struct dcerpc_binding_handle *b = p->binding_handle;
6106
6107 ZERO_STRUCT(devmode_ctr);
6108 ZERO_STRUCT(secdesc_ctr);
6109 ZERO_STRUCT(userlevel_ctr);
6110
6111 torture_comment(tctx, "Testing AddPrinter%s(%s) level 2\n",
6112 ex ? "Ex":"", printername);
6113
6114 devmode_ctr.devmode = devmode;
6115
6116 userlevel_ctr.level = 1;
6117
6118 rex.in.server = NULL;
6119 rex.in.info_ctr = &info_ctr;
6120 rex.in.devmode_ctr = &devmode_ctr;
6121 rex.in.secdesc_ctr = &secdesc_ctr;
6122 rex.in.userlevel_ctr = &userlevel_ctr;
6123 rex.out.handle = &handle;
6124
6125 r.in.server = NULL;
6126 r.in.info_ctr = &info_ctr;
6127 r.in.devmode_ctr = &devmode_ctr;
6128 r.in.secdesc_ctr = &secdesc_ctr;
6129 r.out.handle = &handle;
6130
6131 again:
6132
6133 /* try to add printer to printer list (level 2) */
6134
6135 ZERO_STRUCT(info2);
6136
6137 info_ctr.info.info2 = &info2;
6138 info_ctr.level = 2;
6139
6140 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6141 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6142 "failed to add printer");
6143 result = ex ? rex.out.result : r.out.result;
6144 torture_assert_werr_equal(tctx, result, WERR_INVALID_PRINTER_NAME,
6145 "unexpected result code");
6146
6147 info2.printername = printername;
6148
6149 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6150 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6151 "failed to add printer");
6152 result = ex ? rex.out.result : r.out.result;
6153
6154 if (W_ERROR_EQUAL(result, WERR_PRINTER_ALREADY_EXISTS)) {
6155 struct policy_handle printer_handle;
6156
6157 if (existing_printer_deleted) {
6158 torture_fail(tctx, "already deleted printer still existing?");
6159 }
6160
6161 torture_assert(tctx, call_OpenPrinterEx(tctx, p, printername, NULL, &printer_handle),
6162 "failed to open printer handle");
6163
6164 torture_assert(tctx, test_DeletePrinter(tctx, b, &printer_handle),
6165 "failed to delete printer");
6166
6167 torture_assert(tctx, test_ClosePrinter(tctx, b, &printer_handle),
6168 "failed to close server handle");
6169
6170 existing_printer_deleted = true;
6171
6172 goto again;
6173 }
6174
6175 torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PORT,
6176 "unexpected result code");
6177
6178 info2.portname = portname;
6179
6180 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6181 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6182 "failed to add printer");
6183 result = ex ? rex.out.result : r.out.result;
6184 torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PRINTER_DRIVER,
6185 "unexpected result code");
6186
6187 info2.drivername = drivername;
6188
6189 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6190 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6191 "failed to add printer");
6192 result = ex ? rex.out.result : r.out.result;
6193
6194 /* w2k8r2 allows to add printer w/o defining printprocessor */
6195
6196 if (!W_ERROR_IS_OK(result)) {
6197 torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PRINTPROCESSOR,
6198 "unexpected result code");
6199
6200 info2.printprocessor = "winprint";
6201
6202 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6203 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6204 "failed to add printer");
6205 result = ex ? rex.out.result : r.out.result;
6206 torture_assert_werr_ok(tctx, result,
6207 "failed to add printer");
6208 }
6209
6210 *handle_p = handle;
6211
6212 /* we are paranoid, really check if the printer is there now */
6213
6214 torture_assert(tctx, test_EnumPrinters_findname(tctx, b,
6215 PRINTER_ENUM_LOCAL, 1,
6216 printername,
6217 &found),
6218 "failed to enum printers");
6219 torture_assert(tctx, found, "failed to find newly added printer");
6220
6221 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
6222 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
6223 "failed to add printer");
6224 result = ex ? rex.out.result : r.out.result;
6225 torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
6226 "unexpected result code");
6227
6228 return true;
6229 }
6230
6231 static bool test_printer_info(struct torture_context *tctx,
6232 struct dcerpc_binding_handle *b,
6233 struct policy_handle *handle)
6234 {
6235 bool ret = true;
6236
6237 if (torture_setting_bool(tctx, "samba3", false)) {
6238 torture_skip(tctx, "skipping printer info cross tests against samba 3");
6239 }
6240
6241 if (!test_PrinterInfo(tctx, b, handle)) {
6242 ret = false;
6243 }
6244
6245 if (!test_SetPrinter_errors(tctx, b, handle)) {
6246 ret = false;
6247 }
6248
6249 return ret;
6250 }
6251
6252 static bool test_EnumPrinterKey(struct torture_context *tctx,
6253 struct dcerpc_binding_handle *b,
6254 struct policy_handle *handle,
6255 const char *key_name,
6256 const char ***array)
6257 {
6258 struct spoolss_EnumPrinterKey r;
6259 uint32_t needed = 0;
6260 union spoolss_KeyNames key_buffer;
6261 int32_t offered[] = { 0, 1, 2, 3, 4, 5, -1, -2, -3, -4, -5, 256, 512, 1024, 2048 };
6262 uint32_t _ndr_size;
6263 int i;
6264
6265 r.in.handle = handle;
6266 r.in.key_name = key_name;
6267 r.out.key_buffer = &key_buffer;
6268 r.out.needed = &needed;
6269 r.out._ndr_size = &_ndr_size;
6270
6271 for (i=0; i < ARRAY_SIZE(offered); i++) {
6272
6273 if (offered[i] < 0 && needed) {
6274 if (needed <= 4) {
6275 continue;
6276 }
6277 r.in.offered = needed + offered[i];
6278 } else {
6279 r.in.offered = offered[i];
6280 }
6281
6282 ZERO_STRUCT(key_buffer);
6283
6284 torture_comment(tctx, "Testing EnumPrinterKey(%s) with %d offered\n", r.in.key_name, r.in.offered);
6285
6286 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterKey_r(b, tctx, &r),
6287 "failed to call EnumPrinterKey");
6288 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
6289
6290 torture_assert(tctx, (_ndr_size == r.in.offered/2),
6291 talloc_asprintf(tctx, "EnumPrinterKey size mismatch, _ndr_size %d (expected %d)",
6292 _ndr_size, r.in.offered/2));
6293
6294 r.in.offered = needed;
6295 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterKey_r(b, tctx, &r),
6296 "failed to call EnumPrinterKey");
6297 }
6298
6299 if (offered[i] > 0) {
6300 torture_assert_werr_ok(tctx, r.out.result,
6301 "failed to call EnumPrinterKey");
6302 }
6303
6304 torture_assert(tctx, (_ndr_size == r.in.offered/2),
6305 talloc_asprintf(tctx, "EnumPrinterKey size mismatch, _ndr_size %d (expected %d)",
6306 _ndr_size, r.in.offered/2));
6307
6308 torture_assert(tctx, (*r.out.needed <= r.in.offered),
6309 talloc_asprintf(tctx, "EnumPrinterKey size mismatch: needed %d is not <= offered %d", *r.out.needed, r.in.offered));
6310
6311 torture_assert(tctx, (*r.out.needed <= _ndr_size * 2),
6312 talloc_asprintf(tctx, "EnumPrinterKey size mismatch: needed %d is not <= _ndr_size %d * 2", *r.out.needed, _ndr_size));
6313
6314 if (key_buffer.string_array) {
6315 uint32_t calc_needed = 0;
6316 int s;
6317 for (s=0; key_buffer.string_array[s]; s++) {
6318 calc_needed += strlen_m_term(key_buffer.string_array[s])*2;
6319 }
6320 if (!key_buffer.string_array[0]) {
6321 calc_needed += 2;
6322 }
6323 calc_needed += 2;
6324
6325 torture_assert_int_equal(tctx, *r.out.needed, calc_needed,
6326 "EnumPrinterKey unexpected size");
6327 }
6328 }
6329
6330 if (array) {
6331 *array = key_buffer.string_array;
6332 }
6333
6334 return true;
6335 }
6336
6337 bool test_printer_keys(struct torture_context *tctx,
6338 struct dcerpc_binding_handle *b,
6339 struct policy_handle *handle)
6340 {
6341 const char **key_array = NULL;
6342 int i;
6343
6344 torture_comment(tctx, "Testing Printer Keys\n");
6345
6346 torture_assert(tctx, test_EnumPrinterKey(tctx, b, handle, "", &key_array),
6347 "failed to call test_EnumPrinterKey");
6348
6349 for (i=0; key_array && key_array[i]; i++) {
6350 torture_assert(tctx, test_EnumPrinterKey(tctx, b, handle, key_array[i], NULL),
6351 "failed to call test_EnumPrinterKey");
6352 }
6353 for (i=0; key_array && key_array[i]; i++) {
6354 torture_assert(tctx, test_EnumPrinterDataEx(tctx, b, handle, key_array[i], NULL, NULL),
6355 "failed to call test_EnumPrinterDataEx");
6356 }
6357
6358 torture_comment(tctx, "Printer Keys test succeeded\n\n");
6359
6360 return true;
6361 }
6362
6363 static bool test_one_printer(struct torture_context *tctx,
6364 struct dcerpc_pipe *p,
6365 struct policy_handle *handle,
6366 const char *name,
6367 const char *drivername,
6368 const char *environment,
6369 bool have_driver,
6370 struct spoolss_DeviceMode *devmode)
6371 {
6372 bool ret = true;
6373 struct dcerpc_binding_handle *b = p->binding_handle;
6374
6375 if (!test_PausePrinter(tctx, b, handle)) {
6376 ret = false;
6377 }
6378
6379 if (!test_DoPrintTest(tctx, b, handle)) {
6380 ret = false;
6381 }
6382
6383 if (!test_DoPrintTest_extended(tctx, b, handle)) {
6384 torture_comment(tctx, "extended printing test failed!\n");
6385 }
6386
6387 if (!test_ResumePrinter(tctx, b, handle)) {
6388 ret = false;
6389 }
6390
6391 if (!test_printer_info(tctx, b, handle)) {
6392 ret = false;
6393 }
6394
6395 if (!test_PrinterInfo_SD(tctx, b, handle)) {
6396 ret = false;
6397 }
6398
6399 if (!test_PrinterInfo_DevMode(tctx, p, handle, name, devmode)) {
6400 ret = false;
6401 }
6402
6403 if (!test_PrinterInfo_winreg(tctx, p, handle, name)) {
6404 ret = false;
6405 }
6406
6407 if (!test_ChangeID(tctx, p, handle)) {
6408 ret = false;
6409 }
6410
6411 if (!test_printer_keys(tctx, b, handle)) {
6412 ret = false;
6413 }
6414
6415 if (!test_EnumPrinterData_consistency(tctx, p, handle)) {
6416 ret = false;
6417 }
6418
6419 if (!test_SetPrinterDataEx_matrix(tctx, p, handle, name, NULL, NULL)) {
6420 ret = false;
6421 }
6422
6423 if (!test_PrinterData_winreg(tctx, p, handle, name)) {
6424 ret = false;
6425 }
6426
6427 if (!test_PrinterData_DsSpooler(tctx, p, handle, name)) {
6428 ret = false;
6429 }
6430
6431 if (have_driver) {
6432 if (!test_DriverInfo_winreg(tctx, p, handle, name, drivername, environment)) {
6433 ret = false;
6434 }
6435 }
6436
6437 if (!test_printer_rename(tctx, p, handle, name)) {
6438 ret = false;
6439 }
6440
6441 return ret;
6442 }
6443
6444 static bool test_csetprinter(struct torture_context *tctx,
6445 struct dcerpc_pipe *p,
6446 struct policy_handle *handle,
6447 const char *printername,
6448 const char *drivername,
6449 const char *portname)
6450 {
6451 union spoolss_PrinterInfo info;
6452 struct policy_handle new_handle, new_handle2;
6453 struct dcerpc_binding_handle *b = p->binding_handle;
6454
6455 torture_comment(tctx, "Testing c_setprinter\n");
6456
6457 torture_assert(tctx,
6458 test_GetPrinter_level(tctx, b, handle, 0, &info),
6459 "failed to get level 0 printer info");
6460 torture_comment(tctx, "csetprinter on initial printer handle: %d\n",
6461 info.info0.c_setprinter);
6462
6463 /* check if c_setprinter on 1st handle increases after a printer has
6464 * been added */
6465
6466 torture_assert(tctx,
6467 test_AddPrinter_normal(tctx, p, &new_handle, printername, drivername, portname, NULL, false),
6468 "failed to add new printer");
6469 torture_assert(tctx,
6470 test_GetPrinter_level(tctx, b, handle, 0, &info),
6471 "failed to get level 0 printer info");
6472 torture_comment(tctx, "csetprinter on initial printer handle (after add): %d\n",
6473 info.info0.c_setprinter);
6474
6475 /* check if c_setprinter on new handle increases after a printer has
6476 * been added */
6477
6478 torture_assert(tctx,
6479 test_GetPrinter_level(tctx, b, &new_handle, 0, &info),
6480 "failed to get level 0 printer info");
6481 torture_comment(tctx, "csetprinter on created handle: %d\n",
6482 info.info0.c_setprinter);
6483
6484 /* open the new printer and check if c_setprinter increases */
6485
6486 torture_assert(tctx,
6487 call_OpenPrinterEx(tctx, p, printername, NULL, &new_handle2),
6488 "failed to open created printer");
6489 torture_assert(tctx,
6490 test_GetPrinter_level(tctx, b, &new_handle2, 0, &info),
6491 "failed to get level 0 printer info");
6492 torture_comment(tctx, "csetprinter on new handle (after openprinter): %d\n",
6493 info.info0.c_setprinter);
6494
6495 /* cleanup */
6496
6497 torture_assert(tctx,
6498 test_ClosePrinter(tctx, b, &new_handle2),
6499 "failed to close printer");
6500 torture_assert(tctx,
6501 test_DeletePrinter(tctx, b, &new_handle),
6502 "failed to delete new printer");
6503
6504 return true;
6505 }
6506
6507 static bool test_add_printer_args_with_driver(struct torture_context *tctx,
6508 struct dcerpc_pipe *p,
6509 struct torture_printer_context *t)
6510 {
6511 bool ret = true;
6512 struct policy_handle handle;
6513 bool found = false;
6514 struct dcerpc_binding_handle *b = p->binding_handle;
6515 const char *printer_name = t->info2.printername;
6516 const char *driver_name = t->added_driver ? t->driver.info8.driver_name : t->info2.drivername;
6517 const char *port_name = t->info2.portname;
6518 const char *printer_name2 = talloc_asprintf(tctx, "%s2", printer_name);
6519
6520 if (t->wellknown) {
6521 torture_assert(tctx,
6522 test_AddPrinter_wellknown(tctx, p, printer_name, t->ex),
6523 "failed to add wellknown printer");
6524 } else {
6525 torture_assert(tctx,
6526 test_AddPrinter_normal(tctx, p, &handle, printer_name, driver_name, port_name, t->devmode, t->ex),
6527 "failed to add printer");
6528 }
6529
6530 if (!test_csetprinter(tctx, p, &handle, printer_name2, driver_name, port_name)) {
6531 ret = false;
6532 }
6533
6534 if (!test_one_printer(tctx, p, &handle, printer_name, driver_name, t->driver.remote.environment, t->have_driver, t->devmode)) {
6535 ret = false;
6536 }
6537
6538 if (!test_DeletePrinter(tctx, b, &handle)) {
6539 ret = false;
6540 }
6541
6542 if (!test_EnumPrinters_findname(tctx, b, PRINTER_ENUM_LOCAL, 1,
6543 printer_name, &found)) {
6544 ret = false;
6545 }
6546
6547 torture_assert(tctx, !found, "deleted printer still there");
6548
6549 return ret;
6550 }
6551
6552 static bool compose_local_driver_directory(struct torture_context *tctx,
6553 const char *environment,
6554 const char *local_dir,
6555 const char **path)
6556 {
6557 char *p;
6558
6559 p = strrchr(local_dir, '/');
6560 if (!p) {
6561 return NULL;
6562 }
6563 p++;
6564
6565 if (strequal(environment, "Windows x64")) {
6566 if (!strequal(p, "x64")) {
6567 *path = talloc_asprintf(tctx, "%s/x64", local_dir);
6568 }
6569 } else if (strequal(environment, "Windows NT x86")) {
6570 if (!strequal(p, "i386")) {
6571 *path = talloc_asprintf(tctx, "%s/i386", local_dir);
6572 }
6573 } else {
6574 torture_assert(tctx, "unknown environment: '%s'\n", environment);
6575 }
6576
6577 return true;
6578 }
6579
6580 static bool test_add_printer_args(struct torture_context *tctx,
6581 struct dcerpc_pipe *p,
6582 struct torture_printer_context *t)
6583 {
6584 bool ret = true;
6585 struct dcerpc_binding_handle *b = p->binding_handle;
6586 const char *server_name_slash = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
6587
6588 if (t->wellknown && torture_setting_bool(tctx, "samba3", false)) {
6589 torture_skip(tctx, "skipping AddPrinter level 1 against samba");
6590 }
6591
6592 torture_assert(tctx,
6593 fillup_printserver_info(tctx, p, &t->driver),
6594 "failed to fillup printserver info");
6595
6596 t->driver.info8.architecture = talloc_strdup(t, t->driver.remote.environment);
6597
6598 torture_assert(tctx,
6599 compose_local_driver_directory(tctx, t->driver.remote.environment,
6600 t->driver.local.driver_directory,
6601 &t->driver.local.driver_directory),
6602 "failed to compose local driver directory");
6603
6604 if (test_EnumPrinterDrivers_findone(tctx, b, server_name_slash, t->driver.remote.environment, 3, t->info2.drivername)) {
6605 t->have_driver = true;
6606 goto try_run;
6607 }
6608
6609 torture_comment(tctx, "driver '%s' (architecture: %s, version: 3) does not exist on the server\n",
6610 t->info2.drivername, t->driver.remote.environment);
6611 torture_comment(tctx, "trying to upload own driver\n");
6612
6613 if (!directory_exist(t->driver.local.driver_directory)) {
6614 torture_warning(tctx, "no local driver is available!");
6615 t->have_driver = false;
6616 goto try_run;
6617 }
6618
6619 torture_assert(tctx,
6620 upload_printer_driver(tctx, dcerpc_server_name(p), &t->driver),
6621 "failed to upload printer driver");
6622
6623 torture_assert(tctx,
6624 test_AddPrinterDriver_args_level_3(tctx, b, server_name_slash, &t->driver.info8, 0, false),
6625 "failed to add driver");
6626
6627 t->added_driver = true;
6628 t->have_driver = true;
6629
6630 try_run:
6631 ret = test_add_printer_args_with_driver(tctx, p, t);
6632
6633 if (t->added_driver) {
6634 torture_assert(tctx,
6635 remove_printer_driver(tctx, dcerpc_server_name(p), &t->driver),
6636 "failed to remove printer driver");
6637 }
6638
6639 return ret;
6640 }
6641
6642 static bool test_add_printer(struct torture_context *tctx,
6643 struct dcerpc_pipe *p,
6644 void *private_data)
6645 {
6646 struct torture_printer_context *t =
6647 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
6648
6649 t->ex = false;
6650 t->wellknown = false;
6651 t->info2.printername = TORTURE_PRINTER;
6652
6653 return test_add_printer_args(tctx, p, t);
6654 }
6655
6656 static bool test_add_printer_wellknown(struct torture_context *tctx,
6657 struct dcerpc_pipe *p,
6658 void *private_data)
6659 {
6660 struct torture_printer_context *t =
6661 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
6662
6663 t->ex = false;
6664 t->wellknown = true;
6665 t->info2.printername = TORTURE_WELLKNOWN_PRINTER;
6666 t->devmode = NULL;
6667
6668 return test_add_printer_args(tctx, p, t);
6669 }
6670
6671 static bool test_add_printer_ex(struct torture_context *tctx,
6672 struct dcerpc_pipe *p,
6673 void *private_data)
6674 {
6675 struct torture_printer_context *t =
6676 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
6677
6678 t->ex = true;
6679 t->wellknown = false;
6680 t->info2.printername = TORTURE_PRINTER_EX;
6681 t->devmode = NULL;
6682
6683 return test_add_printer_args(tctx, p, t);
6684 }
6685
6686 static bool test_add_printer_ex_wellknown(struct torture_context *tctx,
6687 struct dcerpc_pipe *p,
6688 void *private_data)
6689 {
6690 struct torture_printer_context *t =
6691 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
6692
6693 t->ex = true;
6694 t->wellknown = true;
6695 t->info2.printername = TORTURE_WELLKNOWN_PRINTER_EX;
6696 t->devmode = NULL;
6697
6698 return test_add_printer_args(tctx, p, t);
6699 }
6700
6701 static struct spoolss_DeviceMode *torture_devicemode(TALLOC_CTX *mem_ctx,
6702 const char *devicename)
6703 {
6704 struct spoolss_DeviceMode *r;
6705
6706 r = talloc_zero(mem_ctx, struct spoolss_DeviceMode);
6707 if (r == NULL) {
6708 return NULL;
6709 }
6710
6711 r->devicename = talloc_strdup(r, devicename);
6712 r->specversion = DMSPEC_NT4_AND_ABOVE;
6713 r->driverversion = 0x0600;
6714 r->size = 0x00dc;
6715 r->__driverextra_length = 0;
6716 r->fields = DEVMODE_FORMNAME |
6717 DEVMODE_TTOPTION |
6718 DEVMODE_PRINTQUALITY |
6719 DEVMODE_DEFAULTSOURCE |
6720 DEVMODE_COPIES |
6721 DEVMODE_SCALE |
6722 DEVMODE_PAPERSIZE |
6723 DEVMODE_ORIENTATION;
6724 r->orientation = DMORIENT_PORTRAIT;
6725 r->papersize = DMPAPER_LETTER;
6726 r->paperlength = 0;
6727 r->paperwidth = 0;
6728 r->scale = 100;
6729 r->copies = 55;
6730 r->defaultsource = DMBIN_FORMSOURCE;
6731 r->printquality = DMRES_HIGH;
6732 r->color = DMRES_MONOCHROME;
6733 r->duplex = DMDUP_SIMPLEX;
6734 r->yresolution = 0;
6735 r->ttoption = DMTT_SUBDEV;
6736 r->collate = DMCOLLATE_FALSE;
6737 r->formname = talloc_strdup(r, "Letter");
6738
6739 return r;
6740 }
6741
6742 static bool test_add_printer_with_devmode(struct torture_context *tctx,
6743 struct dcerpc_pipe *p,
6744 void *private_data)
6745 {
6746 struct torture_printer_context *t =
6747 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
6748
6749 t->ex = true;
6750 t->wellknown = false;
6751 t->info2.printername = TORTURE_PRINTER_EX;
6752 t->devmode = torture_devicemode(t, TORTURE_PRINTER_EX);
6753
6754 return test_add_printer_args(tctx, p, t);
6755 }
6756
6757 static bool test_architecture_buffer(struct torture_context *tctx,
6758 struct dcerpc_pipe *p)
6759 {
6760 struct spoolss_OpenPrinterEx r;
6761 struct spoolss_UserLevel1 u1;
6762 struct policy_handle handle;
6763 uint32_t architectures[] = {
6764 PROCESSOR_ARCHITECTURE_INTEL,
6765 PROCESSOR_ARCHITECTURE_IA64,
6766 PROCESSOR_ARCHITECTURE_AMD64
6767 };
6768 uint32_t needed[3];
6769 int i;
6770 struct dcerpc_binding_handle *b = p->binding_handle;
6771
6772 for (i=0; i < ARRAY_SIZE(architectures); i++) {
6773
6774 torture_comment(tctx, "Testing OpenPrinterEx with architecture %d\n", architectures[i]);
6775
6776 u1.size = 0;
6777 u1.client = NULL;
6778 u1.user = NULL;
6779 u1.build = 0;
6780 u1.major = 3;
6781 u1.minor = 0;
6782 u1.processor = architectures[i];
6783
6784 r.in.printername = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
6785 r.in.datatype = NULL;
6786 r.in.devmode_ctr.devmode= NULL;
6787 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
6788 r.in.level = 1;
6789 r.in.userlevel.level1 = &u1;
6790 r.out.handle = &handle;
6791
6792 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_OpenPrinterEx_r(b, tctx, &r), "");
6793 torture_assert_werr_ok(tctx, r.out.result, "");
6794
6795 {
6796 struct spoolss_EnumPrinters e;
6797 uint32_t count;
6798 union spoolss_PrinterInfo *info;
6799
6800 e.in.flags = PRINTER_ENUM_LOCAL;
6801 e.in.server = NULL;
6802 e.in.level = 2;
6803 e.in.buffer = NULL;
6804 e.in.offered = 0;
6805 e.out.count = &count;
6806 e.out.info = &info;
6807 e.out.needed = &needed[i];
6808
6809 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters_r(b, tctx, &e), "");
6810 #if 0
6811 torture_comment(tctx, "needed was %d\n", needed[i]);
6812 #endif
6813 }
6814
6815 torture_assert(tctx, test_ClosePrinter(tctx, b, &handle), "");
6816 }
6817
6818 for (i=1; i < ARRAY_SIZE(architectures); i++) {
6819 if (needed[i-1] != needed[i]) {
6820 torture_fail(tctx,
6821 talloc_asprintf(tctx, "needed size %d for architecture %d != needed size %d for architecture %d\n",
6822 needed[i-1], architectures[i-1], needed[i], architectures[i]));
6823 }
6824 }
6825
6826 return true;
6827 }
6828
6829 bool torture_rpc_spoolss(struct torture_context *torture)
6830 {
6831 NTSTATUS status;
6832 struct dcerpc_pipe *p;
6833 struct dcerpc_binding_handle *b;
6834 bool ret = true;
6835 struct test_spoolss_context *ctx;
6836 const char *environment = SPOOLSS_ARCHITECTURE_NT_X86;
6837
6838 status = torture_rpc_connection(torture, &p, &ndr_table_spoolss);
6839 if (!NT_STATUS_IS_OK(status)) {
6840 return false;
6841 }
6842 b = p->binding_handle;
6843
6844 ctx = talloc_zero(torture, struct test_spoolss_context);
6845
6846 ret &= test_OpenPrinter_server(torture, p, &ctx->server_handle);
6847 ret &= test_GetPrinterData_list(torture, p, &ctx->server_handle, &environment);
6848 ret &= test_EnumForms_all(torture, b, &ctx->server_handle, true);
6849 ret &= test_Forms(torture, b, &ctx->server_handle, true, NULL, NULL, NULL);
6850 ret &= test_Forms_winreg(torture, b, &ctx->server_handle, true, NULL);
6851 ret &= test_EnumPorts(torture, b, ctx);
6852 ret &= test_GetPrinterDriverDirectory(torture, p, environment);
6853 ret &= test_GetPrintProcessorDirectory(torture, p, environment);
6854 ret &= test_EnumPrinterDrivers(torture, p, ctx, environment);
6855 ret &= test_EnumPrinterDrivers(torture, p, ctx, SPOOLSS_ARCHITECTURE_ALL);
6856 ret &= test_EnumMonitors(torture, b, ctx);
6857 ret &= test_EnumPrintProcessors(torture, b, ctx, environment);
6858 ret &= test_EnumPrintProcDataTypes(torture, b);
6859 ret &= test_EnumPrinters(torture, b, ctx);
6860 ret &= test_OpenPrinter_badname_list(torture, b, dcerpc_server_name(p));
6861
6862 ret &= test_AddPort(torture, p);
6863 ret &= test_EnumPorts_old(torture, p);
6864 ret &= test_EnumPrinters_old(torture, p, environment);
6865 ret &= test_EnumPrinterDrivers_old(torture, p, environment);
6866 ret &= test_architecture_buffer(torture, p);
6867
6868 return ret;
6869 }
6870
6871 struct torture_suite *torture_rpc_spoolss_printer(TALLOC_CTX *mem_ctx)
6872 {
6873 struct torture_suite *suite = torture_suite_create(mem_ctx, "SPOOLSS-PRINTER");
6874
6875 struct torture_rpc_tcase *tcase = torture_suite_add_rpc_iface_tcase(suite,
6876 "printer", &ndr_table_spoolss);
6877
6878 struct torture_printer_context *t;
6879
6880 t = talloc_zero(mem_ctx, struct torture_printer_context);
6881
6882 t->driver.info8.version = SPOOLSS_DRIVER_VERSION_200X;
6883 t->driver.info8.driver_name = TORTURE_DRIVER;
6884 t->driver.info8.driver_path = "pscript5.dll";
6885 t->driver.info8.data_file = "cups6.ppd";
6886 t->driver.info8.config_file = "ps5ui.dll";
6887 t->driver.info8.help_file = "pscript.hlp";
6888 t->driver.info8.default_datatype = "RAW";
6889 t->driver.info8.dependent_files = talloc_zero(t, struct spoolss_StringArray);
6890 t->driver.info8.dependent_files->string = talloc_zero_array(t, const char *, 8 + 1);
6891 t->driver.info8.dependent_files->string[0] = "pscript5.dll";
6892 t->driver.info8.dependent_files->string[1] = "cups6.ppd";
6893 t->driver.info8.dependent_files->string[2] = "ps5ui.dll";
6894 t->driver.info8.dependent_files->string[3] = "pscript.hlp";
6895 t->driver.info8.dependent_files->string[4] = "pscript.ntf";
6896 t->driver.info8.dependent_files->string[5] = "cups6.ini";
6897 t->driver.info8.dependent_files->string[6] = "cupsps6.dll";
6898 t->driver.info8.dependent_files->string[7] = "cupsui6.dll";
6899
6900 t->driver.local.driver_directory= "/usr/share/cups/drivers";
6901
6902 t->info2.drivername = "Microsoft XPS Document Writer";
6903 t->info2.portname = "LPT1:";
6904
6905 torture_rpc_tcase_add_test_ex(tcase, "add_printer", test_add_printer, t);
6906 torture_rpc_tcase_add_test_ex(tcase, "add_printer_wellknown", test_add_printer_wellknown, t);
6907 torture_rpc_tcase_add_test_ex(tcase, "add_printer_ex", test_add_printer_ex, t);
6908 torture_rpc_tcase_add_test_ex(tcase, "add_printer_ex_wellknown", test_add_printer_ex_wellknown, t);
6909
6910 torture_rpc_tcase_add_test_ex(tcase, "add_printer_with_devmode", test_add_printer_with_devmode, t);
6911
6912 return suite;
6913 }
6914
6915 static bool test_GetPrinterDriverDirectory_getdir(struct torture_context *tctx,
6916 struct dcerpc_binding_handle *b,
6917 const char *server,
6918 const char *environment,
6919 const char **dir_p)
6920 {
6921 struct spoolss_GetPrinterDriverDirectory r;
6922 uint32_t needed;
6923
6924 r.in.server = server;
6925 r.in.environment = environment;
6926 r.in.level = 1;
6927 r.in.buffer = NULL;
6928 r.in.offered = 0;
6929 r.out.needed = &needed;
6930
6931 torture_assert_ntstatus_ok(tctx,
6932 dcerpc_spoolss_GetPrinterDriverDirectory_r(b, tctx, &r),
6933 "failed to query driver directory");
6934
6935 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
6936 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
6937 r.in.buffer = &blob;
6938 r.in.offered = needed;
6939
6940 torture_assert_ntstatus_ok(tctx,
6941 dcerpc_spoolss_GetPrinterDriverDirectory_r(b, tctx, &r),
6942 "failed to query driver directory");
6943 }
6944
6945 torture_assert_werr_ok(tctx, r.out.result,
6946 "failed to query driver directory");
6947
6948 if (dir_p) {
6949 *dir_p = r.out.info->info1.directory_name;
6950 }
6951
6952 return true;
6953 }
6954
6955 static const char *get_driver_from_info(struct spoolss_AddDriverInfoCtr *info_ctr)
6956 {
6957 if (info_ctr == NULL) {
6958 return NULL;
6959 }
6960
6961 switch (info_ctr->level) {
6962 case 1:
6963 return info_ctr->info.info1->driver_name;
6964 case 2:
6965 return info_ctr->info.info2->driver_name;
6966 case 3:
6967 return info_ctr->info.info3->driver_name;
6968 case 4:
6969 return info_ctr->info.info4->driver_name;
6970 case 6:
6971 return info_ctr->info.info6->driver_name;
6972 case 8:
6973 return info_ctr->info.info8->driver_name;
6974 default:
6975 return NULL;
6976 }
6977 }
6978
6979 static const char *get_environment_from_info(struct spoolss_AddDriverInfoCtr *info_ctr)
6980 {
6981 if (info_ctr == NULL) {
6982 return NULL;
6983 }
6984
6985 switch (info_ctr->level) {
6986 case 2:
6987 return info_ctr->info.info2->architecture;
6988 case 3:
6989 return info_ctr->info.info3->architecture;
6990 case 4:
6991 return info_ctr->info.info4->architecture;
6992 case 6:
6993 return info_ctr->info.info6->architecture;
6994 case 8:
6995 return info_ctr->info.info8->architecture;
6996 default:
6997 return NULL;
6998 }
6999 }
7000
7001
7002 static bool test_AddPrinterDriver_exp(struct torture_context *tctx,
7003 struct dcerpc_binding_handle *b,
7004 const char *servername,
7005 struct spoolss_AddDriverInfoCtr *info_ctr,
7006 WERROR expected_result)
7007 {
7008 struct spoolss_AddPrinterDriver r;
7009 const char *drivername = get_driver_from_info(info_ctr);
7010 const char *environment = get_environment_from_info(info_ctr);
7011
7012 r.in.servername = servername;
7013 r.in.info_ctr = info_ctr;
7014
7015 torture_comment(tctx, "Testing AddPrinterDriver(%s) level: %d, environment: '%s'\n",
7016 drivername, info_ctr->level, environment);
7017
7018 torture_assert_ntstatus_ok(tctx,
7019 dcerpc_spoolss_AddPrinterDriver_r(b, tctx, &r),
7020 "spoolss_AddPrinterDriver failed");
7021 torture_assert_werr_equal(tctx, r.out.result, expected_result,
7022 "spoolss_AddPrinterDriver failed with unexpected result");
7023
7024 return true;
7025
7026 }
7027
7028 static bool test_AddPrinterDriverEx_exp(struct torture_context *tctx,
7029 struct dcerpc_binding_handle *b,
7030 const char *servername,
7031 struct spoolss_AddDriverInfoCtr *info_ctr,
7032 uint32_t flags,
7033 WERROR expected_result)
7034 {
7035 struct spoolss_AddPrinterDriverEx r;
7036 const char *drivername = get_driver_from_info(info_ctr);
7037 const char *environment = get_environment_from_info(info_ctr);
7038
7039 r.in.servername = servername;
7040 r.in.info_ctr = info_ctr;
7041 r.in.flags = flags;
7042
7043 torture_comment(tctx, "Testing AddPrinterDriverEx(%s) level: %d, environment: '%s'\n",
7044 drivername, info_ctr->level, environment);
7045
7046 torture_assert_ntstatus_ok(tctx,
7047 dcerpc_spoolss_AddPrinterDriverEx_r(b, tctx, &r),
7048 "AddPrinterDriverEx failed");
7049 torture_assert_werr_equal(tctx, r.out.result, expected_result,
7050 "AddPrinterDriverEx failed with unexpected result");
7051
7052 return true;
7053 }
7054
7055 static bool test_AddPrinterDriver_args_level_1(struct torture_context *tctx,
7056 struct dcerpc_binding_handle *b,
7057 const char *server_name,
7058 struct spoolss_AddDriverInfo8 *r,
7059 uint32_t flags,
7060 bool ex)
7061 {
7062 struct spoolss_AddDriverInfoCtr info_ctr;
7063 struct spoolss_AddDriverInfo1 info1;
7064
7065 ZERO_STRUCT(info1);
7066
7067 info_ctr.level = 1;
7068 info_ctr.info.info1 = &info1;
7069
7070 if (ex) {
7071 torture_assert(tctx,
7072 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_UNKNOWN_LEVEL),
7073 "failed to test AddPrinterDriverEx level 1");
7074 } else {
7075 torture_assert(tctx,
7076 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_UNKNOWN_LEVEL),
7077 "failed to test AddPrinterDriver level 1");
7078 }
7079
7080 info1.driver_name = r->driver_name;
7081
7082 if (ex) {
7083 torture_assert(tctx,
7084 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_UNKNOWN_LEVEL),
7085 "failed to test AddPrinterDriverEx level 1");
7086 } else {
7087 torture_assert(tctx,
7088 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_UNKNOWN_LEVEL),
7089 "failed to test AddPrinterDriver level 1");
7090 }
7091
7092 return true;
7093 }
7094
7095 static bool test_AddPrinterDriver_args_level_2(struct torture_context *tctx,
7096 struct dcerpc_binding_handle *b,
7097 const char *server_name,
7098 struct spoolss_AddDriverInfo8 *r,
7099 uint32_t flags,
7100 bool ex)
7101 {
7102 struct spoolss_AddDriverInfoCtr info_ctr;
7103 struct spoolss_AddDriverInfo2 info2;
7104
7105 ZERO_STRUCT(info2);
7106
7107 info_ctr.level = 2;
7108 info_ctr.info.info2 = &info2;
7109
7110 if (ex) {
7111 torture_assert(tctx,
7112 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
7113 "failed to test AddPrinterDriverEx level 2");
7114 } else {
7115 torture_assert(tctx,
7116 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
7117 "failed to test AddPrinterDriver level 2");
7118 }
7119
7120 info2.driver_name = r->driver_name;
7121
7122 if (ex) {
7123 torture_assert(tctx,
7124 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
7125 "failed to test AddPrinterDriverEx level 2");
7126 } else {
7127 torture_assert(tctx,
7128 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
7129 "failed to test AddPrinterDriver level 2");
7130 }
7131
7132 info2.version = r->version;
7133
7134 if (ex) {
7135 torture_assert(tctx,
7136 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
7137 "failed to test AddPrinterDriverEx level 2");
7138 } else {
7139 torture_assert(tctx,
7140 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
7141 "failed to test AddPrinterDriver level 2");
7142 }
7143
7144 info2.architecture = r->architecture;
7145
7146 if (ex) {
7147 torture_assert(tctx,
7148 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
7149 "failed to test AddPrinterDriverEx level 2");
7150 } else {
7151 torture_assert(tctx,
7152 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
7153 "failed to test AddPrinterDriver level 2");
7154 }
7155
7156 info2.driver_path = r->driver_path;
7157
7158 if (ex) {
7159 torture_assert(tctx,
7160 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
7161 "failed to test AddPrinterDriverEx level 2");
7162 } else {
7163 torture_assert(tctx,
7164 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
7165 "failed to test AddPrinterDriver level 2");
7166 }
7167
7168 info2.data_file = r->data_file;
7169
7170 if (ex) {
7171 torture_assert(tctx,
7172 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
7173 "failed to test AddPrinterDriverEx level 2");
7174 } else {
7175 torture_assert(tctx,
7176 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
7177 "failed to test AddPrinterDriver level 2");
7178 }
7179
7180 info2.config_file = r->config_file;
7181
7182 if (ex) {
7183 torture_assert(tctx,
7184 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, 0, WERR_INVALID_PARAM),
7185 "failed to test AddPrinterDriverEx");
7186 }
7187
7188 if (ex) {
7189 torture_assert(tctx,
7190 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
7191 "failed to test AddPrinterDriverEx level 2");
7192 } else {
7193 torture_assert(tctx,
7194 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_OK),
7195 "failed to test AddPrinterDriver level 2");
7196 }
7197
7198 torture_assert(tctx,
7199 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 2, r->driver_name),
7200 "failed to find added printer driver");
7201
7202 return true;
7203 }
7204
7205 static bool test_AddPrinterDriver_args_level_3(struct torture_context *tctx,
7206 struct dcerpc_binding_handle *b,
7207 const char *server_name,
7208 struct spoolss_AddDriverInfo8 *r,
7209 uint32_t flags,
7210 bool ex)
7211 {
7212 struct spoolss_AddDriverInfoCtr info_ctr;
7213 struct spoolss_AddDriverInfo3 info3;
7214
7215 info3.driver_name = r->driver_name;
7216 info3.version = r->version;
7217 info3.architecture = r->architecture;
7218 info3.driver_path = r->driver_path;
7219 info3.data_file = r->data_file;
7220 info3.config_file = r->config_file;
7221 info3.help_file = r->help_file;
7222 info3.monitor_name = r->monitor_name;
7223 info3.default_datatype = r->default_datatype;
7224 info3._ndr_size_dependent_files = r->_ndr_size_dependent_files;
7225 info3.dependent_files = r->dependent_files;
7226
7227 info_ctr.level = 3;
7228 info_ctr.info.info3 = &info3;
7229
7230 if (ex) {
7231 torture_assert(tctx,
7232 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
7233 "failed to test AddPrinterDriverEx level 3");
7234 } else {
7235 torture_assert(tctx,
7236 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_OK),
7237 "failed to test AddPrinterDriver level 3");
7238 }
7239
7240 torture_assert(tctx,
7241 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 3, r->driver_name),
7242 "failed to find added printer driver");
7243
7244 return true;
7245 }
7246
7247 static bool test_AddPrinterDriver_args_level_4(struct torture_context *tctx,
7248 struct dcerpc_binding_handle *b,
7249 const char *server_name,
7250 struct spoolss_AddDriverInfo8 *r,
7251 uint32_t flags,
7252 bool ex)
7253 {
7254 struct spoolss_AddDriverInfoCtr info_ctr;
7255 struct spoolss_AddDriverInfo4 info4;
7256
7257 info4.version = r->version;
7258 info4.driver_name = r->driver_name;
7259 info4.architecture = r->architecture;
7260 info4.driver_path = r->driver_path;
7261 info4.data_file = r->data_file;
7262 info4.config_file = r->config_file;
7263 info4.help_file = r->help_file;
7264 info4.monitor_name = r->monitor_name;
7265 info4.default_datatype = r->default_datatype;
7266 info4._ndr_size_dependent_files = r->_ndr_size_dependent_files;
7267 info4.dependent_files = r->dependent_files;
7268 info4._ndr_size_previous_names = r->_ndr_size_previous_names;
7269 info4.previous_names = r->previous_names;
7270
7271 info_ctr.level = 4;
7272 info_ctr.info.info4 = &info4;
7273
7274 if (ex) {
7275 torture_assert(tctx,
7276 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
7277 "failed to test AddPrinterDriverEx level 4");
7278 } else {
7279 torture_assert(tctx,
7280 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_OK),
7281 "failed to test AddPrinterDriver level 4");
7282 }
7283
7284 torture_assert(tctx,
7285 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 4, r->driver_name),
7286 "failed to find added printer driver");
7287
7288 return true;
7289 }
7290
7291 static bool test_AddPrinterDriver_args_level_6(struct torture_context *tctx,
7292 struct dcerpc_binding_handle *b,
7293 const char *server_name,
7294 struct spoolss_AddDriverInfo8 *r,
7295 uint32_t flags,
7296 bool ex)
7297 {
7298 struct spoolss_AddDriverInfoCtr info_ctr;
7299 struct spoolss_AddDriverInfo6 info6;
7300
7301 info6.version = r->version;
7302 info6.driver_name = r->driver_name;
7303 info6.architecture = r->architecture;
7304 info6.driver_path = r->driver_path;
7305 info6.data_file = r->data_file;
7306 info6.config_file = r->config_file;
7307 info6.help_file = r->help_file;
7308 info6.monitor_name = r->monitor_name;
7309 info6.default_datatype = r->default_datatype;
7310 info6._ndr_size_dependent_files = r->_ndr_size_dependent_files;
7311 info6.dependent_files = r->dependent_files;
7312 info6._ndr_size_previous_names = r->_ndr_size_previous_names;
7313 info6.previous_names = r->previous_names;
7314 info6.driver_date = r->driver_date;
7315 info6.driver_version = r->driver_version;
7316 info6.manufacturer_name = r->manufacturer_name;
7317 info6.manufacturer_url = r->manufacturer_url;
7318 info6.hardware_id = r->hardware_id;
7319 info6.provider = r->provider;
7320
7321 info_ctr.level = 6;
7322 info_ctr.info.info6 = &info6;
7323
7324 if (ex) {
7325 torture_assert(tctx,
7326 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
7327 "failed to test AddPrinterDriverEx level 6");
7328 } else {
7329 torture_assert(tctx,
7330 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_UNKNOWN_LEVEL),
7331 "failed to test AddPrinterDriver level 6");
7332 }
7333
7334 /* spoolss_AddPrinterDriver does not deal with level 6 or 8 - gd */
7335
7336 if (!ex) {
7337 return true;
7338 }
7339
7340 torture_assert(tctx,
7341 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 6, r->driver_name),
7342 "failed to find added printer driver");
7343
7344 return true;
7345 }
7346
7347 static bool test_AddPrinterDriver_args_level_8(struct torture_context *tctx,
7348 struct dcerpc_binding_handle *b,
7349 const char *server_name,
7350 struct spoolss_AddDriverInfo8 *r,
7351 uint32_t flags,
7352 bool ex)
7353 {
7354 struct spoolss_AddDriverInfoCtr info_ctr;
7355
7356 info_ctr.level = 8;
7357 info_ctr.info.info8 = r;
7358
7359 if (ex) {
7360 torture_assert(tctx,
7361 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
7362 "failed to test AddPrinterDriverEx level 8");
7363 } else {
7364 torture_assert(tctx,
7365 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_UNKNOWN_LEVEL),
7366 "failed to test AddPrinterDriver level 8");
7367 }
7368
7369 /* spoolss_AddPrinterDriver does not deal with level 6 or 8 - gd */
7370
7371 if (!ex) {
7372 return true;
7373 }
7374
7375 torture_assert(tctx,
7376 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 8, r->driver_name),
7377 "failed to find added printer driver");
7378
7379 return true;
7380 }
7381
7382 static bool test_DeletePrinterDriver_exp(struct torture_context *tctx,
7383 struct dcerpc_binding_handle *b,
7384 const char *server,
7385 const char *driver,
7386 const char *environment,
7387 WERROR expected_result)
7388 {
7389 struct spoolss_DeletePrinterDriver r;
7390
7391 r.in.server = server;
7392 r.in.architecture = environment;
7393 r.in.driver = driver;
7394
7395 torture_comment(tctx, "Testing DeletePrinterDriver(%s)\n", driver);
7396
7397 torture_assert_ntstatus_ok(tctx,
7398 dcerpc_spoolss_DeletePrinterDriver_r(b, tctx, &r),
7399 "DeletePrinterDriver failed");
7400 torture_assert_werr_equal(tctx, r.out.result, expected_result,
7401 "DeletePrinterDriver failed with unexpected result");
7402
7403 return true;
7404 }
7405
7406 static bool test_DeletePrinterDriverEx_exp(struct torture_context *tctx,
7407 struct dcerpc_binding_handle *b,
7408 const char *server,
7409 const char *driver,
7410 const char *environment,
7411 uint32_t delete_flags,
7412 uint32_t version,
7413 WERROR expected_result)
7414 {
7415 struct spoolss_DeletePrinterDriverEx r;
7416
7417 r.in.server = server;
7418 r.in.architecture = environment;
7419 r.in.driver = driver;
7420 r.in.delete_flags = delete_flags;
7421 r.in.version = version;
7422
7423 torture_comment(tctx, "Testing DeletePrinterDriverEx(%s)\n", driver);
7424
7425 torture_assert_ntstatus_ok(tctx,
7426 dcerpc_spoolss_DeletePrinterDriverEx_r(b, tctx, &r),
7427 "DeletePrinterDriverEx failed");
7428 torture_assert_werr_equal(tctx, r.out.result, expected_result,
7429 "DeletePrinterDriverEx failed with unexpected result");
7430
7431 return true;
7432 }
7433
7434 static bool test_DeletePrinterDriver(struct torture_context *tctx,
7435 struct dcerpc_binding_handle *b,
7436 const char *server_name,
7437 const char *driver,
7438 const char *environment)
7439 {
7440 torture_assert(tctx,
7441 test_DeletePrinterDriver_exp(tctx, b, server_name, driver, "FOOBAR", WERR_INVALID_ENVIRONMENT),
7442 "failed to delete driver");
7443
7444 torture_assert(tctx,
7445 test_DeletePrinterDriver_exp(tctx, b, server_name, driver, environment, WERR_OK),
7446 "failed to delete driver");
7447
7448 if (test_EnumPrinterDrivers_findone(tctx, b, server_name, environment, 1, driver)) {
7449 torture_fail(tctx, "deleted driver still enumerated");
7450 }
7451
7452 torture_assert(tctx,
7453 test_DeletePrinterDriver_exp(tctx, b, server_name, driver, environment, WERR_UNKNOWN_PRINTER_DRIVER),
7454 "2nd delete failed");
7455
7456 return true;
7457 }
7458
7459 static bool test_DeletePrinterDriverEx(struct torture_context *tctx,
7460 struct dcerpc_binding_handle *b,
7461 const char *server_name,
7462 const char *driver,
7463 const char *environment,
7464 uint32_t delete_flags,
7465 uint32_t version)
7466 {
7467 torture_assert(tctx,
7468 test_DeletePrinterDriverEx_exp(tctx, b, server_name, driver, "FOOBAR", delete_flags, version, WERR_INVALID_ENVIRONMENT),
7469 "failed to delete driver");
7470
7471 torture_assert(tctx,
7472 test_DeletePrinterDriverEx_exp(tctx, b, server_name, driver, environment, delete_flags, version, WERR_OK),
7473 "failed to delete driver");
7474
7475 if (test_EnumPrinterDrivers_findone(tctx, b, server_name, environment, 1, driver)) {
7476 torture_fail(tctx, "deleted driver still enumerated");
7477 }
7478
7479 torture_assert(tctx,
7480 test_DeletePrinterDriverEx_exp(tctx, b, server_name, driver, environment, delete_flags, version, WERR_UNKNOWN_PRINTER_DRIVER),
7481 "2nd delete failed");
7482
7483 return true;
7484 }
7485
7486 static bool test_PrinterDriver_args(struct torture_context *tctx,
7487 struct dcerpc_binding_handle *b,
7488 const char *server_name,
7489 uint32_t level,
7490 struct spoolss_AddDriverInfo8 *r,
7491 uint32_t add_flags,
7492 uint32_t delete_flags,
7493 uint32_t delete_version,
7494 bool ex)
7495 {
7496 bool ret = true;
7497
7498 switch (level) {
7499 case 1:
7500 ret = test_AddPrinterDriver_args_level_1(tctx, b, server_name, r, add_flags, ex);
7501 break;
7502 case 2:
7503 ret = test_AddPrinterDriver_args_level_2(tctx, b, server_name, r, add_flags, ex);
7504 break;
7505 case 3:
7506 ret = test_AddPrinterDriver_args_level_3(tctx, b, server_name, r, add_flags, ex);
7507 break;
7508 case 4:
7509 ret = test_AddPrinterDriver_args_level_4(tctx, b, server_name, r, add_flags, ex);
7510 break;
7511 case 6:
7512 ret = test_AddPrinterDriver_args_level_6(tctx, b, server_name, r, add_flags, ex);
7513 break;
7514 case 8:
7515 ret = test_AddPrinterDriver_args_level_8(tctx, b, server_name, r, add_flags, ex);
7516 break;
7517 default:
7518 return false;
7519 }
7520
7521 if (ret == false) {
7522 return ret;
7523 }
7524
7525 if (level == 1) {
7526 return ret;
7527 }
7528
7529 /* spoolss_AddPrinterDriver does not deal with level 6 or 8 - gd */
7530
7531 if (!ex && (level == 6 || level == 8)) {
7532 return ret;
7533 }
7534
7535 if (ex) {
7536 return test_DeletePrinterDriverEx(tctx, b, server_name, r->driver_name, r->architecture, delete_flags, r->version);
7537 } else {
7538 return test_DeletePrinterDriver(tctx, b, server_name, r->driver_name, r->architecture);
7539 }
7540 }
7541
7542 static bool fillup_printserver_info(struct torture_context *tctx,
7543 struct dcerpc_pipe *p,
7544 struct torture_driver_context *d)
7545 {
7546 struct policy_handle server_handle;
7547 struct dcerpc_binding_handle *b = p->binding_handle;
7548 const char *server_name_slash = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
7549
7550 torture_assert(tctx,
7551 test_OpenPrinter_server(tctx, p, &server_handle),
7552 "failed to open printserver");
7553 torture_assert(tctx,
7554 test_get_environment(tctx, b, &server_handle, &d->remote.environment),
7555 "failed to get environment");
7556 torture_assert(tctx,
7557 test_ClosePrinter(tctx, b, &server_handle),
7558 "failed to close printserver");
7559
7560 torture_assert(tctx,
7561 test_GetPrinterDriverDirectory_getdir(tctx, b, server_name_slash,
7562 d->local.environment ? d->local.environment : d->remote.environment,
7563 &d->remote.driver_directory),
7564 "failed to get driver directory");
7565
7566 return true;
7567 }
7568
7569 static const char *driver_directory_dir(const char *driver_directory)
7570 {
7571 char *p;
7572
7573 p = strrchr(driver_directory, '\\');
7574 if (p) {
7575 return p+1;
7576 }
7577
7578 return NULL;
7579 }
7580
7581 static const char *driver_directory_share(struct torture_context *tctx,
7582 const char *driver_directory)
7583 {
7584 const char *p;
7585 char *tok;
7586
7587 if (driver_directory[0] == '\\' && driver_directory[1] == '\\') {
7588 driver_directory += 2;
7589 }
7590
7591 p = talloc_strdup(tctx, driver_directory);
7592
7593 torture_assert(tctx,
7594 next_token_talloc(tctx, &p, &tok, "\\"),
7595 "cannot explode uri");
7596 torture_assert(tctx,
7597 next_token_talloc(tctx, &p, &tok, "\\"),
7598 "cannot explode uri");
7599
7600 return tok;
7601 }
7602
7603 static bool upload_printer_driver_file(struct torture_context *tctx,
7604 struct smbcli_state *cli,
7605 struct torture_driver_context *d,
7606 const char *file_name)
7607 {
7608 XFILE *f;
7609 int fnum;
7610 uint8_t *buf;
7611 int maxwrite = 64512;
7612 off_t nread = 0;
7613 size_t start = 0;
7614 const char *remote_dir = driver_directory_dir(d->remote.driver_directory);
7615 const char *local_name = talloc_asprintf(tctx, "%s/%s", d->local.driver_directory, file_name);
7616 const char *remote_name = talloc_asprintf(tctx, "%s\\%s", remote_dir, file_name);
7617
7618 if (!file_name) {
7619 return true;
7620 }
7621
7622 torture_comment(tctx, "Uploading %s to %s\n", local_name, remote_name);
7623
7624 fnum = smbcli_open(cli->tree, remote_name, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE);
7625 if (fnum == -1) {
7626 torture_fail(tctx, talloc_asprintf(tctx, "failed to open remote file: %s\n", remote_name));
7627 }
7628
7629 f = x_fopen(local_name, O_RDONLY, 0);
7630 if (f == NULL) {
7631 torture_fail(tctx, talloc_asprintf(tctx, "failed to open local file: %s\n", local_name));
7632 }
7633
7634 buf = talloc_array(tctx, uint8_t, maxwrite);
7635 if (!buf) {
7636 return false;
7637 }
7638
7639 while (!x_feof(f)) {
7640 int n = maxwrite;
7641 int ret;
7642
7643 if ((n = x_fread(buf, 1, n, f)) < 1) {
7644 if((n == 0) && x_feof(f))
7645 break; /* Empty local file. */
7646
7647 torture_warning(tctx,
7648 "failed to read file: %s\n", strerror(errno));
7649 break;
7650 }
7651
7652 ret = smbcli_write(cli->tree, fnum, 0, buf, nread + start, n);
7653
7654 if (n != ret) {
7655 torture_warning(tctx,
7656 "failed to write file: %s\n", smbcli_errstr(cli->tree));
7657 break;
7658 }
7659
7660 nread += n;
7661 }
7662
7663 x_fclose(f);
7664
7665 torture_assert_ntstatus_ok(tctx,
7666 smbcli_close(cli->tree, fnum),
7667 "failed to close file");
7668
7669 return true;
7670 }
7671
7672 static bool connect_printer_driver_share(struct torture_context *tctx,
7673 const char *server_name,
7674 const char *share_name,
7675 struct smbcli_state **cli)
7676 {
7677 struct smbcli_options smb_options;
7678 struct smbcli_session_options smb_session_options;
7679
7680 torture_comment(tctx, "Connecting printer driver share '%s' on '%s'\n",
7681 share_name, server_name);
7682
7683 lp_smbcli_options(tctx->lp_ctx, &smb_options);
7684 lp_smbcli_session_options(tctx->lp_ctx, &smb_session_options);
7685
7686 torture_assert_ntstatus_ok(tctx,
7687 smbcli_full_connection(tctx, cli, server_name,
7688 lp_smb_ports(tctx->lp_ctx),
7689 share_name, NULL,
7690 lp_socket_options(tctx->lp_ctx),
7691 cmdline_credentials,
7692 lp_resolve_context(tctx->lp_ctx),
7693 tctx->ev,
7694 &smb_options,
7695 &smb_session_options,
7696 lp_gensec_settings(tctx, tctx->lp_ctx)),
7697 "failed to open driver share");
7698
7699 return true;
7700 }
7701
7702 static bool upload_printer_driver(struct torture_context *tctx,
7703 const char *server_name,
7704 struct torture_driver_context *d)
7705 {
7706 struct smbcli_state *cli;
7707 const char *share_name = driver_directory_share(tctx, d->remote.driver_directory);
7708 int i;
7709
7710 torture_assert(tctx,
7711 connect_printer_driver_share(tctx, server_name, share_name, &cli),
7712 "failed to connect to driver share");
7713
7714 torture_comment(tctx, "Uploading printer driver files to \\\\%s\\%s\n",
7715 server_name, share_name);
7716
7717 torture_assert(tctx,
7718 upload_printer_driver_file(tctx, cli, d, d->info8.driver_path),
7719 "failed to upload driver_path");
7720 torture_assert(tctx,
7721 upload_printer_driver_file(tctx, cli, d, d->info8.data_file),
7722 "failed to upload data_file");
7723 torture_assert(tctx,
7724 upload_printer_driver_file(tctx, cli, d, d->info8.config_file),
7725 "failed to upload config_file");
7726 torture_assert(tctx,
7727 upload_printer_driver_file(tctx, cli, d, d->info8.help_file),
7728 "failed to upload help_file");
7729 if (d->info8.dependent_files) {
7730 for (i=0; d->info8.dependent_files->string && d->info8.dependent_files->string[i] != NULL; i++) {
7731 torture_assert(tctx,
7732 upload_printer_driver_file(tctx, cli, d, d->info8.dependent_files->string[i]),
7733 "failed to upload dependent_files");
7734 }
7735 }
7736
7737 talloc_free(cli);
7738
7739 return true;
7740 }
7741
7742 static bool remove_printer_driver_file(struct torture_context *tctx,
7743 struct smbcli_state *cli,
7744 struct torture_driver_context *d,
7745 const char *file_name)
7746 {
7747 const char *remote_name;
7748 const char *remote_dir = driver_directory_dir(d->remote.driver_directory);
7749
7750 if (!file_name) {
7751 return true;
7752 }
7753
7754 remote_name = talloc_asprintf(tctx, "%s\\%s", remote_dir, file_name);
7755
7756 torture_comment(tctx, "Removing %s\n", remote_name);
7757
7758 torture_assert_ntstatus_ok(tctx,
7759 smbcli_unlink(cli->tree, remote_name),
7760 "failed to unlink");
7761
7762 return true;
7763 }
7764
7765 static bool remove_printer_driver(struct torture_context *tctx,
7766 const char *server_name,
7767 struct torture_driver_context *d)
7768 {
7769 struct smbcli_state *cli;
7770 const char *share_name = driver_directory_share(tctx, d->remote.driver_directory);
7771 int i;
7772
7773 torture_assert(tctx,
7774 connect_printer_driver_share(tctx, server_name, share_name, &cli),
7775 "failed to connect to driver share");
7776
7777 torture_comment(tctx, "Removing printer driver files from \\\\%s\\%s\n",
7778 server_name, share_name);
7779
7780 torture_assert(tctx,
7781 remove_printer_driver_file(tctx, cli, d, d->info8.driver_path),
7782 "failed to remove driver_path");
7783 torture_assert(tctx,
7784 remove_printer_driver_file(tctx, cli, d, d->info8.data_file),
7785 "failed to remove data_file");
7786 torture_assert(tctx,
7787 remove_printer_driver_file(tctx, cli, d, d->info8.config_file),
7788 "failed to remove config_file");
7789 torture_assert(tctx,
7790 remove_printer_driver_file(tctx, cli, d, d->info8.help_file),
7791 "failed to remove help_file");
7792 if (d->info8.dependent_files) {
7793 for (i=0; d->info8.dependent_files->string && d->info8.dependent_files->string[i] != NULL; i++) {
7794 if (strequal(d->info8.dependent_files->string[i], d->info8.driver_path) ||
7795 strequal(d->info8.dependent_files->string[i], d->info8.data_file) ||
7796 strequal(d->info8.dependent_files->string[i], d->info8.config_file) ||
7797 strequal(d->info8.dependent_files->string[i], d->info8.help_file)) {
7798 continue;
7799 }
7800 torture_assert(tctx,
7801 remove_printer_driver_file(tctx, cli, d, d->info8.dependent_files->string[i]),
7802 "failed to remove dependent_files");
7803 }
7804 }
7805
7806 talloc_free(cli);
7807
7808 return true;
7809
7810 }
7811
7812 static bool test_add_driver_arg(struct torture_context *tctx,
7813 struct dcerpc_pipe *p,
7814 struct torture_driver_context *d)
7815 {
7816 bool ret = true;
7817 struct dcerpc_binding_handle *b = p->binding_handle;
7818 const char *server_name_slash = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
7819 uint32_t levels[] = { 1, 2, 3, 4, 6, 8 };
7820 int i;
7821 struct spoolss_AddDriverInfo8 info8;
7822 uint32_t add_flags = APD_COPY_NEW_FILES;
7823 uint32_t delete_flags = 0;
7824
7825 ZERO_STRUCT(info8);
7826
7827 torture_comment(tctx, "Testing PrinterDriver%s '%s' for environment '%s'\n",
7828 d->ex ? "Ex" : "", d->info8.driver_name, d->local.environment);
7829
7830 torture_assert(tctx,
7831 fillup_printserver_info(tctx, p, d),
7832 "failed to fillup printserver info");
7833
7834 if (!directory_exist(d->local.driver_directory)) {
7835 torture_skip(tctx, "Skipping Printer Driver test as no local driver is available");
7836 }
7837
7838 torture_assert(tctx,
7839 upload_printer_driver(tctx, dcerpc_server_name(p), d),
7840 "failed to upload printer driver");
7841
7842 info8.version = d->info8.version;
7843 info8.driver_name = d->info8.driver_name;
7844 info8.architecture = d->local.environment;
7845 info8.driver_path = d->info8.driver_path;
7846 info8.data_file = d->info8.data_file;
7847 info8.config_file = d->info8.config_file;
7848
7849 for (i=0; i < ARRAY_SIZE(levels); i++) {
7850
7851 if (torture_setting_bool(tctx, "samba3", false)) {
7852 switch (levels[i]) {
7853 case 2:
7854 case 4:
7855 case 8:
7856 torture_comment(tctx, "skipping level %d against samba\n", levels[i]);
7857 continue;
7858 default:
7859 break;
7860 }
7861 }
7862
7863 torture_comment(tctx,
7864 "Testing PrinterDriver%s '%s' add & delete level %d\n",
7865 d->ex ? "Ex" : "", info8.driver_name, levels[i]);
7866
7867 ret &= test_PrinterDriver_args(tctx, b, server_name_slash, levels[i], &info8, add_flags, delete_flags, d->info8.version, d->ex);
7868 }
7869
7870 info8.driver_path = talloc_asprintf(tctx, "%s\\%s", d->remote.driver_directory, d->info8.driver_path);
7871 info8.data_file = talloc_asprintf(tctx, "%s\\%s", d->remote.driver_directory, d->info8.data_file);
7872 info8.config_file = talloc_asprintf(tctx, "%s\\%s", d->remote.driver_directory, d->info8.config_file);
7873
7874 for (i=0; i < ARRAY_SIZE(levels); i++) {
7875
7876 if (torture_setting_bool(tctx, "samba3", false)) {
7877 switch (levels[i]) {
7878 case 2:
7879 case 4:
7880 case 8:
7881 torture_comment(tctx, "skipping level %d against samba\n", levels[i]);
7882 continue;
7883 default:
7884 break;
7885 }
7886 }
7887
7888
7889 torture_comment(tctx,
7890 "Testing PrinterDriver%s '%s' add & delete level %d (full unc paths)\n",
7891 d->ex ? "Ex" : "", info8.driver_name, levels[i]);
7892
7893 ret &= test_PrinterDriver_args(tctx, b, server_name_slash, levels[i], &info8, add_flags, delete_flags, d->info8.version, d->ex);
7894 }
7895
7896 torture_assert(tctx,
7897 remove_printer_driver(tctx, dcerpc_server_name(p), d),
7898 "failed to remove printer driver");
7899
7900 torture_comment(tctx, "\n");
7901
7902 return ret;
7903 }
7904
7905 static bool test_add_driver_ex_64(struct torture_context *tctx,
7906 struct dcerpc_pipe *p,
7907 void *private_data)
7908 {
7909 struct torture_driver_context *d =
7910 (struct torture_driver_context *)talloc_get_type_abort(private_data, struct torture_driver_context);
7911
7912 d->local.environment = talloc_strdup(d, "Windows x64");
7913 d->local.driver_directory = talloc_strdup(d, "/usr/share/cups/drivers/x64");
7914 d->info8.driver_name = TORTURE_DRIVER_EX;
7915 d->ex = true;
7916
7917 return test_add_driver_arg(tctx, p, d);
7918 }
7919
7920 static bool test_add_driver_ex_32(struct torture_context *tctx,
7921 struct dcerpc_pipe *p,
7922 void *private_data)
7923 {
7924 struct torture_driver_context *d =
7925 (struct torture_driver_context *)talloc_get_type_abort(private_data, struct torture_driver_context);
7926
7927 d->local.environment = talloc_strdup(d, "Windows NT x86");
7928 d->local.driver_directory = talloc_strdup(d, "/usr/share/cups/drivers/i386");
7929 d->info8.driver_name = TORTURE_DRIVER_EX;
7930 d->ex = true;
7931
7932 return test_add_driver_arg(tctx, p, d);
7933 }
7934
7935 static bool test_add_driver_64(struct torture_context *tctx,
7936 struct dcerpc_pipe *p,
7937 void *private_data)
7938 {
7939 struct torture_driver_context *d =
7940 (struct torture_driver_context *)talloc_get_type_abort(private_data, struct torture_driver_context);
7941
7942 d->local.environment = talloc_strdup(d, "Windows x64");
7943 d->local.driver_directory = talloc_strdup(d, "/usr/share/cups/drivers/x64");
7944 d->info8.driver_name = TORTURE_DRIVER;
7945 d->ex = false;
7946
7947 return test_add_driver_arg(tctx, p, d);
7948 }
7949
7950 static bool test_add_driver_32(struct torture_context *tctx,
7951 struct dcerpc_pipe *p,
7952 void *private_data)
7953 {
7954 struct torture_driver_context *d =
7955 (struct torture_driver_context *)talloc_get_type_abort(private_data, struct torture_driver_context);
7956
7957 d->local.environment = talloc_strdup(d, "Windows NT x86");
7958 d->local.driver_directory = talloc_strdup(d, "/usr/share/cups/drivers/i386");
7959 d->info8.driver_name = TORTURE_DRIVER;
7960 d->ex = false;
7961
7962 return test_add_driver_arg(tctx, p, d);
7963 }
7964
7965 struct torture_suite *torture_rpc_spoolss_driver(TALLOC_CTX *mem_ctx)
7966 {
7967 struct torture_suite *suite = torture_suite_create(mem_ctx, "SPOOLSS-DRIVER");
7968
7969 struct torture_rpc_tcase *tcase = torture_suite_add_rpc_iface_tcase(suite,
7970 "driver", &ndr_table_spoolss);
7971 struct torture_driver_context *t;
7972
7973 t = talloc_zero(mem_ctx, struct torture_driver_context);
7974
7975 t->info8.version = SPOOLSS_DRIVER_VERSION_200X;
7976 t->info8.driver_name = NULL;
7977 t->info8.architecture = NULL;
7978 t->info8.driver_path = talloc_strdup(t, "pscript5.dll");
7979 t->info8.data_file = talloc_strdup(t, "cups6.ppd");
7980 t->info8.config_file = talloc_strdup(t, "cupsui6.dll");
7981
7982 torture_rpc_tcase_add_test_ex(tcase, "add_driver_64", test_add_driver_64, t);
7983 torture_rpc_tcase_add_test_ex(tcase, "add_driver_ex_64", test_add_driver_ex_64, t);
7984
7985 torture_rpc_tcase_add_test_ex(tcase, "add_driver_32", test_add_driver_32, t);
7986 torture_rpc_tcase_add_test_ex(tcase, "add_driver_ex_32", test_add_driver_ex_32, t);
7987
7988 return suite;
7989 }