?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
torture: add AD printer publishing test
[Samba/gebeck_regimport.git] / source4 / torture / rpc / spoolss.c
blob959ba30e8391675bdd307d80da9734f1d8cb415d
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-2011,2013
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 "libcli/smb2/smb2.h"
39 #include "libcli/smb2/smb2_calls.h"
40 #include "lib/cmdline/popt_common.h"
41 #include "system/filesys.h"
42 #include "torture/ndr/ndr.h"
43 #include "torture/smb2/proto.h"
44
45 #define TORTURE_WELLKNOWN_PRINTER "torture_wkn_printer"
46 #define TORTURE_PRINTER "torture_printer"
47 #define TORTURE_WELLKNOWN_PRINTER_EX "torture_wkn_printer_ex"
48 #define TORTURE_PRINTER_EX "torture_printer_ex"
49 #define TORTURE_DRIVER "torture_driver"
50 #define TORTURE_DRIVER_EX "torture_driver_ex"
51 #define TORTURE_DRIVER_ADOBE "torture_driver_adobe"
52 #define TORTURE_DRIVER_EX_ADOBE "torture_driver_ex_adobe"
53 #define TORTURE_DRIVER_ADOBE_CUPSADDSMB "torture_driver_adobe_cupsaddsmb"
54 #define TORTURE_DRIVER_TIMESTAMPS "torture_driver_timestamps"
55 #define TORTURE_DRIVER_DELETER "torture_driver_deleter"
56 #define TORTURE_DRIVER_DELETERIN "torture_driver_deleterin"
57 #define TORTURE_PRINTER_STATIC1 "print1"
58
59 #define TOP_LEVEL_PRINT_KEY "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Print"
60 #define TOP_LEVEL_PRINT_PRINTERS_KEY TOP_LEVEL_PRINT_KEY "\\Printers"
61 #define TOP_LEVEL_CONTROL_KEY "SYSTEM\\CurrentControlSet\\Control\\Print"
62 #define TOP_LEVEL_CONTROL_FORMS_KEY TOP_LEVEL_CONTROL_KEY "\\Forms"
63 #define TOP_LEVEL_CONTROL_PRINTERS_KEY TOP_LEVEL_CONTROL_KEY "\\Printers"
64 #define TOP_LEVEL_CONTROL_ENVIRONMENTS_KEY TOP_LEVEL_CONTROL_KEY "\\Environments"
65
66 struct test_spoolss_context {
67 struct dcerpc_pipe *spoolss_pipe;
68
69 /* server environment */
70 const char *environment;
71
72 /* print server handle */
73 struct policy_handle server_handle;
74
75 /* for EnumPorts */
76 uint32_t port_count[3];
77 union spoolss_PortInfo *ports[3];
78
79 /* for EnumPrinterDrivers */
80 uint32_t driver_count[8];
81 union spoolss_DriverInfo *drivers[8];
82
83 /* for EnumMonitors */
84 uint32_t monitor_count[3];
85 union spoolss_MonitorInfo *monitors[3];
86
87 /* for EnumPrintProcessors */
88 uint32_t print_processor_count[2];
89 union spoolss_PrintProcessorInfo *print_processors[2];
90
91 /* for EnumPrinters */
92 uint32_t printer_count[6];
93 union spoolss_PrinterInfo *printers[6];
94 };
95
96 struct torture_driver_context {
97 struct {
98 const char *driver_directory;
99 const char *environment;
100 } local;
101 struct {
102 const char *driver_directory;
103 const char *environment;
104 } remote;
105 struct spoolss_AddDriverInfo8 info8;
106 bool ex;
107 };
108
109 struct torture_printer_context {
110 struct dcerpc_pipe *spoolss_pipe;
111 struct spoolss_SetPrinterInfo2 info2;
112 struct torture_driver_context driver;
113 bool ex;
114 bool wellknown;
115 bool added_driver;
116 bool have_driver;
117 struct spoolss_DeviceMode *devmode;
118 struct policy_handle handle;
119 };
120
121 static bool upload_printer_driver(struct torture_context *tctx,
122 const char *server_name,
123 struct torture_driver_context *d);
124 static bool remove_printer_driver(struct torture_context *tctx,
125 const char *server_name,
126 struct torture_driver_context *d);
127 static bool fillup_printserver_info(struct torture_context *tctx,
128 struct dcerpc_pipe *p,
129 struct torture_driver_context *d);
130 static bool test_AddPrinterDriver_args_level_3(struct torture_context *tctx,
131 struct dcerpc_binding_handle *b,
132 const char *server_name,
133 struct spoolss_AddDriverInfo8 *r,
134 uint32_t flags,
135 bool ex,
136 const char *remote_driver_dir);
137
138 #define COMPARE_STRING(tctx, c,r,e) \
139 torture_assert_str_equal(tctx, c.e, r.e, "invalid value")
140
141 /* not every compiler supports __typeof__() */
142 #if (__GNUC__ >= 3)
143 #define _CHECK_FIELD_SIZE(c,r,e,type) do {\
144 if (sizeof(__typeof__(c.e)) != sizeof(type)) { \
145 torture_fail(tctx, #c "." #e "field is not " #type "\n"); \
146 }\
147 if (sizeof(__typeof__(r.e)) != sizeof(type)) { \
148 torture_fail(tctx, #r "." #e "field is not " #type "\n"); \
149 }\
150 } while(0)
151 #else
152 #define _CHECK_FIELD_SIZE(c,r,e,type) do {} while(0)
153 #endif
154
155 #define COMPARE_UINT32(tctx, c, r, e) do {\
156 _CHECK_FIELD_SIZE(c, r, e, uint32_t); \
157 torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
158 } while(0)
159
160 #define COMPARE_UINT64(tctx, c, r, e) do {\
161 _CHECK_FIELD_SIZE(c, r, e, uint64_t); \
162 torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
163 } while(0)
164
165
166 #define COMPARE_NTTIME(tctx, c, r, e) do {\
167 _CHECK_FIELD_SIZE(c, r, e, NTTIME); \
168 torture_assert_int_equal(tctx, c.e, r.e, "invalid value"); \
169 } while(0)
170
171 #define COMPARE_STRING_ARRAY(tctx, c,r,e) do {\
172 int __i; \
173 if (!c.e && !r.e) { \
174 break; \
175 } \
176 if (c.e && !r.e) { \
177 torture_fail(tctx, #r "." #e " field is NULL and " #c "." #e " is not\n"); \
178 } \
179 if (!c.e && r.e) { \
180 torture_fail(tctx, #c "." #e " field is NULL and " #r "." #e " is not\n"); \
181 } \
182 for (__i=0;c.e[__i] != NULL; __i++) { \
183 torture_assert_str_equal(tctx, c.e[__i], r.e[__i], "invalid value"); \
184 } \
185 } while(0)
186
187 #define CHECK_ALIGN(size, n) do {\
188 if (size % n) {\
189 torture_warning(tctx, "%d is *NOT* %d byte aligned, should be %d",\
190 size, n, size + n - (size % n));\
191 }\
192 } while(0)
193
194 #define DO_ROUND(size, n) (((size)+((n)-1)) & ~((n)-1))
195
196 #define CHECK_NEEDED_SIZE_ENUM_LEVEL(fn, info, level, count, needed, align) do { \
197 if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
198 uint32_t size = ndr_size_##fn##_info(tctx, level, count, info);\
199 uint32_t round_size = DO_ROUND(size, align);\
200 if (round_size != needed) {\
201 torture_warning(tctx, __location__": "#fn" level %d (count: %d) got unexpected needed size: %d, we calculated: %d", level, count, needed, round_size);\
202 CHECK_ALIGN(size, align);\
203 }\
204 }\
205 } while(0)
206
207 #define CHECK_NEEDED_SIZE_ENUM(fn, info, count, needed, align) do { \
208 if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
209 uint32_t size = ndr_size_##fn##_info(tctx, count, info);\
210 uint32_t round_size = DO_ROUND(size, align);\
211 if (round_size != needed) {\
212 torture_warning(tctx, __location__": "#fn" (count: %d) got unexpected needed size: %d, we calculated: %d", count, needed, round_size);\
213 CHECK_ALIGN(size, align);\
214 }\
215 }\
216 } while(0)
217
218 #define CHECK_NEEDED_SIZE_LEVEL(fn, info, level, needed, align) do { \
219 if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
220 uint32_t size = ndr_size_##fn(info, level, 0);\
221 uint32_t round_size = DO_ROUND(size, align);\
222 if (round_size != needed) {\
223 torture_warning(tctx, __location__": "#fn" level %d got unexpected needed size: %d, we calculated: %d", level, needed, round_size);\
224 CHECK_ALIGN(size, align);\
225 }\
226 }\
227 } while(0)
228
229 static bool PrinterInfo_to_SetPrinterInfo(struct torture_context *tctx,
230 const union spoolss_PrinterInfo *i,
231 uint32_t level,
232 union spoolss_SetPrinterInfo *s)
233 {
234 switch (level) {
235 case 0:
236 s->info0 = talloc(tctx, struct spoolss_SetPrinterInfo0);
237 break;
238 case 2:
239 s->info2 = talloc(tctx, struct spoolss_SetPrinterInfo2);
240 s->info2->servername = i->info2.servername;
241 s->info2->printername = i->info2.printername;
242 s->info2->sharename = i->info2.sharename;
243 s->info2->portname = i->info2.portname;
244 s->info2->drivername = i->info2.drivername;
245 s->info2->comment = i->info2.comment;
246 s->info2->location = i->info2.location;
247 s->info2->devmode_ptr = NULL;
248 s->info2->sepfile = i->info2.sepfile;
249 s->info2->printprocessor = i->info2.printprocessor;
250 s->info2->datatype = i->info2.datatype;
251 s->info2->parameters = i->info2.parameters;
252 s->info2->secdesc_ptr = NULL;
253 s->info2->attributes = i->info2.attributes;
254 s->info2->priority = i->info2.priority;
255 s->info2->defaultpriority = i->info2.defaultpriority;
256 s->info2->starttime = i->info2.starttime;
257 s->info2->untiltime = i->info2.untiltime;
258 s->info2->status = i->info2.status;
259 s->info2->cjobs = i->info2.cjobs;
260 s->info2->averageppm = i->info2.averageppm;
261 break;
262 case 3:
263 case 4:
264 case 5:
265 case 6:
266 case 7:
267 case 8:
268 case 9:
269 default:
270 return false;
271 }
272
273 return true;
274 }
275
276 static bool test_OpenPrinter_server(struct torture_context *tctx,
277 struct dcerpc_pipe *p,
278 struct policy_handle *server_handle)
279 {
280 NTSTATUS status;
281 struct spoolss_OpenPrinter op;
282 struct dcerpc_binding_handle *b = p->binding_handle;
283
284 op.in.printername = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
285 op.in.datatype = NULL;
286 op.in.devmode_ctr.devmode= NULL;
287 op.in.access_mask = 0;
288 op.out.handle = server_handle;
289
290 torture_comment(tctx, "Testing OpenPrinter(%s)\n", op.in.printername);
291
292 status = dcerpc_spoolss_OpenPrinter_r(b, tctx, &op);
293 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_OpenPrinter failed");
294 torture_assert_werr_ok(tctx, op.out.result, "dcerpc_spoolss_OpenPrinter failed");
295
296 return true;
297 }
298
299 static bool test_EnumPorts(struct torture_context *tctx,
300 void *private_data)
301 {
302 struct test_spoolss_context *ctx =
303 talloc_get_type_abort(private_data, struct test_spoolss_context);
304 struct dcerpc_pipe *p = ctx->spoolss_pipe;
305 struct dcerpc_binding_handle *b = p->binding_handle;
306 NTSTATUS status;
307 struct spoolss_EnumPorts r;
308 uint16_t levels[] = { 1, 2 };
309 int i, j;
310
311 for (i=0;i<ARRAY_SIZE(levels);i++) {
312 int level = levels[i];
313 DATA_BLOB blob;
314 uint32_t needed;
315 uint32_t count;
316 union spoolss_PortInfo *info;
317
318 r.in.servername = "";
319 r.in.level = level;
320 r.in.buffer = NULL;
321 r.in.offered = 0;
322 r.out.needed = &needed;
323 r.out.count = &count;
324 r.out.info = &info;
325
326 torture_comment(tctx, "Testing EnumPorts level %u\n", r.in.level);
327
328 status = dcerpc_spoolss_EnumPorts_r(b, ctx, &r);
329 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
330 if (W_ERROR_IS_OK(r.out.result)) {
331 /* TODO: do some more checks here */
332 continue;
333 }
334 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
335 "EnumPorts unexpected return code");
336
337 blob = data_blob_talloc_zero(ctx, needed);
338 r.in.buffer = &blob;
339 r.in.offered = needed;
340
341 status = dcerpc_spoolss_EnumPorts_r(b, ctx, &r);
342 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
343
344 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
345
346 torture_assert(tctx, info, "EnumPorts returned no info");
347
348 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPorts, info, r.in.level, count, needed, 4);
349
350 ctx->port_count[level] = count;
351 ctx->ports[level] = info;
352 }
353
354 for (i=1;i<ARRAY_SIZE(levels);i++) {
355 int level = levels[i];
356 int old_level = levels[i-1];
357 torture_assert_int_equal(tctx, ctx->port_count[level], ctx->port_count[old_level],
358 "EnumPorts invalid value");
359 }
360 /* if the array sizes are not the same we would maybe segfault in the following code */
361
362 for (i=0;i<ARRAY_SIZE(levels);i++) {
363 int level = levels[i];
364 for (j=0;j<ctx->port_count[level];j++) {
365 union spoolss_PortInfo *cur = &ctx->ports[level][j];
366 union spoolss_PortInfo *ref = &ctx->ports[2][j];
367 switch (level) {
368 case 1:
369 COMPARE_STRING(tctx, cur->info1, ref->info2, port_name);
370 break;
371 case 2:
372 /* level 2 is our reference, and it makes no sense to compare it to itself */
373 break;
374 }
375 }
376 }
377
378 return true;
379 }
380
381 static bool test_GetPrintProcessorDirectory(struct torture_context *tctx,
382 void *private_data)
383 {
384 struct test_spoolss_context *ctx =
385 talloc_get_type_abort(private_data, struct test_spoolss_context);
386
387 NTSTATUS status;
388 struct dcerpc_pipe *p = ctx->spoolss_pipe;
389 struct dcerpc_binding_handle *b = p->binding_handle;
390 struct spoolss_GetPrintProcessorDirectory r;
391 struct {
392 uint16_t level;
393 const char *server;
394 } levels[] = {{
395 .level = 1,
396 .server = NULL
397 },{
398 .level = 1,
399 .server = ""
400 },{
401 .level = 78,
402 .server = ""
403 },{
404 .level = 1,
405 .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
406 },{
407 .level = 1024,
408 .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
409 }
410 };
411 int i;
412 uint32_t needed;
413
414 for (i=0;i<ARRAY_SIZE(levels);i++) {
415 int level = levels[i].level;
416 DATA_BLOB blob;
417
418 r.in.server = levels[i].server;
419 r.in.environment = ctx->environment;
420 r.in.level = level;
421 r.in.buffer = NULL;
422 r.in.offered = 0;
423 r.out.needed = &needed;
424
425 torture_comment(tctx, "Testing GetPrintProcessorDirectory level %u\n", r.in.level);
426
427 status = dcerpc_spoolss_GetPrintProcessorDirectory_r(b, tctx, &r);
428 torture_assert_ntstatus_ok(tctx, status,
429 "dcerpc_spoolss_GetPrintProcessorDirectory failed");
430 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
431 "GetPrintProcessorDirectory unexpected return code");
432
433 blob = data_blob_talloc_zero(tctx, needed);
434 r.in.buffer = &blob;
435 r.in.offered = needed;
436
437 status = dcerpc_spoolss_GetPrintProcessorDirectory_r(b, tctx, &r);
438 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrintProcessorDirectory failed");
439
440 torture_assert_werr_ok(tctx, r.out.result, "GetPrintProcessorDirectory failed");
441
442 CHECK_NEEDED_SIZE_LEVEL(spoolss_PrintProcessorDirectoryInfo, r.out.info, r.in.level, needed, 2);
443 }
444
445 return true;
446 }
447
448
449 static bool test_GetPrinterDriverDirectory(struct torture_context *tctx,
450 void *private_data)
451 {
452 struct test_spoolss_context *ctx =
453 talloc_get_type_abort(private_data, struct test_spoolss_context);
454
455 NTSTATUS status;
456 struct dcerpc_pipe *p = ctx->spoolss_pipe;
457 struct dcerpc_binding_handle *b = p->binding_handle;
458 struct spoolss_GetPrinterDriverDirectory r;
459 struct {
460 uint16_t level;
461 const char *server;
462 } levels[] = {{
463 .level = 1,
464 .server = NULL
465 },{
466 .level = 1,
467 .server = ""
468 },{
469 .level = 78,
470 .server = ""
471 },{
472 .level = 1,
473 .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
474 },{
475 .level = 1024,
476 .server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p))
477 }
478 };
479 int i;
480 uint32_t needed;
481
482 for (i=0;i<ARRAY_SIZE(levels);i++) {
483 int level = levels[i].level;
484 DATA_BLOB blob;
485
486 r.in.server = levels[i].server;
487 r.in.environment = ctx->environment;
488 r.in.level = level;
489 r.in.buffer = NULL;
490 r.in.offered = 0;
491 r.out.needed = &needed;
492
493 torture_comment(tctx, "Testing GetPrinterDriverDirectory level %u\n", r.in.level);
494
495 status = dcerpc_spoolss_GetPrinterDriverDirectory_r(b, tctx, &r);
496 torture_assert_ntstatus_ok(tctx, status,
497 "dcerpc_spoolss_GetPrinterDriverDirectory failed");
498 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
499 "GetPrinterDriverDirectory unexpected return code");
500
501 blob = data_blob_talloc_zero(tctx, needed);
502 r.in.buffer = &blob;
503 r.in.offered = needed;
504
505 status = dcerpc_spoolss_GetPrinterDriverDirectory_r(b, tctx, &r);
506 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrinterDriverDirectory failed");
507
508 torture_assert_werr_ok(tctx, r.out.result, "GetPrinterDriverDirectory failed");
509
510 CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverDirectoryInfo, r.out.info, r.in.level, needed, 2);
511 }
512
513 return true;
514 }
515
516 static bool test_EnumPrinterDrivers_args(struct torture_context *tctx,
517 struct dcerpc_binding_handle *b,
518 const char *server_name,
519 const char *environment,
520 uint32_t level,
521 uint32_t *count_p,
522 union spoolss_DriverInfo **info_p)
523 {
524 struct spoolss_EnumPrinterDrivers r;
525 uint32_t needed;
526 uint32_t count;
527 union spoolss_DriverInfo *info;
528
529 r.in.server = server_name;
530 r.in.environment = environment;
531 r.in.level = level;
532 r.in.buffer = NULL;
533 r.in.offered = 0;
534 r.out.needed = &needed;
535 r.out.count = &count;
536 r.out.info = &info;
537
538 torture_comment(tctx, "Testing EnumPrinterDrivers(%s) level %u\n",
539 r.in.environment, r.in.level);
540
541 torture_assert_ntstatus_ok(tctx,
542 dcerpc_spoolss_EnumPrinterDrivers_r(b, tctx, &r),
543 "EnumPrinterDrivers failed");
544 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
545 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
546 r.in.buffer = &blob;
547 r.in.offered = needed;
548
549 torture_assert_ntstatus_ok(tctx,
550 dcerpc_spoolss_EnumPrinterDrivers_r(b, tctx, &r),
551 "EnumPrinterDrivers failed");
552 }
553
554 torture_assert_werr_ok(tctx, r.out.result,
555 "EnumPrinterDrivers failed");
556
557 if (count_p) {
558 *count_p = count;
559 }
560 if (info_p) {
561 *info_p = info;
562 }
563
564 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinterDrivers, info, r.in.level, count, needed, 4);
565
566 return true;
567
568 }
569
570 static bool test_EnumPrinterDrivers_findone(struct torture_context *tctx,
571 struct dcerpc_binding_handle *b,
572 const char *server_name,
573 const char *environment,
574 uint32_t level,
575 const char *driver_name,
576 union spoolss_DriverInfo *info_p)
577 {
578 uint32_t count;
579 union spoolss_DriverInfo *info;
580 int i;
581 const char *environment_ret = NULL;
582
583 torture_assert(tctx,
584 test_EnumPrinterDrivers_args(tctx, b, server_name, environment, level, &count, &info),
585 "failed to enumerate printer drivers");
586
587 for (i=0; i < count; i++) {
588 const char *driver_name_ret;
589 switch (level) {
590 case 1:
591 driver_name_ret = info[i].info1.driver_name;
592 break;
593 case 2:
594 driver_name_ret = info[i].info2.driver_name;
595 environment_ret = info[i].info2.architecture;
596 break;
597 case 3:
598 driver_name_ret = info[i].info3.driver_name;
599 environment_ret = info[i].info3.architecture;
600 break;
601 case 4:
602 driver_name_ret = info[i].info4.driver_name;
603 environment_ret = info[i].info4.architecture;
604 break;
605 case 5:
606 driver_name_ret = info[i].info5.driver_name;
607 environment_ret = info[i].info5.architecture;
608 break;
609 case 6:
610 driver_name_ret = info[i].info6.driver_name;
611 environment_ret = info[i].info6.architecture;
612 break;
613 case 7:
614 driver_name_ret = info[i].info7.driver_name;
615 break;
616 case 8:
617 driver_name_ret = info[i].info8.driver_name;
618 environment_ret = info[i].info8.architecture;
619 break;
620 default:
621 break;
622 }
623 if (environment_ret) {
624 torture_assert_str_equal(tctx, environment, environment_ret, "architecture mismatch");
625 }
626 if (strequal(driver_name, driver_name_ret)) {
627 if (info_p) {
628 *info_p = info[i];
629 }
630 return true;
631 }
632 }
633
634 return false;
635 }
636
637 static bool test_EnumPrinterDrivers(struct torture_context *tctx,
638 void *private_data)
639 {
640 struct test_spoolss_context *ctx =
641 talloc_get_type_abort(private_data, struct test_spoolss_context);
642 struct dcerpc_pipe *p = ctx->spoolss_pipe;
643 struct dcerpc_binding_handle *b = p->binding_handle;
644 uint16_t levels[] = { 1, 2, 3, 4, 5, 6, 8 };
645 int i, j, a;
646
647 /* FIXME: gd, come back and fix "" as server, and handle
648 * priority of returned error codes in torture test and samba 3
649 * server */
650 const char *server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
651 const char *environments[2];
652
653 environments[0] = SPOOLSS_ARCHITECTURE_ALL;
654 environments[1] = ctx->environment;
655
656 for (a=0;a<ARRAY_SIZE(environments);a++) {
657
658 for (i=0;i<ARRAY_SIZE(levels);i++) {
659 int level = levels[i];
660 uint32_t count;
661 union spoolss_DriverInfo *info;
662
663 torture_assert(tctx,
664 test_EnumPrinterDrivers_args(tctx, b, server_name, environments[a], level, &count, &info),
665 "failed to enumerate drivers");
666
667 ctx->driver_count[level] = count;
668 ctx->drivers[level] = info;
669 }
670
671 for (i=1;i<ARRAY_SIZE(levels);i++) {
672 int level = levels[i];
673 int old_level = levels[i-1];
674
675 torture_assert_int_equal(tctx, ctx->driver_count[level], ctx->driver_count[old_level],
676 "EnumPrinterDrivers invalid value");
677 }
678
679 for (i=0;i<ARRAY_SIZE(levels);i++) {
680 int level = levels[i];
681
682 for (j=0;j<ctx->driver_count[level - 1];j++) {
683 union spoolss_DriverInfo *cur = &ctx->drivers[level - 1][j];
684 union spoolss_DriverInfo *ref = &ctx->drivers[8][j];
685
686 switch (level) {
687 case 1:
688 COMPARE_STRING(tctx, cur->info1, ref->info8, driver_name);
689 break;
690 case 2:
691 COMPARE_UINT32(tctx, cur->info2, ref->info8, version);
692 COMPARE_STRING(tctx, cur->info2, ref->info8, driver_name);
693 COMPARE_STRING(tctx, cur->info2, ref->info8, architecture);
694 COMPARE_STRING(tctx, cur->info2, ref->info8, driver_path);
695 COMPARE_STRING(tctx, cur->info2, ref->info8, data_file);
696 COMPARE_STRING(tctx, cur->info2, ref->info8, config_file);
697 break;
698 case 3:
699 COMPARE_UINT32(tctx, cur->info3, ref->info8, version);
700 COMPARE_STRING(tctx, cur->info3, ref->info8, driver_name);
701 COMPARE_STRING(tctx, cur->info3, ref->info8, architecture);
702 COMPARE_STRING(tctx, cur->info3, ref->info8, driver_path);
703 COMPARE_STRING(tctx, cur->info3, ref->info8, data_file);
704 COMPARE_STRING(tctx, cur->info3, ref->info8, config_file);
705 COMPARE_STRING(tctx, cur->info3, ref->info8, help_file);
706 COMPARE_STRING_ARRAY(tctx, cur->info3, ref->info8, dependent_files);
707 COMPARE_STRING(tctx, cur->info3, ref->info8, monitor_name);
708 COMPARE_STRING(tctx, cur->info3, ref->info8, default_datatype);
709 break;
710 case 4:
711 COMPARE_UINT32(tctx, cur->info4, ref->info8, version);
712 COMPARE_STRING(tctx, cur->info4, ref->info8, driver_name);
713 COMPARE_STRING(tctx, cur->info4, ref->info8, architecture);
714 COMPARE_STRING(tctx, cur->info4, ref->info8, driver_path);
715 COMPARE_STRING(tctx, cur->info4, ref->info8, data_file);
716 COMPARE_STRING(tctx, cur->info4, ref->info8, config_file);
717 COMPARE_STRING(tctx, cur->info4, ref->info8, help_file);
718 COMPARE_STRING_ARRAY(tctx, cur->info4, ref->info8, dependent_files);
719 COMPARE_STRING(tctx, cur->info4, ref->info8, monitor_name);
720 COMPARE_STRING(tctx, cur->info4, ref->info8, default_datatype);
721 COMPARE_STRING_ARRAY(tctx, cur->info4, ref->info8, previous_names);
722 break;
723 case 5:
724 COMPARE_UINT32(tctx, cur->info5, ref->info8, version);
725 COMPARE_STRING(tctx, cur->info5, ref->info8, driver_name);
726 COMPARE_STRING(tctx, cur->info5, ref->info8, architecture);
727 COMPARE_STRING(tctx, cur->info5, ref->info8, driver_path);
728 COMPARE_STRING(tctx, cur->info5, ref->info8, data_file);
729 COMPARE_STRING(tctx, cur->info5, ref->info8, config_file);
730 /*COMPARE_UINT32(tctx, cur->info5, ref->info8, driver_attributes);*/
731 /*COMPARE_UINT32(tctx, cur->info5, ref->info8, config_version);*/
732 /*TODO: ! COMPARE_UINT32(tctx, cur->info5, ref->info8, driver_version); */
733 break;
734 case 6:
735 COMPARE_UINT32(tctx, cur->info6, ref->info8, version);
736 COMPARE_STRING(tctx, cur->info6, ref->info8, driver_name);
737 COMPARE_STRING(tctx, cur->info6, ref->info8, architecture);
738 COMPARE_STRING(tctx, cur->info6, ref->info8, driver_path);
739 COMPARE_STRING(tctx, cur->info6, ref->info8, data_file);
740 COMPARE_STRING(tctx, cur->info6, ref->info8, config_file);
741 COMPARE_STRING(tctx, cur->info6, ref->info8, help_file);
742 COMPARE_STRING_ARRAY(tctx, cur->info6, ref->info8, dependent_files);
743 COMPARE_STRING(tctx, cur->info6, ref->info8, monitor_name);
744 COMPARE_STRING(tctx, cur->info6, ref->info8, default_datatype);
745 COMPARE_STRING_ARRAY(tctx, cur->info6, ref->info8, previous_names);
746 COMPARE_NTTIME(tctx, cur->info6, ref->info8, driver_date);
747 COMPARE_UINT64(tctx, cur->info6, ref->info8, driver_version);
748 COMPARE_STRING(tctx, cur->info6, ref->info8, manufacturer_name);
749 COMPARE_STRING(tctx, cur->info6, ref->info8, manufacturer_url);
750 COMPARE_STRING(tctx, cur->info6, ref->info8, hardware_id);
751 COMPARE_STRING(tctx, cur->info6, ref->info8, provider);
752 break;
753 case 8:
754 /* level 8 is our reference, and it makes no sense to compare it to itself */
755 break;
756 }
757 }
758 }
759 }
760
761 return true;
762 }
763
764 static bool test_EnumMonitors(struct torture_context *tctx,
765 void *private_data)
766 {
767 struct test_spoolss_context *ctx =
768 talloc_get_type_abort(private_data, struct test_spoolss_context);
769 struct dcerpc_pipe *p = ctx->spoolss_pipe;
770 struct dcerpc_binding_handle *b = p->binding_handle;
771 NTSTATUS status;
772 struct spoolss_EnumMonitors r;
773 uint16_t levels[] = { 1, 2 };
774 int i, j;
775
776 for (i=0;i<ARRAY_SIZE(levels);i++) {
777 int level = levels[i];
778 DATA_BLOB blob;
779 uint32_t needed;
780 uint32_t count;
781 union spoolss_MonitorInfo *info;
782
783 r.in.servername = "";
784 r.in.level = level;
785 r.in.buffer = NULL;
786 r.in.offered = 0;
787 r.out.needed = &needed;
788 r.out.count = &count;
789 r.out.info = &info;
790
791 torture_comment(tctx, "Testing EnumMonitors level %u\n", r.in.level);
792
793 status = dcerpc_spoolss_EnumMonitors_r(b, ctx, &r);
794 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
795 if (W_ERROR_IS_OK(r.out.result)) {
796 /* TODO: do some more checks here */
797 continue;
798 }
799 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
800 "EnumMonitors failed");
801
802 blob = data_blob_talloc_zero(ctx, needed);
803 r.in.buffer = &blob;
804 r.in.offered = needed;
805
806 status = dcerpc_spoolss_EnumMonitors_r(b, ctx, &r);
807 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
808
809 torture_assert_werr_ok(tctx, r.out.result, "EnumMonitors failed");
810
811 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumMonitors, info, r.in.level, count, needed, 4);
812
813 ctx->monitor_count[level] = count;
814 ctx->monitors[level] = info;
815 }
816
817 for (i=1;i<ARRAY_SIZE(levels);i++) {
818 int level = levels[i];
819 int old_level = levels[i-1];
820 torture_assert_int_equal(tctx, ctx->monitor_count[level], ctx->monitor_count[old_level],
821 "EnumMonitors invalid value");
822 }
823
824 for (i=0;i<ARRAY_SIZE(levels);i++) {
825 int level = levels[i];
826 for (j=0;j<ctx->monitor_count[level];j++) {
827 union spoolss_MonitorInfo *cur = &ctx->monitors[level][j];
828 union spoolss_MonitorInfo *ref = &ctx->monitors[2][j];
829 switch (level) {
830 case 1:
831 COMPARE_STRING(tctx, cur->info1, ref->info2, monitor_name);
832 break;
833 case 2:
834 /* level 2 is our reference, and it makes no sense to compare it to itself */
835 break;
836 }
837 }
838 }
839
840 return true;
841 }
842
843 static bool test_EnumPrintProcessors_level(struct torture_context *tctx,
844 struct dcerpc_binding_handle *b,
845 const char *environment,
846 uint32_t level,
847 uint32_t *count_p,
848 union spoolss_PrintProcessorInfo **info_p,
849 WERROR expected_result)
850 {
851 struct spoolss_EnumPrintProcessors r;
852 DATA_BLOB blob;
853 uint32_t needed;
854 uint32_t count;
855 union spoolss_PrintProcessorInfo *info;
856
857 r.in.servername = "";
858 r.in.environment = environment;
859 r.in.level = level;
860 r.in.buffer = NULL;
861 r.in.offered = 0;
862 r.out.needed = &needed;
863 r.out.count = &count;
864 r.out.info = &info;
865
866 torture_comment(tctx, "Testing EnumPrintProcessors(%s) level %u\n",
867 r.in.environment, r.in.level);
868
869 torture_assert_ntstatus_ok(tctx,
870 dcerpc_spoolss_EnumPrintProcessors_r(b, tctx, &r),
871 "EnumPrintProcessors failed");
872 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
873 blob = data_blob_talloc_zero(tctx, needed);
874 r.in.buffer = &blob;
875 r.in.offered = needed;
876 torture_assert_ntstatus_ok(tctx,
877 dcerpc_spoolss_EnumPrintProcessors_r(b, tctx, &r),
878 "EnumPrintProcessors failed");
879 }
880 torture_assert_werr_equal(tctx, r.out.result, expected_result,
881 "EnumPrintProcessors failed");
882
883 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcessors, info, level, count, needed, 4);
884
885 if (count_p) {
886 *count_p = count;
887 }
888 if (info_p) {
889 *info_p = info;
890 }
891
892 return true;
893 }
894
895 static bool test_EnumPrintProcessors(struct torture_context *tctx,
896 void *private_data)
897 {
898 struct test_spoolss_context *ctx =
899 talloc_get_type_abort(private_data, struct test_spoolss_context);
900
901 uint16_t levels[] = {0, 1, 2, 3, 32, 256 };
902 uint16_t ok[] = {0, 1, 0, 0, 0, 0 };
903 int i;
904 struct dcerpc_pipe *p = ctx->spoolss_pipe;
905 struct dcerpc_binding_handle *b = p->binding_handle;
906
907 torture_assert(tctx,
908 test_EnumPrintProcessors_level(tctx, b, "phantasy", 1, NULL, NULL, WERR_INVALID_ENVIRONMENT),
909 "test_EnumPrintProcessors_level failed");
910
911 for (i=0;i<ARRAY_SIZE(levels);i++) {
912 union spoolss_PrintProcessorInfo *info;
913 uint32_t count;
914 WERROR expected_result = ok[i] ? WERR_OK : WERR_INVALID_LEVEL;
915
916 torture_assert(tctx,
917 test_EnumPrintProcessors_level(tctx, b, ctx->environment, levels[i], &count, &info, expected_result),
918 "test_EnumPrintProcessors_level failed");
919 }
920
921 return true;
922 }
923
924 static bool test_EnumPrintProcDataTypes_level(struct torture_context *tctx,
925 struct dcerpc_binding_handle *b,
926 const char *print_processor_name,
927 uint32_t level,
928 uint32_t *count_p,
929 union spoolss_PrintProcDataTypesInfo **info_p,
930 WERROR expected_result)
931 {
932 struct spoolss_EnumPrintProcDataTypes r;
933 DATA_BLOB blob;
934 uint32_t needed;
935 uint32_t count;
936 union spoolss_PrintProcDataTypesInfo *info;
937
938 r.in.servername = "";
939 r.in.print_processor_name = print_processor_name;
940 r.in.level = level;
941 r.in.buffer = NULL;
942 r.in.offered = 0;
943 r.out.needed = &needed;
944 r.out.count = &count;
945 r.out.info = &info;
946
947 torture_comment(tctx, "Testing EnumPrintProcDataTypes(%s) level %u\n",
948 r.in.print_processor_name, r.in.level);
949
950 torture_assert_ntstatus_ok(tctx,
951 dcerpc_spoolss_EnumPrintProcDataTypes_r(b, tctx, &r),
952 "EnumPrintProcDataTypes failed");
953 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
954 blob = data_blob_talloc_zero(tctx, needed);
955 r.in.buffer = &blob;
956 r.in.offered = needed;
957 torture_assert_ntstatus_ok(tctx,
958 dcerpc_spoolss_EnumPrintProcDataTypes_r(b, tctx, &r),
959 "EnumPrintProcDataTypes failed");
960 }
961 torture_assert_werr_equal(tctx, r.out.result, expected_result,
962 "EnumPrintProcDataTypes failed");
963
964 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcDataTypes, info, level, count, needed, 4);
965
966 if (count_p) {
967 *count_p = count;
968 }
969 if (info_p) {
970 *info_p = info;
971 }
972
973 return true;
974 }
975
976 static bool test_EnumPrintProcDataTypes(struct torture_context *tctx,
977 void *private_data)
978 {
979 struct test_spoolss_context *ctx =
980 talloc_get_type_abort(private_data, struct test_spoolss_context);
981
982 uint16_t levels[] = {0, 1, 2, 3, 32, 256 };
983 uint16_t ok[] = {0, 1, 0, 0, 0, 0 };
984 int i;
985 struct dcerpc_pipe *p = ctx->spoolss_pipe;
986 struct dcerpc_binding_handle *b = p->binding_handle;
987
988 torture_assert(tctx,
989 test_EnumPrintProcDataTypes_level(tctx, b, NULL, 1, NULL, NULL, WERR_UNKNOWN_PRINTPROCESSOR),
990 "test_EnumPrintProcDataTypes_level failed");
991
992 torture_assert(tctx,
993 test_EnumPrintProcDataTypes_level(tctx, b, "nonexisting", 1, NULL, NULL, WERR_UNKNOWN_PRINTPROCESSOR),
994 "test_EnumPrintProcDataTypes_level failed");
995
996 for (i=0;i<ARRAY_SIZE(levels);i++) {
997 int level = levels[i];
998 uint32_t count;
999 union spoolss_PrintProcDataTypesInfo *info;
1000 WERROR expected_result = ok[i] ? WERR_OK : WERR_INVALID_LEVEL;
1001
1002 torture_assert(tctx,
1003 test_EnumPrintProcDataTypes_level(tctx, b, "winprint", level, &count, &info, expected_result),
1004 "test_EnumPrintProcDataTypes_level failed");
1005 }
1006
1007 {
1008 union spoolss_PrintProcessorInfo *info;
1009 uint32_t count;
1010
1011 torture_assert(tctx,
1012 test_EnumPrintProcessors_level(tctx, b, ctx->environment, 1, &count, &info, WERR_OK),
1013 "test_EnumPrintProcessors_level failed");
1014
1015 for (i=0; i < count; i++) {
1016 torture_assert(tctx,
1017 test_EnumPrintProcDataTypes_level(tctx, b, info[i].info1.print_processor_name, 1, NULL, NULL, WERR_OK),
1018 "test_EnumPrintProcDataTypes_level failed");
1019 }
1020 }
1021
1022
1023 return true;
1024 }
1025
1026 static bool test_EnumPrinters(struct torture_context *tctx,
1027 void *private_data)
1028 {
1029 struct test_spoolss_context *ctx =
1030 talloc_get_type_abort(private_data, struct test_spoolss_context);
1031 struct dcerpc_pipe *p = ctx->spoolss_pipe;
1032 struct dcerpc_binding_handle *b = p->binding_handle;
1033 struct spoolss_EnumPrinters r;
1034 NTSTATUS status;
1035 uint16_t levels[] = { 0, 1, 2, 4, 5 };
1036 int i, j;
1037
1038 for (i=0;i<ARRAY_SIZE(levels);i++) {
1039 int level = levels[i];
1040 DATA_BLOB blob;
1041 uint32_t needed;
1042 uint32_t count;
1043 union spoolss_PrinterInfo *info;
1044
1045 r.in.flags = PRINTER_ENUM_LOCAL;
1046 r.in.server = "";
1047 r.in.level = level;
1048 r.in.buffer = NULL;
1049 r.in.offered = 0;
1050 r.out.needed = &needed;
1051 r.out.count = &count;
1052 r.out.info = &info;
1053
1054 torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
1055
1056 status = dcerpc_spoolss_EnumPrinters_r(b, ctx, &r);
1057 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
1058 if (W_ERROR_IS_OK(r.out.result)) {
1059 /* TODO: do some more checks here */
1060 continue;
1061 }
1062 torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
1063 "EnumPrinters unexpected return code");
1064
1065 blob = data_blob_talloc_zero(ctx, needed);
1066 r.in.buffer = &blob;
1067 r.in.offered = needed;
1068
1069 status = dcerpc_spoolss_EnumPrinters_r(b, ctx, &r);
1070 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
1071
1072 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
1073
1074 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, needed, 4);
1075
1076 ctx->printer_count[level] = count;
1077 ctx->printers[level] = info;
1078 }
1079
1080 for (i=1;i<ARRAY_SIZE(levels);i++) {
1081 int level = levels[i];
1082 int old_level = levels[i-1];
1083 torture_assert_int_equal(tctx, ctx->printer_count[level], ctx->printer_count[old_level],
1084 "EnumPrinters invalid value");
1085 }
1086
1087 for (i=0;i<ARRAY_SIZE(levels);i++) {
1088 int level = levels[i];
1089 for (j=0;j<ctx->printer_count[level];j++) {
1090 union spoolss_PrinterInfo *cur = &ctx->printers[level][j];
1091 union spoolss_PrinterInfo *ref = &ctx->printers[2][j];
1092 switch (level) {
1093 case 0:
1094 COMPARE_STRING(tctx, cur->info0, ref->info2, printername);
1095 COMPARE_STRING(tctx, cur->info0, ref->info2, servername);
1096 COMPARE_UINT32(tctx, cur->info0, ref->info2, cjobs);
1097 /*COMPARE_UINT32(tctx, cur->info0, ref->info2, total_jobs);
1098 COMPARE_UINT32(tctx, cur->info0, ref->info2, total_bytes);
1099 COMPARE_SPOOLSS_TIME(cur->info0, ref->info2, spoolss_Time time);
1100 COMPARE_UINT32(tctx, cur->info0, ref->info2, global_counter);
1101 COMPARE_UINT32(tctx, cur->info0, ref->info2, total_pages);
1102 COMPARE_UINT32(tctx, cur->info0, ref->info2, version);
1103 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown10);
1104 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown11);
1105 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown12);
1106 COMPARE_UINT32(tctx, cur->info0, ref->info2, session_counter);
1107 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown14);
1108 COMPARE_UINT32(tctx, cur->info0, ref->info2, printer_errors);
1109 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown16);
1110 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown17);
1111 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown18);
1112 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown19);
1113 COMPARE_UINT32(tctx, cur->info0, ref->info2, change_id);
1114 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown21);*/
1115 COMPARE_UINT32(tctx, cur->info0, ref->info2, status);
1116 /*COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown23);
1117 COMPARE_UINT32(tctx, cur->info0, ref->info2, c_setprinter);
1118 COMPARE_UINT16(cur->info0, ref->info2, unknown25);
1119 COMPARE_UINT16(cur->info0, ref->info2, unknown26);
1120 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown27);
1121 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown28);
1122 COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown29);*/
1123 break;
1124 case 1:
1125 /*COMPARE_UINT32(tctx, cur->info1, ref->info2, flags);*/
1126 /*COMPARE_STRING(tctx, cur->info1, ref->info2, name);*/
1127 /*COMPARE_STRING(tctx, cur->info1, ref->info2, description);*/
1128 COMPARE_STRING(tctx, cur->info1, ref->info2, comment);
1129 break;
1130 case 2:
1131 /* level 2 is our reference, and it makes no sense to compare it to itself */
1132 break;
1133 case 4:
1134 COMPARE_STRING(tctx, cur->info4, ref->info2, printername);
1135 COMPARE_STRING(tctx, cur->info4, ref->info2, servername);
1136 COMPARE_UINT32(tctx, cur->info4, ref->info2, attributes);
1137 break;
1138 case 5:
1139 COMPARE_STRING(tctx, cur->info5, ref->info2, printername);
1140 COMPARE_STRING(tctx, cur->info5, ref->info2, portname);
1141 COMPARE_UINT32(tctx, cur->info5, ref->info2, attributes);
1142 /*COMPARE_UINT32(tctx, cur->info5, ref->info2, device_not_selected_timeout);
1143 COMPARE_UINT32(tctx, cur->info5, ref->info2, transmission_retry_timeout);*/
1144 break;
1145 }
1146 }
1147 }
1148
1149 /* TODO:
1150 * - verify that the port of a printer was in the list returned by EnumPorts
1151 */
1152
1153 return true;
1154 }
1155
1156 static bool test_GetPrinterDriver2(struct torture_context *tctx,
1157 struct dcerpc_binding_handle *b,
1158 struct policy_handle *handle,
1159 const char *driver_name,
1160 const char *environment);
1161
1162 bool test_GetPrinter_level(struct torture_context *tctx,
1163 struct dcerpc_binding_handle *b,
1164 struct policy_handle *handle,
1165 uint32_t level,
1166 union spoolss_PrinterInfo *info)
1167 {
1168 struct spoolss_GetPrinter r;
1169 uint32_t needed;
1170
1171 r.in.handle = handle;
1172 r.in.level = level;
1173 r.in.buffer = NULL;
1174 r.in.offered = 0;
1175 r.out.needed = &needed;
1176
1177 torture_comment(tctx, "Testing GetPrinter level %u\n", r.in.level);
1178
1179 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinter_r(b, tctx, &r),
1180 "GetPrinter failed");
1181
1182 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
1183 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
1184 r.in.buffer = &blob;
1185 r.in.offered = needed;
1186
1187 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinter_r(b, tctx, &r),
1188 "GetPrinter failed");
1189 }
1190
1191 torture_assert_werr_ok(tctx, r.out.result, "GetPrinter failed");
1192
1193 CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterInfo, r.out.info, r.in.level, needed, 4);
1194
1195 if (info && r.out.info) {
1196 *info = *r.out.info;
1197 }
1198
1199 return true;
1200 }
1201
1202
1203 static bool test_GetPrinter(struct torture_context *tctx,
1204 struct dcerpc_binding_handle *b,
1205 struct policy_handle *handle,
1206 const char *environment)
1207 {
1208 uint32_t levels[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
1209 int i;
1210
1211 for (i=0;i<ARRAY_SIZE(levels);i++) {
1212
1213 union spoolss_PrinterInfo info;
1214
1215 ZERO_STRUCT(info);
1216
1217 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, levels[i], &info),
1218 "failed to call GetPrinter");
1219
1220 if ((levels[i] == 2) && info.info2.drivername && strlen(info.info2.drivername)) {
1221 torture_assert(tctx,
1222 test_GetPrinterDriver2(tctx, b, handle, info.info2.drivername, environment),
1223 "failed to call test_GetPrinterDriver2");
1224 }
1225 }
1226
1227 return true;
1228 }
1229
1230 static bool test_SetPrinter(struct torture_context *tctx,
1231 struct dcerpc_binding_handle *b,
1232 struct policy_handle *handle,
1233 struct spoolss_SetPrinterInfoCtr *info_ctr,
1234 struct spoolss_DevmodeContainer *devmode_ctr,
1235 struct sec_desc_buf *secdesc_ctr,
1236 enum spoolss_PrinterControl command)
1237 {
1238 struct spoolss_SetPrinter r;
1239
1240 r.in.handle = handle;
1241 r.in.info_ctr = info_ctr;
1242 r.in.devmode_ctr = devmode_ctr;
1243 r.in.secdesc_ctr = secdesc_ctr;
1244 r.in.command = command;
1245
1246 torture_comment(tctx, "Testing SetPrinter level %d\n", r.in.info_ctr->level);
1247
1248 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r),
1249 "failed to call SetPrinter");
1250 torture_assert_werr_ok(tctx, r.out.result,
1251 "failed to call SetPrinter");
1252
1253 return true;
1254 }
1255
1256 static bool test_SetPrinter_errors(struct torture_context *tctx,
1257 struct dcerpc_binding_handle *b,
1258 struct policy_handle *handle)
1259 {
1260 struct spoolss_SetPrinter r;
1261 uint16_t levels[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
1262 int i;
1263
1264 struct spoolss_SetPrinterInfoCtr info_ctr;
1265 struct spoolss_DevmodeContainer devmode_ctr;
1266 struct sec_desc_buf secdesc_ctr;
1267
1268 info_ctr.level = 0;
1269 info_ctr.info.info0 = NULL;
1270
1271 ZERO_STRUCT(devmode_ctr);
1272 ZERO_STRUCT(secdesc_ctr);
1273
1274 r.in.handle = handle;
1275 r.in.info_ctr = &info_ctr;
1276 r.in.devmode_ctr = &devmode_ctr;
1277 r.in.secdesc_ctr = &secdesc_ctr;
1278 r.in.command = 0;
1279
1280 torture_comment(tctx, "Testing SetPrinter all zero\n");
1281
1282 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r),
1283 "failed to call SetPrinter");
1284 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
1285 "failed to call SetPrinter");
1286
1287 again:
1288 for (i=0; i < ARRAY_SIZE(levels); i++) {
1289
1290 struct spoolss_SetPrinterInfo0 info0;
1291 struct spoolss_SetPrinterInfo1 info1;
1292 struct spoolss_SetPrinterInfo2 info2;
1293 struct spoolss_SetPrinterInfo3 info3;
1294 struct spoolss_SetPrinterInfo4 info4;
1295 struct spoolss_SetPrinterInfo5 info5;
1296 struct spoolss_SetPrinterInfo6 info6;
1297 struct spoolss_SetPrinterInfo7 info7;
1298 struct spoolss_SetPrinterInfo8 info8;
1299 struct spoolss_SetPrinterInfo9 info9;
1300
1301
1302 info_ctr.level = levels[i];
1303 switch (levels[i]) {
1304 case 0:
1305 ZERO_STRUCT(info0);
1306 info_ctr.info.info0 = &info0;
1307 break;
1308 case 1:
1309 ZERO_STRUCT(info1);
1310 info_ctr.info.info1 = &info1;
1311 break;
1312 case 2:
1313 ZERO_STRUCT(info2);
1314 info_ctr.info.info2 = &info2;
1315 break;
1316 case 3:
1317 ZERO_STRUCT(info3);
1318 info_ctr.info.info3 = &info3;
1319 break;
1320 case 4:
1321 ZERO_STRUCT(info4);
1322 info_ctr.info.info4 = &info4;
1323 break;
1324 case 5:
1325 ZERO_STRUCT(info5);
1326 info_ctr.info.info5 = &info5;
1327 break;
1328 case 6:
1329 ZERO_STRUCT(info6);
1330 info_ctr.info.info6 = &info6;
1331 break;
1332 case 7:
1333 ZERO_STRUCT(info7);
1334 info_ctr.info.info7 = &info7;
1335 break;
1336 case 8:
1337 ZERO_STRUCT(info8);
1338 info_ctr.info.info8 = &info8;
1339 break;
1340 case 9:
1341 ZERO_STRUCT(info9);
1342 info_ctr.info.info9 = &info9;
1343 break;
1344 }
1345
1346 torture_comment(tctx, "Testing SetPrinter level %d, command %d\n",
1347 info_ctr.level, r.in.command);
1348
1349 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r),
1350 "failed to call SetPrinter");
1351
1352 switch (r.in.command) {
1353 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: /* 0 */
1354 /* is ignored for all levels other then 0 */
1355 if (info_ctr.level > 0) {
1356 /* ignored then */
1357 break;
1358 }
1359 case SPOOLSS_PRINTER_CONTROL_PAUSE: /* 1 */
1360 case SPOOLSS_PRINTER_CONTROL_RESUME: /* 2 */
1361 case SPOOLSS_PRINTER_CONTROL_PURGE: /* 3 */
1362 if (info_ctr.level > 0) {
1363 /* is invalid for all levels other then 0 */
1364 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PRINTER_COMMAND,
1365 "unexpected error code returned");
1366 continue;
1367 } else {
1368 torture_assert_werr_ok(tctx, r.out.result,
1369 "failed to call SetPrinter with non 0 command");
1370 continue;
1371 }
1372 break;
1373
1374 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: /* 4 */
1375 /* FIXME: gd needs further investigation */
1376 default:
1377 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PRINTER_COMMAND,
1378 "unexpected error code returned");
1379 continue;
1380 }
1381
1382 switch (info_ctr.level) {
1383 case 1:
1384 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
1385 "unexpected error code returned");
1386 break;
1387 case 2:
1388 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_PRINTER_DRIVER,
1389 "unexpected error code returned");
1390 break;
1391 case 3:
1392 case 4:
1393 case 5:
1394 case 7:
1395 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
1396 "unexpected error code returned");
1397 break;
1398 case 9:
1399 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1400 "unexpected error code returned");
1401 break;
1402 default:
1403 torture_assert_werr_ok(tctx, r.out.result,
1404 "failed to call SetPrinter");
1405 break;
1406 }
1407 }
1408
1409 if (r.in.command < 5) {
1410 r.in.command++;
1411 goto again;
1412 }
1413
1414 return true;
1415 }
1416
1417 static void clear_info2(struct spoolss_SetPrinterInfoCtr *r)
1418 {
1419 if ((r->level == 2) && (r->info.info2)) {
1420 r->info.info2->secdesc_ptr = NULL;
1421 r->info.info2->devmode_ptr = NULL;
1422 }
1423 }
1424
1425 static bool test_PrinterInfo(struct torture_context *tctx,
1426 struct dcerpc_binding_handle *b,
1427 struct policy_handle *handle)
1428 {
1429 NTSTATUS status;
1430 struct spoolss_SetPrinter s;
1431 struct spoolss_GetPrinter q;
1432 struct spoolss_GetPrinter q0;
1433 struct spoolss_SetPrinterInfoCtr info_ctr;
1434 union spoolss_PrinterInfo info;
1435 struct spoolss_DevmodeContainer devmode_ctr;
1436 struct sec_desc_buf secdesc_ctr;
1437 uint32_t needed;
1438 bool ret = true;
1439 int i;
1440
1441 torture_skip(tctx, "Printer Info test is currently broken, skipping");
1442
1443 uint32_t status_list[] = {
1444 /* these do not stick
1445 PRINTER_STATUS_PAUSED,
1446 PRINTER_STATUS_ERROR,
1447 PRINTER_STATUS_PENDING_DELETION, */
1448 PRINTER_STATUS_PAPER_JAM,
1449 PRINTER_STATUS_PAPER_OUT,
1450 PRINTER_STATUS_MANUAL_FEED,
1451 PRINTER_STATUS_PAPER_PROBLEM,
1452 PRINTER_STATUS_OFFLINE,
1453 PRINTER_STATUS_IO_ACTIVE,
1454 PRINTER_STATUS_BUSY,
1455 PRINTER_STATUS_PRINTING,
1456 PRINTER_STATUS_OUTPUT_BIN_FULL,
1457 PRINTER_STATUS_NOT_AVAILABLE,
1458 PRINTER_STATUS_WAITING,
1459 PRINTER_STATUS_PROCESSING,
1460 PRINTER_STATUS_INITIALIZING,
1461 PRINTER_STATUS_WARMING_UP,
1462 PRINTER_STATUS_TONER_LOW,
1463 PRINTER_STATUS_NO_TONER,
1464 PRINTER_STATUS_PAGE_PUNT,
1465 PRINTER_STATUS_USER_INTERVENTION,
1466 PRINTER_STATUS_OUT_OF_MEMORY,
1467 PRINTER_STATUS_DOOR_OPEN,
1468 PRINTER_STATUS_SERVER_UNKNOWN,
1469 PRINTER_STATUS_POWER_SAVE,
1470 /* these do not stick
1471 0x02000000,
1472 0x04000000,
1473 0x08000000,
1474 0x10000000,
1475 0x20000000,
1476 0x40000000,
1477 0x80000000 */
1478 };
1479 uint32_t default_attribute = PRINTER_ATTRIBUTE_LOCAL;
1480 uint32_t attribute_list[] = {
1481 PRINTER_ATTRIBUTE_QUEUED,
1482 /* fails with WERR_INVALID_DATATYPE:
1483 PRINTER_ATTRIBUTE_DIRECT, */
1484 /* does not stick
1485 PRINTER_ATTRIBUTE_DEFAULT, */
1486 PRINTER_ATTRIBUTE_SHARED,
1487 /* does not stick
1488 PRINTER_ATTRIBUTE_NETWORK, */
1489 PRINTER_ATTRIBUTE_HIDDEN,
1490 PRINTER_ATTRIBUTE_LOCAL,
1491 PRINTER_ATTRIBUTE_ENABLE_DEVQ,
1492 PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS,
1493 PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST,
1494 PRINTER_ATTRIBUTE_WORK_OFFLINE,
1495 /* does not stick
1496 PRINTER_ATTRIBUTE_ENABLE_BIDI, */
1497 /* fails with WERR_INVALID_DATATYPE:
1498 PRINTER_ATTRIBUTE_RAW_ONLY, */
1499 /* these do not stick
1500 PRINTER_ATTRIBUTE_PUBLISHED,
1501 PRINTER_ATTRIBUTE_FAX,
1502 PRINTER_ATTRIBUTE_TS,
1503 0x00010000,
1504 0x00020000,
1505 0x00040000,
1506 0x00080000,
1507 0x00100000,
1508 0x00200000,
1509 0x00400000,
1510 0x00800000,
1511 0x01000000,
1512 0x02000000,
1513 0x04000000,
1514 0x08000000,
1515 0x10000000,
1516 0x20000000,
1517 0x40000000,
1518 0x80000000 */
1519 };
1520
1521 ZERO_STRUCT(devmode_ctr);
1522 ZERO_STRUCT(secdesc_ctr);
1523
1524 s.in.handle = handle;
1525 s.in.command = 0;
1526 s.in.info_ctr = &info_ctr;
1527 s.in.devmode_ctr = &devmode_ctr;
1528 s.in.secdesc_ctr = &secdesc_ctr;
1529
1530 q.in.handle = handle;
1531 q.out.info = &info;
1532 q0 = q;
1533
1534 #define TESTGETCALL(call, r) \
1535 r.in.buffer = NULL; \
1536 r.in.offered = 0;\
1537 r.out.needed = &needed; \
1538 status = dcerpc_spoolss_ ##call## _r(b, tctx, &r); \
1539 if (!NT_STATUS_IS_OK(status)) { \
1540 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1541 r.in.level, nt_errstr(status), __location__); \
1542 ret = false; \
1543 break; \
1544 }\
1545 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {\
1546 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed); \
1547 r.in.buffer = &blob; \
1548 r.in.offered = needed; \
1549 }\
1550 status = dcerpc_spoolss_ ##call## _r(b, tctx, &r); \
1551 if (!NT_STATUS_IS_OK(status)) { \
1552 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1553 r.in.level, nt_errstr(status), __location__); \
1554 ret = false; \
1555 break; \
1556 } \
1557 if (!W_ERROR_IS_OK(r.out.result)) { \
1558 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1559 r.in.level, win_errstr(r.out.result), __location__); \
1560 ret = false; \
1561 break; \
1562 }
1563
1564
1565 #define TESTSETCALL_EXP(call, r, err) \
1566 clear_info2(&info_ctr);\
1567 status = dcerpc_spoolss_ ##call## _r(b, tctx, &r); \
1568 if (!NT_STATUS_IS_OK(status)) { \
1569 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1570 r.in.info_ctr->level, nt_errstr(status), __location__); \
1571 ret = false; \
1572 break; \
1573 } \
1574 if (!W_ERROR_IS_OK(err)) { \
1575 if (!W_ERROR_EQUAL(err, r.out.result)) { \
1576 torture_comment(tctx, #call " level %u failed - %s, expected %s (%s)\n", \
1577 r.in.info_ctr->level, win_errstr(r.out.result), win_errstr(err), __location__); \
1578 ret = false; \
1579 } \
1580 break; \
1581 } \
1582 if (!W_ERROR_IS_OK(r.out.result)) { \
1583 torture_comment(tctx, #call " level %u failed - %s (%s)\n", \
1584 r.in.info_ctr->level, win_errstr(r.out.result), __location__); \
1585 ret = false; \
1586 break; \
1587 }
1588
1589 #define TESTSETCALL(call, r) \
1590 TESTSETCALL_EXP(call, r, WERR_OK)
1591
1592 #define STRING_EQUAL(s1, s2, field) \
1593 if ((s1 && !s2) || (s2 && !s1) || strcmp(s1, s2)) { \
1594 torture_comment(tctx, "Failed to set %s to '%s' (%s)\n", \
1595 #field, s2, __location__); \
1596 ret = false; \
1597 break; \
1598 }
1599
1600 #define MEM_EQUAL(s1, s2, length, field) \
1601 if ((s1 && !s2) || (s2 && !s1) || memcmp(s1, s2, length)) { \
1602 torture_comment(tctx, "Failed to set %s to '%s' (%s)\n", \
1603 #field, (const char *)s2, __location__); \
1604 ret = false; \
1605 break; \
1606 }
1607
1608 #define INT_EQUAL(i1, i2, field) \
1609 if (i1 != i2) { \
1610 torture_comment(tctx, "Failed to set %s to 0x%llx - got 0x%llx (%s)\n", \
1611 #field, (unsigned long long)i2, (unsigned long long)i1, __location__); \
1612 ret = false; \
1613 break; \
1614 }
1615
1616 #define SD_EQUAL(sd1, sd2, field) \
1617 if (!security_descriptor_equal(sd1, sd2)) { \
1618 torture_comment(tctx, "Failed to set %s (%s)\n", \
1619 #field, __location__); \
1620 ret = false; \
1621 break; \
1622 }
1623
1624 #define TEST_PRINTERINFO_STRING_EXP_ERR(lvl1, field1, lvl2, field2, value, err) do { \
1625 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
1626 q.in.level = lvl1; \
1627 TESTGETCALL(GetPrinter, q) \
1628 info_ctr.level = lvl1; \
1629 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
1630 info_ctr.info.info ## lvl1->field1 = value;\
1631 TESTSETCALL_EXP(SetPrinter, s, err) \
1632 info_ctr.info.info ## lvl1->field1 = ""; \
1633 TESTGETCALL(GetPrinter, q) \
1634 info_ctr.info.info ## lvl1->field1 = value; \
1635 STRING_EQUAL(info_ctr.info.info ## lvl1->field1, value, field1); \
1636 q.in.level = lvl2; \
1637 TESTGETCALL(GetPrinter, q) \
1638 info_ctr.info.info ## lvl2 = (struct spoolss_SetPrinterInfo ## lvl2 *)(void *)&q.out.info->info ## lvl2; \
1639 STRING_EQUAL(info_ctr.info.info ## lvl2->field2, value, field2); \
1640 } while (0)
1641
1642 #define TEST_PRINTERINFO_STRING(lvl1, field1, lvl2, field2, value) do { \
1643 TEST_PRINTERINFO_STRING_EXP_ERR(lvl1, field1, lvl2, field2, value, WERR_OK); \
1644 } while (0);
1645
1646 #define TEST_PRINTERINFO_INT_EXP(lvl1, field1, lvl2, field2, value, exp_value) do { \
1647 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
1648 q.in.level = lvl1; \
1649 TESTGETCALL(GetPrinter, q) \
1650 info_ctr.level = lvl1; \
1651 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
1652 info_ctr.info.info ## lvl1->field1 = value; \
1653 TESTSETCALL(SetPrinter, s) \
1654 info_ctr.info.info ## lvl1->field1 = 0; \
1655 TESTGETCALL(GetPrinter, q) \
1656 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
1657 INT_EQUAL(info_ctr.info.info ## lvl1->field1, exp_value, field1); \
1658 q.in.level = lvl2; \
1659 TESTGETCALL(GetPrinter, q) \
1660 info_ctr.info.info ## lvl2 = (struct spoolss_SetPrinterInfo ## lvl2 *)(void *)&q.out.info->info ## lvl2; \
1661 INT_EQUAL(info_ctr.info.info ## lvl2->field2, exp_value, field1); \
1662 } while (0)
1663
1664 #define TEST_PRINTERINFO_INT(lvl1, field1, lvl2, field2, value) do { \
1665 TEST_PRINTERINFO_INT_EXP(lvl1, field1, lvl2, field2, value, value); \
1666 } while (0)
1667
1668 q0.in.level = 0;
1669 do { TESTGETCALL(GetPrinter, q0) } while (0);
1670
1671 TEST_PRINTERINFO_STRING(2, comment, 1, comment, "xx2-1 comment");
1672 TEST_PRINTERINFO_STRING(2, comment, 2, comment, "xx2-2 comment");
1673
1674 /* level 0 printername does not stick */
1675 /* TEST_PRINTERINFO_STRING(2, printername, 0, printername, "xx2-0 printer"); */
1676 TEST_PRINTERINFO_STRING(2, printername, 1, name, "xx2-1 printer");
1677 TEST_PRINTERINFO_STRING(2, printername, 2, printername, "xx2-2 printer");
1678 TEST_PRINTERINFO_STRING(2, printername, 4, printername, "xx2-4 printer");
1679 TEST_PRINTERINFO_STRING(2, printername, 5, printername, "xx2-5 printer");
1680 /* TEST_PRINTERINFO_STRING(4, printername, 0, printername, "xx4-0 printer"); */
1681 TEST_PRINTERINFO_STRING(4, printername, 1, name, "xx4-1 printer");
1682 TEST_PRINTERINFO_STRING(4, printername, 2, printername, "xx4-2 printer");
1683 TEST_PRINTERINFO_STRING(4, printername, 4, printername, "xx4-4 printer");
1684 TEST_PRINTERINFO_STRING(4, printername, 5, printername, "xx4-5 printer");
1685 /* TEST_PRINTERINFO_STRING(5, printername, 0, printername, "xx5-0 printer"); */
1686 TEST_PRINTERINFO_STRING(5, printername, 1, name, "xx5-1 printer");
1687 TEST_PRINTERINFO_STRING(5, printername, 2, printername, "xx5-2 printer");
1688 TEST_PRINTERINFO_STRING(5, printername, 4, printername, "xx5-4 printer");
1689 TEST_PRINTERINFO_STRING(5, printername, 5, printername, "xx5-5 printer");
1690
1691 /* servername can be set but does not stick
1692 TEST_PRINTERINFO_STRING(2, servername, 0, servername, "xx2-0 servername");
1693 TEST_PRINTERINFO_STRING(2, servername, 2, servername, "xx2-2 servername");
1694 TEST_PRINTERINFO_STRING(2, servername, 4, servername, "xx2-4 servername");
1695 */
1696
1697 /* passing an invalid port will result in WERR_UNKNOWN_PORT */
1698 TEST_PRINTERINFO_STRING_EXP_ERR(2, portname, 2, portname, "xx2-2 portname", WERR_UNKNOWN_PORT);
1699 TEST_PRINTERINFO_STRING_EXP_ERR(2, portname, 5, portname, "xx2-5 portname", WERR_UNKNOWN_PORT);
1700 TEST_PRINTERINFO_STRING_EXP_ERR(5, portname, 2, portname, "xx5-2 portname", WERR_UNKNOWN_PORT);
1701 TEST_PRINTERINFO_STRING_EXP_ERR(5, portname, 5, portname, "xx5-5 portname", WERR_UNKNOWN_PORT);
1702
1703 TEST_PRINTERINFO_STRING(2, sharename, 2, sharename, "xx2-2 sharename");
1704 /* passing an invalid driver will result in WERR_UNKNOWN_PRINTER_DRIVER */
1705 TEST_PRINTERINFO_STRING_EXP_ERR(2, drivername, 2, drivername, "xx2-2 drivername", WERR_UNKNOWN_PRINTER_DRIVER);
1706 TEST_PRINTERINFO_STRING(2, location, 2, location, "xx2-2 location");
1707 /* passing an invalid sepfile will result in WERR_INVALID_SEPARATOR_FILE */
1708 TEST_PRINTERINFO_STRING_EXP_ERR(2, sepfile, 2, sepfile, "xx2-2 sepfile", WERR_INVALID_SEPARATOR_FILE);
1709 /* passing an invalid printprocessor will result in WERR_UNKNOWN_PRINTPROCESSOR */
1710 TEST_PRINTERINFO_STRING_EXP_ERR(2, printprocessor, 2, printprocessor, "xx2-2 printprocessor", WERR_UNKNOWN_PRINTPROCESSOR);
1711 TEST_PRINTERINFO_STRING(2, datatype, 2, datatype, "xx2-2 datatype");
1712 TEST_PRINTERINFO_STRING(2, parameters, 2, parameters, "xx2-2 parameters");
1713
1714 for (i=0; i < ARRAY_SIZE(attribute_list); i++) {
1715 /* TEST_PRINTERINFO_INT_EXP(2, attributes, 1, flags,
1716 attribute_list[i],
1717 (attribute_list[i] | default_attribute)
1718 ); */
1719 TEST_PRINTERINFO_INT_EXP(2, attributes, 2, attributes,
1720 attribute_list[i],
1721 (attribute_list[i] | default_attribute)
1722 );
1723 TEST_PRINTERINFO_INT_EXP(2, attributes, 4, attributes,
1724 attribute_list[i],
1725 (attribute_list[i] | default_attribute)
1726 );
1727 TEST_PRINTERINFO_INT_EXP(2, attributes, 5, attributes,
1728 attribute_list[i],
1729 (attribute_list[i] | default_attribute)
1730 );
1731 /* TEST_PRINTERINFO_INT_EXP(4, attributes, 1, flags,
1732 attribute_list[i],
1733 (attribute_list[i] | default_attribute)
1734 ); */
1735 TEST_PRINTERINFO_INT_EXP(4, attributes, 2, attributes,
1736 attribute_list[i],
1737 (attribute_list[i] | default_attribute)
1738 );
1739 TEST_PRINTERINFO_INT_EXP(4, attributes, 4, attributes,
1740 attribute_list[i],
1741 (attribute_list[i] | default_attribute)
1742 );
1743 TEST_PRINTERINFO_INT_EXP(4, attributes, 5, attributes,
1744 attribute_list[i],
1745 (attribute_list[i] | default_attribute)
1746 );
1747 /* TEST_PRINTERINFO_INT_EXP(5, attributes, 1, flags,
1748 attribute_list[i],
1749 (attribute_list[i] | default_attribute)
1750 ); */
1751 TEST_PRINTERINFO_INT_EXP(5, attributes, 2, attributes,
1752 attribute_list[i],
1753 (attribute_list[i] | default_attribute)
1754 );
1755 TEST_PRINTERINFO_INT_EXP(5, attributes, 4, attributes,
1756 attribute_list[i],
1757 (attribute_list[i] | default_attribute)
1758 );
1759 TEST_PRINTERINFO_INT_EXP(5, attributes, 5, attributes,
1760 attribute_list[i],
1761 (attribute_list[i] | default_attribute)
1762 );
1763 }
1764
1765 for (i=0; i < ARRAY_SIZE(status_list); i++) {
1766 /* level 2 sets do not stick
1767 TEST_PRINTERINFO_INT(2, status, 0, status, status_list[i]);
1768 TEST_PRINTERINFO_INT(2, status, 2, status, status_list[i]);
1769 TEST_PRINTERINFO_INT(2, status, 6, status, status_list[i]); */
1770 TEST_PRINTERINFO_INT(6, status, 0, status, status_list[i]);
1771 TEST_PRINTERINFO_INT(6, status, 2, status, status_list[i]);
1772 TEST_PRINTERINFO_INT(6, status, 6, status, status_list[i]);
1773 }
1774
1775 /* priorities need to be between 0 and 99
1776 passing an invalid priority will result in WERR_INVALID_PRIORITY */
1777 TEST_PRINTERINFO_INT(2, priority, 2, priority, 0);
1778 TEST_PRINTERINFO_INT(2, priority, 2, priority, 1);
1779 TEST_PRINTERINFO_INT(2, priority, 2, priority, 99);
1780 /* TEST_PRINTERINFO_INT(2, priority, 2, priority, 100); */
1781 TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 0);
1782 TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 1);
1783 TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 99);
1784 /* TEST_PRINTERINFO_INT(2, defaultpriority,2, defaultpriority, 100); */
1785
1786 TEST_PRINTERINFO_INT(2, starttime, 2, starttime, __LINE__);
1787 TEST_PRINTERINFO_INT(2, untiltime, 2, untiltime, __LINE__);
1788
1789 /* does not stick
1790 TEST_PRINTERINFO_INT(2, cjobs, 2, cjobs, __LINE__);
1791 TEST_PRINTERINFO_INT(2, averageppm, 2, averageppm, __LINE__); */
1792
1793 /* does not stick
1794 TEST_PRINTERINFO_INT(5, device_not_selected_timeout, 5, device_not_selected_timeout, __LINE__);
1795 TEST_PRINTERINFO_INT(5, transmission_retry_timeout, 5, transmission_retry_timeout, __LINE__); */
1796
1797 /* FIXME: gd also test devmode and secdesc behavior */
1798
1799 {
1800 /* verify composition of level 1 description field */
1801 const char *description;
1802 const char *tmp;
1803
1804 q0.in.level = 1;
1805 do { TESTGETCALL(GetPrinter, q0) } while (0);
1806
1807 description = talloc_strdup(tctx, q0.out.info->info1.description);
1808
1809 q0.in.level = 2;
1810 do { TESTGETCALL(GetPrinter, q0) } while (0);
1811
1812 tmp = talloc_asprintf(tctx, "%s,%s,%s",
1813 q0.out.info->info2.printername,
1814 q0.out.info->info2.drivername,
1815 q0.out.info->info2.location);
1816
1817 do { STRING_EQUAL(description, tmp, "description")} while (0);
1818 }
1819
1820 return ret;
1821 }
1822
1823 static bool test_security_descriptor_equal(struct torture_context *tctx,
1824 const struct security_descriptor *sd1,
1825 const struct security_descriptor *sd2)
1826 {
1827 if (sd1 == sd2) {
1828 return true;
1829 }
1830
1831 if (!sd1 || !sd2) {
1832 torture_comment(tctx, "%s\n", __location__);
1833 return false;
1834 }
1835
1836 torture_assert_int_equal(tctx, sd1->revision, sd2->revision, "revision mismatch");
1837 torture_assert_int_equal(tctx, sd1->type, sd2->type, "type mismatch");
1838
1839 torture_assert_sid_equal(tctx, sd1->owner_sid, sd2->owner_sid, "owner mismatch");
1840 torture_assert_sid_equal(tctx, sd1->group_sid, sd2->group_sid, "group mismatch");
1841
1842 if (!security_acl_equal(sd1->sacl, sd2->sacl)) {
1843 torture_comment(tctx, "%s: sacl mismatch\n", __location__);
1844 NDR_PRINT_DEBUG(security_acl, sd1->sacl);
1845 NDR_PRINT_DEBUG(security_acl, sd2->sacl);
1846 return false;
1847 }
1848 if (!security_acl_equal(sd1->dacl, sd2->dacl)) {
1849 torture_comment(tctx, "%s: dacl mismatch\n", __location__);
1850 NDR_PRINT_DEBUG(security_acl, sd1->dacl);
1851 NDR_PRINT_DEBUG(security_acl, sd2->dacl);
1852 return false;
1853 }
1854
1855 return true;
1856 }
1857
1858 static bool test_sd_set_level(struct torture_context *tctx,
1859 struct dcerpc_binding_handle *b,
1860 struct policy_handle *handle,
1861 uint32_t level,
1862 struct security_descriptor *sd)
1863 {
1864 struct spoolss_SetPrinterInfoCtr info_ctr;
1865 struct spoolss_DevmodeContainer devmode_ctr;
1866 struct sec_desc_buf secdesc_ctr;
1867 union spoolss_SetPrinterInfo sinfo;
1868
1869 ZERO_STRUCT(devmode_ctr);
1870 ZERO_STRUCT(secdesc_ctr);
1871
1872 switch (level) {
1873 case 2: {
1874 union spoolss_PrinterInfo info;
1875 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1876 torture_assert(tctx, PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
1877
1878 info_ctr.level = 2;
1879 info_ctr.info = sinfo;
1880
1881 break;
1882 }
1883 case 3: {
1884 struct spoolss_SetPrinterInfo3 info3;
1885
1886 info3.sec_desc_ptr = NULL;
1887
1888 info_ctr.level = 3;
1889 info_ctr.info.info3 = &info3;
1890
1891 break;
1892 }
1893 default:
1894 return false;
1895 }
1896
1897 secdesc_ctr.sd = sd;
1898
1899 torture_assert(tctx,
1900 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0), "");
1901
1902 return true;
1903 }
1904
1905 static bool test_PrinterInfo_SDs(struct torture_context *tctx,
1906 struct dcerpc_binding_handle *b,
1907 struct policy_handle *handle)
1908 {
1909 union spoolss_PrinterInfo info;
1910 struct security_descriptor *sd1, *sd2;
1911 int i;
1912
1913 /* just compare level 2 and level 3 */
1914
1915 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1916
1917 sd1 = info.info2.secdesc;
1918
1919 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 3, &info), "");
1920
1921 sd2 = info.info3.secdesc;
1922
1923 torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1924 "SD level 2 != SD level 3");
1925
1926
1927 /* query level 2, set level 2, query level 2 */
1928
1929 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1930
1931 sd1 = info.info2.secdesc;
1932
1933 torture_assert(tctx, test_sd_set_level(tctx, b, handle, 2, sd1), "");
1934
1935 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1936
1937 sd2 = info.info2.secdesc;
1938 if (sd1->type & SEC_DESC_DACL_DEFAULTED) {
1939 torture_comment(tctx, "removing SEC_DESC_DACL_DEFAULTED\n");
1940 sd1->type &= ~SEC_DESC_DACL_DEFAULTED;
1941 }
1942
1943 torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1944 "SD level 2 != SD level 2 after SD has been set via level 2");
1945
1946
1947 /* query level 2, set level 3, query level 2 */
1948
1949 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1950
1951 sd1 = info.info2.secdesc;
1952
1953 torture_assert(tctx, test_sd_set_level(tctx, b, handle, 3, sd1), "");
1954
1955 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1956
1957 sd2 = info.info2.secdesc;
1958
1959 torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1960 "SD level 2 != SD level 2 after SD has been set via level 3");
1961
1962 /* set modified sd level 3, query level 2 */
1963
1964 for (i=0; i < 93; i++) {
1965 struct security_ace a;
1966 const char *sid_string = talloc_asprintf(tctx, "S-1-5-32-9999%i", i);
1967 a.type = SEC_ACE_TYPE_ACCESS_ALLOWED;
1968 a.flags = 0;
1969 a.size = 0; /* autogenerated */
1970 a.access_mask = 0;
1971 a.trustee = *dom_sid_parse_talloc(tctx, sid_string);
1972 torture_assert_ntstatus_ok(tctx, security_descriptor_dacl_add(sd1, &a), "");
1973 }
1974
1975 torture_assert(tctx, test_sd_set_level(tctx, b, handle, 3, sd1), "");
1976
1977 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
1978 sd2 = info.info2.secdesc;
1979
1980 if (sd1->type & SEC_DESC_DACL_DEFAULTED) {
1981 torture_comment(tctx, "removing SEC_DESC_DACL_DEFAULTED\n");
1982 sd1->type &= ~SEC_DESC_DACL_DEFAULTED;
1983 }
1984
1985 torture_assert(tctx, test_security_descriptor_equal(tctx, sd1, sd2),
1986 "modified SD level 2 != SD level 2 after SD has been set via level 3");
1987
1988
1989 return true;
1990 }
1991
1992 /*
1993 * wrapper call that saves original sd, runs tests, and restores sd
1994 */
1995
1996 static bool test_PrinterInfo_SD(struct torture_context *tctx,
1997 struct dcerpc_binding_handle *b,
1998 struct policy_handle *handle)
1999 {
2000 union spoolss_PrinterInfo info;
2001 struct security_descriptor *sd;
2002 bool ret = true;
2003
2004 torture_comment(tctx, "Testing Printer Security Descriptors\n");
2005
2006 /* save original sd */
2007
2008 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info),
2009 "failed to get initial security descriptor");
2010
2011 sd = security_descriptor_copy(tctx, info.info2.secdesc);
2012
2013 /* run tests */
2014
2015 ret = test_PrinterInfo_SDs(tctx, b, handle);
2016
2017 /* restore original sd */
2018
2019 torture_assert(tctx, test_sd_set_level(tctx, b, handle, 3, sd),
2020 "failed to restore initial security descriptor");
2021
2022 torture_comment(tctx, "Printer Security Descriptors test %s\n\n",
2023 ret ? "succeeded" : "failed");
2024
2025
2026 return ret;
2027 }
2028
2029 static bool test_devmode_set_level(struct torture_context *tctx,
2030 struct dcerpc_binding_handle *b,
2031 struct policy_handle *handle,
2032 uint32_t level,
2033 struct spoolss_DeviceMode *devmode)
2034 {
2035 struct spoolss_SetPrinterInfoCtr info_ctr;
2036 struct spoolss_DevmodeContainer devmode_ctr;
2037 struct sec_desc_buf secdesc_ctr;
2038 union spoolss_SetPrinterInfo sinfo;
2039
2040 ZERO_STRUCT(devmode_ctr);
2041 ZERO_STRUCT(secdesc_ctr);
2042
2043 switch (level) {
2044 case 2: {
2045 union spoolss_PrinterInfo info;
2046 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
2047 torture_assert(tctx, PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
2048
2049 info_ctr.level = 2;
2050 info_ctr.info = sinfo;
2051
2052 break;
2053 }
2054 case 8: {
2055 struct spoolss_SetPrinterInfo8 info8;
2056
2057 info8.devmode_ptr = NULL;
2058
2059 info_ctr.level = 8;
2060 info_ctr.info.info8 = &info8;
2061
2062 break;
2063 }
2064 default:
2065 return false;
2066 }
2067
2068 devmode_ctr.devmode = devmode;
2069
2070 torture_assert(tctx,
2071 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0), "");
2072
2073 return true;
2074 }
2075
2076
2077 static bool test_devicemode_equal(struct torture_context *tctx,
2078 const struct spoolss_DeviceMode *d1,
2079 const struct spoolss_DeviceMode *d2)
2080 {
2081 if (d1 == d2) {
2082 return true;
2083 }
2084
2085 if (!d1 || !d2) {
2086 torture_comment(tctx, "%s\n", __location__);
2087 return false;
2088 }
2089 torture_assert_str_equal(tctx, d1->devicename, d2->devicename, "devicename mismatch");
2090 torture_assert_int_equal(tctx, d1->specversion, d2->specversion, "specversion mismatch");
2091 torture_assert_int_equal(tctx, d1->driverversion, d2->driverversion, "driverversion mismatch");
2092 torture_assert_int_equal(tctx, d1->size, d2->size, "size mismatch");
2093 torture_assert_int_equal(tctx, d1->__driverextra_length, d2->__driverextra_length, "__driverextra_length mismatch");
2094 torture_assert_int_equal(tctx, d1->fields, d2->fields, "fields mismatch");
2095 torture_assert_int_equal(tctx, d1->orientation, d2->orientation, "orientation mismatch");
2096 torture_assert_int_equal(tctx, d1->papersize, d2->papersize, "papersize mismatch");
2097 torture_assert_int_equal(tctx, d1->paperlength, d2->paperlength, "paperlength mismatch");
2098 torture_assert_int_equal(tctx, d1->paperwidth, d2->paperwidth, "paperwidth mismatch");
2099 torture_assert_int_equal(tctx, d1->scale, d2->scale, "scale mismatch");
2100 torture_assert_int_equal(tctx, d1->copies, d2->copies, "copies mismatch");
2101 torture_assert_int_equal(tctx, d1->defaultsource, d2->defaultsource, "defaultsource mismatch");
2102 torture_assert_int_equal(tctx, d1->printquality, d2->printquality, "printquality mismatch");
2103 torture_assert_int_equal(tctx, d1->color, d2->color, "color mismatch");
2104 torture_assert_int_equal(tctx, d1->duplex, d2->duplex, "duplex mismatch");
2105 torture_assert_int_equal(tctx, d1->yresolution, d2->yresolution, "yresolution mismatch");
2106 torture_assert_int_equal(tctx, d1->ttoption, d2->ttoption, "ttoption mismatch");
2107 torture_assert_int_equal(tctx, d1->collate, d2->collate, "collate mismatch");
2108 torture_assert_str_equal(tctx, d1->formname, d2->formname, "formname mismatch");
2109 torture_assert_int_equal(tctx, d1->logpixels, d2->logpixels, "logpixels mismatch");
2110 torture_assert_int_equal(tctx, d1->bitsperpel, d2->bitsperpel, "bitsperpel mismatch");
2111 torture_assert_int_equal(tctx, d1->pelswidth, d2->pelswidth, "pelswidth mismatch");
2112 torture_assert_int_equal(tctx, d1->pelsheight, d2->pelsheight, "pelsheight mismatch");
2113 torture_assert_int_equal(tctx, d1->displayflags, d2->displayflags, "displayflags mismatch");
2114 torture_assert_int_equal(tctx, d1->displayfrequency, d2->displayfrequency, "displayfrequency mismatch");
2115 torture_assert_int_equal(tctx, d1->icmmethod, d2->icmmethod, "icmmethod mismatch");
2116 torture_assert_int_equal(tctx, d1->icmintent, d2->icmintent, "icmintent mismatch");
2117 torture_assert_int_equal(tctx, d1->mediatype, d2->mediatype, "mediatype mismatch");
2118 torture_assert_int_equal(tctx, d1->dithertype, d2->dithertype, "dithertype mismatch");
2119 torture_assert_int_equal(tctx, d1->reserved1, d2->reserved1, "reserved1 mismatch");
2120 torture_assert_int_equal(tctx, d1->reserved2, d2->reserved2, "reserved2 mismatch");
2121 torture_assert_int_equal(tctx, d1->panningwidth, d2->panningwidth, "panningwidth mismatch");
2122 torture_assert_int_equal(tctx, d1->panningheight, d2->panningheight, "panningheight mismatch");
2123 torture_assert_data_blob_equal(tctx, d1->driverextra_data, d2->driverextra_data, "driverextra_data mismatch");
2124
2125 return true;
2126 }
2127
2128 static bool test_devicemode_full(struct torture_context *tctx,
2129 struct dcerpc_binding_handle *b,
2130 struct policy_handle *handle)
2131 {
2132 struct spoolss_SetPrinter s;
2133 struct spoolss_GetPrinter q;
2134 struct spoolss_GetPrinter q0;
2135 struct spoolss_SetPrinterInfoCtr info_ctr;
2136 struct spoolss_SetPrinterInfo8 info8;
2137 union spoolss_PrinterInfo info;
2138 struct spoolss_DevmodeContainer devmode_ctr;
2139 struct sec_desc_buf secdesc_ctr;
2140 uint32_t needed;
2141 bool ret = true;
2142 NTSTATUS status;
2143
2144 #define TEST_DEVMODE_INT_EXP_RESULT(lvl1, field1, lvl2, field2, value, exp_value, expected_result) do { \
2145 torture_comment(tctx, "field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
2146 q.in.level = lvl1; \
2147 TESTGETCALL(GetPrinter, q) \
2148 info_ctr.level = lvl1; \
2149 if (lvl1 == 2) {\
2150 info_ctr.info.info ## lvl1 = (struct spoolss_SetPrinterInfo ## lvl1 *)(void *)&q.out.info->info ## lvl1; \
2151 } else if (lvl1 == 8) {\
2152 info_ctr.info.info ## lvl1 = &info8; \
2153 }\
2154 devmode_ctr.devmode = q.out.info->info ## lvl1.devmode; \
2155 devmode_ctr.devmode->field1 = value; \
2156 TESTSETCALL_EXP(SetPrinter, s, expected_result) \
2157 if (W_ERROR_IS_OK(expected_result)) { \
2158 TESTGETCALL(GetPrinter, q) \
2159 INT_EQUAL(q.out.info->info ## lvl1.devmode->field1, exp_value, field1); \
2160 q.in.level = lvl2; \
2161 TESTGETCALL(GetPrinter, q) \
2162 INT_EQUAL(q.out.info->info ## lvl2.devmode->field2, exp_value, field1); \
2163 }\
2164 } while (0)
2165
2166 #define TEST_DEVMODE_INT_EXP(lvl1, field1, lvl2, field2, value, expected_result) do { \
2167 TEST_DEVMODE_INT_EXP_RESULT(lvl1, field1, lvl2, field2, value, value, expected_result); \
2168 } while (0)
2169
2170 #define TEST_DEVMODE_INT(lvl1, field1, lvl2, field2, value) do { \
2171 TEST_DEVMODE_INT_EXP_RESULT(lvl1, field1, lvl2, field2, value, value, WERR_OK); \
2172 } while (0)
2173
2174 ZERO_STRUCT(devmode_ctr);
2175 ZERO_STRUCT(secdesc_ctr);
2176 ZERO_STRUCT(info8);
2177
2178 s.in.handle = handle;
2179 s.in.command = 0;
2180 s.in.info_ctr = &info_ctr;
2181 s.in.devmode_ctr = &devmode_ctr;
2182 s.in.secdesc_ctr = &secdesc_ctr;
2183
2184 q.in.handle = handle;
2185 q.out.info = &info;
2186 q0 = q;
2187
2188 #if 0
2189 const char *devicename;/* [charset(UTF16)] */
2190 enum spoolss_DeviceModeSpecVersion specversion;
2191 uint16_t driverversion;
2192 uint16_t __driverextra_length;/* [value(r->driverextra_data.length)] */
2193 uint32_t fields;
2194 #endif
2195 TEST_DEVMODE_INT_EXP(8, size, 8, size, __LINE__, WERR_INVALID_PARAM);
2196 TEST_DEVMODE_INT_EXP(8, size, 8, size, 0, WERR_INVALID_PARAM);
2197 TEST_DEVMODE_INT_EXP(8, size, 8, size, 0xffff, WERR_INVALID_PARAM);
2198 TEST_DEVMODE_INT_EXP(8, size, 8, size, ndr_size_spoolss_DeviceMode(devmode_ctr.devmode, 0), (devmode_ctr.devmode->__driverextra_length > 0 ) ? WERR_INVALID_PARAM : WERR_OK);
2199 TEST_DEVMODE_INT(8, size, 8, size, ndr_size_spoolss_DeviceMode(devmode_ctr.devmode, 0) - devmode_ctr.devmode->__driverextra_length);
2200
2201 devmode_ctr.devmode->driverextra_data = data_blob_string_const("foobar");
2202 torture_assert(tctx,
2203 test_devmode_set_level(tctx, b, handle, 8, devmode_ctr.devmode),
2204 "failed to set devmode");
2205
2206 TEST_DEVMODE_INT_EXP(8, size, 8, size, ndr_size_spoolss_DeviceMode(devmode_ctr.devmode, 0), (devmode_ctr.devmode->__driverextra_length > 0 ) ? WERR_INVALID_PARAM : WERR_OK);
2207 TEST_DEVMODE_INT(8, size, 8, size, ndr_size_spoolss_DeviceMode(devmode_ctr.devmode, 0) - devmode_ctr.devmode->__driverextra_length);
2208
2209 TEST_DEVMODE_INT(8, orientation, 8, orientation, __LINE__);
2210 TEST_DEVMODE_INT(8, papersize, 8, papersize, __LINE__);
2211 TEST_DEVMODE_INT(8, paperlength, 8, paperlength, __LINE__);
2212 TEST_DEVMODE_INT(8, paperwidth, 8, paperwidth, __LINE__);
2213 TEST_DEVMODE_INT(8, scale, 8, scale, __LINE__);
2214 TEST_DEVMODE_INT(8, copies, 8, copies, __LINE__);
2215 TEST_DEVMODE_INT(8, defaultsource, 8, defaultsource, __LINE__);
2216 TEST_DEVMODE_INT(8, printquality, 8, printquality, __LINE__);
2217 TEST_DEVMODE_INT(8, color, 8, color, __LINE__);
2218 TEST_DEVMODE_INT(8, duplex, 8, duplex, __LINE__);
2219 TEST_DEVMODE_INT(8, yresolution, 8, yresolution, __LINE__);
2220 TEST_DEVMODE_INT(8, ttoption, 8, ttoption, __LINE__);
2221 TEST_DEVMODE_INT(8, collate, 8, collate, __LINE__);
2222 #if 0
2223 const char *formname;/* [charset(UTF16)] */
2224 #endif
2225 TEST_DEVMODE_INT(8, logpixels, 8, logpixels, __LINE__);
2226 TEST_DEVMODE_INT(8, bitsperpel, 8, bitsperpel, __LINE__);
2227 TEST_DEVMODE_INT(8, pelswidth, 8, pelswidth, __LINE__);
2228 TEST_DEVMODE_INT(8, pelsheight, 8, pelsheight, __LINE__);
2229 TEST_DEVMODE_INT(8, displayflags, 8, displayflags, __LINE__);
2230 TEST_DEVMODE_INT(8, displayfrequency, 8, displayfrequency, __LINE__);
2231 TEST_DEVMODE_INT(8, icmmethod, 8, icmmethod, __LINE__);
2232 TEST_DEVMODE_INT(8, icmintent, 8, icmintent, __LINE__);
2233 TEST_DEVMODE_INT(8, mediatype, 8, mediatype, __LINE__);
2234 TEST_DEVMODE_INT(8, dithertype, 8, dithertype, __LINE__);
2235 TEST_DEVMODE_INT(8, reserved1, 8, reserved1, __LINE__);
2236 TEST_DEVMODE_INT(8, reserved2, 8, reserved2, __LINE__);
2237 TEST_DEVMODE_INT(8, panningwidth, 8, panningwidth, __LINE__);
2238 TEST_DEVMODE_INT(8, panningheight, 8, panningheight, __LINE__);
2239
2240 return ret;
2241 }
2242
2243 static bool call_OpenPrinterEx(struct torture_context *tctx,
2244 struct dcerpc_pipe *p,
2245 const char *name,
2246 struct spoolss_DeviceMode *devmode,
2247 struct policy_handle *handle);
2248
2249 static bool test_PrinterInfo_DevModes(struct torture_context *tctx,
2250 struct dcerpc_pipe *p,
2251 struct policy_handle *handle,
2252 const char *name)
2253 {
2254 union spoolss_PrinterInfo info;
2255 struct spoolss_DeviceMode *devmode;
2256 struct spoolss_DeviceMode *devmode2;
2257 struct policy_handle handle_devmode;
2258 struct dcerpc_binding_handle *b = p->binding_handle;
2259
2260 /* simply compare level8 and level2 devmode */
2261
2262 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info), "");
2263
2264 devmode = info.info8.devmode;
2265
2266 if (devmode && devmode->size == 0) {
2267 torture_fail(tctx,
2268 "devmode of zero size!");
2269 }
2270
2271 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
2272
2273 devmode2 = info.info2.devmode;
2274
2275 if (devmode2 && devmode2->size == 0) {
2276 torture_fail(tctx,
2277 "devmode of zero size!");
2278 }
2279
2280 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2281 "DM level 8 != DM level 2");
2282
2283
2284 /* set devicemode level 8 and see if it persists */
2285
2286 devmode->copies = 93;
2287 devmode->formname = talloc_strdup(tctx, "Legal");
2288
2289 torture_assert(tctx, test_devmode_set_level(tctx, b, handle, 8, devmode), "");
2290
2291 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info), "");
2292
2293 devmode2 = info.info8.devmode;
2294
2295 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2296 "modified DM level 8 != DM level 8 after DM has been set via level 8");
2297
2298 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
2299
2300 devmode2 = info.info2.devmode;
2301
2302 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2303 "modified DM level 8 != DM level 2");
2304
2305
2306 /* set devicemode level 2 and see if it persists */
2307
2308 devmode->copies = 39;
2309 devmode->formname = talloc_strdup(tctx, "Executive");
2310
2311 torture_assert(tctx, test_devmode_set_level(tctx, b, handle, 2, devmode), "");
2312
2313 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info), "");
2314
2315 devmode2 = info.info8.devmode;
2316
2317 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2318 "modified DM level 8 != DM level 8 after DM has been set via level 2");
2319
2320 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
2321
2322 devmode2 = info.info2.devmode;
2323
2324 torture_assert(tctx, test_devicemode_equal(tctx, devmode, devmode2),
2325 "modified DM level 8 != DM level 2");
2326
2327
2328 /* check every single bit in public part of devicemode */
2329
2330 torture_assert(tctx, test_devicemode_full(tctx, b, handle),
2331 "failed to set every single devicemode component");
2332
2333
2334 /* change formname upon open and see if it persists in getprinter calls */
2335
2336 devmode->formname = talloc_strdup(tctx, "A4");
2337 devmode->copies = 42;
2338
2339 torture_assert(tctx, call_OpenPrinterEx(tctx, p, name, devmode, &handle_devmode),
2340 "failed to open printer handle");
2341
2342 torture_assert(tctx, test_GetPrinter_level(tctx, b, &handle_devmode, 8, &info), "");
2343
2344 devmode2 = info.info8.devmode;
2345
2346 if (strequal(devmode->devicename, devmode2->devicename)) {
2347 torture_warning(tctx, "devicenames are the same\n");
2348 } else {
2349 torture_comment(tctx, "devicename passed in for open: %s\n", devmode->devicename);
2350 torture_comment(tctx, "devicename after level 8 get: %s\n", devmode2->devicename);
2351 }
2352
2353 if (strequal(devmode->formname, devmode2->formname)) {
2354 torture_warning(tctx, "formname are the same\n");
2355 } else {
2356 torture_comment(tctx, "formname passed in for open: %s\n", devmode->formname);
2357 torture_comment(tctx, "formname after level 8 get: %s\n", devmode2->formname);
2358 }
2359
2360 if (devmode->copies == devmode2->copies) {
2361 torture_warning(tctx, "copies are the same\n");
2362 } else {
2363 torture_comment(tctx, "copies passed in for open: %d\n", devmode->copies);
2364 torture_comment(tctx, "copies after level 8 get: %d\n", devmode2->copies);
2365 }
2366
2367 torture_assert(tctx, test_GetPrinter_level(tctx, b, &handle_devmode, 2, &info), "");
2368
2369 devmode2 = info.info2.devmode;
2370
2371 if (strequal(devmode->devicename, devmode2->devicename)) {
2372 torture_warning(tctx, "devicenames are the same\n");
2373 } else {
2374 torture_comment(tctx, "devicename passed in for open: %s\n", devmode->devicename);
2375 torture_comment(tctx, "devicename after level 2 get: %s\n", devmode2->devicename);
2376 }
2377
2378 if (strequal(devmode->formname, devmode2->formname)) {
2379 torture_warning(tctx, "formname is the same\n");
2380 } else {
2381 torture_comment(tctx, "formname passed in for open: %s\n", devmode->formname);
2382 torture_comment(tctx, "formname after level 2 get: %s\n", devmode2->formname);
2383 }
2384
2385 if (devmode->copies == devmode2->copies) {
2386 torture_warning(tctx, "copies are the same\n");
2387 } else {
2388 torture_comment(tctx, "copies passed in for open: %d\n", devmode->copies);
2389 torture_comment(tctx, "copies after level 2 get: %d\n", devmode2->copies);
2390 }
2391
2392 test_ClosePrinter(tctx, b, &handle_devmode);
2393
2394 return true;
2395 }
2396
2397 /*
2398 * wrapper call that saves original devmode, runs tests, and restores devmode
2399 */
2400
2401 static bool test_PrinterInfo_DevMode(struct torture_context *tctx,
2402 struct dcerpc_pipe *p,
2403 struct policy_handle *handle,
2404 const char *name,
2405 struct spoolss_DeviceMode *addprinter_devmode)
2406 {
2407 union spoolss_PrinterInfo info;
2408 struct spoolss_DeviceMode *devmode;
2409 bool ret = true;
2410 struct dcerpc_binding_handle *b = p->binding_handle;
2411
2412 torture_comment(tctx, "Testing Printer Devicemodes\n");
2413
2414 /* save original devmode */
2415
2416 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 8, &info),
2417 "failed to get initial global devicemode");
2418
2419 devmode = info.info8.devmode;
2420
2421 if (devmode && devmode->size == 0) {
2422 torture_fail(tctx,
2423 "devmode of zero size!");
2424 }
2425
2426 if (addprinter_devmode) {
2427 if (!test_devicemode_equal(tctx, devmode, addprinter_devmode)) {
2428 torture_warning(tctx, "current global DM is != DM provided in addprinter");
2429 }
2430 }
2431
2432 /* run tests */
2433
2434 ret = test_PrinterInfo_DevModes(tctx, p, handle, name);
2435
2436 /* restore original devmode */
2437
2438 torture_assert(tctx, test_devmode_set_level(tctx, b, handle, 8, devmode),
2439 "failed to restore initial global device mode");
2440
2441 torture_comment(tctx, "Printer Devicemodes test %s\n\n",
2442 ret ? "succeeded" : "failed");
2443
2444
2445 return ret;
2446 }
2447
2448 bool test_ClosePrinter(struct torture_context *tctx,
2449 struct dcerpc_binding_handle *b,
2450 struct policy_handle *handle)
2451 {
2452 NTSTATUS status;
2453 struct spoolss_ClosePrinter r;
2454
2455 r.in.handle = handle;
2456 r.out.handle = handle;
2457
2458 torture_comment(tctx, "Testing ClosePrinter\n");
2459
2460 status = dcerpc_spoolss_ClosePrinter_r(b, tctx, &r);
2461 torture_assert_ntstatus_ok(tctx, status, "ClosePrinter failed");
2462 torture_assert_werr_ok(tctx, r.out.result, "ClosePrinter failed");
2463
2464 return true;
2465 }
2466
2467 static bool test_GetForm_args(struct torture_context *tctx,
2468 struct dcerpc_binding_handle *b,
2469 struct policy_handle *handle,
2470 const char *form_name,
2471 uint32_t level,
2472 union spoolss_FormInfo *info_p)
2473 {
2474 NTSTATUS status;
2475 struct spoolss_GetForm r;
2476 uint32_t needed;
2477
2478 r.in.handle = handle;
2479 r.in.form_name = form_name;
2480 r.in.level = level;
2481 r.in.buffer = NULL;
2482 r.in.offered = 0;
2483 r.out.needed = &needed;
2484
2485 torture_comment(tctx, "Testing GetForm(%s) level %d\n", form_name, r.in.level);
2486
2487 status = dcerpc_spoolss_GetForm_r(b, tctx, &r);
2488 torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
2489
2490 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2491 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2492 r.in.buffer = &blob;
2493 r.in.offered = needed;
2494 status = dcerpc_spoolss_GetForm_r(b, tctx, &r);
2495 torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
2496
2497 torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
2498
2499 torture_assert(tctx, r.out.info, "No form info returned");
2500 }
2501
2502 torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
2503
2504 CHECK_NEEDED_SIZE_LEVEL(spoolss_FormInfo, r.out.info, r.in.level, needed, 4);
2505
2506 if (info_p) {
2507 *info_p = *r.out.info;
2508 }
2509
2510 return true;
2511 }
2512
2513 static bool test_GetForm(struct torture_context *tctx,
2514 struct dcerpc_binding_handle *b,
2515 struct policy_handle *handle,
2516 const char *form_name,
2517 uint32_t level)
2518 {
2519 return test_GetForm_args(tctx, b, handle, form_name, level, NULL);
2520 }
2521
2522 static bool test_EnumForms(struct torture_context *tctx,
2523 struct dcerpc_binding_handle *b,
2524 struct policy_handle *handle,
2525 bool print_server,
2526 uint32_t level,
2527 uint32_t *count_p,
2528 union spoolss_FormInfo **info_p)
2529 {
2530 struct spoolss_EnumForms r;
2531 uint32_t needed;
2532 uint32_t count;
2533 union spoolss_FormInfo *info;
2534
2535 r.in.handle = handle;
2536 r.in.level = level;
2537 r.in.buffer = NULL;
2538 r.in.offered = 0;
2539 r.out.needed = &needed;
2540 r.out.count = &count;
2541 r.out.info = &info;
2542
2543 torture_comment(tctx, "Testing EnumForms level %d\n", r.in.level);
2544
2545 torture_assert_ntstatus_ok(tctx,
2546 dcerpc_spoolss_EnumForms_r(b, tctx, &r),
2547 "EnumForms failed");
2548
2549 if ((r.in.level == 2) && (W_ERROR_EQUAL(r.out.result, WERR_UNKNOWN_LEVEL))) {
2550 torture_skip(tctx, "EnumForms level 2 not supported");
2551 }
2552
2553 if (print_server && W_ERROR_EQUAL(r.out.result, WERR_BADFID)) {
2554 torture_fail(tctx, "EnumForms on the PrintServer isn't supported by test server (NT4)");
2555 }
2556
2557 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2558 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
2559 r.in.buffer = &blob;
2560 r.in.offered = needed;
2561
2562 torture_assert_ntstatus_ok(tctx,
2563 dcerpc_spoolss_EnumForms_r(b, tctx, &r),
2564 "EnumForms failed");
2565
2566 torture_assert(tctx, info, "No forms returned");
2567 }
2568
2569 torture_assert_werr_ok(tctx, r.out.result, "EnumForms failed");
2570
2571 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumForms, info, r.in.level, count, needed, 4);
2572
2573 if (info_p) {
2574 *info_p = info;
2575 }
2576 if (count_p) {
2577 *count_p = count;
2578 }
2579
2580 return true;
2581 }
2582
2583 static bool test_EnumForms_all(struct torture_context *tctx,
2584 struct dcerpc_binding_handle *b,
2585 struct policy_handle *handle,
2586 bool print_server)
2587 {
2588 uint32_t levels[] = { 1, 2 };
2589 int i, j;
2590
2591 for (i=0; i<ARRAY_SIZE(levels); i++) {
2592
2593 uint32_t count = 0;
2594 union spoolss_FormInfo *info = NULL;
2595
2596 torture_assert(tctx,
2597 test_EnumForms(tctx, b, handle, print_server, levels[i], &count, &info),
2598 "failed to enum forms");
2599
2600 for (j = 0; j < count; j++) {
2601 if (!print_server) {
2602 torture_assert(tctx,
2603 test_GetForm(tctx, b, handle, info[j].info1.form_name, levels[i]),
2604 "failed to get form");
2605 }
2606 }
2607 }
2608
2609 return true;
2610 }
2611
2612 static bool test_EnumForms_find_one(struct torture_context *tctx,
2613 struct dcerpc_binding_handle *b,
2614 struct policy_handle *handle,
2615 bool print_server,
2616 const char *form_name)
2617 {
2618 union spoolss_FormInfo *info;
2619 uint32_t count;
2620 bool found = false;
2621 int i;
2622
2623 torture_assert(tctx,
2624 test_EnumForms(tctx, b, handle, print_server, 1, &count, &info),
2625 "failed to enumerate forms");
2626
2627 for (i=0; i<count; i++) {
2628 if (strequal(form_name, info[i].info1.form_name)) {
2629 found = true;
2630 break;
2631 }
2632 }
2633
2634 return found;
2635 }
2636
2637 static bool test_DeleteForm(struct torture_context *tctx,
2638 struct dcerpc_binding_handle *b,
2639 struct policy_handle *handle,
2640 const char *form_name,
2641 WERROR expected_result)
2642 {
2643 struct spoolss_DeleteForm r;
2644
2645 r.in.handle = handle;
2646 r.in.form_name = form_name;
2647
2648 torture_comment(tctx, "Testing DeleteForm(%s)\n", form_name);
2649
2650 torture_assert_ntstatus_ok(tctx,
2651 dcerpc_spoolss_DeleteForm_r(b, tctx, &r),
2652 "DeleteForm failed");
2653 torture_assert_werr_equal(tctx, r.out.result, expected_result,
2654 "DeleteForm gave unexpected result");
2655 if (W_ERROR_IS_OK(r.out.result)) {
2656 torture_assert_ntstatus_ok(tctx,
2657 dcerpc_spoolss_DeleteForm_r(b, tctx, &r),
2658 "2nd DeleteForm failed");
2659 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_FORM_NAME,
2660 "2nd DeleteForm failed");
2661 }
2662
2663 return true;
2664 }
2665
2666 static bool test_AddForm(struct torture_context *tctx,
2667 struct dcerpc_binding_handle *b,
2668 struct policy_handle *handle,
2669 uint32_t level,
2670 union spoolss_AddFormInfo *info,
2671 WERROR expected_result)
2672 {
2673 struct spoolss_AddForm r;
2674 struct spoolss_AddFormInfoCtr info_ctr;
2675
2676 info_ctr.level = level;
2677 info_ctr.info = *info;
2678
2679 if (level != 1) {
2680 torture_skip(tctx, "only level 1 supported");
2681 }
2682
2683 r.in.handle = handle;
2684 r.in.info_ctr = &info_ctr;
2685
2686 torture_comment(tctx, "Testing AddForm(%s) level %d, type %d\n",
2687 r.in.info_ctr->info.info1->form_name, level,
2688 r.in.info_ctr->info.info1->flags);
2689
2690 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_AddForm_r(b, tctx, &r),
2691 "AddForm failed");
2692 torture_assert_werr_equal(tctx, r.out.result, expected_result,
2693 "AddForm gave unexpected result");
2694
2695 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_AddForm_r(b, tctx, &r),
2696 "2nd AddForm failed");
2697 if (W_ERROR_EQUAL(expected_result, WERR_INVALID_PARAM)) {
2698 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
2699 "2nd AddForm gave unexpected result");
2700 } else {
2701 torture_assert_werr_equal(tctx, r.out.result, WERR_FILE_EXISTS,
2702 "2nd AddForm gave unexpected result");
2703 }
2704
2705 return true;
2706 }
2707
2708 static bool test_SetForm(struct torture_context *tctx,
2709 struct dcerpc_binding_handle *b,
2710 struct policy_handle *handle,
2711 const char *form_name,
2712 uint32_t level,
2713 union spoolss_AddFormInfo *info)
2714 {
2715 struct spoolss_SetForm r;
2716 struct spoolss_AddFormInfoCtr info_ctr;
2717
2718 info_ctr.level = level;
2719 info_ctr.info = *info;
2720
2721 r.in.handle = handle;
2722 r.in.form_name = form_name;
2723 r.in.info_ctr = &info_ctr;
2724
2725 torture_comment(tctx, "Testing SetForm(%s) level %d\n",
2726 form_name, level);
2727
2728 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetForm_r(b, tctx, &r),
2729 "SetForm failed");
2730
2731 torture_assert_werr_ok(tctx, r.out.result,
2732 "SetForm failed");
2733
2734 return true;
2735 }
2736
2737 static bool test_GetForm_winreg(struct torture_context *tctx,
2738 struct dcerpc_binding_handle *b,
2739 struct policy_handle *handle,
2740 const char *key_name,
2741 const char *form_name,
2742 enum winreg_Type *w_type,
2743 uint32_t *w_size,
2744 uint32_t *w_length,
2745 uint8_t **w_data);
2746
2747 static bool test_Forms_args(struct torture_context *tctx,
2748 struct dcerpc_binding_handle *b,
2749 struct policy_handle *handle,
2750 bool print_server,
2751 const char *printer_name,
2752 struct dcerpc_binding_handle *winreg_handle,
2753 struct policy_handle *hive_handle,
2754 const char *form_name,
2755 struct spoolss_AddFormInfo1 *info1,
2756 WERROR expected_add_result,
2757 WERROR expected_delete_result)
2758 {
2759 union spoolss_FormInfo info;
2760 union spoolss_AddFormInfo add_info;
2761
2762 enum winreg_Type w_type;
2763 uint32_t w_size;
2764 uint32_t w_length;
2765 uint8_t *w_data;
2766
2767 add_info.info1 = info1;
2768
2769 torture_assert(tctx,
2770 test_AddForm(tctx, b, handle, 1, &add_info, expected_add_result),
2771 "failed to add form");
2772
2773 if (winreg_handle && hive_handle && W_ERROR_IS_OK(expected_add_result)) {
2774
2775 struct spoolss_FormInfo1 i1;
2776
2777 torture_assert(tctx,
2778 test_GetForm_winreg(tctx, winreg_handle, hive_handle, TOP_LEVEL_CONTROL_FORMS_KEY, form_name, &w_type, &w_size, &w_length, &w_data),
2779 "failed to get form via winreg");
2780
2781 i1.size.width = IVAL(w_data, 0);
2782 i1.size.height = IVAL(w_data, 4);
2783 i1.area.left = IVAL(w_data, 8);
2784 i1.area.top = IVAL(w_data, 12);
2785 i1.area.right = IVAL(w_data, 16);
2786 i1.area.bottom = IVAL(w_data, 20);
2787 /* skip index here */
2788 i1.flags = IVAL(w_data, 28);
2789
2790 torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");
2791 torture_assert_int_equal(tctx, w_size, 0x20, "unexpected size");
2792 torture_assert_int_equal(tctx, w_length, 0x20, "unexpected length");
2793 torture_assert_int_equal(tctx, i1.size.width, add_info.info1->size.width, "width mismatch");
2794 torture_assert_int_equal(tctx, i1.size.height, add_info.info1->size.height, "height mismatch");
2795 torture_assert_int_equal(tctx, i1.area.left, add_info.info1->area.left, "left mismatch");
2796 torture_assert_int_equal(tctx, i1.area.top, add_info.info1->area.top, "top mismatch");
2797 torture_assert_int_equal(tctx, i1.area.right, add_info.info1->area.right, "right mismatch");
2798 torture_assert_int_equal(tctx, i1.area.bottom, add_info.info1->area.bottom, "bottom mismatch");
2799 torture_assert_int_equal(tctx, i1.flags, add_info.info1->flags, "flags mismatch");
2800 }
2801
2802 if (!print_server && W_ERROR_IS_OK(expected_add_result)) {
2803 torture_assert(tctx,
2804 test_GetForm_args(tctx, b, handle, form_name, 1, &info),
2805 "failed to get added form");
2806
2807 torture_assert_int_equal(tctx, info.info1.size.width, add_info.info1->size.width, "width mismatch");
2808 torture_assert_int_equal(tctx, info.info1.size.height, add_info.info1->size.height, "height mismatch");
2809 torture_assert_int_equal(tctx, info.info1.area.left, add_info.info1->area.left, "left mismatch");
2810 torture_assert_int_equal(tctx, info.info1.area.top, add_info.info1->area.top, "top mismatch");
2811 torture_assert_int_equal(tctx, info.info1.area.right, add_info.info1->area.right, "right mismatch");
2812 torture_assert_int_equal(tctx, info.info1.area.bottom, add_info.info1->area.bottom, "bottom mismatch");
2813 torture_assert_int_equal(tctx, info.info1.flags, add_info.info1->flags, "flags mismatch");
2814
2815 if (winreg_handle && hive_handle) {
2816
2817 struct spoolss_FormInfo1 i1;
2818
2819 i1.size.width = IVAL(w_data, 0);
2820 i1.size.height = IVAL(w_data, 4);
2821 i1.area.left = IVAL(w_data, 8);
2822 i1.area.top = IVAL(w_data, 12);
2823 i1.area.right = IVAL(w_data, 16);
2824 i1.area.bottom = IVAL(w_data, 20);
2825 /* skip index here */
2826 i1.flags = IVAL(w_data, 28);
2827
2828 torture_assert_int_equal(tctx, i1.size.width, info.info1.size.width, "width mismatch");
2829 torture_assert_int_equal(tctx, i1.size.height, info.info1.size.height, "height mismatch");
2830 torture_assert_int_equal(tctx, i1.area.left, info.info1.area.left, "left mismatch");
2831 torture_assert_int_equal(tctx, i1.area.top, info.info1.area.top, "top mismatch");
2832 torture_assert_int_equal(tctx, i1.area.right, info.info1.area.right, "right mismatch");
2833 torture_assert_int_equal(tctx, i1.area.bottom, info.info1.area.bottom, "bottom mismatch");
2834 torture_assert_int_equal(tctx, i1.flags, info.info1.flags, "flags mismatch");
2835 }
2836
2837 add_info.info1->size.width = 1234;
2838
2839 torture_assert(tctx,
2840 test_SetForm(tctx, b, handle, form_name, 1, &add_info),
2841 "failed to set form");
2842 torture_assert(tctx,
2843 test_GetForm_args(tctx, b, handle, form_name, 1, &info),
2844 "failed to get setted form");
2845
2846 torture_assert_int_equal(tctx, info.info1.size.width, add_info.info1->size.width, "width mismatch");
2847 }
2848
2849 if (!W_ERROR_EQUAL(expected_add_result, WERR_INVALID_PARAM)) {
2850 torture_assert(tctx,
2851 test_EnumForms_find_one(tctx, b, handle, print_server, form_name),
2852 "Newly added form not found in enum call");
2853 }
2854
2855 torture_assert(tctx,
2856 test_DeleteForm(tctx, b, handle, form_name, expected_delete_result),
2857 "failed to delete form");
2858
2859 return true;
2860 }
2861
2862 static bool test_Forms(struct torture_context *tctx,
2863 struct dcerpc_binding_handle *b,
2864 struct policy_handle *handle,
2865 bool print_server,
2866 const char *printer_name,
2867 struct dcerpc_binding_handle *winreg_handle,
2868 struct policy_handle *hive_handle)
2869 {
2870 const struct spoolss_FormSize size = {
2871 .width = 50,
2872 .height = 25
2873 };
2874 const struct spoolss_FormArea area = {
2875 .left = 5,
2876 .top = 10,
2877 .right = 45,
2878 .bottom = 15
2879 };
2880 int i;
2881
2882 struct {
2883 struct spoolss_AddFormInfo1 info1;
2884 WERROR expected_add_result;
2885 WERROR expected_delete_result;
2886 } forms[] = {
2887 {
2888 .info1 = {
2889 .flags = SPOOLSS_FORM_USER,
2890 .form_name = "testform_user",
2891 .size = size,
2892 .area = area,
2893 },
2894 .expected_add_result = WERR_OK,
2895 .expected_delete_result = WERR_OK
2896 },
2897 /*
2898 weird, we can add a builtin form but we can never remove it
2899 again - gd
2900
2901 {
2902 .info1 = {
2903 .flags = SPOOLSS_FORM_BUILTIN,
2904 .form_name = "testform_builtin",
2905 .size = size,
2906 .area = area,
2907 },
2908 .expected_add_result = WERR_OK,
2909 .expected_delete_result = WERR_INVALID_PARAM,
2910 },
2911 */
2912 {
2913 .info1 = {
2914 .flags = SPOOLSS_FORM_PRINTER,
2915 .form_name = "testform_printer",
2916 .size = size,
2917 .area = area,
2918 },
2919 .expected_add_result = WERR_OK,
2920 .expected_delete_result = WERR_OK
2921 },
2922 {
2923 .info1 = {
2924 .flags = SPOOLSS_FORM_USER,
2925 .form_name = "Letter",
2926 .size = size,
2927 .area = area,
2928 },
2929 .expected_add_result = WERR_FILE_EXISTS,
2930 .expected_delete_result = WERR_INVALID_PARAM
2931 },
2932 {
2933 .info1 = {
2934 .flags = SPOOLSS_FORM_BUILTIN,
2935 .form_name = "Letter",
2936 .size = size,
2937 .area = area,
2938 },
2939 .expected_add_result = WERR_FILE_EXISTS,
2940 .expected_delete_result = WERR_INVALID_PARAM
2941 },
2942 {
2943 .info1 = {
2944 .flags = SPOOLSS_FORM_PRINTER,
2945 .form_name = "Letter",
2946 .size = size,
2947 .area = area,
2948 },
2949 .expected_add_result = WERR_FILE_EXISTS,
2950 .expected_delete_result = WERR_INVALID_PARAM
2951 },
2952 {
2953 .info1 = {
2954 .flags = 12345,
2955 .form_name = "invalid_flags",
2956 .size = size,
2957 .area = area,
2958 },
2959 .expected_add_result = WERR_INVALID_PARAM,
2960 .expected_delete_result = WERR_INVALID_FORM_NAME
2961 }
2962
2963 };
2964
2965 for (i=0; i < ARRAY_SIZE(forms); i++) {
2966 torture_assert(tctx,
2967 test_Forms_args(tctx, b, handle, print_server, printer_name,
2968 winreg_handle, hive_handle,
2969 forms[i].info1.form_name,
2970 &forms[i].info1,
2971 forms[i].expected_add_result,
2972 forms[i].expected_delete_result),
2973 talloc_asprintf(tctx, "failed to test form '%s'", forms[i].info1.form_name));
2974 }
2975
2976 return true;
2977 }
2978
2979 static bool test_EnumPorts_old(struct torture_context *tctx,
2980 void *private_data)
2981 {
2982 struct test_spoolss_context *ctx =
2983 talloc_get_type_abort(private_data, struct test_spoolss_context);
2984
2985 NTSTATUS status;
2986 struct spoolss_EnumPorts r;
2987 uint32_t needed;
2988 uint32_t count;
2989 union spoolss_PortInfo *info;
2990 struct dcerpc_pipe *p = ctx->spoolss_pipe;
2991 struct dcerpc_binding_handle *b = p->binding_handle;
2992
2993 r.in.servername = talloc_asprintf(tctx, "\\\\%s",
2994 dcerpc_server_name(p));
2995 r.in.level = 2;
2996 r.in.buffer = NULL;
2997 r.in.offered = 0;
2998 r.out.needed = &needed;
2999 r.out.count = &count;
3000 r.out.info = &info;
3001
3002 torture_comment(tctx, "Testing EnumPorts\n");
3003
3004 status = dcerpc_spoolss_EnumPorts_r(b, tctx, &r);
3005
3006 torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
3007
3008 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
3009 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
3010 r.in.buffer = &blob;
3011 r.in.offered = needed;
3012
3013 status = dcerpc_spoolss_EnumPorts_r(b, tctx, &r);
3014 torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
3015 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
3016
3017 torture_assert(tctx, info, "No ports returned");
3018 }
3019
3020 torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
3021
3022 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPorts, info, 2, count, needed, 4);
3023
3024 return true;
3025 }
3026
3027 static bool test_AddPort(struct torture_context *tctx,
3028 void *private_data)
3029 {
3030 struct test_spoolss_context *ctx =
3031 talloc_get_type_abort(private_data, struct test_spoolss_context);
3032
3033 NTSTATUS status;
3034 struct spoolss_AddPort r;
3035 struct dcerpc_pipe *p = ctx->spoolss_pipe;
3036 struct dcerpc_binding_handle *b = p->binding_handle;
3037
3038 r.in.server_name = talloc_asprintf(tctx, "\\\\%s",
3039 dcerpc_server_name(p));
3040 r.in.unknown = 0;
3041 r.in.monitor_name = "foo";
3042
3043 torture_comment(tctx, "Testing AddPort\n");
3044
3045 status = dcerpc_spoolss_AddPort_r(b, tctx, &r);
3046
3047 torture_assert_ntstatus_ok(tctx, status, "AddPort failed");
3048
3049 /* win2k3 returns WERR_NOT_SUPPORTED */
3050
3051 #if 0
3052
3053 if (!W_ERROR_IS_OK(r.out.result)) {
3054 printf("AddPort failed - %s\n", win_errstr(r.out.result));
3055 return false;
3056 }
3057
3058 #endif
3059
3060 return true;
3061 }
3062
3063 static bool test_GetJob_args(struct torture_context *tctx,
3064 struct dcerpc_binding_handle *b,
3065 struct policy_handle *handle,
3066 uint32_t job_id,
3067 uint32_t level,
3068 union spoolss_JobInfo *info_p)
3069 {
3070 NTSTATUS status;
3071 struct spoolss_GetJob r;
3072 union spoolss_JobInfo info;
3073 uint32_t needed;
3074
3075 r.in.handle = handle;
3076 r.in.job_id = job_id;
3077 r.in.level = level;
3078 r.in.buffer = NULL;
3079 r.in.offered = 0;
3080 r.out.needed = &needed;
3081 r.out.info = &info;
3082
3083 torture_comment(tctx, "Testing GetJob(%d), level %d\n", job_id, r.in.level);
3084
3085 status = dcerpc_spoolss_GetJob_r(b, tctx, &r);
3086 torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
3087 if (level == 0) {
3088 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "Unexpected return code");
3089 }
3090
3091 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
3092 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
3093 r.in.buffer = &blob;
3094 r.in.offered = needed;
3095
3096 status = dcerpc_spoolss_GetJob_r(b, tctx, &r);
3097 torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
3098 }
3099
3100 torture_assert_werr_ok(tctx, r.out.result, "GetJob failed");
3101 torture_assert(tctx, r.out.info, "No job info returned");
3102
3103 CHECK_NEEDED_SIZE_LEVEL(spoolss_JobInfo, r.out.info, r.in.level, needed, 4);
3104
3105 if (info_p) {
3106 *info_p = *r.out.info;
3107 }
3108
3109 return true;
3110 }
3111
3112 static bool test_GetJob(struct torture_context *tctx,
3113 struct dcerpc_binding_handle *b,
3114 struct policy_handle *handle,
3115 uint32_t job_id)
3116 {
3117 uint32_t levels[] = {0, 1, 2 /* 3, 4 */};
3118 uint32_t i;
3119
3120 for (i=0; i < ARRAY_SIZE(levels); i++) {
3121 torture_assert(tctx,
3122 test_GetJob_args(tctx, b, handle, job_id, levels[i], NULL),
3123 "GetJob failed");
3124 }
3125
3126 return true;
3127 }
3128
3129 static bool test_SetJob(struct torture_context *tctx,
3130 struct dcerpc_binding_handle *b,
3131 struct policy_handle *handle,
3132 uint32_t job_id,
3133 struct spoolss_JobInfoContainer *ctr,
3134 enum spoolss_JobControl command)
3135 {
3136 NTSTATUS status;
3137 struct spoolss_SetJob r;
3138
3139 r.in.handle = handle;
3140 r.in.job_id = job_id;
3141 r.in.ctr = ctr;
3142 r.in.command = command;
3143
3144 switch (command) {
3145 case SPOOLSS_JOB_CONTROL_PAUSE:
3146 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_PAUSE\n", job_id);
3147 break;
3148 case SPOOLSS_JOB_CONTROL_RESUME:
3149 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RESUME\n", job_id);
3150 break;
3151 case SPOOLSS_JOB_CONTROL_CANCEL:
3152 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_CANCEL\n", job_id);
3153 break;
3154 case SPOOLSS_JOB_CONTROL_RESTART:
3155 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RESTART\n", job_id);
3156 break;
3157 case SPOOLSS_JOB_CONTROL_DELETE:
3158 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_DELETE\n", job_id);
3159 break;
3160 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER:
3161 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER\n", job_id);
3162 break;
3163 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED:
3164 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED\n", job_id);
3165 break;
3166 case SPOOLSS_JOB_CONTROL_RETAIN:
3167 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RETAIN\n", job_id);
3168 break;
3169 case SPOOLSS_JOB_CONTROL_RELEASE:
3170 torture_comment(tctx, "Testing SetJob(%d), SPOOLSS_JOB_CONTROL_RELEASE\n", job_id);
3171 break;
3172 default:
3173 torture_comment(tctx, "Testing SetJob(%d)\n", job_id);
3174 break;
3175 }
3176
3177 status = dcerpc_spoolss_SetJob_r(b, tctx, &r);
3178 torture_assert_ntstatus_ok(tctx, status, "SetJob failed");
3179 torture_assert_werr_ok(tctx, r.out.result, "SetJob failed");
3180
3181 return true;
3182 }
3183
3184 static bool test_AddJob(struct torture_context *tctx,
3185 struct dcerpc_binding_handle *b,
3186 struct policy_handle *handle)
3187 {
3188 NTSTATUS status;
3189 struct spoolss_AddJob r;
3190 uint32_t needed;
3191
3192 r.in.level = 0;
3193 r.in.handle = handle;
3194 r.in.offered = 0;
3195 r.out.needed = &needed;
3196 r.in.buffer = r.out.buffer = NULL;
3197
3198 torture_comment(tctx, "Testing AddJob\n");
3199
3200 status = dcerpc_spoolss_AddJob_r(b, tctx, &r);
3201 torture_assert_ntstatus_ok(tctx, status, "AddJob failed");
3202 torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "AddJob failed");
3203
3204 r.in.level = 1;
3205
3206 status = dcerpc_spoolss_AddJob_r(b, tctx, &r);
3207 torture_assert_ntstatus_ok(tctx, status, "AddJob failed");
3208 torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM, "AddJob failed");
3209
3210 return true;
3211 }
3212
3213
3214 static bool test_EnumJobs_args(struct torture_context *tctx,
3215 struct dcerpc_binding_handle *b,
3216 struct policy_handle *handle,
3217 uint32_t level,
3218 uint32_t *count_p,
3219 union spoolss_JobInfo **info_p)
3220 {
3221 NTSTATUS status;
3222 struct spoolss_EnumJobs r;
3223 uint32_t needed;
3224 uint32_t count;
3225 union spoolss_JobInfo *info;
3226
3227 r.in.handle = handle;
3228 r.in.firstjob = 0;
3229 r.in.numjobs = 0xffffffff;
3230 r.in.level = level;
3231 r.in.buffer = NULL;
3232 r.in.offered = 0;
3233 r.out.needed = &needed;
3234 r.out.count = &count;
3235 r.out.info = &info;
3236
3237 torture_comment(tctx, "Testing EnumJobs level %d\n", level);
3238
3239 status = dcerpc_spoolss_EnumJobs_r(b, tctx, &r);
3240
3241 torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
3242
3243 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
3244 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
3245 r.in.buffer = &blob;
3246 r.in.offered = needed;
3247
3248 status = dcerpc_spoolss_EnumJobs_r(b, tctx, &r);
3249
3250 torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
3251 torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
3252 torture_assert(tctx, info, "No jobs returned");
3253
3254 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumJobs, *r.out.info, r.in.level, count, needed, 4);
3255
3256 } else {
3257 torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
3258 }
3259
3260 if (count_p) {
3261 *count_p = count;
3262 }
3263 if (info_p) {
3264 *info_p = info;
3265 }
3266
3267 return true;
3268 }
3269
3270 static bool test_JobPropertiesEnum(struct torture_context *tctx,
3271 struct dcerpc_binding_handle *b,
3272 struct policy_handle *handle,
3273 uint32_t job_id)
3274 {
3275 struct spoolss_RpcEnumJobNamedProperties r;
3276 uint32_t pcProperties = 0;
3277 struct RPC_PrintNamedProperty *ppProperties = NULL;
3278
3279 r.in.hPrinter = handle;
3280 r.in.JobId = job_id;
3281 r.out.pcProperties = &pcProperties;
3282 r.out.ppProperties = &ppProperties;
3283
3284 torture_comment(tctx, "Testing RpcEnumJobNamedProperties(%d)\n", job_id);
3285
3286 torture_assert_ntstatus_ok(tctx,
3287 dcerpc_spoolss_RpcEnumJobNamedProperties_r(b, tctx, &r),
3288 "spoolss_RpcEnumJobNamedProperties failed");
3289 torture_assert_werr_ok(tctx, r.out.result,
3290 "spoolss_RpcEnumJobNamedProperties failed");
3291
3292 return true;
3293 }
3294
3295 static bool test_JobPropertySet(struct torture_context *tctx,
3296 struct dcerpc_binding_handle *b,
3297 struct policy_handle *handle,
3298 uint32_t job_id,
3299 struct RPC_PrintNamedProperty *property)
3300 {
3301 struct spoolss_RpcSetJobNamedProperty r;
3302
3303 r.in.hPrinter = handle;
3304 r.in.JobId = job_id;
3305 r.in.pProperty = property;
3306
3307 torture_comment(tctx, "Testing RpcSetJobNamedProperty(%d) %s - %d\n",
3308 job_id, property->propertyName,
3309 property->propertyValue.ePropertyType);
3310
3311 torture_assert_ntstatus_ok(tctx,
3312 dcerpc_spoolss_RpcSetJobNamedProperty_r(b, tctx, &r),
3313 "spoolss_RpcSetJobNamedProperty failed");
3314 torture_assert_werr_ok(tctx, r.out.result,
3315 "spoolss_RpcSetJobNamedProperty failed");
3316
3317 return true;
3318 }
3319
3320 static bool test_JobPropertyGetValue(struct torture_context *tctx,
3321 struct dcerpc_binding_handle *b,
3322 struct policy_handle *handle,
3323 uint32_t job_id,
3324 const char *property_name,
3325 struct RPC_PrintPropertyValue *value)
3326 {
3327 struct spoolss_RpcGetJobNamedPropertyValue r;
3328
3329 r.in.hPrinter = handle;
3330 r.in.JobId = job_id;
3331 r.in.pszName = property_name;
3332 r.out.pValue = value;
3333
3334 torture_comment(tctx, "Testing RpcGetJobNamedPropertyValue(%d) %s\n",
3335 job_id, property_name);
3336
3337 torture_assert_ntstatus_ok(tctx,
3338 dcerpc_spoolss_RpcGetJobNamedPropertyValue_r(b, tctx, &r),
3339 "spoolss_RpcGetJobNamedPropertyValue failed");
3340 torture_assert_werr_ok(tctx, r.out.result,
3341 "spoolss_RpcGetJobNamedPropertyValue failed");
3342
3343 return true;
3344 }
3345
3346 static bool test_JobPropertyDelete(struct torture_context *tctx,
3347 struct dcerpc_binding_handle *b,
3348 struct policy_handle *handle,
3349 uint32_t job_id,
3350 const char *property_name)
3351 {
3352 struct spoolss_RpcDeleteJobNamedProperty r;
3353
3354 r.in.hPrinter = handle;
3355 r.in.JobId = job_id;
3356 r.in.pszName = property_name;
3357
3358 torture_comment(tctx, "Testing RpcDeleteJobNamedProperty(%d) %s\n",
3359 job_id, property_name);
3360
3361 torture_assert_ntstatus_ok(tctx,
3362 dcerpc_spoolss_RpcDeleteJobNamedProperty_r(b, tctx, &r),
3363 "spoolss_RpcDeleteJobNamedProperty failed");
3364 torture_assert_werr_ok(tctx, r.out.result,
3365 "spoolss_RpcDeleteJobNamedProperty failed");
3366
3367 return true;
3368 }
3369
3370
3371 static bool test_DoPrintTest_add_one_job(struct torture_context *tctx,
3372 struct dcerpc_binding_handle *b,
3373 struct policy_handle *handle,
3374 const char *document_name,
3375 uint32_t *job_id)
3376 {
3377 NTSTATUS status;
3378 struct spoolss_StartDocPrinter s;
3379 struct spoolss_DocumentInfoCtr info_ctr;
3380 struct spoolss_DocumentInfo1 info1;
3381 struct spoolss_StartPagePrinter sp;
3382 struct spoolss_WritePrinter w;
3383 struct spoolss_EndPagePrinter ep;
3384 struct spoolss_EndDocPrinter e;
3385 int i;
3386 uint32_t num_written;
3387
3388 torture_comment(tctx, "Testing StartDocPrinter\n");
3389
3390 s.in.handle = handle;
3391 s.in.info_ctr = &info_ctr;
3392 s.out.job_id = job_id;
3393
3394 info1.document_name = document_name;
3395 info1.output_file = NULL;
3396 info1.datatype = "RAW";
3397
3398 info_ctr.level = 1;
3399 info_ctr.info.info1 = &info1;
3400
3401 status = dcerpc_spoolss_StartDocPrinter_r(b, tctx, &s);
3402 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_StartDocPrinter failed");
3403 torture_assert_werr_ok(tctx, s.out.result, "StartDocPrinter failed");
3404
3405 for (i=1; i < 4; i++) {
3406 torture_comment(tctx, "Testing StartPagePrinter: Page[%d], JobId[%d]\n", i, *job_id);
3407
3408 sp.in.handle = handle;
3409
3410 status = dcerpc_spoolss_StartPagePrinter_r(b, tctx, &sp);
3411 torture_assert_ntstatus_ok(tctx, status,
3412 "dcerpc_spoolss_StartPagePrinter failed");
3413 torture_assert_werr_ok(tctx, sp.out.result, "StartPagePrinter failed");
3414
3415 torture_comment(tctx, "Testing WritePrinter: Page[%d], JobId[%d]\n", i, *job_id);
3416
3417 w.in.handle = handle;
3418 w.in.data = data_blob_string_const(talloc_asprintf(tctx,"TortureTestPage: %d\nData\n",i));
3419 w.out.num_written = &num_written;
3420
3421 status = dcerpc_spoolss_WritePrinter_r(b, tctx, &w);
3422 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_WritePrinter failed");
3423 torture_assert_werr_ok(tctx, w.out.result, "WritePrinter failed");
3424
3425 torture_comment(tctx, "Testing EndPagePrinter: Page[%d], JobId[%d]\n", i, *job_id);
3426
3427 ep.in.handle = handle;
3428
3429 status = dcerpc_spoolss_EndPagePrinter_r(b, tctx, &ep);
3430 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndPagePrinter failed");
3431 torture_assert_werr_ok(tctx, ep.out.result, "EndPagePrinter failed");
3432 }
3433
3434 torture_comment(tctx, "Testing EndDocPrinter: JobId[%d]\n", *job_id);
3435
3436 e.in.handle = handle;
3437
3438 status = dcerpc_spoolss_EndDocPrinter_r(b, tctx, &e);
3439 torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndDocPrinter failed");
3440 torture_assert_werr_ok(tctx, e.out.result, "EndDocPrinter failed");
3441
3442 return true;
3443 }
3444
3445 static bool test_DoPrintTest_check_jobs(struct torture_context *tctx,
3446 struct dcerpc_binding_handle *b,
3447 struct policy_handle *handle,
3448 uint32_t num_jobs,
3449 uint32_t *job_ids)
3450 {
3451 uint32_t count;
3452 union spoolss_JobInfo *info = NULL;
3453 int i;
3454
3455 torture_assert(tctx,
3456 test_AddJob(tctx, b, handle),
3457 "AddJob failed");
3458
3459 torture_assert(tctx,
3460 test_EnumJobs_args(tctx, b, handle, 1, &count, &info),
3461 "EnumJobs level 1 failed");
3462
3463 torture_assert_int_equal(tctx, count, num_jobs, "unexpected number of jobs in queue");
3464
3465 for (i=0; i < num_jobs; i++) {
3466 union spoolss_JobInfo ginfo;
3467 const char *document_name;
3468 const char *new_document_name = "any_other_docname";
3469 struct spoolss_JobInfoContainer ctr;
3470 struct spoolss_SetJobInfo1 info1;
3471
3472 torture_assert_int_equal(tctx, info[i].info1.job_id, job_ids[i], "job id mismatch");
3473
3474 torture_assert(tctx,
3475 test_GetJob_args(tctx, b, handle, info[i].info1.job_id, 1, &ginfo),
3476 "failed to call test_GetJob");
3477
3478 torture_assert_int_equal(tctx, ginfo.info1.job_id, info[i].info1.job_id, "job id mismatch");
3479
3480 document_name = ginfo.info1.document_name;
3481
3482 info1.job_id = ginfo.info1.job_id;
3483 info1.printer_name = ginfo.info1.printer_name;
3484 info1.server_name = ginfo.info1.server_name;
3485 info1.user_name = ginfo.info1.user_name;
3486 info1.document_name = new_document_name;
3487 info1.data_type = ginfo.info1.data_type;
3488 info1.text_status = ginfo.info1.text_status;
3489 info1.status = ginfo.info1.status;
3490 info1.priority = ginfo.info1.priority;
3491 info1.position = ginfo.info1.position;
3492 info1.total_pages = ginfo.info1.total_pages;
3493 info1.pages_printed = ginfo.info1.pages_printed;
3494 info1.submitted = ginfo.info1.submitted;
3495
3496 ctr.level = 1;
3497 ctr.info.info1 = &info1;
3498
3499 torture_assert(tctx,
3500 test_SetJob(tctx, b, handle, info[i].info1.job_id, &ctr, 0),
3501 "failed to call test_SetJob level 1");
3502
3503 torture_assert(tctx,
3504 test_GetJob_args(tctx, b, handle, info[i].info1.job_id, 1, &ginfo),
3505 "failed to call test_GetJob");
3506
3507 if (strequal(ginfo.info1.document_name, document_name)) {
3508 torture_warning(tctx,
3509 "document_name did *NOT* change from '%s' to '%s'\n",
3510 document_name, new_document_name);
3511 }
3512 }
3513
3514 for (i=0; i < num_jobs; i++) {
3515 if (!test_SetJob(tctx, b, handle, info[i].info1.job_id, NULL, SPOOLSS_JOB_CONTROL_PAUSE)) {
3516 torture_warning(tctx, "failed to pause printjob\n");
3517 }
3518 if (!test_SetJob(tctx, b, handle, info[i].info1.job_id, NULL, SPOOLSS_JOB_CONTROL_RESUME)) {
3519 torture_warning(tctx, "failed to resume printjob\n");
3520 }
3521 }
3522
3523 return true;
3524 }
3525
3526 static bool test_DoPrintTest(struct torture_context *tctx,
3527 struct dcerpc_binding_handle *b,
3528 struct policy_handle *handle)
3529 {
3530 bool ret = true;
3531 uint32_t num_jobs = 8;
3532 uint32_t *job_ids;
3533 int i;
3534
3535 torture_comment(tctx, "Testing real print operations\n");
3536
3537 job_ids = talloc_zero_array(tctx, uint32_t, num_jobs);
3538
3539 for (i=0; i < num_jobs; i++) {
3540 ret &= test_DoPrintTest_add_one_job(tctx, b, handle, "TorturePrintJob", &job_ids[i]);
3541 }
3542
3543 for (i=0; i < num_jobs; i++) {
3544 ret &= test_SetJob(tctx, b, handle, job_ids[i], NULL, SPOOLSS_JOB_CONTROL_DELETE);
3545 }
3546
3547 if (ret == true) {
3548 torture_comment(tctx, "real print operations test succeeded\n\n");
3549 }
3550
3551 return ret;
3552 }
3553
3554 static bool test_DoPrintTest_extended(struct torture_context *tctx,
3555 struct dcerpc_binding_handle *b,
3556 struct policy_handle *handle)
3557 {
3558 bool ret = true;
3559 uint32_t num_jobs = 8;
3560 uint32_t *job_ids;
3561 int i;
3562 torture_comment(tctx, "Testing real print operations (extended)\n");
3563
3564 job_ids = talloc_zero_array(tctx, uint32_t, num_jobs);
3565
3566 for (i=0; i < num_jobs; i++) {
3567 ret &= test_DoPrintTest_add_one_job(tctx, b, handle, "TorturePrintJob", &job_ids[i]);
3568 }
3569
3570 ret &= test_DoPrintTest_check_jobs(tctx, b, handle, num_jobs, job_ids);
3571
3572 for (i=0; i < num_jobs; i++) {
3573 ret &= test_SetJob(tctx, b, handle, job_ids[i], NULL, SPOOLSS_JOB_CONTROL_DELETE);
3574 }
3575
3576 if (ret == true) {
3577 torture_comment(tctx, "real print operations (extended) test succeeded\n\n");
3578 }
3579
3580 return ret;
3581 }
3582
3583 static bool test_JobPrintProperties_equal(struct torture_context *tctx,
3584 struct RPC_PrintPropertyValue *got,
3585 struct RPC_PrintNamedProperty *exp)
3586 {
3587 torture_assert_int_equal(tctx,
3588 got->ePropertyType,
3589 exp->propertyValue.ePropertyType,
3590 "ePropertyType");
3591
3592 switch (exp->propertyValue.ePropertyType) {
3593 case kRpcPropertyTypeString:
3594 torture_assert_str_equal(tctx,
3595 got->value.propertyString,
3596 exp->propertyValue.value.propertyString,
3597 "propertyString");
3598 break;
3599 case kRpcPropertyTypeInt32:
3600 torture_assert_int_equal(tctx,
3601 got->value.propertyInt32,
3602 exp->propertyValue.value.propertyInt32,
3603 "propertyInt32");
3604 break;
3605 case kRpcPropertyTypeInt64:
3606 torture_assert_u64_equal(tctx,
3607 got->value.propertyInt64,
3608 exp->propertyValue.value.propertyInt64,
3609 "propertyInt64");
3610 break;
3611 case kRpcPropertyTypeByte:
3612 torture_assert_int_equal(tctx,
3613 got->value.propertyByte,
3614 exp->propertyValue.value.propertyByte,
3615 "propertyByte");
3616 break;
3617 case kRpcPropertyTypeBuffer:
3618 torture_assert_int_equal(tctx,
3619 got->value.propertyBlob.cbBuf,
3620 exp->propertyValue.value.propertyBlob.cbBuf,
3621 "propertyBlob.cbBuf");
3622 torture_assert_mem_equal(tctx,
3623 got->value.propertyBlob.pBuf,
3624 exp->propertyValue.value.propertyBlob.pBuf,
3625 exp->propertyValue.value.propertyBlob.cbBuf,
3626 "propertyBlob.pBuf");
3627
3628 break;
3629
3630 }
3631
3632 return true;
3633 }
3634
3635 static bool test_JobPrintProperties(struct torture_context *tctx,
3636 struct dcerpc_binding_handle *b,
3637 struct policy_handle *handle,
3638 uint32_t job_id)
3639 {
3640 struct RPC_PrintNamedProperty in;
3641 struct RPC_PrintPropertyValue out;
3642 int i;
3643 DATA_BLOB blob = data_blob_string_const("blob");
3644 struct {
3645 const char *property_name;
3646 enum RPC_EPrintPropertyType type;
3647 union RPC_PrintPropertyValueUnion value;
3648 WERROR expected_result;
3649 } tests[] = {
3650 {
3651 .property_name = "torture_property_string",
3652 .type = kRpcPropertyTypeString,
3653 .value.propertyString = "torture_property_value_string",
3654 },{
3655 .property_name = "torture_property_int32",
3656 .type = kRpcPropertyTypeInt32,
3657 .value.propertyInt32 = 42,
3658 },{
3659 .property_name = "torture_property_int64",
3660 .type = kRpcPropertyTypeInt64,
3661 .value.propertyInt64 = 0xaffe,
3662 },{
3663 .property_name = "torture_property_byte",
3664 .type = kRpcPropertyTypeByte,
3665 .value.propertyByte = 0xab,
3666 },{
3667 .property_name = "torture_property_buffer",
3668 .type = kRpcPropertyTypeBuffer,
3669 .value.propertyBlob.cbBuf = blob.length,
3670 .value.propertyBlob.pBuf = blob.data,
3671 }
3672 };
3673
3674 torture_assert(tctx,
3675 test_JobPropertiesEnum(tctx, b, handle, job_id),
3676 "failed to enum properties");
3677
3678 for (i=0; i <ARRAY_SIZE(tests); i++) {
3679
3680 in.propertyName = tests[i].property_name;
3681 in.propertyValue.ePropertyType = tests[i].type;
3682 in.propertyValue.value = tests[i].value;
3683
3684 torture_assert(tctx,
3685 test_JobPropertySet(tctx, b, handle, job_id, &in),
3686 "failed to set property");
3687
3688 torture_assert(tctx,
3689 test_JobPropertyGetValue(tctx, b, handle, job_id, in.propertyName, &out),
3690 "failed to get property");
3691
3692 torture_assert(tctx,
3693 test_JobPrintProperties_equal(tctx, &out, &in),
3694 "property unequal");
3695
3696 torture_assert(tctx,
3697 test_JobPropertiesEnum(tctx, b, handle, job_id),
3698 "failed to enum properties");
3699
3700 torture_assert(tctx,
3701 test_JobPropertyDelete(tctx, b, handle, job_id, in.propertyName),
3702 "failed to delete job property");
3703 }
3704
3705 torture_assert(tctx,
3706 test_JobPropertiesEnum(tctx, b, handle, job_id),
3707 "failed to enum properties");
3708
3709 return true;
3710 }
3711
3712 static bool test_DoPrintTest_properties(struct torture_context *tctx,
3713 struct dcerpc_binding_handle *b,
3714 struct policy_handle *handle)
3715 {
3716 uint32_t num_jobs = 8;
3717 uint32_t *job_ids;
3718 int i;
3719 torture_comment(tctx, "Testing real print operations (properties)\n");
3720
3721 job_ids = talloc_zero_array(tctx, uint32_t, num_jobs);
3722
3723 for (i=0; i < num_jobs; i++) {
3724 torture_assert(tctx,
3725 test_DoPrintTest_add_one_job(tctx, b, handle, "TorturePrintJob", &job_ids[i]),
3726 "failed to create print job");
3727 }
3728
3729 for (i=0; i < num_jobs; i++) {
3730 torture_assert(tctx,
3731 test_JobPrintProperties(tctx, b, handle, job_ids[i]),
3732 "failed to test job properties");
3733 }
3734
3735
3736 for (i=0; i < num_jobs; i++) {
3737 torture_assert(tctx,
3738 test_SetJob(tctx, b, handle, job_ids[i], NULL, SPOOLSS_JOB_CONTROL_DELETE),
3739 "failed to delete printjob");
3740 }
3741
3742 torture_comment(tctx, "real print operations (properties) test succeeded\n\n");
3743
3744 return true;
3745 }
3746
3747 static bool test_PausePrinter(struct torture_context *tctx,
3748 struct dcerpc_binding_handle *b,
3749 struct policy_handle *handle)
3750 {
3751 NTSTATUS status;
3752 struct spoolss_SetPrinter r;
3753 struct spoolss_SetPrinterInfoCtr info_ctr;
3754 struct spoolss_DevmodeContainer devmode_ctr;
3755 struct sec_desc_buf secdesc_ctr;
3756
3757 info_ctr.level = 0;
3758 info_ctr.info.info0 = NULL;
3759
3760 ZERO_STRUCT(devmode_ctr);
3761 ZERO_STRUCT(secdesc_ctr);
3762
3763 r.in.handle = handle;
3764 r.in.info_ctr = &info_ctr;
3765 r.in.devmode_ctr = &devmode_ctr;
3766 r.in.secdesc_ctr = &secdesc_ctr;
3767 r.in.command = SPOOLSS_PRINTER_CONTROL_PAUSE;
3768
3769 torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_PAUSE\n");
3770
3771 status = dcerpc_spoolss_SetPrinter_r(b, tctx, &r);
3772
3773 torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
3774
3775 torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
3776
3777 return true;
3778 }
3779
3780 static bool test_ResumePrinter(struct torture_context *tctx,
3781 struct dcerpc_binding_handle *b,
3782 struct policy_handle *handle)
3783 {
3784 NTSTATUS status;
3785 struct spoolss_SetPrinter r;
3786 struct spoolss_SetPrinterInfoCtr info_ctr;
3787 struct spoolss_DevmodeContainer devmode_ctr;
3788 struct sec_desc_buf secdesc_ctr;
3789
3790 info_ctr.level = 0;
3791 info_ctr.info.info0 = NULL;
3792
3793 ZERO_STRUCT(devmode_ctr);
3794 ZERO_STRUCT(secdesc_ctr);
3795
3796 r.in.handle = handle;
3797 r.in.info_ctr = &info_ctr;
3798 r.in.devmode_ctr = &devmode_ctr;
3799 r.in.secdesc_ctr = &secdesc_ctr;
3800 r.in.command = SPOOLSS_PRINTER_CONTROL_RESUME;
3801
3802 torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_RESUME\n");
3803
3804 status = dcerpc_spoolss_SetPrinter_r(b, tctx, &r);
3805
3806 torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
3807
3808 torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
3809
3810 return true;
3811 }
3812
3813 static bool test_GetPrinterData_checktype(struct torture_context *tctx,
3814 struct dcerpc_binding_handle *b,
3815 struct policy_handle *handle,
3816 const char *value_name,
3817 enum winreg_Type *expected_type,
3818 enum winreg_Type *type_p,
3819 uint8_t **data_p,
3820 uint32_t *needed_p)
3821 {
3822 NTSTATUS status;
3823 struct spoolss_GetPrinterData r;
3824 uint32_t needed;
3825 enum winreg_Type type;
3826 union spoolss_PrinterData data;
3827
3828 r.in.handle = handle;
3829 r.in.value_name = value_name;
3830 r.in.offered = 0;
3831 r.out.needed = &needed;
3832 r.out.type = &type;
3833 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3834
3835 torture_comment(tctx, "Testing GetPrinterData(%s)\n", r.in.value_name);
3836
3837 status = dcerpc_spoolss_GetPrinterData_r(b, tctx, &r);
3838 torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
3839
3840 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3841 if (expected_type) {
3842 torture_assert_int_equal(tctx, type, *expected_type, "unexpected type");
3843 }
3844 r.in.offered = needed;
3845 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3846 status = dcerpc_spoolss_GetPrinterData_r(b, tctx, &r);
3847 torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
3848 }
3849
3850 torture_assert_werr_ok(tctx, r.out.result,
3851 talloc_asprintf(tctx, "GetPrinterData(%s) failed", r.in.value_name));
3852
3853 CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterData, &data, type, needed, 1);
3854
3855 if (type_p) {
3856 *type_p = type;
3857 }
3858
3859 if (data_p) {
3860 *data_p = r.out.data;
3861 }
3862
3863 if (needed_p) {
3864 *needed_p = needed;
3865 }
3866
3867 return true;
3868 }
3869
3870 static bool test_GetPrinterData(struct torture_context *tctx,
3871 struct dcerpc_binding_handle *b,
3872 struct policy_handle *handle,
3873 const char *value_name,
3874 enum winreg_Type *type_p,
3875 uint8_t **data_p,
3876 uint32_t *needed_p)
3877 {
3878 return test_GetPrinterData_checktype(tctx, b, handle, value_name,
3879 NULL, type_p, data_p, needed_p);
3880 }
3881
3882 static bool test_GetPrinterDataEx_checktype(struct torture_context *tctx,
3883 struct dcerpc_pipe *p,
3884 struct policy_handle *handle,
3885 const char *key_name,
3886 const char *value_name,
3887 enum winreg_Type *expected_type,
3888 enum winreg_Type *type_p,
3889 uint8_t **data_p,
3890 uint32_t *needed_p)
3891 {
3892 NTSTATUS status;
3893 struct spoolss_GetPrinterDataEx r;
3894 enum winreg_Type type;
3895 uint32_t needed;
3896 union spoolss_PrinterData data;
3897 struct dcerpc_binding_handle *b = p->binding_handle;
3898
3899 r.in.handle = handle;
3900 r.in.key_name = key_name;
3901 r.in.value_name = value_name;
3902 r.in.offered = 0;
3903 r.out.type = &type;
3904 r.out.needed = &needed;
3905 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3906
3907 torture_comment(tctx, "Testing GetPrinterDataEx(%s - %s)\n",
3908 r.in.key_name, r.in.value_name);
3909
3910 status = dcerpc_spoolss_GetPrinterDataEx_r(b, tctx, &r);
3911 if (!NT_STATUS_IS_OK(status)) {
3912 if (NT_STATUS_EQUAL(status, NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE)) {
3913 torture_skip(tctx, "GetPrinterDataEx not supported by server\n");
3914 }
3915 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
3916 }
3917
3918 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3919 if (expected_type) {
3920 torture_assert_int_equal(tctx, type, *expected_type, "unexpected type");
3921 }
3922 r.in.offered = needed;
3923 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.offered);
3924 status = dcerpc_spoolss_GetPrinterDataEx_r(b, tctx, &r);
3925 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
3926 }
3927
3928 torture_assert_werr_ok(tctx, r.out.result,
3929 talloc_asprintf(tctx, "GetPrinterDataEx(%s - %s) failed", r.in.key_name, r.in.value_name));
3930
3931 CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterData, &data, type, needed, 1);
3932
3933 if (type_p) {
3934 *type_p = type;
3935 }
3936
3937 if (data_p) {
3938 *data_p = r.out.data;
3939 }
3940
3941 if (needed_p) {
3942 *needed_p = needed;
3943 }
3944
3945 return true;
3946 }
3947
3948 static bool test_GetPrinterDataEx(struct torture_context *tctx,
3949 struct dcerpc_pipe *p,
3950 struct policy_handle *handle,
3951 const char *key_name,
3952 const char *value_name,
3953 enum winreg_Type *type_p,
3954 uint8_t **data_p,
3955 uint32_t *needed_p)
3956 {
3957 return test_GetPrinterDataEx_checktype(tctx, p, handle, key_name, value_name,
3958 NULL, type_p, data_p, needed_p);
3959 }
3960
3961 static bool test_get_environment(struct torture_context *tctx,
3962 struct dcerpc_binding_handle *b,
3963 struct policy_handle *handle,
3964 const char **architecture)
3965 {
3966 DATA_BLOB blob;
3967 enum winreg_Type type;
3968 uint8_t *data;
3969 uint32_t needed;
3970
3971 torture_assert(tctx,
3972 test_GetPrinterData(tctx, b, handle, "Architecture", &type, &data, &needed),
3973 "failed to get Architecture");
3974
3975 torture_assert_int_equal(tctx, type, REG_SZ, "unexpected type");
3976
3977 blob = data_blob_const(data, needed);
3978 *architecture = reg_val_data_string(tctx, REG_SZ, blob);
3979
3980 return true;
3981 }
3982
3983 static bool test_GetPrinterData_list(struct torture_context *tctx,
3984 void *private_data)
3985 {
3986 struct test_spoolss_context *ctx =
3987 talloc_get_type_abort(private_data, struct test_spoolss_context);
3988 struct dcerpc_pipe *p = ctx->spoolss_pipe;
3989 struct dcerpc_binding_handle *b = p->binding_handle;
3990 const char *list[] = {
3991 "W3SvcInstalled",
3992 "BeepEnabled",
3993 "EventLog",
3994 /* "NetPopup", not on w2k8 */
3995 /* "NetPopupToComputer", not on w2k8 */
3996 "MajorVersion",
3997 "MinorVersion",
3998 "DefaultSpoolDirectory",
3999 "Architecture",
4000 "DsPresent",
4001 "OSVersion",
4002 /* "OSVersionEx", not on s3 */
4003 "DNSMachineName"
4004 };
4005 int i;
4006
4007 for (i=0; i < ARRAY_SIZE(list); i++) {
4008 enum winreg_Type type, type_ex;
4009 uint8_t *data, *data_ex;
4010 uint32_t needed, needed_ex;
4011
4012 torture_assert(tctx, test_GetPrinterData(tctx, b, &ctx->server_handle, list[i], &type, &data, &needed),
4013 talloc_asprintf(tctx, "GetPrinterData failed on %s\n", list[i]));
4014 torture_assert(tctx, test_GetPrinterDataEx(tctx, p, &ctx->server_handle, "random_string", list[i], &type_ex, &data_ex, &needed_ex),
4015 talloc_asprintf(tctx, "GetPrinterDataEx failed on %s\n", list[i]));
4016 torture_assert_int_equal(tctx, type, type_ex, "type mismatch");
4017 torture_assert_int_equal(tctx, needed, needed_ex, "needed mismatch");
4018 torture_assert_mem_equal(tctx, data, data_ex, needed, "data mismatch");
4019 }
4020
4021 return true;
4022 }
4023
4024 static bool test_EnumPrinterData(struct torture_context *tctx,
4025 struct dcerpc_pipe *p,
4026 struct policy_handle *handle,
4027 uint32_t enum_index,
4028 uint32_t value_offered,
4029 uint32_t data_offered,
4030 enum winreg_Type *type_p,
4031 uint32_t *value_needed_p,
4032 uint32_t *data_needed_p,
4033 const char **value_name_p,
4034 uint8_t **data_p,
4035 WERROR *result_p)
4036 {
4037 struct spoolss_EnumPrinterData r;
4038 uint32_t data_needed;
4039 uint32_t value_needed;
4040 enum winreg_Type type;
4041 struct dcerpc_binding_handle *b = p->binding_handle;
4042
4043 r.in.handle = handle;
4044 r.in.enum_index = enum_index;
4045 r.in.value_offered = value_offered;
4046 r.in.data_offered = data_offered;
4047 r.out.data_needed = &data_needed;
4048 r.out.value_needed = &value_needed;
4049 r.out.type = &type;
4050 r.out.data = talloc_zero_array(tctx, uint8_t, r.in.data_offered);
4051 r.out.value_name = talloc_zero_array(tctx, const char, r.in.value_offered);
4052
4053 torture_comment(tctx, "Testing EnumPrinterData(%d)\n", enum_index);
4054
4055 torture_assert_ntstatus_ok(tctx,
4056 dcerpc_spoolss_EnumPrinterData_r(b, tctx, &r),
4057 "EnumPrinterData failed");
4058
4059 if (type_p) {
4060 *type_p = type;
4061 }
4062 if (value_needed_p) {
4063 *value_needed_p = value_needed;
4064 }
4065 if (data_needed_p) {
4066 *data_needed_p = data_needed;
4067 }
4068 if (value_name_p) {
4069 *value_name_p = r.out.value_name;
4070 }
4071 if (data_p) {
4072 *data_p = r.out.data;
4073 }
4074 if (result_p) {
4075 *result_p = r.out.result;
4076 }
4077
4078 return true;
4079 }
4080
4081
4082 static bool test_EnumPrinterData_all(struct torture_context *tctx,
4083 struct dcerpc_pipe *p,
4084 struct policy_handle *handle)
4085 {
4086 uint32_t enum_index = 0;
4087 enum winreg_Type type;
4088 uint32_t value_needed;
4089 uint32_t data_needed;
4090 uint8_t *data;
4091 const char *value_name;
4092 WERROR result;
4093
4094 torture_comment(tctx, "Testing EnumPrinterData\n");
4095
4096 do {
4097 torture_assert(tctx,
4098 test_EnumPrinterData(tctx, p, handle, enum_index, 0, 0,
4099 &type, &value_needed, &data_needed,
4100 &value_name, &data, &result),
4101 "EnumPrinterData failed");
4102
4103 if (W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS)) {
4104 break;
4105 }
4106
4107 torture_assert(tctx,
4108 test_EnumPrinterData(tctx, p, handle, enum_index, value_needed, data_needed,
4109 &type, &value_needed, &data_needed,
4110 &value_name, &data, &result),
4111 "EnumPrinterData failed");
4112
4113 if (W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS)) {
4114 break;
4115 }
4116
4117 enum_index++;
4118
4119 } while (W_ERROR_IS_OK(result));
4120
4121 torture_comment(tctx, "EnumPrinterData test succeeded\n");
4122
4123 return true;
4124 }
4125
4126 static bool test_EnumPrinterDataEx(struct torture_context *tctx,
4127 struct dcerpc_binding_handle *b,
4128 struct policy_handle *handle,
4129 const char *key_name,
4130 uint32_t *count_p,
4131 struct spoolss_PrinterEnumValues **info_p)
4132 {
4133 struct spoolss_EnumPrinterDataEx r;
4134 struct spoolss_PrinterEnumValues *info;
4135 uint32_t needed;
4136 uint32_t count;
4137
4138 r.in.handle = handle;
4139 r.in.key_name = key_name;
4140 r.in.offered = 0;
4141 r.out.needed = &needed;
4142 r.out.count = &count;
4143 r.out.info = &info;
4144
4145 torture_comment(tctx, "Testing EnumPrinterDataEx(%s)\n", key_name);
4146
4147 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterDataEx_r(b, tctx, &r),
4148 "EnumPrinterDataEx failed");
4149 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
4150 r.in.offered = needed;
4151 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterDataEx_r(b, tctx, &r),
4152 "EnumPrinterDataEx failed");
4153 }
4154
4155 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDataEx failed");
4156
4157 CHECK_NEEDED_SIZE_ENUM(spoolss_EnumPrinterDataEx, info, count, needed, 1);
4158
4159 if (count_p) {
4160 *count_p = count;
4161 }
4162 if (info_p) {
4163 *info_p = info;
4164 }
4165
4166 return true;
4167 }
4168
4169 static bool test_SetPrinterData(struct torture_context *tctx,
4170 struct dcerpc_binding_handle *b,
4171 struct policy_handle *handle,
4172 const char *value_name,
4173 enum winreg_Type type,
4174 uint8_t *data,
4175 uint32_t offered);
4176 static bool test_DeletePrinterData(struct torture_context *tctx,
4177 struct dcerpc_binding_handle *b,
4178 struct policy_handle *handle,
4179 const char *value_name);
4180
4181 static bool test_EnumPrinterData_consistency(struct torture_context *tctx,
4182 struct dcerpc_pipe *p,
4183 struct policy_handle *handle)
4184 {
4185 uint32_t count;
4186 struct spoolss_PrinterEnumValues *info;
4187 int i;
4188 uint32_t value_needed, data_needed;
4189 uint32_t value_offered, data_offered;
4190 WERROR result;
4191 struct dcerpc_binding_handle *b = p->binding_handle;
4192
4193 enum winreg_Type type;
4194 DATA_BLOB blob;
4195
4196 torture_comment(tctx, "Testing EnumPrinterData vs EnumPrinterDataEx consistency\n");
4197
4198 torture_assert(tctx, push_reg_sz(tctx, &blob, "torture_data1"), "");
4199 type = REG_SZ;
4200
4201 torture_assert(tctx,
4202 test_SetPrinterData(tctx, b, handle, "torture_value1", type, blob.data, blob.length),
4203 "SetPrinterData failed");
4204
4205 blob = data_blob_string_const("torture_data2");
4206
4207 torture_assert(tctx,
4208 test_SetPrinterData(tctx, b, handle, "torture_value2", REG_BINARY, blob.data, blob.length),
4209 "SetPrinterData failed");
4210
4211 blob = data_blob_talloc(tctx, NULL, 4);
4212 SIVAL(blob.data, 0, 0x11223344);
4213
4214 torture_assert(tctx,
4215 test_SetPrinterData(tctx, b, handle, "torture_value3", type, blob.data, blob.length),
4216 "SetPrinterData failed");
4217
4218 torture_assert(tctx,
4219 test_EnumPrinterDataEx(tctx, b, handle, "PrinterDriverData", &count, &info),
4220 "failed to call EnumPrinterDataEx");
4221
4222 /* get the max sizes for value and data */
4223
4224 torture_assert(tctx,
4225 test_EnumPrinterData(tctx, p, handle, 0, 0, 0,
4226 NULL, &value_needed, &data_needed,
4227 NULL, NULL, &result),
4228 "EnumPrinterData failed");
4229 torture_assert_werr_ok(tctx, result, "unexpected result");
4230
4231 /* check if the reply from the EnumPrinterData really matches max values */
4232
4233 for (i=0; i < count; i++) {
4234 if (info[i].value_name_len > value_needed) {
4235 torture_fail(tctx,
4236 talloc_asprintf(tctx,
4237 "EnumPrinterDataEx gave a reply with value length %d which is larger then expected max value length %d from EnumPrinterData",
4238 info[i].value_name_len, value_needed));
4239 }
4240 if (info[i].data_length > data_needed) {
4241 torture_fail(tctx,
4242 talloc_asprintf(tctx,
4243 "EnumPrinterDataEx gave a reply with data length %d which is larger then expected max data length %d from EnumPrinterData",
4244 info[i].data_length, data_needed));
4245 }
4246 }
4247
4248 /* assuming that both EnumPrinterData and EnumPrinterDataEx do either
4249 * sort or not sort the replies by value name, we should be able to do
4250 * the following entry comparison */
4251
4252 data_offered = data_needed;
4253 value_offered = value_needed;
4254
4255 for (i=0; i < count; i++) {
4256
4257 const char *value_name;
4258 uint8_t *data;
4259
4260 torture_assert(tctx,
4261 test_EnumPrinterData(tctx, p, handle, i, value_offered, data_offered,
4262 &type, &value_needed, &data_needed,
4263 &value_name, &data, &result),
4264 "EnumPrinterData failed");
4265
4266 if (i -1 == count) {
4267 torture_assert_werr_equal(tctx, result, WERR_NO_MORE_ITEMS,
4268 "unexpected result");
4269 break;
4270 } else {
4271 torture_assert_werr_ok(tctx, result, "unexpected result");
4272 }
4273
4274 torture_assert_int_equal(tctx, type, info[i].type, "type mismatch");
4275 torture_assert_int_equal(tctx, value_needed, info[i].value_name_len, "value name length mismatch");
4276 torture_assert_str_equal(tctx, value_name, info[i].value_name, "value name mismatch");
4277 torture_assert_int_equal(tctx, data_needed, info[i].data_length, "data length mismatch");
4278 torture_assert_mem_equal(tctx, data, info[i].data->data, info[i].data_length, "data mismatch");
4279 }
4280
4281 torture_assert(tctx,
4282 test_DeletePrinterData(tctx, b, handle, "torture_value1"),
4283 "DeletePrinterData failed");
4284 torture_assert(tctx,
4285 test_DeletePrinterData(tctx, b, handle, "torture_value2"),
4286 "DeletePrinterData failed");
4287 torture_assert(tctx,
4288 test_DeletePrinterData(tctx, b, handle, "torture_value3"),
4289 "DeletePrinterData failed");
4290
4291 torture_comment(tctx, "EnumPrinterData vs EnumPrinterDataEx consistency test succeeded\n\n");
4292
4293 return true;
4294 }
4295
4296 static bool test_DeletePrinterData(struct torture_context *tctx,
4297 struct dcerpc_binding_handle *b,
4298 struct policy_handle *handle,
4299 const char *value_name)
4300 {
4301 NTSTATUS status;
4302 struct spoolss_DeletePrinterData r;
4303
4304 r.in.handle = handle;
4305 r.in.value_name = value_name;
4306
4307 torture_comment(tctx, "Testing DeletePrinterData(%s)\n",
4308 r.in.value_name);
4309
4310 status = dcerpc_spoolss_DeletePrinterData_r(b, tctx, &r);
4311
4312 torture_assert_ntstatus_ok(tctx, status, "DeletePrinterData failed");
4313 torture_assert_werr_ok(tctx, r.out.result, "DeletePrinterData failed");
4314
4315 return true;
4316 }
4317
4318 static bool test_DeletePrinterDataEx(struct torture_context *tctx,
4319 struct dcerpc_binding_handle *b,
4320 struct policy_handle *handle,
4321 const char *key_name,
4322 const char *value_name)
4323 {
4324 struct spoolss_DeletePrinterDataEx r;
4325
4326 r.in.handle = handle;
4327 r.in.key_name = key_name;
4328 r.in.value_name = value_name;
4329
4330 torture_comment(tctx, "Testing DeletePrinterDataEx(%s - %s)\n",
4331 r.in.key_name, r.in.value_name);
4332
4333 torture_assert_ntstatus_ok(tctx,
4334 dcerpc_spoolss_DeletePrinterDataEx_r(b, tctx, &r),
4335 "DeletePrinterDataEx failed");
4336 torture_assert_werr_ok(tctx, r.out.result,
4337 "DeletePrinterDataEx failed");
4338
4339 return true;
4340 }
4341
4342 static bool test_DeletePrinterKey(struct torture_context *tctx,
4343 struct dcerpc_binding_handle *b,
4344 struct policy_handle *handle,
4345 const char *key_name)
4346 {
4347 struct spoolss_DeletePrinterKey r;
4348
4349 r.in.handle = handle;
4350 r.in.key_name = key_name;
4351
4352 torture_comment(tctx, "Testing DeletePrinterKey(%s)\n", r.in.key_name);
4353
4354 if (strequal(key_name, "") && !torture_setting_bool(tctx, "dangerous", false)) {
4355 torture_skip(tctx, "not wiping out printer registry - enable dangerous tests to use\n");
4356 return true;
4357 }
4358
4359 torture_assert_ntstatus_ok(tctx,
4360 dcerpc_spoolss_DeletePrinterKey_r(b, tctx, &r),
4361 "DeletePrinterKey failed");
4362 torture_assert_werr_ok(tctx, r.out.result,
4363 "DeletePrinterKey failed");
4364
4365 return true;
4366 }
4367
4368 static bool test_winreg_OpenHKLM(struct torture_context *tctx,
4369 struct dcerpc_binding_handle *b,
4370 struct policy_handle *handle)
4371 {
4372 struct winreg_OpenHKLM r;
4373
4374 r.in.system_name = NULL;
4375 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
4376 r.out.handle = handle;
4377
4378 torture_comment(tctx, "Testing winreg_OpenHKLM\n");
4379
4380 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_OpenHKLM_r(b, tctx, &r), "OpenHKLM failed");
4381 torture_assert_werr_ok(tctx, r.out.result, "OpenHKLM failed");
4382
4383 return true;
4384 }
4385
4386 static void init_winreg_String(struct winreg_String *name, const char *s)
4387 {
4388 name->name = s;
4389 if (s) {
4390 name->name_len = 2 * (strlen_m(s) + 1);
4391 name->name_size = name->name_len;
4392 } else {
4393 name->name_len = 0;
4394 name->name_size = 0;
4395 }
4396 }
4397
4398 static bool test_winreg_OpenKey_opts(struct torture_context *tctx,
4399 struct dcerpc_binding_handle *b,
4400 struct policy_handle *hive_handle,
4401 const char *keyname,
4402 uint32_t options,
4403 struct policy_handle *key_handle)
4404 {
4405 struct winreg_OpenKey r;
4406
4407 r.in.parent_handle = hive_handle;
4408 init_winreg_String(&r.in.keyname, keyname);
4409 r.in.options = options;
4410 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
4411 r.out.handle = key_handle;
4412
4413 torture_comment(tctx, "Testing winreg_OpenKey(%s)\n", keyname);
4414
4415 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_OpenKey_r(b, tctx, &r), "OpenKey failed");
4416 torture_assert_werr_ok(tctx, r.out.result, "OpenKey failed");
4417
4418 return true;
4419 }
4420
4421 static bool test_winreg_OpenKey(struct torture_context *tctx,
4422 struct dcerpc_binding_handle *b,
4423 struct policy_handle *hive_handle,
4424 const char *keyname,
4425 struct policy_handle *key_handle)
4426 {
4427 return test_winreg_OpenKey_opts(tctx, b, hive_handle, keyname,
4428 REG_OPTION_NON_VOLATILE, key_handle);
4429 }
4430
4431 static bool test_winreg_CloseKey(struct torture_context *tctx,
4432 struct dcerpc_binding_handle *b,
4433 struct policy_handle *handle)
4434 {
4435 struct winreg_CloseKey r;
4436
4437 r.in.handle = handle;
4438 r.out.handle = handle;
4439
4440 torture_comment(tctx, "Testing winreg_CloseKey\n");
4441
4442 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_CloseKey_r(b, tctx, &r), "CloseKey failed");
4443 torture_assert_werr_ok(tctx, r.out.result, "CloseKey failed");
4444
4445 return true;
4446 }
4447
4448 bool test_winreg_QueryValue(struct torture_context *tctx,
4449 struct dcerpc_binding_handle *b,
4450 struct policy_handle *handle,
4451 const char *value_name,
4452 enum winreg_Type *type_p,
4453 uint32_t *data_size_p,
4454 uint32_t *data_length_p,
4455 uint8_t **data_p)
4456 {
4457 struct winreg_QueryValue r;
4458 enum winreg_Type type = REG_NONE;
4459 uint32_t data_size = 0;
4460 uint32_t data_length = 0;
4461 struct winreg_String valuename;
4462 uint8_t *data = NULL;
4463
4464 init_winreg_String(&valuename, value_name);
4465
4466 data = talloc_zero_array(tctx, uint8_t, 0);
4467
4468 r.in.handle = handle;
4469 r.in.value_name = &valuename;
4470 r.in.type = &type;
4471 r.in.data_size = &data_size;
4472 r.in.data_length = &data_length;
4473 r.in.data = data;
4474 r.out.type = &type;
4475 r.out.data = data;
4476 r.out.data_size = &data_size;
4477 r.out.data_length = &data_length;
4478
4479 torture_comment(tctx, "Testing winreg_QueryValue(%s)\n", value_name);
4480
4481 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue_r(b, tctx, &r), "QueryValue failed");
4482 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
4483 *r.in.data_size = *r.out.data_size;
4484 data = talloc_zero_array(tctx, uint8_t, *r.in.data_size);
4485 r.in.data = data;
4486 r.out.data = data;
4487 torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue_r(b, tctx, &r), "QueryValue failed");
4488 }
4489 torture_assert_werr_ok(tctx, r.out.result, "QueryValue failed");
4490
4491 if (type_p) {
4492 *type_p = *r.out.type;
4493 }
4494 if (data_size_p) {
4495 *data_size_p = *r.out.data_size;
4496 }
4497 if (data_length_p) {
4498 *data_length_p = *r.out.data_length;
4499 }
4500 if (data_p) {
4501 *data_p = r.out.data;
4502 }
4503
4504 return true;
4505 }
4506
4507 static bool test_winreg_query_printerdata(struct torture_context *tctx,
4508 struct dcerpc_binding_handle *b,
4509 struct policy_handle *handle,
4510 const char *printer_name,
4511 const char *key_name,
4512 const char *value_name,
4513 enum winreg_Type *w_type,
4514 uint32_t *w_size,
4515 uint32_t *w_length,
4516 uint8_t **w_data)
4517 {
4518 const char *printer_key;
4519 struct policy_handle key_handle;
4520
4521 printer_key = talloc_asprintf(tctx, "%s\\%s\\%s",
4522 TOP_LEVEL_PRINT_PRINTERS_KEY, printer_name, key_name);
4523
4524 torture_assert(tctx,
4525 test_winreg_OpenKey(tctx, b, handle, printer_key, &key_handle), "");
4526
4527 torture_assert(tctx,
4528 test_winreg_QueryValue(tctx, b, &key_handle, value_name, w_type, w_size, w_length, w_data), "");
4529
4530 torture_assert(tctx,
4531 test_winreg_CloseKey(tctx, b, &key_handle), "");
4532
4533 return true;
4534 }
4535
4536 static bool test_GetForm_winreg(struct torture_context *tctx,
4537 struct dcerpc_binding_handle *b,
4538 struct policy_handle *handle,
4539 const char *key_name,
4540 const char *form_name,
4541 enum winreg_Type *w_type,
4542 uint32_t *w_size,
4543 uint32_t *w_length,
4544 uint8_t **w_data)
4545 {
4546 struct policy_handle key_handle;
4547
4548 torture_assert(tctx,
4549 test_winreg_OpenKey(tctx, b, handle, key_name, &key_handle), "");
4550
4551 torture_assert(tctx,
4552 test_winreg_QueryValue(tctx, b, &key_handle, form_name, w_type, w_size, w_length, w_data), "");
4553
4554 torture_assert(tctx,
4555 test_winreg_CloseKey(tctx, b, &key_handle), "");
4556
4557 return true;
4558 }
4559
4560 static bool test_winreg_symbolic_link(struct torture_context *tctx,
4561 struct dcerpc_binding_handle *b,
4562 struct policy_handle *handle,
4563 const char *symlink_keyname,
4564 const char *symlink_destination)
4565 {
4566 /* check if the first key is a symlink to the second key */
4567
4568 enum winreg_Type w_type;
4569 uint32_t w_size;
4570 uint32_t w_length;
4571 uint8_t *w_data;
4572 struct policy_handle key_handle;
4573 DATA_BLOB blob;
4574 const char *str;
4575
4576 if (torture_setting_bool(tctx, "samba3", false)) {
4577 torture_skip(tctx, "skip winreg symlink test against samba");
4578 }
4579
4580 torture_assert(tctx,
4581 test_winreg_OpenKey_opts(tctx, b, handle, symlink_keyname, REG_OPTION_OPEN_LINK, &key_handle),
4582 "failed to open key link");
4583
4584 torture_assert(tctx,
4585 test_winreg_QueryValue(tctx, b, &key_handle,
4586 "SymbolicLinkValue",
4587 &w_type, &w_size, &w_length, &w_data),
4588 "failed to query for 'SymbolicLinkValue' attribute");
4589
4590 torture_assert_int_equal(tctx, w_type, REG_LINK, "unexpected type");
4591
4592 blob = data_blob(w_data, w_size);
4593 str = reg_val_data_string(tctx, REG_SZ, blob);
4594
4595 torture_assert_str_equal(tctx, str, symlink_destination, "unexpected symlink target string");
4596
4597 torture_assert(tctx,
4598 test_winreg_CloseKey(tctx, b, &key_handle),
4599 "failed to close key link");
4600
4601 return true;
4602 }
4603
4604 static const char *strip_unc(const char *unc)
4605 {
4606 char *name;
4607
4608 if (!unc) {
4609 return NULL;
4610 }
4611
4612 if (unc[0] == '\\' && unc[1] == '\\') {
4613 unc +=2;
4614 }
4615
4616 name = strchr(unc, '\\');
4617 if (name) {
4618 return name+1;
4619 }
4620
4621 return unc;
4622 }
4623
4624 static bool test_GetPrinterInfo_winreg(struct torture_context *tctx,
4625 struct dcerpc_binding_handle *b,
4626 struct policy_handle *handle,
4627 const char *printer_name,
4628 struct dcerpc_binding_handle *winreg_handle,
4629 struct policy_handle *hive_handle)
4630 {
4631 union spoolss_PrinterInfo info;
4632 const char *keys[] = {
4633 TOP_LEVEL_CONTROL_PRINTERS_KEY,
4634 TOP_LEVEL_PRINT_PRINTERS_KEY
4635 };
4636 int i;
4637 const char *printername, *sharename;
4638
4639 torture_comment(tctx, "Testing Printer Info and winreg consistency\n");
4640
4641 torture_assert(tctx,
4642 test_GetPrinter_level(tctx, b, handle, 2, &info),
4643 "failed to get printer info level 2");
4644
4645 printername = strip_unc(info.info2.printername);
4646 sharename = strip_unc(info.info2.sharename);
4647
4648 #define test_sz(wname, iname) \
4649 do {\
4650 DATA_BLOB blob;\
4651 const char *str;\
4652 enum winreg_Type w_type;\
4653 uint32_t w_size;\
4654 uint32_t w_length;\
4655 uint8_t *w_data;\
4656 torture_assert(tctx,\
4657 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4658 &w_type, &w_size, &w_length, &w_data),\
4659 "failed to query winreg");\
4660 torture_assert_int_equal(tctx, w_type, REG_SZ, "unexpected type");\
4661 blob = data_blob(w_data, w_size);\
4662 str = reg_val_data_string(tctx, REG_SZ, blob);\
4663 if (w_size == 2 && iname == NULL) {\
4664 /*torture_comment(tctx, "%s: \"\", %s: (null)\n", #wname, #iname);\ */\
4665 } else {\
4666 torture_assert_str_equal(tctx, str, iname,\
4667 talloc_asprintf(tctx, "%s - %s mismatch", #wname, #iname));\
4668 }\
4669 } while(0);
4670
4671 #define test_dword(wname, iname) \
4672 do {\
4673 uint32_t value;\
4674 enum winreg_Type w_type;\
4675 uint32_t w_size;\
4676 uint32_t w_length;\
4677 uint8_t *w_data;\
4678 torture_assert(tctx,\
4679 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4680 &w_type, &w_size, &w_length, &w_data),\
4681 "failed to query winreg");\
4682 torture_assert_int_equal(tctx, w_type, REG_DWORD, "unexpected type");\
4683 torture_assert_int_equal(tctx, w_size, 4, "unexpected size");\
4684 torture_assert_int_equal(tctx, w_length, 4, "unexpected length");\
4685 value = IVAL(w_data, 0);\
4686 torture_assert_int_equal(tctx, value, iname,\
4687 talloc_asprintf(tctx, "%s - %s mismatch", #wname, #iname));\
4688 } while(0);
4689
4690 #define test_binary(wname, iname) \
4691 do {\
4692 enum winreg_Type w_type;\
4693 uint32_t w_size;\
4694 uint32_t w_length;\
4695 uint8_t *w_data;\
4696 torture_assert(tctx,\
4697 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4698 &w_type, &w_size, &w_length, &w_data),\
4699 "failed to query winreg");\
4700 torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");\
4701 torture_assert_int_equal(tctx, w_size, iname.length, "unexpected length");\
4702 torture_assert_mem_equal(tctx, w_data, iname.data, w_size, \
4703 "binary unequal");\
4704 } while(0);
4705
4706
4707 #define test_dm(wname, iname) \
4708 do {\
4709 DATA_BLOB blob;\
4710 struct spoolss_DeviceMode dm;\
4711 enum ndr_err_code ndr_err;\
4712 enum winreg_Type w_type;\
4713 uint32_t w_size;\
4714 uint32_t w_length;\
4715 uint8_t *w_data;\
4716 torture_assert(tctx,\
4717 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4718 &w_type, &w_size, &w_length, &w_data),\
4719 "failed to query winreg");\
4720 torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");\
4721 blob = data_blob(w_data, w_size);\
4722 ndr_err = ndr_pull_struct_blob(&blob, tctx, &dm,\
4723 (ndr_pull_flags_fn_t)ndr_pull_spoolss_DeviceMode);\
4724 torture_assert_ndr_success(tctx, ndr_err, "failed to unmarshall dm");\
4725 torture_assert(tctx, test_devicemode_equal(tctx, &dm, iname),\
4726 "dm unequal");\
4727 } while(0);
4728
4729 #define test_sd(wname, iname) \
4730 do {\
4731 DATA_BLOB blob;\
4732 struct security_descriptor sd;\
4733 enum ndr_err_code ndr_err;\
4734 enum winreg_Type w_type;\
4735 uint32_t w_size;\
4736 uint32_t w_length;\
4737 uint8_t *w_data;\
4738 torture_assert(tctx,\
4739 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4740 &w_type, &w_size, &w_length, &w_data),\
4741 "failed to query winreg");\
4742 torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");\
4743 blob = data_blob(w_data, w_size);\
4744 ndr_err = ndr_pull_struct_blob(&blob, tctx, &sd,\
4745 (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);\
4746 torture_assert_ndr_success(tctx, ndr_err, "failed to unmarshall sd");\
4747 torture_assert(tctx, test_security_descriptor_equal(tctx, &sd, iname),\
4748 "sd unequal");\
4749 } while(0);
4750
4751 #define test_multi_sz(wname, iname) \
4752 do {\
4753 DATA_BLOB blob;\
4754 const char **array;\
4755 enum winreg_Type w_type;\
4756 uint32_t w_size;\
4757 uint32_t w_length;\
4758 uint8_t *w_data;\
4759 int i;\
4760 torture_assert(tctx,\
4761 test_winreg_QueryValue(tctx, winreg_handle, &key_handle, wname,\
4762 &w_type, &w_size, &w_length, &w_data),\
4763 "failed to query winreg");\
4764 torture_assert_int_equal(tctx, w_type, REG_MULTI_SZ, "unexpected type");\
4765 blob = data_blob(w_data, w_size);\
4766 torture_assert(tctx, \
4767 pull_reg_multi_sz(tctx, &blob, &array),\
4768 "failed to pull multi sz");\
4769 for (i=0; array[i] != NULL; i++) {\
4770 torture_assert_str_equal(tctx, array[i], iname[i],\
4771 talloc_asprintf(tctx, "%s - %s mismatch", #wname, iname[i]));\
4772 }\
4773 } while(0);
4774
4775 if (!test_winreg_symbolic_link(tctx, winreg_handle, hive_handle,
4776 TOP_LEVEL_CONTROL_PRINTERS_KEY,
4777 "\\Registry\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Print\\Printers"))
4778 {
4779 torture_warning(tctx, "failed to check for winreg symlink");
4780 }
4781
4782 for (i=0; i < ARRAY_SIZE(keys); i++) {
4783
4784 const char *printer_key;
4785 struct policy_handle key_handle;
4786
4787 printer_key = talloc_asprintf(tctx, "%s\\%s",
4788 keys[i], printer_name);
4789
4790 torture_assert(tctx,
4791 test_winreg_OpenKey(tctx, winreg_handle, hive_handle, printer_key, &key_handle), "");
4792
4793 test_sz("Name", printername);
4794 test_sz("Share Name", sharename);
4795 test_sz("Port", info.info2.portname);
4796 test_sz("Printer Driver", info.info2.drivername);
4797 test_sz("Description", info.info2.comment);
4798 test_sz("Location", info.info2.location);
4799 test_sz("Separator File", info.info2.sepfile);
4800 test_sz("Print Processor", info.info2.printprocessor);
4801 test_sz("Datatype", info.info2.datatype);
4802 test_sz("Parameters", info.info2.parameters);
4803 /* winreg: 0, spoolss not */
4804 /* test_dword("Attributes", info.info2.attributes); */
4805 test_dword("Priority", info.info2.priority);
4806 test_dword("Default Priority", info.info2.defaultpriority);
4807 /* winreg: 60, spoolss: 0 */
4808 /* test_dword("StartTime", info.info2.starttime); */
4809 /* test_dword("UntilTime", info.info2.untiltime); */
4810 /* winreg != spoolss */
4811 /* test_dword("Status", info.info2.status); */
4812 test_dm("Default DevMode", info.info2.devmode);
4813 test_sd("Security", info.info2.secdesc);
4814
4815 torture_assert(tctx,
4816 test_winreg_CloseKey(tctx, winreg_handle, &key_handle), "");
4817 }
4818
4819 #undef test_dm
4820 #undef test_sd
4821
4822 torture_comment(tctx, "Printer Info and winreg consistency test succeeded\n\n");
4823
4824 return true;
4825 }
4826
4827 static bool test_PrintProcessors(struct torture_context *tctx,
4828 struct dcerpc_binding_handle *b,
4829 const char *environment,
4830 struct dcerpc_binding_handle *winreg_handle,
4831 struct policy_handle *hive_handle)
4832 {
4833 union spoolss_PrintProcessorInfo *info;
4834 uint32_t count;
4835 int i;
4836
4837 torture_comment(tctx, "Testing Print Processor Info and winreg consistency\n");
4838
4839 torture_assert(tctx,
4840 test_EnumPrintProcessors_level(tctx, b, environment, 1, &count, &info, WERR_OK),
4841 "failed to enum print processors level 1");
4842
4843 for (i=0; i < count; i++) {
4844
4845 const char *processor_key;
4846 struct policy_handle key_handle;
4847
4848 processor_key = talloc_asprintf(tctx, "%s\\%s\\Print Processors\\%s",
4849 TOP_LEVEL_CONTROL_ENVIRONMENTS_KEY,
4850 environment,
4851 info[i].info1.print_processor_name);
4852
4853 torture_assert(tctx,
4854 test_winreg_OpenKey(tctx, winreg_handle, hive_handle, processor_key, &key_handle), "");
4855
4856 /* nothing to check in there so far */
4857
4858 torture_assert(tctx,
4859 test_winreg_CloseKey(tctx, winreg_handle, &key_handle), "");
4860 }
4861
4862 torture_comment(tctx, "Print Processor Info and winreg consistency test succeeded\n\n");
4863
4864 return true;
4865 }
4866
4867 static bool test_GetPrinterDriver2_level(struct torture_context *tctx,
4868 struct dcerpc_binding_handle *b,
4869 struct policy_handle *handle,
4870 const char *driver_name,
4871 const char *architecture,
4872 uint32_t level,
4873 uint32_t client_major_version,
4874 uint32_t client_minor_version,
4875 union spoolss_DriverInfo *info_p,
4876 WERROR *result);
4877
4878 static const char *strip_path(const char *path)
4879 {
4880 char *p;
4881
4882 if (path == NULL) {
4883 return NULL;
4884 }
4885
4886 p = strrchr(path, '\\');
4887 if (p) {
4888 return p+1;
4889 }
4890
4891 return path;
4892 }
4893
4894 static const char **strip_paths(const char **path_array)
4895 {
4896 int i;
4897
4898 if (path_array == NULL) {
4899 return NULL;
4900 }
4901
4902 for (i=0; path_array[i] != NULL; i++) {
4903 path_array[i] = strip_path(path_array[i]);
4904 }
4905
4906 return path_array;
4907 }
4908
4909 static const char *driver_winreg_date(TALLOC_CTX *mem_ctx, NTTIME nt)
4910 {
4911 time_t t;
4912 struct tm *tm;
4913
4914 if (nt == 0) {
4915 return talloc_strdup(mem_ctx, "01/01/1601");
4916 }
4917
4918 t = nt_time_to_unix(nt);
4919 tm = localtime(&t);
4920
4921 return talloc_asprintf(mem_ctx, "%02d/%02d/%04d",
4922 tm->tm_mon + 1, tm->tm_mday, tm->tm_year + 1900);
4923 }
4924
4925 static const char *driver_winreg_version(TALLOC_CTX *mem_ctx, uint64_t v)
4926 {
4927 return talloc_asprintf(mem_ctx, "%u.%u.%u.%u",
4928 (unsigned)((v >> 48) & 0xFFFF),
4929 (unsigned)((v >> 32) & 0xFFFF),
4930 (unsigned)((v >> 16) & 0xFFFF),
4931 (unsigned)(v & 0xFFFF));
4932 }
4933
4934 static bool test_GetDriverInfo_winreg(struct torture_context *tctx,
4935 struct dcerpc_binding_handle *b,
4936 struct policy_handle *handle,
4937 const char *printer_name,
4938 const char *driver_name,
4939 const char *environment,
4940 enum spoolss_DriverOSVersion version,
4941 struct dcerpc_binding_handle *winreg_handle,
4942 struct policy_handle *hive_handle,
4943 const char *server_name_slash)
4944 {
4945 WERROR result;
4946 union spoolss_DriverInfo info;
4947 const char *driver_key;
4948 struct policy_handle key_handle;
4949
4950 const char *driver_path;
4951 const char *data_file;
4952 const char *config_file;
4953 const char *help_file;
4954 const char **dependent_files;
4955
4956 const char *driver_date;
4957 const char *inbox_driver_date;
4958
4959 const char *driver_version;
4960 const char *inbox_driver_version;
4961
4962 torture_comment(tctx, "Testing Driver Info and winreg consistency\n");
4963
4964 driver_key = talloc_asprintf(tctx, "%s\\%s\\Drivers\\Version-%d\\%s",
4965 TOP_LEVEL_CONTROL_ENVIRONMENTS_KEY,
4966 environment,
4967 version,
4968 driver_name);
4969
4970 torture_assert(tctx,
4971 test_winreg_OpenKey(tctx, winreg_handle, hive_handle, driver_key, &key_handle),
4972 "failed to open driver key");
4973
4974 if (torture_setting_bool(tctx, "samba3", false) ||
4975 torture_setting_bool(tctx, "w2k3", false)) {
4976 goto try_level6;
4977 }
4978
4979 if (handle) {
4980 torture_assert(tctx,
4981 test_GetPrinterDriver2_level(tctx, b, handle, driver_name, environment, 8, version, 0, &info, &result),
4982 "failed to get driver info level 8");
4983 } else {
4984 torture_assert(tctx,
4985 test_EnumPrinterDrivers_findone(tctx, b, server_name_slash, environment, 8, driver_name, &info),
4986 "failed to get driver info level 8");
4987 }
4988
4989 if (W_ERROR_EQUAL(result, WERR_INVALID_LEVEL)) {
4990 goto try_level6;
4991 }
4992
4993 driver_path = strip_path(info.info8.driver_path);
4994 data_file = strip_path(info.info8.data_file);
4995 config_file = strip_path(info.info8.config_file);
4996 help_file = strip_path(info.info8.help_file);
4997 dependent_files = strip_paths(info.info8.dependent_files);
4998
4999 driver_date = driver_winreg_date(tctx, info.info8.driver_date);
5000 inbox_driver_date = driver_winreg_date(tctx, info.info8.min_inbox_driver_ver_date);
5001
5002 driver_version = driver_winreg_version(tctx, info.info8.driver_version);
5003 inbox_driver_version = driver_winreg_version(tctx, info.info8.min_inbox_driver_ver_version);
5004
5005 test_sz("Configuration File", config_file);
5006 test_sz("Data File", data_file);
5007 test_sz("Datatype", info.info8.default_datatype);
5008 test_sz("Driver", driver_path);
5009 test_sz("DriverDate", driver_date);
5010 test_sz("DriverVersion", driver_version);
5011 test_sz("HardwareID", info.info8.hardware_id);
5012 test_sz("Help File", help_file);
5013 test_sz("InfPath", info.info8.inf_path);
5014 test_sz("Manufacturer", info.info8.manufacturer_name);
5015 test_sz("MinInboxDriverVerDate", inbox_driver_date);
5016 test_sz("MinInboxDriverVerVersion", inbox_driver_version);
5017 test_sz("Monitor", info.info8.monitor_name);
5018 test_sz("OEM URL", info.info8.manufacturer_url);
5019 test_sz("Print Processor", info.info8.print_processor);
5020 test_sz("Provider", info.info8.provider);
5021 test_sz("VendorSetup", info.info8.vendor_setup);
5022 test_multi_sz("ColorProfiles", info.info8.color_profiles);
5023 test_multi_sz("Dependent Files", dependent_files);
5024 test_multi_sz("CoreDependencies", info.info8.core_driver_dependencies);
5025 test_multi_sz("Previous Names", info.info8.previous_names);
5026 /* test_dword("Attributes", ?); */
5027 test_dword("PrinterDriverAttributes", info.info8.printer_driver_attributes);
5028 test_dword("Version", info.info8.version);
5029 /* test_dword("TempDir", ?); */
5030
5031 try_level6:
5032
5033 if (handle) {
5034 torture_assert(tctx,
5035 test_GetPrinterDriver2_level(tctx, b, handle, driver_name, environment, 6, version, 0, &info, &result),
5036 "failed to get driver info level 6");
5037 } else {
5038 torture_assert(tctx,
5039 test_EnumPrinterDrivers_findone(tctx, b, server_name_slash, environment, 6, driver_name, &info),
5040 "failed to get driver info level 6");
5041 }
5042
5043 driver_path = strip_path(info.info6.driver_path);
5044 data_file = strip_path(info.info6.data_file);
5045 config_file = strip_path(info.info6.config_file);
5046 help_file = strip_path(info.info6.help_file);
5047 dependent_files = strip_paths(info.info6.dependent_files);
5048
5049 driver_date = driver_winreg_date(tctx, info.info6.driver_date);
5050
5051 driver_version = driver_winreg_version(tctx, info.info6.driver_version);
5052
5053 test_sz("Configuration File", config_file);
5054 test_sz("Data File", data_file);
5055 test_sz("Datatype", info.info6.default_datatype);
5056 test_sz("Driver", driver_path);
5057 if (torture_setting_bool(tctx, "w2k3", false)) {
5058 DATA_BLOB blob = data_blob_talloc_zero(tctx, 8);
5059 push_nttime(blob.data, 0, info.info6.driver_date);
5060 test_binary("DriverDate", blob);
5061 SBVAL(blob.data, 0, info.info6.driver_version);
5062 test_binary("DriverVersion", blob);
5063 } else {
5064 test_sz("DriverDate", driver_date);
5065 test_sz("DriverVersion", driver_version);
5066 }
5067 test_sz("HardwareID", info.info6.hardware_id);
5068 test_sz("Help File", help_file);
5069 test_sz("Manufacturer", info.info6.manufacturer_name);
5070 test_sz("Monitor", info.info6.monitor_name);
5071 test_sz("OEM URL", info.info6.manufacturer_url);
5072 test_sz("Provider", info.info6.provider);
5073 test_multi_sz("Dependent Files", dependent_files);
5074 test_multi_sz("Previous Names", info.info6.previous_names);
5075 /* test_dword("Attributes", ?); */
5076 test_dword("Version", info.info6.version);
5077 /* test_dword("TempDir", ?); */
5078
5079 if (handle) {
5080 torture_assert(tctx,
5081 test_GetPrinterDriver2_level(tctx, b, handle, driver_name, environment, 3, version, 0, &info, &result),
5082 "failed to get driver info level 3");
5083 } else {
5084 torture_assert(tctx,
5085 test_EnumPrinterDrivers_findone(tctx, b, server_name_slash, environment, 3, driver_name, &info),
5086 "failed to get driver info level 3");
5087 }
5088
5089 driver_path = strip_path(info.info3.driver_path);
5090 data_file = strip_path(info.info3.data_file);
5091 config_file = strip_path(info.info3.config_file);
5092 help_file = strip_path(info.info3.help_file);
5093 dependent_files = strip_paths(info.info3.dependent_files);
5094
5095 test_sz("Configuration File", config_file);
5096 test_sz("Data File", data_file);
5097 test_sz("Datatype", info.info3.default_datatype);
5098 test_sz("Driver", driver_path);
5099 test_sz("Help File", help_file);
5100 test_sz("Monitor", info.info3.monitor_name);
5101 test_multi_sz("Dependent Files", dependent_files);
5102 /* test_dword("Attributes", ?); */
5103 test_dword("Version", info.info3.version);
5104 /* test_dword("TempDir", ?); */
5105
5106
5107 torture_assert(tctx,
5108 test_winreg_CloseKey(tctx, winreg_handle, &key_handle), "");
5109
5110 torture_comment(tctx, "Driver Info and winreg consistency test succeeded\n\n");
5111
5112 return true;
5113 }
5114
5115 #undef test_sz
5116 #undef test_dword
5117
5118 static bool test_SetPrinterData(struct torture_context *tctx,
5119 struct dcerpc_binding_handle *b,
5120 struct policy_handle *handle,
5121 const char *value_name,
5122 enum winreg_Type type,
5123 uint8_t *data,
5124 uint32_t offered)
5125 {
5126 struct spoolss_SetPrinterData r;
5127
5128 r.in.handle = handle;
5129 r.in.value_name = value_name;
5130 r.in.type = type;
5131 r.in.data = data;
5132 r.in.offered = offered;
5133
5134 torture_comment(tctx, "Testing SetPrinterData(%s)\n",
5135 r.in.value_name);
5136
5137 torture_assert_ntstatus_ok(tctx,
5138 dcerpc_spoolss_SetPrinterData_r(b, tctx, &r),
5139 "SetPrinterData failed");
5140 torture_assert_werr_ok(tctx, r.out.result,
5141 "SetPrinterData failed");
5142
5143 return true;
5144 }
5145
5146 static bool test_SetPrinterData_matrix(struct torture_context *tctx,
5147 struct dcerpc_binding_handle *b,
5148 struct policy_handle *handle,
5149 const char *printer_name,
5150 struct dcerpc_binding_handle *winreg_handle,
5151 struct policy_handle *hive_handle)
5152 {
5153 const char *values[] = {
5154 "spootyfoot",
5155 "spooty\\foot",
5156 #if 0
5157 /* FIXME: not working with s3 atm. */
5158 "spooty,foot",
5159 "spooty,fo,ot",
5160 #endif
5161 "spooty foot",
5162 #if 0
5163 /* FIXME: not working with s3 atm. */
5164 "spooty\\fo,ot",
5165 "spooty,fo\\ot"
5166 #endif
5167 };
5168 int i;
5169
5170 for (i=0; i < ARRAY_SIZE(values); i++) {
5171
5172 enum winreg_Type type, expected_type = REG_SZ;
5173 DATA_BLOB blob;
5174 uint8_t *data;
5175 uint32_t needed;
5176
5177 torture_assert(tctx, push_reg_sz(tctx, &blob, "dog"), "");
5178 type = REG_SZ;
5179
5180 torture_assert(tctx,
5181 test_SetPrinterData(tctx, b, handle, values[i], REG_SZ, blob.data, blob.length),
5182 "SetPrinterData failed");
5183
5184 torture_assert(tctx,
5185 test_GetPrinterData_checktype(tctx, b, handle, values[i], &expected_type, &type, &data, &needed),
5186 "GetPrinterData failed");
5187
5188 torture_assert_int_equal(tctx, type, REG_SZ, "type mismatch");
5189 torture_assert_int_equal(tctx, needed, blob.length, "size mismatch");
5190 torture_assert_mem_equal(tctx, data, blob.data, blob.length, "buffer mismatch");
5191
5192 if (winreg_handle && hive_handle) {
5193
5194 enum winreg_Type w_type;
5195 uint32_t w_size;
5196 uint32_t w_length;
5197 uint8_t *w_data;
5198
5199 torture_assert(tctx,
5200 test_winreg_query_printerdata(tctx, winreg_handle, hive_handle,
5201 printer_name, "PrinterDriverData", values[i],
5202 &w_type, &w_size, &w_length, &w_data), "");
5203
5204 torture_assert_int_equal(tctx, w_type, REG_SZ, "winreg type mismatch");
5205 torture_assert_int_equal(tctx, w_size, blob.length, "winreg size mismatch");
5206 torture_assert_int_equal(tctx, w_length, blob.length, "winreg length mismatch");
5207 torture_assert_mem_equal(tctx, w_data, blob.data, blob.length, "winreg buffer mismatch");
5208 }
5209
5210 torture_assert(tctx,
5211 test_DeletePrinterData(tctx, b, handle, values[i]),
5212 "DeletePrinterData failed");
5213 }
5214
5215 return true;
5216 }
5217
5218
5219 static bool test_EnumPrinterKey(struct torture_context *tctx,
5220 struct dcerpc_binding_handle *b,
5221 struct policy_handle *handle,
5222 const char *key_name,
5223 const char ***array);
5224
5225 static bool test_SetPrinterDataEx(struct torture_context *tctx,
5226 struct dcerpc_binding_handle *b,
5227 struct policy_handle *handle,
5228 const char *key_name,
5229 const char *value_name,
5230 enum winreg_Type type,
5231 uint8_t *data,
5232 uint32_t offered)
5233 {
5234 NTSTATUS status;
5235 struct spoolss_SetPrinterDataEx r;
5236
5237 r.in.handle = handle;
5238 r.in.key_name = key_name;
5239 r.in.value_name = value_name;
5240 r.in.type = type;
5241 r.in.data = data;
5242 r.in.offered = offered;
5243
5244 torture_comment(tctx, "Testing SetPrinterDataEx(%s - %s) type: %s, offered: 0x%08x\n",
5245 r.in.key_name, r.in.value_name, str_regtype(r.in.type), r.in.offered);
5246
5247 status = dcerpc_spoolss_SetPrinterDataEx_r(b, tctx, &r);
5248
5249 torture_assert_ntstatus_ok(tctx, status, "SetPrinterDataEx failed");
5250 torture_assert_werr_ok(tctx, r.out.result, "SetPrinterDataEx failed");
5251
5252 return true;
5253 }
5254
5255 static bool test_SetPrinterDataEx_keys(struct torture_context *tctx,
5256 struct dcerpc_pipe *p,
5257 struct policy_handle *handle)
5258 {
5259 struct dcerpc_binding_handle *b = p->binding_handle;
5260 const char *value_name = "dog";
5261 const char *keys[] = {
5262 "torturedataex",
5263 "torture data ex",
5264 "torturedataex_with_subkey\\subkey",
5265 "torturedataex_with_subkey\\subkey:0",
5266 "torturedataex_with_subkey\\subkey:1",
5267 "torturedataex_with_subkey\\subkey\\subsubkey",
5268 "torturedataex_with_subkey\\subkey\\subsubkey:0",
5269 "torturedataex_with_subkey\\subkey\\subsubkey:1",
5270 "torture,data",
5271 "torture,data,ex",
5272 "torture,data\\ex",
5273 "torture\\data,ex",
5274 "torture/data",
5275 "torture/data ex",
5276 "torture/data ex/sub",
5277 "torture//data",
5278 "torture//data ex",
5279 "torture//data ex/sub",
5280 "torture//data ex//sub",
5281 };
5282 int i;
5283
5284 for (i=0; i < ARRAY_SIZE(keys); i++) {
5285
5286 char *c;
5287 const char *key;
5288 enum winreg_Type type;
5289 DATA_BLOB blob_in, blob_out;
5290 const char **subkeys;
5291 uint32_t ecount;
5292 struct spoolss_PrinterEnumValues *einfo;
5293 uint32_t needed;
5294
5295 blob_in = data_blob_talloc(tctx, NULL, 42);
5296
5297 generate_random_buffer(blob_in.data, blob_in.length);
5298
5299 torture_assert(tctx,
5300 test_SetPrinterDataEx(tctx, b, handle, keys[i], value_name, REG_BINARY, blob_in.data, blob_in.length),
5301 "failed to call SetPrinterDataEx");
5302
5303 torture_assert(tctx,
5304 test_GetPrinterDataEx(tctx, p, handle, keys[i], value_name, &type, &blob_out.data, &needed),
5305 "failed to call GetPrinterDataEx");
5306
5307 blob_out.length = needed;
5308 torture_assert(tctx,
5309 test_EnumPrinterDataEx(tctx, b, handle, keys[i], &ecount, &einfo),
5310 "failed to call EnumPrinterDataEx");
5311
5312 torture_assert_int_equal(tctx, type, REG_BINARY, "type mismatch");
5313 torture_assert_int_equal(tctx, blob_out.length, blob_in.length, "size mismatch");
5314 torture_assert_mem_equal(tctx, blob_out.data, blob_in.data, blob_in.length, "buffer mismatch");
5315
5316 torture_assert_int_equal(tctx, ecount, 1, "unexpected enum count");
5317 torture_assert_str_equal(tctx, einfo[0].value_name, value_name, "value_name mismatch");
5318 torture_assert_int_equal(tctx, einfo[0].value_name_len, strlen_m_term(value_name)*2, "unexpected value_name_len");
5319 torture_assert_int_equal(tctx, einfo[0].type, REG_BINARY, "type mismatch");
5320 torture_assert_int_equal(tctx, einfo[0].data_length, blob_in.length, "size mismatch");
5321 if (einfo[0].data_length > 0) {
5322 torture_assert_mem_equal(tctx, einfo[0].data->data, blob_in.data, blob_in.length, "buffer mismatch");
5323 }
5324
5325 key = talloc_strdup(tctx, keys[i]);
5326
5327 if (!test_DeletePrinterDataEx(tctx, b, handle, keys[i], value_name)) {
5328 return false;
5329 }
5330
5331 c = strchr(key, '\\');
5332 if (c) {
5333 int k;
5334
5335 /* we have subkeys */
5336
5337 *c = 0;
5338
5339 if (!test_EnumPrinterKey(tctx, b, handle, key, &subkeys)) {
5340 return false;
5341 }
5342
5343 for (k=0; subkeys && subkeys[k]; k++) {
5344
5345 const char *current_key = talloc_asprintf(tctx, "%s\\%s", key, subkeys[k]);
5346
5347 if (!test_DeletePrinterKey(tctx, b, handle, current_key)) {
5348 return false;
5349 }
5350 }
5351
5352 if (!test_DeletePrinterKey(tctx, b, handle, key)) {
5353 return false;
5354 }
5355
5356 } else {
5357 if (!test_DeletePrinterKey(tctx, b, handle, key)) {
5358 return false;
5359 }
5360 }
5361 }
5362
5363 return true;
5364 }
5365
5366 static bool test_SetPrinterDataEx_values(struct torture_context *tctx,
5367 struct dcerpc_pipe *p,
5368 struct policy_handle *handle)
5369 {
5370 struct dcerpc_binding_handle *b = p->binding_handle;
5371 const char *key = "torturedataex";
5372 const char *values[] = {
5373 "torture_value",
5374 "torture value",
5375 "torture,value",
5376 "torture/value",
5377 "torture\\value",
5378 "torture\\\\value"
5379 };
5380 int i;
5381
5382 for (i=0; i < ARRAY_SIZE(values); i++) {
5383
5384 enum winreg_Type type;
5385 DATA_BLOB blob_in, blob_out;
5386 uint32_t ecount;
5387 struct spoolss_PrinterEnumValues *einfo;
5388 uint32_t needed;
5389
5390 if (torture_setting_bool(tctx, "samba3", false)) {
5391 char *q;
5392 q = strrchr(values[i], ',');
5393 if (q) {
5394 torture_comment(tctx, "skipping valuename '%s' including ',' character against Samba3\n",
5395 values[i]);
5396 continue;
5397 }
5398 }
5399
5400 blob_in = data_blob_talloc(tctx, NULL, 42);
5401
5402 generate_random_buffer(blob_in.data, blob_in.length);
5403
5404 torture_assert(tctx,
5405 test_SetPrinterDataEx(tctx, b, handle, key, values[i], REG_BINARY, blob_in.data, blob_in.length),
5406 "failed to call SetPrinterDataEx");
5407
5408 torture_assert(tctx,
5409 test_GetPrinterDataEx(tctx, p, handle, key, values[i], &type, &blob_out.data, &needed),
5410 "failed to call GetPrinterDataEx");
5411
5412 blob_out.length = needed;
5413 torture_assert(tctx,
5414 test_EnumPrinterDataEx(tctx, b, handle, key, &ecount, &einfo),
5415 "failed to call EnumPrinterDataEx");
5416
5417 torture_assert_int_equal(tctx, type, REG_BINARY, "type mismatch");
5418 torture_assert_int_equal(tctx, blob_out.length, blob_in.length, "size mismatch");
5419 torture_assert_mem_equal(tctx, blob_out.data, blob_in.data, blob_in.length, "buffer mismatch");
5420
5421 torture_assert_int_equal(tctx, ecount, 1, "unexpected enum count");
5422 torture_assert_str_equal(tctx, einfo[0].value_name, values[i], "value_name mismatch");
5423 torture_assert_int_equal(tctx, einfo[0].value_name_len, strlen_m_term(values[i])*2, "unexpected value_name_len");
5424 torture_assert_int_equal(tctx, einfo[0].type, REG_BINARY, "type mismatch");
5425 torture_assert_int_equal(tctx, einfo[0].data_length, blob_in.length, "size mismatch");
5426 if (einfo[0].data_length > 0) {
5427 torture_assert_mem_equal(tctx, einfo[0].data->data, blob_in.data, blob_in.length, "buffer mismatch");
5428 }
5429
5430 torture_assert(tctx,
5431 test_DeletePrinterDataEx(tctx, b, handle, key, values[i]),
5432 "failed to call DeletePrinterDataEx");
5433 }
5434
5435 return true;
5436 }
5437
5438
5439 static bool test_SetPrinterDataEx_matrix(struct torture_context *tctx,
5440 struct dcerpc_pipe *p,
5441 struct policy_handle *handle,
5442 const char *printername,
5443 struct dcerpc_binding_handle *winreg_handle,
5444 struct policy_handle *hive_handle)
5445 {
5446 struct dcerpc_binding_handle *b = p->binding_handle;
5447 const char *value_name = "dog";
5448 const char *key_name = "torturedataex";
5449 enum winreg_Type types[] = {
5450 REG_SZ,
5451 REG_MULTI_SZ,
5452 REG_DWORD,
5453 REG_BINARY
5454 };
5455 const char *str = "abcdefghi";
5456 int t, s;
5457
5458 for (t=0; t < ARRAY_SIZE(types); t++) {
5459 for (s=0; s < strlen(str); s++) {
5460
5461 enum winreg_Type type;
5462 const char *string = talloc_strndup(tctx, str, s);
5463 const char *array[2];
5464 DATA_BLOB blob = data_blob_string_const(string);
5465 DATA_BLOB data;
5466 uint8_t *data_out;
5467 uint32_t needed, offered = 0;
5468 uint32_t ecount;
5469 struct spoolss_PrinterEnumValues *einfo;
5470
5471 array[0] = talloc_strdup(tctx, string);
5472 array[1] = NULL;
5473
5474 if (types[t] == REG_DWORD) {
5475 s = 0xffff;
5476 }
5477
5478 switch (types[t]) {
5479 case REG_BINARY:
5480 data = blob;
5481 offered = blob.length;
5482 break;
5483 case REG_DWORD:
5484 data = data_blob_talloc(tctx, NULL, 4);
5485 SIVAL(data.data, 0, 0x12345678);
5486 offered = 4;
5487 break;
5488 case REG_SZ:
5489 torture_assert(tctx, push_reg_sz(tctx, &data, string), "");
5490 type = REG_SZ;
5491 offered = data.length;
5492 /*strlen_m_term(data.string)*2;*/
5493 break;
5494 case REG_MULTI_SZ:
5495 torture_assert(tctx, push_reg_multi_sz(tctx, &data, array), "");
5496 type = REG_MULTI_SZ;
5497 offered = data.length;
5498 break;
5499 default:
5500 torture_fail(tctx, talloc_asprintf(tctx, "type %d untested\n", types[t]));
5501 }
5502
5503 torture_assert(tctx,
5504 test_SetPrinterDataEx(tctx, b, handle, key_name, value_name, types[t], data.data, offered),
5505 "failed to call SetPrinterDataEx");
5506
5507 torture_assert(tctx,
5508 test_GetPrinterDataEx_checktype(tctx, p, handle, key_name, value_name, &types[t], &type, &data_out, &needed),
5509 "failed to call GetPrinterDataEx");
5510
5511 torture_assert(tctx,
5512 test_EnumPrinterDataEx(tctx, b, handle, key_name, &ecount, &einfo),
5513 "failed to call EnumPrinterDataEx");
5514
5515 torture_assert_int_equal(tctx, types[t], type, "type mismatch");
5516 torture_assert_int_equal(tctx, needed, offered, "size mismatch");
5517 torture_assert_mem_equal(tctx, data_out, data.data, offered, "buffer mismatch");
5518
5519 torture_assert_int_equal(tctx, ecount, 1, "unexpected enum count");
5520 torture_assert_str_equal(tctx, einfo[0].value_name, value_name, "value_name mismatch");
5521 torture_assert_int_equal(tctx, einfo[0].value_name_len, strlen_m_term(value_name)*2, "unexpected value_name_len");
5522 torture_assert_int_equal(tctx, einfo[0].type, types[t], "type mismatch");
5523 torture_assert_int_equal(tctx, einfo[0].data_length, offered, "size mismatch");
5524 if (einfo[0].data_length > 0) {
5525 torture_assert_mem_equal(tctx, einfo[0].data->data, data.data, offered, "buffer mismatch");
5526 }
5527
5528 if (winreg_handle && hive_handle) {
5529 enum winreg_Type w_type;
5530 uint32_t w_size;
5531 uint32_t w_length;
5532 uint8_t *w_data;
5533
5534 torture_assert(tctx,
5535 test_winreg_query_printerdata(tctx, winreg_handle, hive_handle,
5536 printername, key_name, value_name,
5537 &w_type, &w_size, &w_length, &w_data), "");
5538
5539 torture_assert_int_equal(tctx, w_type, types[t], "winreg type mismatch");
5540 torture_assert_int_equal(tctx, w_size, offered, "winreg size mismatch");
5541 torture_assert_int_equal(tctx, w_length, offered, "winreg length mismatch");
5542 torture_assert_mem_equal(tctx, w_data, data.data, offered, "winreg buffer mismatch");
5543 }
5544
5545 torture_assert(tctx,
5546 test_DeletePrinterDataEx(tctx, b, handle, key_name, value_name),
5547 "failed to call DeletePrinterDataEx");
5548 }
5549 }
5550
5551 return true;
5552 }
5553
5554 static bool test_PrinterData_winreg(struct torture_context *tctx,
5555 struct dcerpc_pipe *p,
5556 struct policy_handle *handle,
5557 const char *printer_name)
5558 {
5559 struct dcerpc_binding_handle *b = p->binding_handle;
5560 struct dcerpc_pipe *p2;
5561 bool ret = true;
5562 struct policy_handle hive_handle;
5563 struct dcerpc_binding_handle *b2;
5564
5565 torture_assert_ntstatus_ok(tctx,
5566 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
5567 "could not open winreg pipe");
5568 b2 = p2->binding_handle;
5569
5570 torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
5571
5572 ret &= test_SetPrinterData_matrix(tctx, b, handle, printer_name, b2, &hive_handle);
5573 ret &= test_SetPrinterDataEx_matrix(tctx, p, handle, printer_name, b2, &hive_handle);
5574
5575 test_winreg_CloseKey(tctx, b2, &hive_handle);
5576
5577 talloc_free(p2);
5578
5579 return ret;
5580 }
5581
5582 static bool test_Forms_winreg(struct torture_context *tctx,
5583 struct dcerpc_binding_handle *b,
5584 struct policy_handle *handle,
5585 bool print_server,
5586 const char *printer_name)
5587 {
5588 struct dcerpc_pipe *p2;
5589 bool ret = true;
5590 struct policy_handle hive_handle;
5591 struct dcerpc_binding_handle *b2;
5592
5593 torture_assert_ntstatus_ok(tctx,
5594 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
5595 "could not open winreg pipe");
5596 b2 = p2->binding_handle;
5597
5598 torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
5599
5600 ret = test_Forms(tctx, b, handle, print_server, printer_name, b2, &hive_handle);
5601
5602 test_winreg_CloseKey(tctx, b2, &hive_handle);
5603
5604 talloc_free(p2);
5605
5606 return ret;
5607 }
5608
5609 static bool test_PrinterInfo_winreg(struct torture_context *tctx,
5610 struct dcerpc_pipe *p,
5611 struct policy_handle *handle,
5612 const char *printer_name)
5613 {
5614 struct dcerpc_binding_handle *b = p->binding_handle;
5615 struct dcerpc_pipe *p2;
5616 bool ret = true;
5617 struct policy_handle hive_handle;
5618 struct dcerpc_binding_handle *b2;
5619
5620 torture_assert_ntstatus_ok(tctx,
5621 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
5622 "could not open winreg pipe");
5623 b2 = p2->binding_handle;
5624
5625 torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
5626
5627 ret = test_GetPrinterInfo_winreg(tctx, b, handle, printer_name, b2, &hive_handle);
5628
5629 test_winreg_CloseKey(tctx, b2, &hive_handle);
5630
5631 talloc_free(p2);
5632
5633 return ret;
5634 }
5635
5636 static bool test_DriverInfo_winreg(struct torture_context *tctx,
5637 struct dcerpc_pipe *p,
5638 struct policy_handle *handle,
5639 const char *printer_name,
5640 const char *driver_name,
5641 const char *environment,
5642 enum spoolss_DriverOSVersion version)
5643 {
5644 struct dcerpc_binding_handle *b = p->binding_handle;
5645 struct dcerpc_pipe *p2;
5646 bool ret = true;
5647 struct policy_handle hive_handle;
5648 struct dcerpc_binding_handle *b2;
5649
5650 torture_assert_ntstatus_ok(tctx,
5651 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
5652 "could not open winreg pipe");
5653 b2 = p2->binding_handle;
5654
5655 torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
5656
5657 ret = test_GetDriverInfo_winreg(tctx, b, handle, printer_name, driver_name, environment, version, b2, &hive_handle, NULL);
5658
5659 test_winreg_CloseKey(tctx, b2, &hive_handle);
5660
5661 talloc_free(p2);
5662
5663 return ret;
5664 }
5665
5666 static bool test_PrintProcessors_winreg(struct torture_context *tctx,
5667 struct dcerpc_binding_handle *b,
5668 const char *environment)
5669 {
5670 struct dcerpc_pipe *p2;
5671 bool ret = true;
5672 struct policy_handle hive_handle;
5673 struct dcerpc_binding_handle *b2;
5674
5675 torture_assert_ntstatus_ok(tctx,
5676 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
5677 "could not open winreg pipe");
5678 b2 = p2->binding_handle;
5679
5680 torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
5681
5682 ret = test_PrintProcessors(tctx, b, environment, b2, &hive_handle);
5683
5684 test_winreg_CloseKey(tctx, b2, &hive_handle);
5685
5686 talloc_free(p2);
5687
5688 return ret;
5689 }
5690
5691 static bool test_PrinterData_DsSpooler(struct torture_context *tctx,
5692 struct dcerpc_pipe *p,
5693 struct policy_handle *handle,
5694 const char *printer_name)
5695 {
5696 struct spoolss_SetPrinterInfoCtr info_ctr;
5697 struct spoolss_DevmodeContainer devmode_ctr;
5698 struct sec_desc_buf secdesc_ctr;
5699 union spoolss_SetPrinterInfo sinfo;
5700 union spoolss_PrinterInfo info;
5701 struct dcerpc_binding_handle *b = p->binding_handle;
5702 const char *pname;
5703
5704 ZERO_STRUCT(info_ctr);
5705 ZERO_STRUCT(devmode_ctr);
5706 ZERO_STRUCT(secdesc_ctr);
5707
5708 torture_comment(tctx, "Testing DsSpooler <-> SetPrinter relations\n");
5709
5710 torture_assert(tctx,
5711 test_GetPrinter_level(tctx, b, handle, 2, &info),
5712 "failed to query Printer level 2");
5713
5714 torture_assert(tctx,
5715 PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo),
5716 "failed to convert");
5717
5718 info_ctr.level = 2;
5719 info_ctr.info = sinfo;
5720
5721 #define TEST_SZ(wname, iname) \
5722 do {\
5723 enum winreg_Type type;\
5724 uint8_t *data;\
5725 uint32_t needed;\
5726 DATA_BLOB blob;\
5727 const char *str;\
5728 torture_assert(tctx,\
5729 test_GetPrinterDataEx(tctx, p, handle, "DsSpooler", wname, &type, &data, &needed),\
5730 "failed to query");\
5731 torture_assert_int_equal(tctx, type, REG_SZ, "unexpected type");\
5732 blob = data_blob_const(data, needed);\
5733 torture_assert(tctx,\
5734 pull_reg_sz(tctx, &blob, &str),\
5735 "failed to pull REG_SZ");\
5736 torture_assert_str_equal(tctx, str, iname, "unexpected result");\
5737 } while(0);
5738
5739
5740 #define TEST_SET_SZ(wname, iname, val) \
5741 do {\
5742 enum winreg_Type type;\
5743 uint8_t *data;\
5744 uint32_t needed;\
5745 DATA_BLOB blob;\
5746 const char *str;\
5747 sinfo.info2->iname = val;\
5748 torture_assert(tctx,\
5749 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),\
5750 "failed to call SetPrinter");\
5751 torture_assert(tctx,\
5752 test_GetPrinterDataEx(tctx, p, handle, "DsSpooler", wname, &type, &data, &needed),\
5753 "failed to query");\
5754 torture_assert_int_equal(tctx, type, REG_SZ, "unexpected type");\
5755 blob = data_blob_const(data, needed);\
5756 torture_assert(tctx,\
5757 pull_reg_sz(tctx, &blob, &str),\
5758 "failed to pull REG_SZ");\
5759 torture_assert_str_equal(tctx, str, val, "unexpected result");\
5760 } while(0);
5761
5762 #define TEST_SET_DWORD(wname, iname, val) \
5763 do {\
5764 enum winreg_Type type;\
5765 uint8_t *data;\
5766 uint32_t needed;\
5767 uint32_t value;\
5768 sinfo.info2->iname = val;\
5769 torture_assert(tctx,\
5770 test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),\
5771 "failed to call SetPrinter");\
5772 torture_assert(tctx,\
5773 test_GetPrinterDataEx(tctx, p, handle, "DsSpooler", wname, &type, &data, &needed),\
5774 "failed to query");\
5775 torture_assert_int_equal(tctx, type, REG_DWORD, "unexpected type");\
5776 torture_assert_int_equal(tctx, needed, 4, "unexpected length");\
5777 value = IVAL(data, 0); \
5778 torture_assert_int_equal(tctx, value, val, "unexpected result");\
5779 } while(0);
5780
5781 TEST_SET_SZ("description", comment, "newval");
5782 TEST_SET_SZ("location", location, "newval");
5783 TEST_SET_SZ("driverName", drivername, "newval");
5784 /* TEST_SET_DWORD("priority", priority, 25); */
5785
5786 torture_assert(tctx,
5787 test_GetPrinter_level(tctx, b, handle, 2, &info),
5788 "failed to query Printer level 2");
5789
5790 TEST_SZ("description", info.info2.comment);
5791 TEST_SZ("driverName", info.info2.drivername);
5792 TEST_SZ("location", info.info2.location);
5793
5794 pname = strrchr(info.info2.printername, '\\');
5795 if (pname == NULL) {
5796 pname = info.info2.printername;
5797 } else {
5798 pname++;
5799 }
5800 TEST_SZ("printerName", pname);
5801 /* TEST_SZ("printSeparatorFile", info.info2.sepfile); */
5802 /* TEST_SZ("printShareName", info.info2.sharename); */
5803
5804 /* FIXME gd: complete the list */
5805
5806 #undef TEST_SZ
5807 #undef TEST_SET_SZ
5808 #undef TEST_DWORD
5809
5810 torture_comment(tctx, "DsSpooler <-> SetPrinter relations test succeeded\n\n");
5811
5812 return true;
5813 }
5814
5815 static bool test_print_processors_winreg(struct torture_context *tctx,
5816 void *private_data)
5817 {
5818 struct test_spoolss_context *ctx =
5819 talloc_get_type_abort(private_data, struct test_spoolss_context);
5820 struct dcerpc_pipe *p = ctx->spoolss_pipe;
5821 struct dcerpc_binding_handle *b = p->binding_handle;
5822
5823 return test_PrintProcessors_winreg(tctx, b, ctx->environment);
5824 }
5825
5826 static bool test_AddPrintProcessor(struct torture_context *tctx,
5827 struct dcerpc_binding_handle *b,
5828 const char *environment,
5829 const char *path_name,
5830 const char *print_processor_name,
5831 WERROR expected_error)
5832 {
5833 struct spoolss_AddPrintProcessor r;
5834
5835 r.in.server = NULL;
5836 r.in.architecture = environment;
5837 r.in.path_name = path_name;
5838 r.in.print_processor_name = print_processor_name;
5839
5840 torture_comment(tctx, "Testing AddPrintProcessor(%s)\n",
5841 print_processor_name);
5842
5843 torture_assert_ntstatus_ok(tctx,
5844 dcerpc_spoolss_AddPrintProcessor_r(b, tctx, &r),
5845 "spoolss_AddPrintProcessor failed");
5846 torture_assert_werr_equal(tctx, r.out.result, expected_error,
5847 "spoolss_AddPrintProcessor failed");
5848
5849 return true;
5850 }
5851
5852 static bool test_DeletePrintProcessor(struct torture_context *tctx,
5853 struct dcerpc_binding_handle *b,
5854 const char *environment,
5855 const char *print_processor_name,
5856 WERROR expected_error)
5857 {
5858 struct spoolss_DeletePrintProcessor r;
5859
5860 r.in.server = NULL;
5861 r.in.architecture = environment;
5862 r.in.print_processor_name = print_processor_name;
5863
5864 torture_comment(tctx, "Testing DeletePrintProcessor(%s)\n",
5865 print_processor_name);
5866
5867 torture_assert_ntstatus_ok(tctx,
5868 dcerpc_spoolss_DeletePrintProcessor_r(b, tctx, &r),
5869 "spoolss_DeletePrintProcessor failed");
5870 torture_assert_werr_equal(tctx, r.out.result, expected_error,
5871 "spoolss_DeletePrintProcessor failed");
5872
5873 return true;
5874 }
5875
5876 static bool test_add_print_processor(struct torture_context *tctx,
5877 void *private_data)
5878 {
5879 struct test_spoolss_context *ctx =
5880 talloc_get_type_abort(private_data, struct test_spoolss_context);
5881 struct dcerpc_pipe *p = ctx->spoolss_pipe;
5882 struct dcerpc_binding_handle *b = p->binding_handle;
5883 int i;
5884
5885 struct {
5886 const char *environment;
5887 const char *path_name;
5888 const char *print_processor_name;
5889 WERROR expected_add_result;
5890 WERROR expected_del_result;
5891 } tests[] = {
5892 {
5893 .environment = ctx->environment,
5894 .path_name = "",
5895 .print_processor_name = "winprint",
5896 .expected_add_result = WERR_PRINT_PROCESSOR_ALREADY_INSTALLED,
5897 .expected_del_result = WERR_CAN_NOT_COMPLETE
5898 },{
5899 .environment = ctx->environment,
5900 .path_name = "",
5901 .print_processor_name = "unknown",
5902 .expected_add_result = WERR_MOD_NOT_FOUND,
5903 .expected_del_result = WERR_UNKNOWN_PRINTPROCESSOR
5904 }
5905 };
5906
5907 for (i=0; i < ARRAY_SIZE(tests); i++) {
5908 torture_assert(tctx,
5909 test_AddPrintProcessor(tctx, b,
5910 tests[i].environment,
5911 tests[i].path_name,
5912 tests[i].print_processor_name,
5913 tests[i].expected_add_result),
5914 "add print processor failed");
5915 torture_assert(tctx,
5916 test_DeletePrintProcessor(tctx, b,
5917 tests[i].environment,
5918 tests[i].print_processor_name,
5919 tests[i].expected_del_result),
5920 "delete print processor failed");
5921 }
5922
5923 return true;
5924 }
5925
5926 static bool test_GetChangeID_PrinterData(struct torture_context *tctx,
5927 struct dcerpc_binding_handle *b,
5928 struct policy_handle *handle,
5929 uint32_t *change_id)
5930 {
5931 enum winreg_Type type;
5932 uint8_t *data;
5933 uint32_t needed;
5934
5935 torture_assert(tctx,
5936 test_GetPrinterData(tctx, b, handle, "ChangeID", &type, &data, &needed),
5937 "failed to call GetPrinterData");
5938
5939 torture_assert(tctx, type == REG_DWORD, "unexpected type");
5940 torture_assert_int_equal(tctx, needed, 4, "unexpected size");
5941
5942 *change_id = IVAL(data, 0);
5943
5944 return true;
5945 }
5946
5947 static bool test_GetChangeID_PrinterDataEx(struct torture_context *tctx,
5948 struct dcerpc_pipe *p,
5949 struct policy_handle *handle,
5950 uint32_t *change_id)
5951 {
5952 enum winreg_Type type;
5953 uint8_t *data;
5954 uint32_t needed;
5955
5956 torture_assert(tctx,
5957 test_GetPrinterDataEx(tctx, p, handle, "PrinterDriverData", "ChangeID", &type, &data, &needed),
5958 "failed to call GetPrinterData");
5959
5960 torture_assert(tctx, type == REG_DWORD, "unexpected type");
5961 torture_assert_int_equal(tctx, needed, 4, "unexpected size");
5962
5963 *change_id = IVAL(data, 0);
5964
5965 return true;
5966 }
5967
5968 static bool test_GetChangeID_PrinterInfo(struct torture_context *tctx,
5969 struct dcerpc_binding_handle *b,
5970 struct policy_handle *handle,
5971 uint32_t *change_id)
5972 {
5973 union spoolss_PrinterInfo info;
5974
5975 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 0, &info),
5976 "failed to query Printer level 0");
5977
5978 *change_id = info.info0.change_id;
5979
5980 return true;
5981 }
5982
5983 static bool test_ChangeID(struct torture_context *tctx,
5984 struct dcerpc_pipe *p,
5985 struct policy_handle *handle)
5986 {
5987 uint32_t change_id, change_id_ex, change_id_info;
5988 uint32_t change_id2, change_id_ex2, change_id_info2;
5989 union spoolss_PrinterInfo info;
5990 const char *comment;
5991 struct dcerpc_binding_handle *b = p->binding_handle;
5992
5993 torture_comment(tctx, "Testing ChangeID: id change test #1\n");
5994
5995 torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id),
5996 "failed to query for ChangeID");
5997 torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
5998 "failed to query for ChangeID");
5999 torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info),
6000 "failed to query for ChangeID");
6001
6002 torture_assert_int_equal(tctx, change_id, change_id_ex,
6003 "change_ids should all be equal");
6004 torture_assert_int_equal(tctx, change_id_ex, change_id_info,
6005 "change_ids should all be equal");
6006
6007
6008 torture_comment(tctx, "Testing ChangeID: id change test #2\n");
6009
6010 torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id),
6011 "failed to query for ChangeID");
6012 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info),
6013 "failed to query Printer level 2");
6014 torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
6015 "failed to query for ChangeID");
6016 torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info),
6017 "failed to query for ChangeID");
6018 torture_assert_int_equal(tctx, change_id, change_id_ex,
6019 "change_id should not have changed");
6020 torture_assert_int_equal(tctx, change_id_ex, change_id_info,
6021 "change_id should not have changed");
6022
6023
6024 torture_comment(tctx, "Testing ChangeID: id change test #3\n");
6025
6026 torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id),
6027 "failed to query for ChangeID");
6028 torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex),
6029 "failed to query for ChangeID");
6030 torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info),
6031 "failed to query for ChangeID");
6032 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info),
6033 "failed to query Printer level 2");
6034 comment = talloc_strdup(tctx, info.info2.comment);
6035
6036 {
6037 struct spoolss_SetPrinterInfoCtr info_ctr;
6038 struct spoolss_DevmodeContainer devmode_ctr;
6039 struct sec_desc_buf secdesc_ctr;
6040 union spoolss_SetPrinterInfo sinfo;
6041
6042 ZERO_STRUCT(info_ctr);
6043 ZERO_STRUCT(devmode_ctr);
6044 ZERO_STRUCT(secdesc_ctr);
6045
6046
6047 torture_assert(tctx, PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
6048 sinfo.info2->comment = "torture_comment";
6049
6050 info_ctr.level = 2;
6051 info_ctr.info = sinfo;
6052
6053 torture_assert(tctx, test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
6054 "failed to call SetPrinter");
6055
6056 sinfo.info2->comment = comment;
6057
6058 torture_assert(tctx, test_SetPrinter(tctx, b, handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
6059 "failed to call SetPrinter");
6060
6061 }
6062
6063 torture_assert(tctx, test_GetChangeID_PrinterData(tctx, b, handle, &change_id2),
6064 "failed to query for ChangeID");
6065 torture_assert(tctx, test_GetChangeID_PrinterDataEx(tctx, p, handle, &change_id_ex2),
6066 "failed to query for ChangeID");
6067 torture_assert(tctx, test_GetChangeID_PrinterInfo(tctx, b, handle, &change_id_info2),
6068 "failed to query for ChangeID");
6069
6070 torture_assert_int_equal(tctx, change_id2, change_id_ex2,
6071 "change_ids should all be equal");
6072 torture_assert_int_equal(tctx, change_id_ex2, change_id_info2,
6073 "change_ids should all be equal");
6074
6075 torture_assert(tctx, (change_id < change_id2),
6076 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
6077 change_id2, change_id));
6078 torture_assert(tctx, (change_id_ex < change_id_ex2),
6079 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
6080 change_id_ex2, change_id_ex));
6081 torture_assert(tctx, (change_id_info < change_id_info2),
6082 talloc_asprintf(tctx, "change_id %d needs to be larger than change_id %d",
6083 change_id_info2, change_id_info));
6084
6085 torture_comment(tctx, "ChangeID tests succeeded\n\n");
6086
6087 return true;
6088 }
6089
6090 static bool test_SecondaryClosePrinter(struct torture_context *tctx,
6091 struct dcerpc_pipe *p,
6092 struct policy_handle *handle)
6093 {
6094 NTSTATUS status;
6095 struct dcerpc_binding *b;
6096 struct dcerpc_pipe *p2;
6097 struct spoolss_ClosePrinter cp;
6098
6099 /* only makes sense on SMB */
6100 if (p->conn->transport.transport != NCACN_NP) {
6101 return true;
6102 }
6103
6104 torture_comment(tctx, "Testing close on secondary pipe\n");
6105
6106 status = dcerpc_parse_binding(tctx, p->conn->binding_string, &b);
6107 torture_assert_ntstatus_ok(tctx, status, "Failed to parse dcerpc binding");
6108
6109 status = dcerpc_secondary_connection(p, &p2, b);
6110 torture_assert_ntstatus_ok(tctx, status, "Failed to create secondary connection");
6111
6112 status = dcerpc_bind_auth_none(p2, &ndr_table_spoolss);
6113 torture_assert_ntstatus_ok(tctx, status, "Failed to create bind on secondary connection");
6114
6115 cp.in.handle = handle;
6116 cp.out.handle = handle;
6117
6118 status = dcerpc_spoolss_ClosePrinter_r(p2->binding_handle, tctx, &cp);
6119 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_RPC_SS_CONTEXT_MISMATCH,
6120 "ERROR: Allowed close on secondary connection");
6121
6122 talloc_free(p2);
6123
6124 return true;
6125 }
6126
6127 static bool test_OpenPrinter_badname(struct torture_context *tctx,
6128 struct dcerpc_binding_handle *b, const char *name)
6129 {
6130 NTSTATUS status;
6131 struct spoolss_OpenPrinter op;
6132 struct spoolss_OpenPrinterEx opEx;
6133 struct policy_handle handle;
6134 bool ret = true;
6135
6136 op.in.printername = name;
6137 op.in.datatype = NULL;
6138 op.in.devmode_ctr.devmode= NULL;
6139 op.in.access_mask = 0;
6140 op.out.handle = &handle;
6141
6142 torture_comment(tctx, "Testing OpenPrinter(%s) with bad name\n", op.in.printername);
6143
6144 status = dcerpc_spoolss_OpenPrinter_r(b, tctx, &op);
6145 torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
6146 torture_assert_werr_equal(tctx, op.out.result, WERR_INVALID_PRINTER_NAME,
6147 "unexpected result");
6148
6149 if (W_ERROR_IS_OK(op.out.result)) {
6150 ret &=test_ClosePrinter(tctx, b, &handle);
6151 }
6152
6153 opEx.in.printername = name;
6154 opEx.in.datatype = NULL;
6155 opEx.in.devmode_ctr.devmode = NULL;
6156 opEx.in.access_mask = 0;
6157 opEx.in.userlevel_ctr.level = 1;
6158 opEx.in.userlevel_ctr.user_info.level1 = NULL;
6159 opEx.out.handle = &handle;
6160
6161 torture_comment(tctx, "Testing OpenPrinterEx(%s) with bad name\n", opEx.in.printername);
6162
6163 status = dcerpc_spoolss_OpenPrinterEx_r(b, tctx, &opEx);
6164 torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
6165 torture_assert_werr_equal(tctx, opEx.out.result, WERR_INVALID_PARAM,
6166 "unexpected result");
6167
6168 if (W_ERROR_IS_OK(opEx.out.result)) {
6169 ret &=test_ClosePrinter(tctx, b, &handle);
6170 }
6171
6172 return ret;
6173 }
6174
6175 static bool test_OpenPrinter_badname_list(struct torture_context *tctx,
6176 void *private_data)
6177 {
6178 struct test_spoolss_context *ctx =
6179 talloc_get_type_abort(private_data, struct test_spoolss_context);
6180
6181 const char *badnames[] = {
6182 "__INVALID_PRINTER__",
6183 "\\\\__INVALID_HOST__",
6184 "",
6185 "\\\\\\",
6186 "\\\\\\__INVALID_PRINTER__"
6187 };
6188 const char *badname;
6189 struct dcerpc_pipe *p = ctx->spoolss_pipe;
6190 const char *server_name = dcerpc_server_name(p);
6191 struct dcerpc_binding_handle *b = p->binding_handle;
6192 int i;
6193
6194 for (i=0; i < ARRAY_SIZE(badnames); i++) {
6195 torture_assert(tctx,
6196 test_OpenPrinter_badname(tctx, b, badnames[i]),
6197 "");
6198 }
6199
6200 badname = talloc_asprintf(tctx, "\\\\%s\\", server_name);
6201 torture_assert(tctx,
6202 test_OpenPrinter_badname(tctx, b, badname),
6203 "");
6204
6205 badname = talloc_asprintf(tctx, "\\\\%s\\__INVALID_PRINTER__", server_name);
6206 torture_assert(tctx,
6207 test_OpenPrinter_badname(tctx, b, badname),
6208 "");
6209
6210 return true;
6211 }
6212
6213 static bool test_OpenPrinter(struct torture_context *tctx,
6214 struct dcerpc_pipe *p,
6215 const char *name,
6216 const char *environment,
6217 bool open_only)
6218 {
6219 NTSTATUS status;
6220 struct spoolss_OpenPrinter r;
6221 struct policy_handle handle;
6222 bool ret = true;
6223 struct dcerpc_binding_handle *b = p->binding_handle;
6224
6225 r.in.printername = name;
6226 r.in.datatype = NULL;
6227 r.in.devmode_ctr.devmode= NULL;
6228 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
6229 r.out.handle = &handle;
6230
6231 torture_comment(tctx, "Testing OpenPrinter(%s)\n", r.in.printername);
6232
6233 status = dcerpc_spoolss_OpenPrinter_r(b, tctx, &r);
6234
6235 torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
6236
6237 torture_assert_werr_ok(tctx, r.out.result, "OpenPrinter failed");
6238
6239 if (open_only) {
6240 goto close_printer;
6241 }
6242
6243 if (!test_GetPrinter(tctx, b, &handle, environment)) {
6244 ret = false;
6245 }
6246
6247 if (!torture_setting_bool(tctx, "samba3", false)) {
6248 if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
6249 ret = false;
6250 }
6251 }
6252
6253 close_printer:
6254 if (!test_ClosePrinter(tctx, b, &handle)) {
6255 ret = false;
6256 }
6257
6258 return ret;
6259 }
6260
6261 static bool test_OpenPrinterEx(struct torture_context *tctx,
6262 struct dcerpc_binding_handle *b,
6263 const char *printername,
6264 const char *datatype,
6265 struct spoolss_DeviceMode *devmode,
6266 uint32_t access_mask,
6267 struct spoolss_UserLevelCtr *userlevel_ctr,
6268 struct policy_handle *handle,
6269 WERROR expected_result)
6270 {
6271 struct spoolss_OpenPrinterEx r;
6272
6273 r.in.printername = printername;
6274 r.in.datatype = datatype;
6275 r.in.devmode_ctr.devmode= devmode;
6276 r.in.access_mask = access_mask;
6277 r.in.userlevel_ctr = *userlevel_ctr;
6278 r.out.handle = handle;
6279
6280 torture_comment(tctx, "Testing OpenPrinterEx(%s)\n", r.in.printername);
6281
6282 torture_assert_ntstatus_ok(tctx,
6283 dcerpc_spoolss_OpenPrinterEx_r(b, tctx, &r),
6284 "OpenPrinterEx failed");
6285
6286 torture_assert_werr_equal(tctx, r.out.result, expected_result,
6287 "OpenPrinterEx failed");
6288
6289 return true;
6290 }
6291
6292 static bool call_OpenPrinterEx(struct torture_context *tctx,
6293 struct dcerpc_pipe *p,
6294 const char *name,
6295 struct spoolss_DeviceMode *devmode,
6296 struct policy_handle *handle)
6297 {
6298 struct spoolss_UserLevelCtr userlevel_ctr;
6299 struct spoolss_UserLevel1 userlevel1;
6300 struct dcerpc_binding_handle *b = p->binding_handle;
6301
6302 userlevel1.size = 1234;
6303 userlevel1.client = "hello";
6304 userlevel1.user = "spottyfoot!";
6305 userlevel1.build = 1;
6306 userlevel1.major = 2;
6307 userlevel1.minor = 3;
6308 userlevel1.processor = 4;
6309
6310 userlevel_ctr.level = 1;
6311 userlevel_ctr.user_info.level1 = &userlevel1;
6312
6313 return test_OpenPrinterEx(tctx, b, name, NULL, devmode,
6314 SEC_FLAG_MAXIMUM_ALLOWED,
6315 &userlevel_ctr,
6316 handle,
6317 WERR_OK);
6318 }
6319
6320 static bool test_printer_rename(struct torture_context *tctx,
6321 void *private_data)
6322 {
6323 struct torture_printer_context *t =
6324 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
6325 struct dcerpc_pipe *p = t->spoolss_pipe;
6326
6327 bool ret = true;
6328 union spoolss_PrinterInfo info;
6329 union spoolss_SetPrinterInfo sinfo;
6330 struct spoolss_SetPrinterInfoCtr info_ctr;
6331 struct spoolss_DevmodeContainer devmode_ctr;
6332 struct sec_desc_buf secdesc_ctr;
6333 const char *printer_name;
6334 const char *printer_name_orig;
6335 const char *printer_name_new = "SAMBA smbtorture Test Printer (Copy 2)";
6336 struct policy_handle new_handle;
6337 const char *q;
6338 struct dcerpc_binding_handle *b = p->binding_handle;
6339
6340 ZERO_STRUCT(devmode_ctr);
6341 ZERO_STRUCT(secdesc_ctr);
6342
6343 torture_comment(tctx, "Testing Printer rename operations\n");
6344
6345 torture_assert(tctx,
6346 test_GetPrinter_level(tctx, b, &t->handle, 2, &info),
6347 "failed to call GetPrinter level 2");
6348
6349 printer_name_orig = talloc_strdup(tctx, info.info2.printername);
6350
6351 q = strrchr(info.info2.printername, '\\');
6352 if (q) {
6353 torture_warning(tctx,
6354 "server returns printername %s incl. servername although we did not set servername", info.info2.printername);
6355 }
6356
6357 torture_assert(tctx,
6358 PrinterInfo_to_SetPrinterInfo(tctx, &info, 2, &sinfo), "");
6359
6360 sinfo.info2->printername = printer_name_new;
6361
6362 info_ctr.level = 2;
6363 info_ctr.info = sinfo;
6364
6365 torture_assert(tctx,
6366 test_SetPrinter(tctx, b, &t->handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
6367 "failed to call SetPrinter level 2");
6368
6369 torture_assert(tctx,
6370 test_GetPrinter_level(tctx, b, &t->handle, 2, &info),
6371 "failed to call GetPrinter level 2");
6372
6373 printer_name = talloc_strdup(tctx, info.info2.printername);
6374
6375 q = strrchr(info.info2.printername, '\\');
6376 if (q) {
6377 torture_warning(tctx,
6378 "server returns printername %s incl. servername although we did not set servername", info.info2.printername);
6379 q++;
6380 printer_name = q;
6381 }
6382
6383 torture_assert_str_equal(tctx, printer_name, printer_name_new,
6384 "new printer name was not set");
6385
6386 /* samba currently cannot fully rename printers */
6387 if (!torture_setting_bool(tctx, "samba3", false)) {
6388 torture_assert(tctx,
6389 test_OpenPrinter_badname(tctx, b, printer_name_orig),
6390 "still can open printer with oldname after rename");
6391 } else {
6392 torture_warning(tctx, "*not* checking for open with oldname after rename for samba3");
6393 }
6394
6395 torture_assert(tctx,
6396 call_OpenPrinterEx(tctx, p, printer_name_new, NULL, &new_handle),
6397 "failed to open printer with new name");
6398
6399 torture_assert(tctx,
6400 test_GetPrinter_level(tctx, b, &new_handle, 2, &info),
6401 "failed to call GetPrinter level 2");
6402
6403 torture_assert_str_equal(tctx, info.info2.printername, printer_name_new,
6404 "new printer name was not set");
6405
6406 torture_assert(tctx,
6407 test_ClosePrinter(tctx, b, &new_handle),
6408 "failed to close printer");
6409
6410 torture_comment(tctx, "Printer rename operations test succeeded\n\n");
6411
6412 return ret;
6413 }
6414
6415 static bool test_openprinter(struct torture_context *tctx,
6416 struct dcerpc_binding_handle *b,
6417 const char *real_printername)
6418 {
6419 struct spoolss_UserLevelCtr userlevel_ctr;
6420 struct policy_handle handle;
6421 struct spoolss_UserLevel1 userlevel1;
6422 const char *printername = NULL;
6423 int i;
6424
6425 struct {
6426 const char *suffix;
6427 WERROR expected_result;
6428 } tests[] = {
6429 {
6430 .suffix = "rubbish",
6431 .expected_result = WERR_INVALID_PRINTER_NAME
6432 },{
6433 .suffix = ", LocalOnl",
6434 .expected_result = WERR_INVALID_PRINTER_NAME
6435 },{
6436 .suffix = ", localOnly",
6437 .expected_result = WERR_INVALID_PRINTER_NAME
6438 },{
6439 .suffix = ", localonl",
6440 .expected_result = WERR_INVALID_PRINTER_NAME
6441 },{
6442 .suffix = ",LocalOnl",
6443 .expected_result = WERR_INVALID_PRINTER_NAME
6444 },{
6445 .suffix = ",localOnl2",
6446 .expected_result = WERR_INVALID_PRINTER_NAME
6447 },{
6448 .suffix = ", DrvConver2t",
6449 .expected_result = WERR_INVALID_PRINTER_NAME
6450 },{
6451 .suffix = ", drvconvert",
6452 .expected_result = WERR_INVALID_PRINTER_NAME
6453 },{
6454 .suffix = ",drvconvert",
6455 .expected_result = WERR_INVALID_PRINTER_NAME
6456 },{
6457 .suffix = ", DrvConvert",
6458 .expected_result = WERR_OK
6459 },{
6460 .suffix = " , DrvConvert",
6461 .expected_result = WERR_INVALID_PRINTER_NAME
6462 },{
6463 .suffix = ",DrvConvert",
6464 .expected_result = WERR_OK
6465 },{
6466 .suffix = ", DrvConvertsadfasdf",
6467 .expected_result = WERR_OK
6468 },{
6469 .suffix = ",DrvConvertasdfasd",
6470 .expected_result = WERR_OK
6471 },{
6472 .suffix = ", LocalOnly",
6473 .expected_result = WERR_OK
6474 },{
6475 .suffix = " , LocalOnly",
6476 .expected_result = WERR_INVALID_PRINTER_NAME
6477 },{
6478 .suffix = ",LocalOnly",
6479 .expected_result = WERR_OK
6480 },{
6481 .suffix = ", LocalOnlysagi4gjfkd",
6482 .expected_result = WERR_OK
6483 },{
6484 .suffix = ",LocalOnlysagi4gjfkd",
6485 .expected_result = WERR_OK
6486 }
6487 };
6488
6489 userlevel1.size = 1234;
6490 userlevel1.client = "hello";
6491 userlevel1.user = "spottyfoot!";
6492 userlevel1.build = 1;
6493 userlevel1.major = 2;
6494 userlevel1.minor = 3;
6495 userlevel1.processor = 4;
6496
6497 userlevel_ctr.level = 1;
6498 userlevel_ctr.user_info.level1 = &userlevel1;
6499
6500 torture_comment(tctx, "Testing openprinterex printername pattern\n");
6501
6502 torture_assert(tctx,
6503 test_OpenPrinterEx(tctx, b, real_printername, NULL, NULL, 0,
6504 &userlevel_ctr, &handle,
6505 WERR_OK),
6506 "OpenPrinterEx failed");
6507 test_ClosePrinter(tctx, b, &handle);
6508
6509 for (i=0; i < ARRAY_SIZE(tests); i++) {
6510
6511 printername = talloc_asprintf(tctx, "%s%s",
6512 real_printername,
6513 tests[i].suffix);
6514
6515 torture_assert(tctx,
6516 test_OpenPrinterEx(tctx, b, printername, NULL, NULL, 0,
6517 &userlevel_ctr, &handle,
6518 tests[i].expected_result),
6519 "OpenPrinterEx failed");
6520 if (W_ERROR_IS_OK(tests[i].expected_result)) {
6521 test_ClosePrinter(tctx, b, &handle);
6522 }
6523 }
6524
6525 return true;
6526 }
6527
6528
6529 static bool test_existing_printer_openprinterex(struct torture_context *tctx,
6530 struct dcerpc_pipe *p,
6531 const char *name,
6532 const char *environment)
6533 {
6534 struct policy_handle handle;
6535 bool ret = true;
6536 struct dcerpc_binding_handle *b = p->binding_handle;
6537
6538 if (!test_openprinter(tctx, b, name)) {
6539 return false;
6540 }
6541
6542 if (!call_OpenPrinterEx(tctx, p, name, NULL, &handle)) {
6543 return false;
6544 }
6545
6546 if (!test_PrinterInfo_SD(tctx, b, &handle)) {
6547 ret = false;
6548 }
6549
6550 if (!test_GetPrinter(tctx, b, &handle, environment)) {
6551 ret = false;
6552 }
6553
6554 if (!test_EnumForms_all(tctx, b, &handle, false)) {
6555 ret = false;
6556 }
6557
6558 if (!test_Forms(tctx, b, &handle, false, name, NULL, NULL)) {
6559 ret = false;
6560 }
6561
6562 if (!test_Forms_winreg(tctx, b, &handle, false, name)) {
6563 ret = false;
6564 }
6565
6566 if (!test_EnumPrinterData_all(tctx, p, &handle)) {
6567 ret = false;
6568 }
6569
6570 if (!test_EnumPrinterDataEx(tctx, b, &handle, "PrinterDriverData", NULL, NULL)) {
6571 ret = false;
6572 }
6573
6574 if (!test_EnumPrinterData_consistency(tctx, p, &handle)) {
6575 ret = false;
6576 }
6577
6578 if (!test_printer_all_keys(tctx, b, &handle)) {
6579 ret = false;
6580 }
6581
6582 if (!test_PausePrinter(tctx, b, &handle)) {
6583 ret = false;
6584 }
6585
6586 if (!test_DoPrintTest(tctx, b, &handle)) {
6587 ret = false;
6588 }
6589
6590 if (!test_ResumePrinter(tctx, b, &handle)) {
6591 ret = false;
6592 }
6593
6594 if (!test_SetPrinterData_matrix(tctx, b, &handle, name, NULL, NULL)) {
6595 ret = false;
6596 }
6597
6598 if (!test_SetPrinterDataEx_matrix(tctx, p, &handle, name, NULL, NULL)) {
6599 ret = false;
6600 }
6601
6602 if (!torture_setting_bool(tctx, "samba3", false)) {
6603 if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
6604 ret = false;
6605 }
6606 }
6607
6608 if (!test_ClosePrinter(tctx, b, &handle)) {
6609 ret = false;
6610 }
6611
6612 return ret;
6613 }
6614
6615 static bool test_EnumPrinters_old(struct torture_context *tctx,
6616 void *private_data)
6617 {
6618 struct test_spoolss_context *ctx =
6619 talloc_get_type_abort(private_data, struct test_spoolss_context);
6620 struct spoolss_EnumPrinters r;
6621 NTSTATUS status;
6622 uint16_t levels[] = {1, 2, 4, 5};
6623 int i;
6624 bool ret = true;
6625 struct dcerpc_pipe *p = ctx->spoolss_pipe;
6626 struct dcerpc_binding_handle *b = p->binding_handle;
6627
6628 for (i=0;i<ARRAY_SIZE(levels);i++) {
6629 union spoolss_PrinterInfo *info;
6630 int j;
6631 uint32_t needed;
6632 uint32_t count;
6633
6634 r.in.flags = PRINTER_ENUM_LOCAL;
6635 r.in.server = "";
6636 r.in.level = levels[i];
6637 r.in.buffer = NULL;
6638 r.in.offered = 0;
6639 r.out.needed = &needed;
6640 r.out.count = &count;
6641 r.out.info = &info;
6642
6643 torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
6644
6645 status = dcerpc_spoolss_EnumPrinters_r(b, tctx, &r);
6646 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
6647
6648 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
6649 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
6650 r.in.buffer = &blob;
6651 r.in.offered = needed;
6652 status = dcerpc_spoolss_EnumPrinters_r(b, tctx, &r);
6653 }
6654
6655 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
6656
6657 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
6658
6659 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, needed, 4);
6660
6661 if (!info) {
6662 torture_comment(tctx, "No printers returned\n");
6663 return true;
6664 }
6665
6666 for (j=0;j<count;j++) {
6667 if (r.in.level == 1) {
6668 char *unc = talloc_strdup(tctx, info[j].info1.name);
6669 char *slash, *name, *full_name;
6670 name = unc;
6671 if (unc[0] == '\\' && unc[1] == '\\') {
6672 unc +=2;
6673 }
6674 slash = strchr(unc, '\\');
6675 if (slash) {
6676 slash++;
6677 name = slash;
6678 }
6679 full_name = talloc_asprintf(tctx, "\\\\%s\\%s",
6680 dcerpc_server_name(p), name);
6681 if (!test_OpenPrinter(tctx, p, name, ctx->environment, true)) {
6682 ret = false;
6683 }
6684 if (!test_OpenPrinter(tctx, p, full_name, ctx->environment, true)) {
6685 ret = false;
6686 }
6687 if (!test_OpenPrinter(tctx, p, name, ctx->environment, false)) {
6688 ret = false;
6689 }
6690 if (!test_existing_printer_openprinterex(tctx, p, name, ctx->environment)) {
6691 ret = false;
6692 }
6693 }
6694 }
6695 }
6696
6697 return ret;
6698 }
6699
6700 static bool test_EnumPrinters_level(struct torture_context *tctx,
6701 struct dcerpc_binding_handle *b,
6702 uint32_t flags,
6703 const char *servername,
6704 uint32_t level,
6705 uint32_t *count_p,
6706 union spoolss_PrinterInfo **info_p)
6707 {
6708 struct spoolss_EnumPrinters r;
6709 union spoolss_PrinterInfo *info;
6710 uint32_t needed;
6711 uint32_t count;
6712
6713 r.in.flags = flags;
6714 r.in.server = servername;
6715 r.in.level = level;
6716 r.in.buffer = NULL;
6717 r.in.offered = 0;
6718 r.out.needed = &needed;
6719 r.out.count = &count;
6720 r.out.info = &info;
6721
6722 torture_comment(tctx, "Testing EnumPrinters(%s) level %u\n",
6723 r.in.server, r.in.level);
6724
6725 torture_assert_ntstatus_ok(tctx,
6726 dcerpc_spoolss_EnumPrinters_r(b, tctx, &r),
6727 "EnumPrinters failed");
6728 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
6729 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
6730 r.in.buffer = &blob;
6731 r.in.offered = needed;
6732 torture_assert_ntstatus_ok(tctx,
6733 dcerpc_spoolss_EnumPrinters_r(b, tctx, &r),
6734 "EnumPrinters failed");
6735 }
6736
6737 torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
6738
6739 CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, needed, 4);
6740
6741 if (count_p) {
6742 *count_p = count;
6743 }
6744 if (info_p) {
6745 *info_p = info;
6746 }
6747
6748 return true;
6749 }
6750
6751 static const char *get_short_printername(struct torture_context *tctx,
6752 const char *name)
6753 {
6754 const char *short_name;
6755
6756 if (name[0] == '\\' && name[1] == '\\') {
6757 name += 2;
6758 short_name = strchr(name, '\\');
6759 if (short_name) {
6760 return talloc_strdup(tctx, short_name+1);
6761 }
6762 }
6763
6764 return name;
6765 }
6766
6767 static const char *get_full_printername(struct torture_context *tctx,
6768 const char *name)
6769 {
6770 const char *full_name = talloc_strdup(tctx, name);
6771 char *p;
6772
6773 if (name && name[0] == '\\' && name[1] == '\\') {
6774 name += 2;
6775 p = strchr(name, '\\');
6776 if (p) {
6777 return full_name;
6778 }
6779 }
6780
6781 return NULL;
6782 }
6783
6784 static bool test_OnePrinter_servername(struct torture_context *tctx,
6785 struct dcerpc_pipe *p,
6786 struct dcerpc_binding_handle *b,
6787 const char *servername,
6788 const char *printername)
6789 {
6790 union spoolss_PrinterInfo info;
6791 const char *short_name = get_short_printername(tctx, printername);
6792 const char *full_name = get_full_printername(tctx, printername);
6793
6794 if (short_name) {
6795 struct policy_handle handle;
6796 torture_assert(tctx,
6797 call_OpenPrinterEx(tctx, p, short_name, NULL, &handle),
6798 "failed to open printer");
6799
6800 torture_assert(tctx,
6801 test_GetPrinter_level(tctx, b, &handle, 2, &info),
6802 "failed to get printer info");
6803
6804 torture_assert_casestr_equal(tctx, info.info2.servername, NULL,
6805 "unexpected servername");
6806 torture_assert_casestr_equal(tctx, info.info2.printername, short_name,
6807 "unexpected printername");
6808
6809 if (info.info2.devmode) {
6810 const char *expected_devicename;
6811 expected_devicename = talloc_strndup(tctx, short_name, MIN(strlen(short_name), 31));
6812 torture_assert_casestr_equal(tctx, info.info2.devmode->devicename, expected_devicename,
6813 "unexpected devicemode devicename");
6814 }
6815
6816 torture_assert(tctx,
6817 test_ClosePrinter(tctx, b, &handle),
6818 "failed to close printer");
6819 }
6820
6821 if (full_name) {
6822 struct policy_handle handle;
6823
6824 torture_assert(tctx,
6825 call_OpenPrinterEx(tctx, p, full_name, NULL, &handle),
6826 "failed to open printer");
6827
6828 torture_assert(tctx,
6829 test_GetPrinter_level(tctx, b, &handle, 2, &info),
6830 "failed to get printer info");
6831
6832 torture_assert_casestr_equal(tctx, info.info2.servername, servername,
6833 "unexpected servername");
6834 torture_assert_casestr_equal(tctx, info.info2.printername, full_name,
6835 "unexpected printername");
6836
6837 if (info.info2.devmode) {
6838 const char *expected_devicename;
6839 expected_devicename = talloc_strndup(tctx, full_name, MIN(strlen(full_name), 31));
6840 torture_assert_casestr_equal(tctx, info.info2.devmode->devicename, expected_devicename,
6841 "unexpected devicemode devicename");
6842 }
6843
6844 torture_assert(tctx,
6845 test_ClosePrinter(tctx, b, &handle),
6846 "failed to close printer");
6847 }
6848
6849 return true;
6850 }
6851
6852 static bool test_EnumPrinters_servername(struct torture_context *tctx,
6853 void *private_data)
6854 {
6855 struct test_spoolss_context *ctx =
6856 talloc_get_type_abort(private_data, struct test_spoolss_context);
6857 int i;
6858 struct dcerpc_pipe *p = ctx->spoolss_pipe;
6859 struct dcerpc_binding_handle *b = p->binding_handle;
6860 uint32_t count;
6861 union spoolss_PrinterInfo *info;
6862 const char *servername;
6863 uint32_t flags = PRINTER_ENUM_NAME|PRINTER_ENUM_LOCAL;
6864
6865 torture_comment(tctx, "Testing servername behaviour in EnumPrinters and GetPrinters\n");
6866
6867 servername = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
6868
6869 torture_assert(tctx,
6870 test_EnumPrinters_level(tctx, b, flags, servername, 2, &count, &info),
6871 "failed to enumerate printers");
6872
6873 for (i=0; i < count; i++) {
6874
6875 torture_assert_casestr_equal(tctx, info[i].info2.servername, servername,
6876 "unexpected servername");
6877
6878 torture_assert(tctx,
6879 test_OnePrinter_servername(tctx, p, b, servername, info[i].info2.printername),
6880 "failed to check printer");
6881 }
6882
6883 servername = "";
6884
6885 torture_assert(tctx,
6886 test_EnumPrinters_level(tctx, b, flags, servername, 2, &count, &info),
6887 "failed to enumerate printers");
6888
6889 for (i=0; i < count; i++) {
6890
6891 torture_assert_casestr_equal(tctx, info[i].info2.servername, NULL,
6892 "unexpected servername");
6893
6894 torture_assert(tctx,
6895 test_OnePrinter_servername(tctx, p, b, servername, info[i].info2.printername),
6896 "failed to check printer");
6897 }
6898
6899
6900 return true;
6901 }
6902
6903
6904 static bool test_GetPrinterDriver(struct torture_context *tctx,
6905 struct dcerpc_binding_handle *b,
6906 struct policy_handle *handle,
6907 const char *driver_name)
6908 {
6909 struct spoolss_GetPrinterDriver r;
6910 uint32_t needed;
6911
6912 r.in.handle = handle;
6913 r.in.architecture = "W32X86";
6914 r.in.level = 1;
6915 r.in.buffer = NULL;
6916 r.in.offered = 0;
6917 r.out.needed = &needed;
6918
6919 torture_comment(tctx, "Testing GetPrinterDriver level %d\n", r.in.level);
6920
6921 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver_r(b, tctx, &r),
6922 "failed to call GetPrinterDriver");
6923 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
6924 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
6925 r.in.buffer = &blob;
6926 r.in.offered = needed;
6927 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_GetPrinterDriver_r(b, tctx, &r),
6928 "failed to call GetPrinterDriver");
6929 }
6930
6931 torture_assert_werr_ok(tctx, r.out.result,
6932 "failed to call GetPrinterDriver");
6933
6934 CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverInfo, r.out.info, r.in.level, needed, 4);
6935
6936 return true;
6937 }
6938
6939 static bool test_GetPrinterDriver2_level(struct torture_context *tctx,
6940 struct dcerpc_binding_handle *b,
6941 struct policy_handle *handle,
6942 const char *driver_name,
6943 const char *architecture,
6944 uint32_t level,
6945 uint32_t client_major_version,
6946 uint32_t client_minor_version,
6947 union spoolss_DriverInfo *info_p,
6948 WERROR *result_p)
6949
6950 {
6951 struct spoolss_GetPrinterDriver2 r;
6952 uint32_t needed;
6953 uint32_t server_major_version;
6954 uint32_t server_minor_version;
6955
6956 r.in.handle = handle;
6957 r.in.architecture = architecture;
6958 r.in.client_major_version = client_major_version;
6959 r.in.client_minor_version = client_minor_version;
6960 r.in.buffer = NULL;
6961 r.in.offered = 0;
6962 r.in.level = level;
6963 r.out.needed = &needed;
6964 r.out.server_major_version = &server_major_version;
6965 r.out.server_minor_version = &server_minor_version;
6966
6967 torture_comment(tctx, "Testing GetPrinterDriver2(%s) level %d\n",
6968 driver_name, r.in.level);
6969
6970 torture_assert_ntstatus_ok(tctx,
6971 dcerpc_spoolss_GetPrinterDriver2_r(b, tctx, &r),
6972 "failed to call GetPrinterDriver2");
6973 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
6974 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
6975 r.in.buffer = &blob;
6976 r.in.offered = needed;
6977 torture_assert_ntstatus_ok(tctx,
6978 dcerpc_spoolss_GetPrinterDriver2_r(b, tctx, &r),
6979 "failed to call GetPrinterDriver2");
6980 }
6981
6982 if (result_p) {
6983 *result_p = r.out.result;
6984 }
6985
6986 if (W_ERROR_EQUAL(r.out.result, WERR_INVALID_LEVEL)) {
6987 switch (r.in.level) {
6988 case 101:
6989 case 8:
6990 torture_comment(tctx,
6991 "level %d not implemented, not considering as an error\n",
6992 r.in.level);
6993 return true;
6994 default:
6995 break;
6996 }
6997 }
6998
6999 torture_assert_werr_ok(tctx, r.out.result,
7000 "failed to call GetPrinterDriver2");
7001
7002 CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverInfo, r.out.info, r.in.level, needed, 4);
7003
7004 if (info_p) {
7005 *info_p = *r.out.info;
7006 }
7007
7008 return true;
7009 }
7010
7011 static bool test_GetPrinterDriver2(struct torture_context *tctx,
7012 struct dcerpc_binding_handle *b,
7013 struct policy_handle *handle,
7014 const char *driver_name,
7015 const char *architecture)
7016 {
7017 uint16_t levels[] = {1, 2, 3, 4, 5, 6, 8, 101 };
7018 int i;
7019
7020
7021 for (i=0;i<ARRAY_SIZE(levels);i++) {
7022
7023 torture_assert(tctx,
7024 test_GetPrinterDriver2_level(tctx, b, handle, driver_name, architecture, levels[i], 3, 0, NULL, NULL),
7025 "");
7026 }
7027
7028 return true;
7029 }
7030
7031 static bool test_EnumPrinterDrivers_old(struct torture_context *tctx,
7032 void *private_data)
7033 {
7034 struct test_spoolss_context *ctx =
7035 talloc_get_type_abort(private_data, struct test_spoolss_context);
7036 uint16_t levels[] = {1, 2, 3, 4, 5, 6};
7037 int i;
7038 struct dcerpc_pipe *p = ctx->spoolss_pipe;
7039 struct dcerpc_binding_handle *b = p->binding_handle;
7040 const char *server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
7041
7042 for (i=0;i<ARRAY_SIZE(levels);i++) {
7043
7044 uint32_t count;
7045 union spoolss_DriverInfo *info;
7046
7047 torture_assert(tctx,
7048 test_EnumPrinterDrivers_args(tctx, b, server_name, ctx->environment, levels[i], &count, &info),
7049 "failed to enumerate drivers");
7050
7051 if (!info) {
7052 torture_comment(tctx, "No printer drivers returned\n");
7053 break;
7054 }
7055 }
7056
7057 return true;
7058 }
7059
7060 static bool test_DeletePrinter(struct torture_context *tctx,
7061 struct dcerpc_binding_handle *b,
7062 struct policy_handle *handle)
7063 {
7064 struct spoolss_DeletePrinter r;
7065
7066 torture_comment(tctx, "Testing DeletePrinter\n");
7067
7068 r.in.handle = handle;
7069
7070 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_DeletePrinter_r(b, tctx, &r),
7071 "failed to delete printer");
7072 torture_assert_werr_ok(tctx, r.out.result,
7073 "failed to delete printer");
7074
7075 return true;
7076 }
7077
7078 static bool test_EnumPrinters_findname(struct torture_context *tctx,
7079 struct dcerpc_binding_handle *b,
7080 uint32_t flags,
7081 uint32_t level,
7082 const char *name,
7083 bool *found)
7084 {
7085 struct spoolss_EnumPrinters e;
7086 uint32_t count;
7087 union spoolss_PrinterInfo *info;
7088 uint32_t needed;
7089 int i;
7090
7091 *found = false;
7092
7093 e.in.flags = flags;
7094 e.in.server = NULL;
7095 e.in.level = level;
7096 e.in.buffer = NULL;
7097 e.in.offered = 0;
7098 e.out.count = &count;
7099 e.out.info = &info;
7100 e.out.needed = &needed;
7101
7102 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters_r(b, tctx, &e),
7103 "failed to enum printers");
7104
7105 if (W_ERROR_EQUAL(e.out.result, WERR_INSUFFICIENT_BUFFER)) {
7106 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
7107 e.in.buffer = &blob;
7108 e.in.offered = needed;
7109
7110 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters_r(b, tctx, &e),
7111 "failed to enum printers");
7112 }
7113
7114 torture_assert_werr_ok(tctx, e.out.result,
7115 "failed to enum printers");
7116
7117 for (i=0; i < count; i++) {
7118
7119 const char *current = NULL;
7120 const char *q;
7121
7122 switch (level) {
7123 case 1:
7124 current = info[i].info1.name;
7125 break;
7126 }
7127
7128 if (strequal(current, name)) {
7129 *found = true;
7130 break;
7131 }
7132
7133 q = strrchr(current, '\\');
7134 if (q) {
7135 if (!e.in.server) {
7136 torture_warning(tctx,
7137 "server returns printername %s incl. servername although we did not set servername", current);
7138 }
7139 q++;
7140 if (strequal(q, name)) {
7141 *found = true;
7142 break;
7143 }
7144 }
7145 }
7146
7147 return true;
7148 }
7149
7150 static bool test_AddPrinter_wellknown(struct torture_context *tctx,
7151 struct dcerpc_pipe *p,
7152 const char *printername,
7153 bool ex)
7154 {
7155 WERROR result;
7156 struct spoolss_AddPrinter r;
7157 struct spoolss_AddPrinterEx rex;
7158 struct spoolss_SetPrinterInfoCtr info_ctr;
7159 struct spoolss_SetPrinterInfo1 info1;
7160 struct spoolss_DevmodeContainer devmode_ctr;
7161 struct sec_desc_buf secdesc_ctr;
7162 struct spoolss_UserLevelCtr userlevel_ctr;
7163 struct policy_handle handle;
7164 bool found = false;
7165 struct dcerpc_binding_handle *b = p->binding_handle;
7166
7167 ZERO_STRUCT(devmode_ctr);
7168 ZERO_STRUCT(secdesc_ctr);
7169 ZERO_STRUCT(userlevel_ctr);
7170 ZERO_STRUCT(info1);
7171
7172 torture_comment(tctx, "Testing AddPrinter%s(%s) level 1\n",
7173 ex ? "Ex":"", printername);
7174
7175 /* try to add printer to wellknown printer list (level 1) */
7176
7177 userlevel_ctr.level = 1;
7178
7179 info_ctr.info.info1 = &info1;
7180 info_ctr.level = 1;
7181
7182 rex.in.server = NULL;
7183 rex.in.info_ctr = &info_ctr;
7184 rex.in.devmode_ctr = &devmode_ctr;
7185 rex.in.secdesc_ctr = &secdesc_ctr;
7186 rex.in.userlevel_ctr = &userlevel_ctr;
7187 rex.out.handle = &handle;
7188
7189 r.in.server = NULL;
7190 r.in.info_ctr = &info_ctr;
7191 r.in.devmode_ctr = &devmode_ctr;
7192 r.in.secdesc_ctr = &secdesc_ctr;
7193 r.out.handle = &handle;
7194
7195 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
7196 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
7197 "failed to add printer");
7198 result = ex ? rex.out.result : r.out.result;
7199 torture_assert_werr_equal(tctx, result, WERR_INVALID_PRINTER_NAME,
7200 "unexpected result code");
7201
7202 info1.name = printername;
7203 info1.flags = PRINTER_ATTRIBUTE_SHARED;
7204
7205 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
7206 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
7207 "failed to add printer");
7208 result = ex ? rex.out.result : r.out.result;
7209 torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
7210 "unexpected result code");
7211
7212 /* bizarre protocol, WERR_PRINTER_ALREADY_EXISTS means success here,
7213 better do a real check to see the printer is really there */
7214
7215 torture_assert(tctx, test_EnumPrinters_findname(tctx, b,
7216 PRINTER_ENUM_NETWORK, 1,
7217 printername,
7218 &found),
7219 "failed to enum printers");
7220
7221 torture_assert(tctx, found, "failed to find newly added printer");
7222
7223 info1.flags = 0;
7224
7225 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
7226 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
7227 "failed to add printer");
7228 result = ex ? rex.out.result : r.out.result;
7229 torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
7230 "unexpected result code");
7231
7232 /* bizarre protocol, WERR_PRINTER_ALREADY_EXISTS means success here,
7233 better do a real check to see the printer has really been removed
7234 from the well known printer list */
7235
7236 found = false;
7237
7238 torture_assert(tctx, test_EnumPrinters_findname(tctx, b,
7239 PRINTER_ENUM_NETWORK, 1,
7240 printername,
7241 &found),
7242 "failed to enum printers");
7243 #if 0
7244 torture_assert(tctx, !found, "printer still in well known printer list");
7245 #endif
7246 return true;
7247 }
7248
7249 static bool test_AddPrinter_normal(struct torture_context *tctx,
7250 struct dcerpc_pipe *p,
7251 struct policy_handle *handle_p,
7252 const char *printername,
7253 const char *drivername,
7254 const char *portname,
7255 struct spoolss_DeviceMode *devmode,
7256 bool ex)
7257 {
7258 WERROR result;
7259 struct spoolss_AddPrinter r;
7260 struct spoolss_AddPrinterEx rex;
7261 struct spoolss_SetPrinterInfoCtr info_ctr;
7262 struct spoolss_SetPrinterInfo2 info2;
7263 struct spoolss_DevmodeContainer devmode_ctr;
7264 struct sec_desc_buf secdesc_ctr;
7265 struct spoolss_UserLevelCtr userlevel_ctr;
7266 struct policy_handle handle;
7267 bool found = false;
7268 bool existing_printer_deleted = false;
7269 struct dcerpc_binding_handle *b = p->binding_handle;
7270
7271 ZERO_STRUCT(devmode_ctr);
7272 ZERO_STRUCT(secdesc_ctr);
7273 ZERO_STRUCT(userlevel_ctr);
7274
7275 torture_comment(tctx, "Testing AddPrinter%s(%s) level 2\n",
7276 ex ? "Ex":"", printername);
7277
7278 devmode_ctr.devmode = devmode;
7279
7280 userlevel_ctr.level = 1;
7281
7282 rex.in.server = NULL;
7283 rex.in.info_ctr = &info_ctr;
7284 rex.in.devmode_ctr = &devmode_ctr;
7285 rex.in.secdesc_ctr = &secdesc_ctr;
7286 rex.in.userlevel_ctr = &userlevel_ctr;
7287 rex.out.handle = &handle;
7288
7289 r.in.server = NULL;
7290 r.in.info_ctr = &info_ctr;
7291 r.in.devmode_ctr = &devmode_ctr;
7292 r.in.secdesc_ctr = &secdesc_ctr;
7293 r.out.handle = &handle;
7294
7295 again:
7296
7297 /* try to add printer to printer list (level 2) */
7298
7299 ZERO_STRUCT(info2);
7300
7301 info_ctr.info.info2 = &info2;
7302 info_ctr.level = 2;
7303
7304 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
7305 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
7306 "failed to add printer");
7307 result = ex ? rex.out.result : r.out.result;
7308 torture_assert_werr_equal(tctx, result, WERR_INVALID_PRINTER_NAME,
7309 "unexpected result code");
7310
7311 info2.printername = printername;
7312
7313 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
7314 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
7315 "failed to add printer");
7316 result = ex ? rex.out.result : r.out.result;
7317
7318 if (W_ERROR_EQUAL(result, WERR_PRINTER_ALREADY_EXISTS)) {
7319 struct policy_handle printer_handle;
7320
7321 if (existing_printer_deleted) {
7322 torture_fail(tctx, "already deleted printer still existing?");
7323 }
7324
7325 torture_assert(tctx, call_OpenPrinterEx(tctx, p, printername, NULL, &printer_handle),
7326 "failed to open printer handle");
7327
7328 torture_assert(tctx, test_DeletePrinter(tctx, b, &printer_handle),
7329 "failed to delete printer");
7330
7331 torture_assert(tctx, test_ClosePrinter(tctx, b, &printer_handle),
7332 "failed to close server handle");
7333
7334 existing_printer_deleted = true;
7335
7336 goto again;
7337 }
7338
7339 torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PORT,
7340 "unexpected result code");
7341
7342 info2.portname = portname;
7343
7344 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
7345 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
7346 "failed to add printer");
7347 result = ex ? rex.out.result : r.out.result;
7348 torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PRINTER_DRIVER,
7349 "unexpected result code");
7350
7351 info2.drivername = drivername;
7352
7353 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
7354 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
7355 "failed to add printer");
7356 result = ex ? rex.out.result : r.out.result;
7357
7358 /* w2k8r2 allows to add printer w/o defining printprocessor */
7359
7360 if (!W_ERROR_IS_OK(result)) {
7361 torture_assert_werr_equal(tctx, result, WERR_UNKNOWN_PRINTPROCESSOR,
7362 "unexpected result code");
7363
7364 info2.printprocessor = "winprint";
7365
7366 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
7367 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
7368 "failed to add printer");
7369 result = ex ? rex.out.result : r.out.result;
7370 torture_assert_werr_ok(tctx, result,
7371 "failed to add printer");
7372 }
7373
7374 *handle_p = handle;
7375
7376 /* we are paranoid, really check if the printer is there now */
7377
7378 torture_assert(tctx, test_EnumPrinters_findname(tctx, b,
7379 PRINTER_ENUM_LOCAL, 1,
7380 printername,
7381 &found),
7382 "failed to enum printers");
7383 torture_assert(tctx, found, "failed to find newly added printer");
7384
7385 torture_assert_ntstatus_ok(tctx, ex ? dcerpc_spoolss_AddPrinterEx_r(b, tctx, &rex) :
7386 dcerpc_spoolss_AddPrinter_r(b, tctx, &r),
7387 "failed to add printer");
7388 result = ex ? rex.out.result : r.out.result;
7389 torture_assert_werr_equal(tctx, result, WERR_PRINTER_ALREADY_EXISTS,
7390 "unexpected result code");
7391
7392 return true;
7393 }
7394
7395 static bool test_printer_info(struct torture_context *tctx,
7396 void *private_data)
7397 {
7398 struct torture_printer_context *t =
7399 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
7400 struct dcerpc_pipe *p = t->spoolss_pipe;
7401 struct dcerpc_binding_handle *b = p->binding_handle;
7402
7403 bool ret = true;
7404
7405 if (torture_setting_bool(tctx, "samba3", false)) {
7406 torture_skip(tctx, "skipping printer info cross tests against samba 3");
7407 }
7408
7409 if (!test_PrinterInfo(tctx, b, &t->handle)) {
7410 ret = false;
7411 }
7412
7413 if (!test_SetPrinter_errors(tctx, b, &t->handle)) {
7414 ret = false;
7415 }
7416
7417 return ret;
7418 }
7419
7420 static bool test_EnumPrinterKey(struct torture_context *tctx,
7421 struct dcerpc_binding_handle *b,
7422 struct policy_handle *handle,
7423 const char *key_name,
7424 const char ***array)
7425 {
7426 struct spoolss_EnumPrinterKey r;
7427 uint32_t needed = 0;
7428 union spoolss_KeyNames key_buffer;
7429 int32_t offered[] = { 0, 1, 2, 3, 4, 5, -1, -2, -3, -4, -5, 256, 512, 1024, 2048 };
7430 uint32_t _ndr_size;
7431 int i;
7432
7433 r.in.handle = handle;
7434 r.in.key_name = key_name;
7435 r.out.key_buffer = &key_buffer;
7436 r.out.needed = &needed;
7437 r.out._ndr_size = &_ndr_size;
7438
7439 for (i=0; i < ARRAY_SIZE(offered); i++) {
7440
7441 if (offered[i] < 0 && needed) {
7442 if (needed <= 4) {
7443 continue;
7444 }
7445 r.in.offered = needed + offered[i];
7446 } else {
7447 r.in.offered = offered[i];
7448 }
7449
7450 ZERO_STRUCT(key_buffer);
7451
7452 torture_comment(tctx, "Testing EnumPrinterKey(%s) with %d offered\n", r.in.key_name, r.in.offered);
7453
7454 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterKey_r(b, tctx, &r),
7455 "failed to call EnumPrinterKey");
7456 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
7457
7458 torture_assert(tctx, (_ndr_size == r.in.offered/2),
7459 talloc_asprintf(tctx, "EnumPrinterKey size mismatch, _ndr_size %d (expected %d)",
7460 _ndr_size, r.in.offered/2));
7461
7462 r.in.offered = needed;
7463 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinterKey_r(b, tctx, &r),
7464 "failed to call EnumPrinterKey");
7465 }
7466
7467 if (offered[i] > 0) {
7468 torture_assert_werr_ok(tctx, r.out.result,
7469 "failed to call EnumPrinterKey");
7470 }
7471
7472 torture_assert(tctx, (_ndr_size == r.in.offered/2),
7473 talloc_asprintf(tctx, "EnumPrinterKey size mismatch, _ndr_size %d (expected %d)",
7474 _ndr_size, r.in.offered/2));
7475
7476 torture_assert(tctx, (*r.out.needed <= r.in.offered),
7477 talloc_asprintf(tctx, "EnumPrinterKey size mismatch: needed %d is not <= offered %d", *r.out.needed, r.in.offered));
7478
7479 torture_assert(tctx, (*r.out.needed <= _ndr_size * 2),
7480 talloc_asprintf(tctx, "EnumPrinterKey size mismatch: needed %d is not <= _ndr_size %d * 2", *r.out.needed, _ndr_size));
7481
7482 if (key_buffer.string_array) {
7483 uint32_t calc_needed = 0;
7484 int s;
7485 for (s=0; key_buffer.string_array[s]; s++) {
7486 calc_needed += strlen_m_term(key_buffer.string_array[s])*2;
7487 }
7488 if (!key_buffer.string_array[0]) {
7489 calc_needed += 2;
7490 }
7491 calc_needed += 2;
7492
7493 torture_assert_int_equal(tctx, *r.out.needed, calc_needed,
7494 "EnumPrinterKey unexpected size");
7495 }
7496 }
7497
7498 if (array) {
7499 *array = key_buffer.string_array;
7500 }
7501
7502 return true;
7503 }
7504
7505 bool test_printer_all_keys(struct torture_context *tctx,
7506 struct dcerpc_binding_handle *b,
7507 struct policy_handle *handle)
7508 {
7509 const char **key_array = NULL;
7510 int i;
7511
7512 torture_comment(tctx, "Testing Printer Keys\n");
7513
7514 torture_assert(tctx, test_EnumPrinterKey(tctx, b, handle, "", &key_array),
7515 "failed to call test_EnumPrinterKey");
7516
7517 for (i=0; key_array && key_array[i]; i++) {
7518 torture_assert(tctx, test_EnumPrinterKey(tctx, b, handle, key_array[i], NULL),
7519 "failed to call test_EnumPrinterKey");
7520 }
7521 for (i=0; key_array && key_array[i]; i++) {
7522 torture_assert(tctx, test_EnumPrinterDataEx(tctx, b, handle, key_array[i], NULL, NULL),
7523 "failed to call test_EnumPrinterDataEx");
7524 }
7525
7526 torture_comment(tctx, "Printer Keys test succeeded\n\n");
7527
7528 return true;
7529 }
7530
7531 static bool test_openprinter_wrap(struct torture_context *tctx,
7532 void *private_data)
7533 {
7534 struct torture_printer_context *t =
7535 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
7536 struct dcerpc_pipe *p = t->spoolss_pipe;
7537 struct dcerpc_binding_handle *b = p->binding_handle;
7538 const char *printername = t->info2.printername;
7539
7540 return test_openprinter(tctx, b, printername);
7541 }
7542
7543 static bool test_csetprinter(struct torture_context *tctx,
7544 void *private_data)
7545 {
7546 struct torture_printer_context *t =
7547 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
7548 struct dcerpc_pipe *p = t->spoolss_pipe;
7549
7550 const char *printername = talloc_asprintf(tctx, "%s2", t->info2.printername);
7551 const char *drivername = t->added_driver ? t->driver.info8.driver_name : t->info2.drivername;
7552 const char *portname = t->info2.portname;
7553
7554 union spoolss_PrinterInfo info;
7555 struct policy_handle new_handle, new_handle2;
7556 struct dcerpc_binding_handle *b = p->binding_handle;
7557
7558 torture_comment(tctx, "Testing c_setprinter\n");
7559
7560 torture_assert(tctx,
7561 test_GetPrinter_level(tctx, b, &t->handle, 0, &info),
7562 "failed to get level 0 printer info");
7563 torture_comment(tctx, "csetprinter on initial printer handle: %d\n",
7564 info.info0.c_setprinter);
7565
7566 /* check if c_setprinter on 1st handle increases after a printer has
7567 * been added */
7568
7569 torture_assert(tctx,
7570 test_AddPrinter_normal(tctx, p, &new_handle, printername, drivername, portname, NULL, false),
7571 "failed to add new printer");
7572 torture_assert(tctx,
7573 test_GetPrinter_level(tctx, b, &t->handle, 0, &info),
7574 "failed to get level 0 printer info");
7575 torture_comment(tctx, "csetprinter on initial printer handle (after add): %d\n",
7576 info.info0.c_setprinter);
7577
7578 /* check if c_setprinter on new handle increases after a printer has
7579 * been added */
7580
7581 torture_assert(tctx,
7582 test_GetPrinter_level(tctx, b, &new_handle, 0, &info),
7583 "failed to get level 0 printer info");
7584 torture_comment(tctx, "csetprinter on created handle: %d\n",
7585 info.info0.c_setprinter);
7586
7587 /* open the new printer and check if c_setprinter increases */
7588
7589 torture_assert(tctx,
7590 call_OpenPrinterEx(tctx, p, printername, NULL, &new_handle2),
7591 "failed to open created printer");
7592 torture_assert(tctx,
7593 test_GetPrinter_level(tctx, b, &new_handle2, 0, &info),
7594 "failed to get level 0 printer info");
7595 torture_comment(tctx, "csetprinter on new handle (after openprinter): %d\n",
7596 info.info0.c_setprinter);
7597
7598 /* cleanup */
7599
7600 torture_assert(tctx,
7601 test_ClosePrinter(tctx, b, &new_handle2),
7602 "failed to close printer");
7603 torture_assert(tctx,
7604 test_DeletePrinter(tctx, b, &new_handle),
7605 "failed to delete new printer");
7606
7607 return true;
7608 }
7609
7610 static bool compose_local_driver_directory(struct torture_context *tctx,
7611 const char *environment,
7612 const char *local_dir,
7613 const char **path)
7614 {
7615 char *p;
7616
7617 p = strrchr(local_dir, '/');
7618 if (!p) {
7619 return NULL;
7620 }
7621 p++;
7622
7623 if (strequal(environment, "Windows x64")) {
7624 if (!strequal(p, "x64")) {
7625 *path = talloc_asprintf(tctx, "%s/x64", local_dir);
7626 }
7627 } else if (strequal(environment, "Windows NT x86")) {
7628 if (!strequal(p, "i386")) {
7629 *path = talloc_asprintf(tctx, "%s/i386", local_dir);
7630 }
7631 } else {
7632 torture_assert(tctx, "unknown environment: '%s'\n", environment);
7633 }
7634
7635 return true;
7636 }
7637
7638 static struct spoolss_DeviceMode *torture_devicemode(TALLOC_CTX *mem_ctx,
7639 const char *devicename)
7640 {
7641 struct spoolss_DeviceMode *r;
7642
7643 r = talloc_zero(mem_ctx, struct spoolss_DeviceMode);
7644 if (r == NULL) {
7645 return NULL;
7646 }
7647
7648 r->devicename = talloc_strdup(r, devicename);
7649 r->specversion = DMSPEC_NT4_AND_ABOVE;
7650 r->driverversion = 0x0600;
7651 r->size = 0x00dc;
7652 r->__driverextra_length = 0;
7653 r->fields = DEVMODE_FORMNAME |
7654 DEVMODE_TTOPTION |
7655 DEVMODE_PRINTQUALITY |
7656 DEVMODE_DEFAULTSOURCE |
7657 DEVMODE_COPIES |
7658 DEVMODE_SCALE |
7659 DEVMODE_PAPERSIZE |
7660 DEVMODE_ORIENTATION;
7661 r->orientation = DMORIENT_PORTRAIT;
7662 r->papersize = DMPAPER_LETTER;
7663 r->paperlength = 0;
7664 r->paperwidth = 0;
7665 r->scale = 100;
7666 r->copies = 55;
7667 r->defaultsource = DMBIN_FORMSOURCE;
7668 r->printquality = DMRES_HIGH;
7669 r->color = DMRES_MONOCHROME;
7670 r->duplex = DMDUP_SIMPLEX;
7671 r->yresolution = 0;
7672 r->ttoption = DMTT_SUBDEV;
7673 r->collate = DMCOLLATE_FALSE;
7674 r->formname = talloc_strdup(r, "Letter");
7675
7676 return r;
7677 }
7678
7679 static bool test_architecture_buffer(struct torture_context *tctx,
7680 void *private_data)
7681 {
7682 struct test_spoolss_context *ctx =
7683 talloc_get_type_abort(private_data, struct test_spoolss_context);
7684
7685 struct spoolss_OpenPrinterEx r;
7686 struct spoolss_UserLevel1 u1;
7687 struct policy_handle handle;
7688 uint32_t architectures[] = {
7689 PROCESSOR_ARCHITECTURE_INTEL,
7690 PROCESSOR_ARCHITECTURE_IA64,
7691 PROCESSOR_ARCHITECTURE_AMD64
7692 };
7693 uint32_t needed[3];
7694 int i;
7695 struct dcerpc_pipe *p = ctx->spoolss_pipe;
7696 struct dcerpc_binding_handle *b = p->binding_handle;
7697
7698 for (i=0; i < ARRAY_SIZE(architectures); i++) {
7699
7700 torture_comment(tctx, "Testing OpenPrinterEx with architecture %d\n", architectures[i]);
7701
7702 u1.size = 0;
7703 u1.client = NULL;
7704 u1.user = NULL;
7705 u1.build = 0;
7706 u1.major = 3;
7707 u1.minor = 0;
7708 u1.processor = architectures[i];
7709
7710 r.in.printername = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
7711 r.in.datatype = NULL;
7712 r.in.devmode_ctr.devmode= NULL;
7713 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
7714 r.in.userlevel_ctr.level = 1;
7715 r.in.userlevel_ctr.user_info.level1 = &u1;
7716 r.out.handle = &handle;
7717
7718 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_OpenPrinterEx_r(b, tctx, &r), "");
7719 torture_assert_werr_ok(tctx, r.out.result, "");
7720
7721 {
7722 struct spoolss_EnumPrinters e;
7723 uint32_t count;
7724 union spoolss_PrinterInfo *info;
7725
7726 e.in.flags = PRINTER_ENUM_LOCAL;
7727 e.in.server = NULL;
7728 e.in.level = 2;
7729 e.in.buffer = NULL;
7730 e.in.offered = 0;
7731 e.out.count = &count;
7732 e.out.info = &info;
7733 e.out.needed = &needed[i];
7734
7735 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_EnumPrinters_r(b, tctx, &e), "");
7736 #if 0
7737 torture_comment(tctx, "needed was %d\n", needed[i]);
7738 #endif
7739 }
7740
7741 torture_assert(tctx, test_ClosePrinter(tctx, b, &handle), "");
7742 }
7743
7744 for (i=1; i < ARRAY_SIZE(architectures); i++) {
7745 if (needed[i-1] != needed[i]) {
7746 torture_fail(tctx,
7747 talloc_asprintf(tctx, "needed size %d for architecture %d != needed size %d for architecture %d\n",
7748 needed[i-1], architectures[i-1], needed[i], architectures[i]));
7749 }
7750 }
7751
7752 return true;
7753 }
7754
7755 static bool test_PrintServer_Forms_Winreg(struct torture_context *tctx,
7756 void *private_data)
7757 {
7758 struct test_spoolss_context *ctx =
7759 talloc_get_type_abort(private_data, struct test_spoolss_context);
7760 struct dcerpc_pipe *p = ctx->spoolss_pipe;
7761 struct dcerpc_binding_handle *b = p->binding_handle;
7762
7763 return test_Forms_winreg(tctx, b, &ctx->server_handle, true, NULL);
7764 }
7765
7766 static bool test_PrintServer_Forms(struct torture_context *tctx,
7767 void *private_data)
7768 {
7769 struct test_spoolss_context *ctx =
7770 talloc_get_type_abort(private_data, struct test_spoolss_context);
7771 struct dcerpc_pipe *p = ctx->spoolss_pipe;
7772 struct dcerpc_binding_handle *b = p->binding_handle;
7773
7774 return test_Forms(tctx, b, &ctx->server_handle, true, NULL, NULL, NULL);
7775 }
7776
7777 static bool test_PrintServer_EnumForms(struct torture_context *tctx,
7778 void *private_data)
7779 {
7780 struct test_spoolss_context *ctx =
7781 talloc_get_type_abort(private_data, struct test_spoolss_context);
7782 struct dcerpc_pipe *p = ctx->spoolss_pipe;
7783 struct dcerpc_binding_handle *b = p->binding_handle;
7784
7785 return test_EnumForms_all(tctx, b, &ctx->server_handle, true);
7786 }
7787
7788 static bool torture_rpc_spoolss_setup_common(struct torture_context *tctx, struct test_spoolss_context *t)
7789 {
7790 NTSTATUS status;
7791
7792 status = torture_rpc_connection(tctx, &t->spoolss_pipe, &ndr_table_spoolss);
7793
7794 torture_assert_ntstatus_ok(tctx, status, "Error connecting to server");
7795
7796 torture_assert(tctx,
7797 test_OpenPrinter_server(tctx, t->spoolss_pipe, &t->server_handle),
7798 "failed to open printserver");
7799 torture_assert(tctx,
7800 test_get_environment(tctx, t->spoolss_pipe->binding_handle, &t->server_handle, &t->environment),
7801 "failed to get environment");
7802
7803 return true;
7804 }
7805
7806 static bool torture_rpc_spoolss_setup(struct torture_context *tctx, void **data)
7807 {
7808 struct test_spoolss_context *t;
7809
7810 *data = t = talloc_zero(tctx, struct test_spoolss_context);
7811
7812 return torture_rpc_spoolss_setup_common(tctx, t);
7813 }
7814
7815 static bool torture_rpc_spoolss_teardown_common(struct torture_context *tctx, struct test_spoolss_context *t)
7816 {
7817 test_ClosePrinter(tctx, t->spoolss_pipe->binding_handle, &t->server_handle);
7818
7819 return true;
7820 }
7821
7822 static bool torture_rpc_spoolss_teardown(struct torture_context *tctx, void *data)
7823 {
7824 struct test_spoolss_context *t = talloc_get_type(data, struct test_spoolss_context);
7825 bool ret;
7826
7827 ret = torture_rpc_spoolss_teardown_common(tctx, t);
7828 talloc_free(t);
7829
7830 return ret;
7831 }
7832
7833 static bool torture_rpc_spoolss_printer_setup_common(struct torture_context *tctx, struct torture_printer_context *t)
7834 {
7835 struct dcerpc_pipe *p;
7836 struct dcerpc_binding_handle *b;
7837 const char *server_name_slash;
7838 const char *driver_name;
7839 const char *printer_name;
7840 const char *port_name;
7841
7842 torture_assert_ntstatus_ok(tctx,
7843 torture_rpc_connection(tctx, &t->spoolss_pipe, &ndr_table_spoolss),
7844 "Error connecting to server");
7845
7846 p = t->spoolss_pipe;
7847 b = p->binding_handle;
7848 server_name_slash = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
7849
7850 t->driver.info8.version = SPOOLSS_DRIVER_VERSION_200X;
7851 t->driver.info8.driver_name = TORTURE_DRIVER;
7852 t->driver.info8.driver_path = "pscript5.dll";
7853 t->driver.info8.data_file = "cups6.ppd";
7854 t->driver.info8.config_file = "ps5ui.dll";
7855 t->driver.info8.help_file = "pscript.hlp";
7856 t->driver.info8.default_datatype = "RAW";
7857 t->driver.info8.dependent_files = talloc_zero(t, struct spoolss_StringArray);
7858 t->driver.info8.dependent_files->string = talloc_zero_array(t, const char *, 8 + 1);
7859 t->driver.info8.dependent_files->string[0] = "pscript5.dll";
7860 t->driver.info8.dependent_files->string[1] = "cups6.ppd";
7861 t->driver.info8.dependent_files->string[2] = "ps5ui.dll";
7862 t->driver.info8.dependent_files->string[3] = "pscript.hlp";
7863 t->driver.info8.dependent_files->string[4] = "pscript.ntf";
7864 t->driver.info8.dependent_files->string[5] = "cups6.ini";
7865 t->driver.info8.dependent_files->string[6] = "cupsps6.dll";
7866 t->driver.info8.dependent_files->string[7] = "cupsui6.dll";
7867
7868 t->driver.local.driver_directory= "/usr/share/cups/drivers";
7869
7870 t->info2.portname = "LPT1:";
7871
7872 printer_name = t->info2.printername;
7873 port_name = t->info2.portname;
7874
7875 torture_assert(tctx,
7876 fillup_printserver_info(tctx, p, &t->driver),
7877 "failed to fillup printserver info");
7878
7879 t->driver.info8.architecture = talloc_strdup(t, t->driver.remote.environment);
7880
7881 torture_assert(tctx,
7882 compose_local_driver_directory(tctx, t->driver.remote.environment,
7883 t->driver.local.driver_directory,
7884 &t->driver.local.driver_directory),
7885 "failed to compose local driver directory");
7886
7887 t->info2.drivername = "Microsoft XPS Document Writer";
7888
7889 if (test_EnumPrinterDrivers_findone(tctx, b, server_name_slash, t->driver.remote.environment, 3, t->info2.drivername, NULL)) {
7890 torture_comment(tctx, "driver '%s' (architecture: %s, version: 3) is present on server\n",
7891 t->info2.drivername, t->driver.remote.environment);
7892 t->have_driver = true;
7893 goto try_add;
7894 }
7895
7896 torture_comment(tctx, "driver '%s' (architecture: %s, version: 3) does not exist on the server\n",
7897 t->info2.drivername, t->driver.remote.environment);
7898
7899 t->info2.drivername = "Microsoft XPS Document Writer v4";
7900
7901 if (test_EnumPrinterDrivers_findone(tctx, b, server_name_slash, t->driver.remote.environment, 3, t->info2.drivername, NULL)) {
7902 torture_comment(tctx, "driver '%s' (architecture: %s, version: 4) is present on server\n",
7903 t->info2.drivername, t->driver.remote.environment);
7904 t->have_driver = true;
7905 goto try_add;
7906 }
7907
7908 torture_comment(tctx, "trying to upload own driver\n");
7909
7910 if (!directory_exist(t->driver.local.driver_directory)) {
7911 torture_warning(tctx, "no local driver is available!");
7912 t->have_driver = false;
7913 goto try_add;
7914 }
7915
7916 torture_assert(tctx,
7917 upload_printer_driver(tctx, dcerpc_server_name(p), &t->driver),
7918 "failed to upload printer driver");
7919
7920 torture_assert(tctx,
7921 test_AddPrinterDriver_args_level_3(tctx, b, server_name_slash, &t->driver.info8, 0, false, NULL),
7922 "failed to add driver");
7923
7924 t->added_driver = true;
7925 t->have_driver = true;
7926
7927 try_add:
7928 driver_name = t->added_driver ? t->driver.info8.driver_name : t->info2.drivername;
7929
7930 if (t->wellknown) {
7931 torture_assert(tctx,
7932 test_AddPrinter_wellknown(tctx, p, printer_name, t->ex),
7933 "failed to add wellknown printer");
7934 } else {
7935 torture_assert(tctx,
7936 test_AddPrinter_normal(tctx, p, &t->handle, printer_name, driver_name, port_name, t->devmode, t->ex),
7937 "failed to add printer");
7938 }
7939
7940 return true;
7941 }
7942
7943 static bool torture_rpc_spoolss_printer_setup(struct torture_context *tctx, void **data)
7944 {
7945 struct torture_printer_context *t;
7946
7947 *data = t = talloc_zero(tctx, struct torture_printer_context);
7948
7949 t->ex = false;
7950 t->wellknown = false;
7951 t->info2.printername = TORTURE_PRINTER;
7952 t->devmode = NULL;
7953
7954 return torture_rpc_spoolss_printer_setup_common(tctx, t);
7955 }
7956
7957 static bool torture_rpc_spoolss_printerex_setup(struct torture_context *tctx, void **data)
7958 {
7959 struct torture_printer_context *t;
7960
7961 *data = t = talloc_zero(tctx, struct torture_printer_context);
7962
7963 t->ex = true;
7964 t->wellknown = false;
7965 t->info2.printername = TORTURE_PRINTER_EX;
7966 t->devmode = NULL;
7967
7968 return torture_rpc_spoolss_printer_setup_common(tctx, t);
7969 }
7970
7971 static bool torture_rpc_spoolss_printerwkn_setup(struct torture_context *tctx, void **data)
7972 {
7973 struct torture_printer_context *t;
7974
7975 *data = t = talloc_zero(tctx, struct torture_printer_context);
7976
7977 t->ex = false;
7978 t->wellknown = true;
7979 t->info2.printername = TORTURE_WELLKNOWN_PRINTER;
7980 t->devmode = NULL;
7981
7982 /* FIXME */
7983 if (t->wellknown) {
7984 torture_skip(tctx, "skipping AddPrinter level 1");
7985 }
7986
7987 return torture_rpc_spoolss_printer_setup_common(tctx, t);
7988 }
7989
7990 static bool torture_rpc_spoolss_printerexwkn_setup(struct torture_context *tctx, void **data)
7991 {
7992 struct torture_printer_context *t;
7993
7994 *data = t = talloc_zero(tctx, struct torture_printer_context);
7995
7996 t->ex = true;
7997 t->wellknown = true;
7998 t->info2.printername = TORTURE_WELLKNOWN_PRINTER_EX;
7999 t->devmode = NULL;
8000
8001 /* FIXME */
8002 if (t->wellknown) {
8003 torture_skip(tctx, "skipping AddPrinterEx level 1");
8004 }
8005
8006 return torture_rpc_spoolss_printer_setup_common(tctx, t);
8007 }
8008
8009 static bool torture_rpc_spoolss_printerdm_setup(struct torture_context *tctx, void **data)
8010 {
8011 struct torture_printer_context *t;
8012
8013 *data = t = talloc_zero(tctx, struct torture_printer_context);
8014
8015 t->ex = true;
8016 t->wellknown = false;
8017 t->info2.printername = TORTURE_PRINTER_EX;
8018 t->devmode = torture_devicemode(t, TORTURE_PRINTER_EX);
8019
8020 return torture_rpc_spoolss_printer_setup_common(tctx, t);
8021 }
8022
8023 static bool torture_rpc_spoolss_printer_teardown_common(struct torture_context *tctx, struct torture_printer_context *t)
8024 {
8025 bool found = false;
8026 struct dcerpc_pipe *p = t->spoolss_pipe;
8027 struct dcerpc_binding_handle *b;
8028 const char *printer_name = t->info2.printername;
8029
8030 if (t->added_driver) {
8031 torture_assert(tctx,
8032 remove_printer_driver(tctx, dcerpc_server_name(t->spoolss_pipe), &t->driver),
8033 "failed to remove printer driver");
8034 }
8035
8036 if (p && !t->wellknown) {
8037 b = p->binding_handle;
8038
8039 torture_assert(tctx,
8040 test_DeletePrinter(tctx, b, &t->handle),
8041 "failed to delete printer");
8042
8043 torture_assert(tctx,
8044 test_EnumPrinters_findname(tctx, b, PRINTER_ENUM_LOCAL, 1,
8045 printer_name, &found),
8046 "failed to enumerate printers");
8047
8048 torture_assert(tctx, !found, "deleted printer still there");
8049 }
8050
8051 return true;
8052 }
8053
8054 static bool torture_rpc_spoolss_printer_teardown(struct torture_context *tctx, void *data)
8055 {
8056 struct torture_printer_context *t = talloc_get_type(data, struct torture_printer_context);
8057 bool ret;
8058
8059 ret = torture_rpc_spoolss_printer_teardown_common(tctx, t);
8060 talloc_free(t);
8061
8062 return ret;
8063 }
8064
8065 static bool test_print_test(struct torture_context *tctx,
8066 void *private_data)
8067 {
8068 struct torture_printer_context *t =
8069 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8070 struct dcerpc_pipe *p = t->spoolss_pipe;
8071 struct dcerpc_binding_handle *b = p->binding_handle;
8072
8073 torture_assert(tctx,
8074 test_PausePrinter(tctx, b, &t->handle),
8075 "failed to pause printer");
8076
8077 torture_assert(tctx,
8078 test_DoPrintTest(tctx, b, &t->handle),
8079 "failed to do print test");
8080
8081 torture_assert(tctx,
8082 test_ResumePrinter(tctx, b, &t->handle),
8083 "failed to resume printer");
8084
8085 return true;
8086 }
8087
8088 static bool test_print_test_extended(struct torture_context *tctx,
8089 void *private_data)
8090 {
8091 struct torture_printer_context *t =
8092 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8093 struct dcerpc_pipe *p = t->spoolss_pipe;
8094 struct dcerpc_binding_handle *b = p->binding_handle;
8095 bool ret = true;
8096
8097 torture_assert(tctx,
8098 test_PausePrinter(tctx, b, &t->handle),
8099 "failed to pause printer");
8100
8101 ret = test_DoPrintTest_extended(tctx, b, &t->handle);
8102 if (ret == false) {
8103 torture_comment(tctx, "WARNING! failed to do extended print test\n");
8104 if (torture_setting_bool(tctx, "samba3", false)) {
8105 torture_comment(tctx, "non-critical for samba3\n");
8106 ret = true;
8107 tctx->last_result = TORTURE_SKIP;
8108 }
8109 }
8110
8111 torture_assert(tctx,
8112 test_ResumePrinter(tctx, b, &t->handle),
8113 "failed to resume printer");
8114
8115 return ret;
8116 }
8117
8118 static bool test_print_test_properties(struct torture_context *tctx,
8119 void *private_data)
8120 {
8121 struct torture_printer_context *t =
8122 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8123 struct dcerpc_pipe *p = t->spoolss_pipe;
8124 struct dcerpc_binding_handle *b = p->binding_handle;
8125
8126 if (torture_setting_bool(tctx, "samba3", false)) {
8127 torture_skip(tctx, "skip printer job property tests against samba");
8128 }
8129
8130 torture_assert(tctx,
8131 test_PausePrinter(tctx, b, &t->handle),
8132 "failed to pause printer");
8133
8134 torture_assert(tctx,
8135 test_DoPrintTest_properties(tctx, b, &t->handle),
8136 "failed to test print job properties");
8137
8138 torture_assert(tctx,
8139 test_ResumePrinter(tctx, b, &t->handle),
8140 "failed to resume printer");
8141
8142 return true;
8143 }
8144
8145 /* use smbd file IO to spool a print job */
8146 static bool test_print_test_smbd(struct torture_context *tctx,
8147 void *private_data)
8148 {
8149 struct torture_printer_context *t =
8150 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8151 struct dcerpc_pipe *p = t->spoolss_pipe;
8152 struct dcerpc_binding_handle *b = p->binding_handle;
8153 NTSTATUS status;
8154 uint32_t count;
8155 union spoolss_JobInfo *info = NULL;
8156 int i;
8157
8158 struct smb2_tree *tree;
8159 struct smb2_handle job_h;
8160 struct cli_credentials *credentials = cmdline_credentials;
8161 struct smbcli_options options;
8162 TALLOC_CTX *mem_ctx = talloc_new(tctx);
8163 /*
8164 * Do not test against the dynamically added printers, printing via
8165 * smbd means that a different spoolss process may handle the
8166 * OpenPrinter request to the one that handled the AddPrinter request.
8167 * This currently leads to an ugly race condition where one process
8168 * sees the new printer and one doesn't.
8169 */
8170 const char *share = TORTURE_PRINTER_STATIC1;
8171
8172 torture_comment(tctx, "Testing smbd job spooling\n");
8173 lpcfg_smbcli_options(tctx->lp_ctx, &options);
8174
8175 status = smb2_connect_ext(mem_ctx,
8176 torture_setting_string(tctx, "host", NULL),
8177 lpcfg_smb_ports(tctx->lp_ctx),
8178 share,
8179 lpcfg_resolve_context(tctx->lp_ctx),
8180 credentials,
8181 0,
8182 &tree,
8183 tctx->ev,
8184 &options,
8185 lpcfg_socket_options(tctx->lp_ctx),
8186 lpcfg_gensec_settings(tctx, tctx->lp_ctx));
8187 if (!NT_STATUS_IS_OK(status)) {
8188 printf("Failed to connect to SMB2 printer %s - %s\n",
8189 share, nt_errstr(status));
8190 return false;
8191 }
8192
8193 status = torture_smb2_testfile(tree, "smbd_spooler_job", &job_h);
8194 torture_assert_ntstatus_ok(tctx, status, "smbd spool job create");
8195
8196 status = smb2_util_write(tree, job_h, "exciting print job data", 0,
8197 sizeof("exciting print job data"));
8198 torture_assert_ntstatus_ok(tctx, status, "smbd spool job write");
8199
8200 /* check back end spoolss job was created */
8201 torture_assert(tctx,
8202 test_EnumJobs_args(tctx, b, &t->handle, 1, &count, &info),
8203 "EnumJobs level 1 failed");
8204
8205 for (i = 0; i < count; i++) {
8206 if (!strcmp(info[i].info1.document_name, "smbd_spooler_job")) {
8207 break;
8208 }
8209 }
8210 torture_assert(tctx, (i != count), "smbd_spooler_job not found");
8211
8212 status = smb2_util_close(tree, job_h);
8213 torture_assert_ntstatus_ok(tctx, status, "smbd spool job close");
8214
8215 /* disconnect from printer share */
8216 talloc_free(mem_ctx);
8217
8218 return true;
8219 }
8220
8221 static bool test_printer_sd(struct torture_context *tctx,
8222 void *private_data)
8223 {
8224 struct torture_printer_context *t =
8225 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8226 struct dcerpc_pipe *p = t->spoolss_pipe;
8227 struct dcerpc_binding_handle *b = p->binding_handle;
8228
8229 torture_assert(tctx,
8230 test_PrinterInfo_SD(tctx, b, &t->handle),
8231 "failed to test security descriptors");
8232
8233 return true;
8234 }
8235
8236 static bool test_printer_dm(struct torture_context *tctx,
8237 void *private_data)
8238 {
8239 struct torture_printer_context *t =
8240 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8241 struct dcerpc_pipe *p = t->spoolss_pipe;
8242
8243 torture_assert(tctx,
8244 test_PrinterInfo_DevMode(tctx, p, &t->handle, t->info2.printername, t->devmode),
8245 "failed to test devicemodes");
8246
8247 return true;
8248 }
8249
8250 static bool test_printer_info_winreg(struct torture_context *tctx,
8251 void *private_data)
8252 {
8253 struct torture_printer_context *t =
8254 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8255 struct dcerpc_pipe *p = t->spoolss_pipe;
8256
8257 torture_assert(tctx,
8258 test_PrinterInfo_winreg(tctx, p, &t->handle, t->info2.printername),
8259 "failed to test printer info winreg");
8260
8261 return true;
8262 }
8263
8264 static bool test_printer_change_id(struct torture_context *tctx,
8265 void *private_data)
8266 {
8267 struct torture_printer_context *t =
8268 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8269 struct dcerpc_pipe *p = t->spoolss_pipe;
8270
8271 torture_assert(tctx,
8272 test_ChangeID(tctx, p, &t->handle),
8273 "failed to test change id");
8274
8275 return true;
8276 }
8277
8278 static bool test_printer_keys(struct torture_context *tctx,
8279 void *private_data)
8280 {
8281 struct torture_printer_context *t =
8282 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8283 struct dcerpc_pipe *p = t->spoolss_pipe;
8284 struct dcerpc_binding_handle *b = p->binding_handle;
8285
8286 torture_assert(tctx,
8287 test_printer_all_keys(tctx, b, &t->handle),
8288 "failed to test printer keys");
8289
8290 return true;
8291 }
8292
8293 static bool test_printer_data_consistency(struct torture_context *tctx,
8294 void *private_data)
8295 {
8296 struct torture_printer_context *t =
8297 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8298 struct dcerpc_pipe *p = t->spoolss_pipe;
8299
8300 torture_assert(tctx,
8301 test_EnumPrinterData_consistency(tctx, p, &t->handle),
8302 "failed to test printer data consistency");
8303
8304 return true;
8305 }
8306
8307 static bool test_printer_data_keys(struct torture_context *tctx,
8308 void *private_data)
8309 {
8310 struct torture_printer_context *t =
8311 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8312 struct dcerpc_pipe *p = t->spoolss_pipe;
8313
8314 torture_assert(tctx,
8315 test_SetPrinterDataEx_keys(tctx, p, &t->handle),
8316 "failed to test printer data keys");
8317
8318 return true;
8319 }
8320
8321 static bool test_printer_data_values(struct torture_context *tctx,
8322 void *private_data)
8323 {
8324 struct torture_printer_context *t =
8325 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8326 struct dcerpc_pipe *p = t->spoolss_pipe;
8327
8328 torture_assert(tctx,
8329 test_SetPrinterDataEx_values(tctx, p, &t->handle),
8330 "failed to test printer data values");
8331
8332 return true;
8333 }
8334
8335 static bool test_printer_data_set(struct torture_context *tctx,
8336 void *private_data)
8337 {
8338 struct torture_printer_context *t =
8339 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8340 struct dcerpc_pipe *p = t->spoolss_pipe;
8341
8342 torture_assert(tctx,
8343 test_SetPrinterDataEx_matrix(tctx, p, &t->handle, t->info2.printername, NULL, NULL),
8344 "failed to test printer data set");
8345
8346 return true;
8347 }
8348
8349 static bool test_printer_data_winreg(struct torture_context *tctx,
8350 void *private_data)
8351 {
8352 struct torture_printer_context *t =
8353 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8354 struct dcerpc_pipe *p = t->spoolss_pipe;
8355
8356 torture_assert(tctx,
8357 test_PrinterData_winreg(tctx, p, &t->handle, t->info2.printername),
8358 "failed to test printer data winreg");
8359
8360 return true;
8361 }
8362
8363 static bool test_printer_data_dsspooler(struct torture_context *tctx,
8364 void *private_data)
8365 {
8366 struct torture_printer_context *t =
8367 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8368 struct dcerpc_pipe *p = t->spoolss_pipe;
8369
8370 torture_assert(tctx,
8371 test_PrinterData_DsSpooler(tctx, p, &t->handle, t->info2.printername),
8372 "failed to test printer data winreg dsspooler");
8373
8374 return true;
8375 }
8376
8377 static bool test_printer_ic(struct torture_context *tctx,
8378 void *private_data)
8379 {
8380 struct torture_printer_context *t =
8381 talloc_get_type_abort(private_data,
8382 struct torture_printer_context);
8383 struct dcerpc_pipe *p = t->spoolss_pipe;
8384 struct dcerpc_binding_handle *b = p->binding_handle;
8385 struct policy_handle gdi_handle;
8386
8387 if (torture_setting_bool(tctx, "samba3", false)) {
8388 torture_skip(tctx, "skip printer information context tests against samba");
8389 }
8390
8391 {
8392 struct spoolss_CreatePrinterIC r;
8393 struct spoolss_DevmodeContainer devmode_ctr;
8394
8395 ZERO_STRUCT(devmode_ctr);
8396
8397 r.in.handle = &t->handle;
8398 r.in.devmode_ctr = &devmode_ctr;
8399 r.out.gdi_handle = &gdi_handle;
8400
8401 torture_assert_ntstatus_ok(tctx,
8402 dcerpc_spoolss_CreatePrinterIC_r(b, tctx, &r),
8403 "CreatePrinterIC failed");
8404 torture_assert_werr_ok(tctx, r.out.result,
8405 "CreatePrinterIC failed");
8406 }
8407
8408 {
8409 struct spoolss_PlayGDIScriptOnPrinterIC r;
8410 DATA_BLOB in,out;
8411 int i;
8412 uint32_t num_fonts = 0;
8413
8414 in = data_blob_string_const("");
8415
8416 r.in.gdi_handle = &gdi_handle;
8417 r.in.pIn = in.data;
8418 r.in.cIn = in.length;
8419 r.in.ul = 0;
8420
8421 for (i = 0; i < 4; i++) {
8422
8423 out = data_blob_talloc_zero(tctx, i);
8424
8425 r.in.cOut = out.length;
8426 r.out.pOut = out.data;
8427
8428 torture_assert_ntstatus_ok(tctx,
8429 dcerpc_spoolss_PlayGDIScriptOnPrinterIC_r(b, tctx, &r),
8430 "PlayGDIScriptOnPrinterIC failed");
8431 torture_assert_werr_equal(tctx, r.out.result, WERR_NOMEM,
8432 "PlayGDIScriptOnPrinterIC failed");
8433 }
8434
8435 out = data_blob_talloc_zero(tctx, 4);
8436
8437 r.in.cOut = out.length;
8438 r.out.pOut = out.data;
8439
8440 torture_assert_ntstatus_ok(tctx,
8441 dcerpc_spoolss_PlayGDIScriptOnPrinterIC_r(b, tctx, &r),
8442 "PlayGDIScriptOnPrinterIC failed");
8443 torture_assert_werr_equal(tctx, r.out.result, WERR_OK,
8444 "PlayGDIScriptOnPrinterIC failed");
8445
8446 /* now we should have the required length, so retry with a
8447 * buffer which is large enough to carry all font ids */
8448
8449 num_fonts = IVAL(r.out.pOut, 0);
8450
8451 torture_comment(tctx, "PlayGDIScriptOnPrinterIC gave font count of %d\n", num_fonts);
8452
8453 out = data_blob_talloc_zero(tctx,
8454 num_fonts * sizeof(struct UNIVERSAL_FONT_ID) + 4);
8455
8456 r.in.cOut = out.length;
8457 r.out.pOut = out.data;
8458
8459 torture_assert_ntstatus_ok(tctx,
8460 dcerpc_spoolss_PlayGDIScriptOnPrinterIC_r(b, tctx, &r),
8461 "PlayGDIScriptOnPrinterIC failed");
8462 torture_assert_werr_equal(tctx, r.out.result, WERR_OK,
8463 "PlayGDIScriptOnPrinterIC failed");
8464
8465 }
8466
8467 {
8468 struct spoolss_DeletePrinterIC r;
8469
8470 r.in.gdi_handle = &gdi_handle;
8471 r.out.gdi_handle = &gdi_handle;
8472
8473 torture_assert_ntstatus_ok(tctx,
8474 dcerpc_spoolss_DeletePrinterIC_r(b, tctx, &r),
8475 "DeletePrinterIC failed");
8476 torture_assert_werr_ok(tctx, r.out.result,
8477 "DeletePrinterIC failed");
8478
8479 }
8480
8481 return true;
8482 }
8483
8484 static bool test_printer_bidi(struct torture_context *tctx,
8485 void *private_data)
8486 {
8487 struct torture_printer_context *t =
8488 talloc_get_type_abort(private_data,
8489 struct torture_printer_context);
8490 struct dcerpc_pipe *p = t->spoolss_pipe;
8491 struct dcerpc_binding_handle *b = p->binding_handle;
8492 struct spoolss_RpcSendRecvBidiData r;
8493 struct RPC_BIDI_REQUEST_CONTAINER bidi_req;
8494 struct RPC_BIDI_RESPONSE_CONTAINER *bidi_rep = NULL;
8495
8496 if (torture_setting_bool(tctx, "samba3", false)) {
8497 torture_skip(tctx, "skip printer bidirectional tests against samba");
8498 }
8499
8500 ZERO_STRUCT(bidi_req);
8501
8502 r.in.hPrinter = t->handle;
8503 r.in.pAction = "foobar";
8504 r.in.pReqData = &bidi_req;
8505 r.out.ppRespData = &bidi_rep;
8506
8507 torture_assert_ntstatus_ok(tctx,
8508 dcerpc_spoolss_RpcSendRecvBidiData_r(b, tctx, &r),
8509 "RpcSendRecvBidiData failed");
8510 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
8511 "RpcSendRecvBidiData failed");
8512
8513 if (!(t->info2.attributes & PRINTER_ATTRIBUTE_ENABLE_BIDI)) {
8514 torture_skip(tctx, "skipping further tests as printer is not BIDI enabled");
8515 }
8516
8517 r.in.pAction = BIDI_ACTION_ENUM_SCHEMA;
8518
8519 torture_assert_ntstatus_ok(tctx,
8520 dcerpc_spoolss_RpcSendRecvBidiData_r(b, tctx, &r),
8521 "RpcSendRecvBidiData failed");
8522 torture_assert_werr_ok(tctx, r.out.result,
8523 "RpcSendRecvBidiData failed");
8524
8525 return true;
8526 }
8527
8528 static bool test_printer_set_publish(struct torture_context *tctx,
8529 struct dcerpc_binding_handle *b,
8530 struct policy_handle *handle)
8531 {
8532 union spoolss_PrinterInfo info;
8533 struct spoolss_SetPrinterInfo7 info7;
8534 struct spoolss_SetPrinterInfoCtr info_ctr;
8535 struct spoolss_DevmodeContainer devmode_ctr;
8536 struct sec_desc_buf secdesc_ctr;
8537 struct GUID guid;
8538
8539 info7.guid = "";
8540 info7.action = DSPRINT_PUBLISH;
8541
8542 ZERO_STRUCT(info_ctr);
8543 ZERO_STRUCT(devmode_ctr);
8544 ZERO_STRUCT(secdesc_ctr);
8545 info_ctr.level = 7;
8546 info_ctr.info.info7 = &info7;
8547
8548 torture_assert(tctx,
8549 test_SetPrinter(tctx, b, handle, &info_ctr,
8550 &devmode_ctr, &secdesc_ctr, 0), "");
8551
8552 torture_assert(tctx,
8553 test_GetPrinter_level(tctx, b, handle, 2, &info),
8554 "");
8555 torture_assert(tctx,
8556 (info.info2.attributes & PRINTER_ATTRIBUTE_PUBLISHED),
8557 "info2 publish flag not set");
8558 torture_assert(tctx,
8559 test_GetPrinter_level(tctx, b, handle, 7, &info),
8560 "");
8561 torture_assert_int_equal(tctx,
8562 info.info7.action, DSPRINT_PUBLISH,
8563 "info7 publish flag not set");
8564 torture_assert_ntstatus_ok(tctx, GUID_from_string(info.info7.guid, &guid),
8565 "invalid guid for published printer");
8566
8567 return true;
8568 }
8569
8570 static bool test_printer_set_unpublish(struct torture_context *tctx,
8571 struct dcerpc_binding_handle *b,
8572 struct policy_handle *handle)
8573 {
8574 union spoolss_PrinterInfo info;
8575 struct spoolss_SetPrinterInfo7 info7;
8576 struct spoolss_SetPrinterInfoCtr info_ctr;
8577 struct spoolss_DevmodeContainer devmode_ctr;
8578 struct sec_desc_buf secdesc_ctr;
8579
8580 info7.action = DSPRINT_UNPUBLISH;
8581 info7.guid = "";
8582
8583 ZERO_STRUCT(info_ctr);
8584 ZERO_STRUCT(devmode_ctr);
8585 ZERO_STRUCT(secdesc_ctr);
8586 info_ctr.level = 7;
8587 info_ctr.info.info7 = &info7;
8588
8589 torture_assert(tctx,
8590 test_SetPrinter(tctx, b, handle, &info_ctr,
8591 &devmode_ctr, &secdesc_ctr, 0), "");
8592
8593 torture_assert(tctx,
8594 test_GetPrinter_level(tctx, b, handle, 2, &info),
8595 "");
8596 torture_assert(tctx,
8597 !(info.info2.attributes & PRINTER_ATTRIBUTE_PUBLISHED),
8598 "info2 publish flag still set");
8599 torture_assert(tctx,
8600 test_GetPrinter_level(tctx, b, handle, 7, &info),
8601 "");
8602 torture_assert_int_equal(tctx,
8603 info.info7.action, DSPRINT_UNPUBLISH,
8604 "info7 unpublish flag not set");
8605 torture_assert_str_equal(tctx,
8606 info.info7.guid, "",
8607 "guid not empty after unpublish");
8608
8609 return true;
8610 }
8611
8612 static bool test_printer_publish_toggle(struct torture_context *tctx,
8613 void *private_data)
8614 {
8615 struct torture_printer_context *t =
8616 talloc_get_type_abort(private_data,
8617 struct torture_printer_context);
8618 struct dcerpc_pipe *p = t->spoolss_pipe;
8619 struct dcerpc_binding_handle *b = p->binding_handle;
8620 struct policy_handle *handle = &t->handle;
8621 union spoolss_PrinterInfo info7;
8622 union spoolss_PrinterInfo info2;
8623
8624 /* check publish status via level 7 and level 2 */
8625 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 7, &info7),
8626 "");
8627 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info2),
8628 "");
8629
8630 if (info2.info2.attributes & PRINTER_ATTRIBUTE_PUBLISHED) {
8631 torture_assert_int_equal(tctx,
8632 info7.info7.action, DSPRINT_PUBLISH,
8633 "info7 publish flag not set");
8634 torture_assert(tctx, test_printer_set_unpublish(tctx, b, handle), "");
8635 torture_assert(tctx, test_printer_set_publish(tctx, b, handle), "");
8636 } else {
8637 torture_assert_int_equal(tctx,
8638 info7.info7.action, DSPRINT_UNPUBLISH,
8639 "info7 unpublish flag not set");
8640 torture_assert(tctx, test_printer_set_publish(tctx, b, handle), "");
8641 torture_assert(tctx, test_printer_set_unpublish(tctx, b, handle), "");
8642 }
8643
8644 return true;
8645 }
8646
8647 static bool test_driver_info_winreg(struct torture_context *tctx,
8648 void *private_data)
8649 {
8650 struct torture_printer_context *t =
8651 (struct torture_printer_context *)talloc_get_type_abort(private_data, struct torture_printer_context);
8652 struct dcerpc_pipe *p = t->spoolss_pipe;
8653 const char *driver_name = t->added_driver ? t->driver.info8.driver_name : t->info2.drivername;
8654
8655 if (!t->have_driver) {
8656 torture_skip(tctx, "skipping driver info winreg test as we don't have a driver");
8657 }
8658
8659 torture_assert(tctx,
8660 test_DriverInfo_winreg(tctx, p, &t->handle, t->info2.printername, driver_name, t->driver.remote.environment, 3),
8661 "failed to test driver info winreg");
8662
8663 return true;
8664 }
8665
8666 void torture_tcase_printer(struct torture_tcase *tcase)
8667 {
8668 torture_tcase_add_simple_test(tcase, "openprinter", test_openprinter_wrap);
8669 torture_tcase_add_simple_test(tcase, "csetprinter", test_csetprinter);
8670 torture_tcase_add_simple_test(tcase, "print_test", test_print_test);
8671 torture_tcase_add_simple_test(tcase, "print_test_extended", test_print_test_extended);
8672 torture_tcase_add_simple_test(tcase, "print_test_smbd", test_print_test_smbd);
8673 torture_tcase_add_simple_test(tcase, "print_test_properties", test_print_test_properties);
8674 torture_tcase_add_simple_test(tcase, "printer_info", test_printer_info);
8675 torture_tcase_add_simple_test(tcase, "sd", test_printer_sd);
8676 torture_tcase_add_simple_test(tcase, "dm", test_printer_dm);
8677 torture_tcase_add_simple_test(tcase, "printer_info_winreg", test_printer_info_winreg);
8678 torture_tcase_add_simple_test(tcase, "change_id", test_printer_change_id);
8679 torture_tcase_add_simple_test(tcase, "keys", test_printer_keys);
8680 torture_tcase_add_simple_test(tcase, "printerdata_consistency", test_printer_data_consistency);
8681 torture_tcase_add_simple_test(tcase, "printerdata_keys", test_printer_data_keys);
8682 torture_tcase_add_simple_test(tcase, "printerdata_values", test_printer_data_values);
8683 torture_tcase_add_simple_test(tcase, "printerdata_set", test_printer_data_set);
8684 torture_tcase_add_simple_test(tcase, "printerdata_winreg", test_printer_data_winreg);
8685 torture_tcase_add_simple_test(tcase, "printerdata_dsspooler", test_printer_data_dsspooler);
8686 torture_tcase_add_simple_test(tcase, "driver_info_winreg", test_driver_info_winreg);
8687 torture_tcase_add_simple_test(tcase, "printer_rename", test_printer_rename);
8688 torture_tcase_add_simple_test(tcase, "printer_ic", test_printer_ic);
8689 torture_tcase_add_simple_test(tcase, "bidi", test_printer_bidi);
8690 torture_tcase_add_simple_test(tcase, "publish_toggle",
8691 test_printer_publish_toggle);
8692 }
8693
8694 struct torture_suite *torture_rpc_spoolss_printer(TALLOC_CTX *mem_ctx)
8695 {
8696 struct torture_suite *suite = torture_suite_create(mem_ctx, "printer");
8697 struct torture_tcase *tcase;
8698
8699 tcase = torture_suite_add_tcase(suite, "addprinter");
8700
8701 torture_tcase_set_fixture(tcase,
8702 torture_rpc_spoolss_printer_setup,
8703 torture_rpc_spoolss_printer_teardown);
8704
8705 torture_tcase_printer(tcase);
8706
8707 tcase = torture_suite_add_tcase(suite, "addprinterex");
8708
8709 torture_tcase_set_fixture(tcase,
8710 torture_rpc_spoolss_printerex_setup,
8711 torture_rpc_spoolss_printer_teardown);
8712
8713 torture_tcase_printer(tcase);
8714
8715 tcase = torture_suite_add_tcase(suite, "addprinterwkn");
8716
8717 torture_tcase_set_fixture(tcase,
8718 torture_rpc_spoolss_printerwkn_setup,
8719 torture_rpc_spoolss_printer_teardown);
8720
8721 tcase = torture_suite_add_tcase(suite, "addprinterexwkn");
8722
8723 torture_tcase_set_fixture(tcase,
8724 torture_rpc_spoolss_printerexwkn_setup,
8725 torture_rpc_spoolss_printer_teardown);
8726
8727 #if 0
8728 /* test is not correct */
8729 tcase = torture_suite_add_tcase(suite, "addprinterdm");
8730
8731 torture_tcase_set_fixture(tcase,
8732 torture_rpc_spoolss_printerdm_setup,
8733 torture_rpc_spoolss_printer_teardown);
8734
8735 torture_tcase_printer(tcase);
8736 #endif
8737 return suite;
8738 }
8739
8740 struct torture_suite *torture_rpc_spoolss(TALLOC_CTX *mem_ctx)
8741 {
8742 struct torture_suite *suite = torture_suite_create(mem_ctx, "spoolss");
8743 struct torture_tcase *tcase = torture_suite_add_tcase(suite, "printserver");
8744
8745 torture_tcase_set_fixture(tcase,
8746 torture_rpc_spoolss_setup,
8747 torture_rpc_spoolss_teardown);
8748
8749 torture_tcase_add_simple_test(tcase, "openprinter_badnamelist", test_OpenPrinter_badname_list);
8750 torture_tcase_add_simple_test(tcase, "printer_data_list", test_GetPrinterData_list);
8751 torture_tcase_add_simple_test(tcase, "enum_forms", test_PrintServer_EnumForms);
8752 torture_tcase_add_simple_test(tcase, "forms", test_PrintServer_Forms);
8753 torture_tcase_add_simple_test(tcase, "forms_winreg", test_PrintServer_Forms_Winreg);
8754 torture_tcase_add_simple_test(tcase, "enum_ports", test_EnumPorts);
8755 torture_tcase_add_simple_test(tcase, "add_port", test_AddPort);
8756 torture_tcase_add_simple_test(tcase, "get_printer_driver_directory", test_GetPrinterDriverDirectory);
8757 torture_tcase_add_simple_test(tcase, "get_print_processor_directory", test_GetPrintProcessorDirectory);
8758 torture_tcase_add_simple_test(tcase, "enum_printer_drivers", test_EnumPrinterDrivers);
8759 torture_tcase_add_simple_test(tcase, "enum_monitors", test_EnumMonitors);
8760 torture_tcase_add_simple_test(tcase, "enum_print_processors", test_EnumPrintProcessors);
8761 torture_tcase_add_simple_test(tcase, "print_processors_winreg", test_print_processors_winreg);
8762 torture_tcase_add_simple_test(tcase, "add_processor", test_add_print_processor);
8763 torture_tcase_add_simple_test(tcase, "enum_printprocdata", test_EnumPrintProcDataTypes);
8764 torture_tcase_add_simple_test(tcase, "enum_printers", test_EnumPrinters);
8765 torture_tcase_add_simple_test(tcase, "enum_ports_old", test_EnumPorts_old);
8766 torture_tcase_add_simple_test(tcase, "enum_printers_old", test_EnumPrinters_old);
8767 torture_tcase_add_simple_test(tcase, "enum_printers_servername", test_EnumPrinters_servername);
8768 torture_tcase_add_simple_test(tcase, "enum_printer_drivers_old", test_EnumPrinterDrivers_old);
8769 torture_tcase_add_simple_test(tcase, "architecture_buffer", test_architecture_buffer);
8770
8771 torture_suite_add_suite(suite, torture_rpc_spoolss_printer(suite));
8772
8773 return suite;
8774 }
8775
8776 static bool test_GetPrinterDriverDirectory_getdir(struct torture_context *tctx,
8777 struct dcerpc_binding_handle *b,
8778 const char *server,
8779 const char *environment,
8780 const char **dir_p)
8781 {
8782 struct spoolss_GetPrinterDriverDirectory r;
8783 uint32_t needed;
8784
8785 r.in.server = server;
8786 r.in.environment = environment;
8787 r.in.level = 1;
8788 r.in.buffer = NULL;
8789 r.in.offered = 0;
8790 r.out.needed = &needed;
8791
8792 torture_assert_ntstatus_ok(tctx,
8793 dcerpc_spoolss_GetPrinterDriverDirectory_r(b, tctx, &r),
8794 "failed to query driver directory");
8795
8796 if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
8797 DATA_BLOB blob = data_blob_talloc_zero(tctx, needed);
8798 r.in.buffer = &blob;
8799 r.in.offered = needed;
8800
8801 torture_assert_ntstatus_ok(tctx,
8802 dcerpc_spoolss_GetPrinterDriverDirectory_r(b, tctx, &r),
8803 "failed to query driver directory");
8804 }
8805
8806 torture_assert_werr_ok(tctx, r.out.result,
8807 "failed to query driver directory");
8808
8809 if (dir_p) {
8810 *dir_p = r.out.info->info1.directory_name;
8811 }
8812
8813 return true;
8814 }
8815
8816 static const char *get_driver_from_info(struct spoolss_AddDriverInfoCtr *info_ctr)
8817 {
8818 if (info_ctr == NULL) {
8819 return NULL;
8820 }
8821
8822 switch (info_ctr->level) {
8823 case 1:
8824 return info_ctr->info.info1->driver_name;
8825 case 2:
8826 return info_ctr->info.info2->driver_name;
8827 case 3:
8828 return info_ctr->info.info3->driver_name;
8829 case 4:
8830 return info_ctr->info.info4->driver_name;
8831 case 6:
8832 return info_ctr->info.info6->driver_name;
8833 case 8:
8834 return info_ctr->info.info8->driver_name;
8835 default:
8836 return NULL;
8837 }
8838 }
8839
8840 static const char *get_environment_from_info(struct spoolss_AddDriverInfoCtr *info_ctr)
8841 {
8842 if (info_ctr == NULL) {
8843 return NULL;
8844 }
8845
8846 switch (info_ctr->level) {
8847 case 2:
8848 return info_ctr->info.info2->architecture;
8849 case 3:
8850 return info_ctr->info.info3->architecture;
8851 case 4:
8852 return info_ctr->info.info4->architecture;
8853 case 6:
8854 return info_ctr->info.info6->architecture;
8855 case 8:
8856 return info_ctr->info.info8->architecture;
8857 default:
8858 return NULL;
8859 }
8860 }
8861
8862
8863 static bool test_AddPrinterDriver_exp(struct torture_context *tctx,
8864 struct dcerpc_binding_handle *b,
8865 const char *servername,
8866 struct spoolss_AddDriverInfoCtr *info_ctr,
8867 WERROR expected_result)
8868 {
8869 struct spoolss_AddPrinterDriver r;
8870 const char *drivername = get_driver_from_info(info_ctr);
8871 const char *environment = get_environment_from_info(info_ctr);
8872
8873 r.in.servername = servername;
8874 r.in.info_ctr = info_ctr;
8875
8876 torture_comment(tctx, "Testing AddPrinterDriver(%s) level: %d, environment: '%s'\n",
8877 drivername, info_ctr->level, environment);
8878
8879 torture_assert_ntstatus_ok(tctx,
8880 dcerpc_spoolss_AddPrinterDriver_r(b, tctx, &r),
8881 "spoolss_AddPrinterDriver failed");
8882 torture_assert_werr_equal(tctx, r.out.result, expected_result,
8883 "spoolss_AddPrinterDriver failed with unexpected result");
8884
8885 return true;
8886
8887 }
8888
8889 static bool test_AddPrinterDriverEx_exp(struct torture_context *tctx,
8890 struct dcerpc_binding_handle *b,
8891 const char *servername,
8892 struct spoolss_AddDriverInfoCtr *info_ctr,
8893 uint32_t flags,
8894 WERROR expected_result)
8895 {
8896 struct spoolss_AddPrinterDriverEx r;
8897 const char *drivername = get_driver_from_info(info_ctr);
8898 const char *environment = get_environment_from_info(info_ctr);
8899
8900 r.in.servername = servername;
8901 r.in.info_ctr = info_ctr;
8902 r.in.flags = flags;
8903
8904 torture_comment(tctx, "Testing AddPrinterDriverEx(%s) level: %d, environment: '%s'\n",
8905 drivername, info_ctr->level, environment);
8906
8907 torture_assert_ntstatus_ok(tctx,
8908 dcerpc_spoolss_AddPrinterDriverEx_r(b, tctx, &r),
8909 "AddPrinterDriverEx failed");
8910 torture_assert_werr_equal(tctx, r.out.result, expected_result,
8911 "AddPrinterDriverEx failed with unexpected result");
8912
8913 return true;
8914 }
8915
8916 #define ASSERT_DRIVER_PATH(tctx, path, driver_dir, cmt) \
8917 if (path && strlen(path)) {\
8918 torture_assert_strn_equal(tctx, path, driver_dir, strlen(driver_dir), cmt); \
8919 }
8920
8921 static bool test_AddPrinterDriver_args_level_1(struct torture_context *tctx,
8922 struct dcerpc_binding_handle *b,
8923 const char *server_name,
8924 struct spoolss_AddDriverInfo8 *r,
8925 uint32_t flags,
8926 bool ex,
8927 const char *remote_driver_dir)
8928 {
8929 struct spoolss_AddDriverInfoCtr info_ctr;
8930 struct spoolss_AddDriverInfo1 info1;
8931
8932 ZERO_STRUCT(info1);
8933
8934 info_ctr.level = 1;
8935 info_ctr.info.info1 = &info1;
8936
8937 if (ex) {
8938 torture_assert(tctx,
8939 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_UNKNOWN_LEVEL),
8940 "failed to test AddPrinterDriverEx level 1");
8941 } else {
8942 torture_assert(tctx,
8943 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_UNKNOWN_LEVEL),
8944 "failed to test AddPrinterDriver level 1");
8945 }
8946
8947 info1.driver_name = r->driver_name;
8948
8949 if (ex) {
8950 torture_assert(tctx,
8951 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_UNKNOWN_LEVEL),
8952 "failed to test AddPrinterDriverEx level 1");
8953 } else {
8954 torture_assert(tctx,
8955 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_UNKNOWN_LEVEL),
8956 "failed to test AddPrinterDriver level 1");
8957 }
8958
8959 return true;
8960 }
8961
8962 static bool test_AddPrinterDriver_args_level_2(struct torture_context *tctx,
8963 struct dcerpc_binding_handle *b,
8964 const char *server_name,
8965 struct spoolss_AddDriverInfo8 *r,
8966 uint32_t flags,
8967 bool ex,
8968 const char *remote_driver_dir)
8969 {
8970 struct spoolss_AddDriverInfoCtr info_ctr;
8971 struct spoolss_AddDriverInfo2 info2;
8972 union spoolss_DriverInfo info;
8973
8974 ZERO_STRUCT(info2);
8975
8976 info_ctr.level = 2;
8977 info_ctr.info.info2 = &info2;
8978
8979 if (ex) {
8980 torture_assert(tctx,
8981 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
8982 "failed to test AddPrinterDriverEx level 2");
8983 } else {
8984 torture_assert(tctx,
8985 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
8986 "failed to test AddPrinterDriver level 2");
8987 }
8988
8989 info2.driver_name = r->driver_name;
8990
8991 if (ex) {
8992 torture_assert(tctx,
8993 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
8994 "failed to test AddPrinterDriverEx level 2");
8995 } else {
8996 torture_assert(tctx,
8997 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
8998 "failed to test AddPrinterDriver level 2");
8999 }
9000
9001 info2.version = r->version;
9002
9003 if (ex) {
9004 torture_assert(tctx,
9005 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
9006 "failed to test AddPrinterDriverEx level 2");
9007 } else {
9008 torture_assert(tctx,
9009 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
9010 "failed to test AddPrinterDriver level 2");
9011 }
9012
9013 info2.architecture = r->architecture;
9014
9015 if (ex) {
9016 torture_assert(tctx,
9017 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
9018 "failed to test AddPrinterDriverEx level 2");
9019 } else {
9020 torture_assert(tctx,
9021 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
9022 "failed to test AddPrinterDriver level 2");
9023 }
9024
9025 info2.driver_path = r->driver_path;
9026
9027 if (ex) {
9028 torture_assert(tctx,
9029 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
9030 "failed to test AddPrinterDriverEx level 2");
9031 } else {
9032 torture_assert(tctx,
9033 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
9034 "failed to test AddPrinterDriver level 2");
9035 }
9036
9037 info2.data_file = r->data_file;
9038
9039 if (ex) {
9040 torture_assert(tctx,
9041 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
9042 "failed to test AddPrinterDriverEx level 2");
9043 } else {
9044 torture_assert(tctx,
9045 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
9046 "failed to test AddPrinterDriver level 2");
9047 }
9048
9049 info2.config_file = r->config_file;
9050
9051 if (ex) {
9052 torture_assert(tctx,
9053 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, 0, WERR_INVALID_PARAM),
9054 "failed to test AddPrinterDriverEx");
9055 }
9056
9057 if (ex) {
9058 torture_assert(tctx,
9059 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
9060 "failed to test AddPrinterDriverEx level 2");
9061 } else {
9062 torture_assert(tctx,
9063 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_OK),
9064 "failed to test AddPrinterDriver level 2");
9065 }
9066
9067 torture_assert(tctx,
9068 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 2, r->driver_name, &info),
9069 "failed to find added printer driver");
9070
9071 if (remote_driver_dir) {
9072 ASSERT_DRIVER_PATH(tctx, info.info2.driver_path, remote_driver_dir, "unexpected path");
9073 ASSERT_DRIVER_PATH(tctx, info.info2.data_file, remote_driver_dir, "unexpected path");
9074 ASSERT_DRIVER_PATH(tctx, info.info2.config_file, remote_driver_dir, "unexpected path");
9075 }
9076
9077 return true;
9078 }
9079
9080 static bool test_AddPrinterDriver_args_level_3(struct torture_context *tctx,
9081 struct dcerpc_binding_handle *b,
9082 const char *server_name,
9083 struct spoolss_AddDriverInfo8 *r,
9084 uint32_t flags,
9085 bool ex,
9086 const char *remote_driver_dir)
9087 {
9088 struct spoolss_AddDriverInfoCtr info_ctr;
9089 struct spoolss_AddDriverInfo3 info3;
9090 union spoolss_DriverInfo info;
9091
9092 info3.driver_name = r->driver_name;
9093 info3.version = r->version;
9094 info3.architecture = r->architecture;
9095 info3.driver_path = r->driver_path;
9096 info3.data_file = r->data_file;
9097 info3.config_file = r->config_file;
9098 info3.help_file = r->help_file;
9099 info3.monitor_name = r->monitor_name;
9100 info3.default_datatype = r->default_datatype;
9101 info3._ndr_size_dependent_files = r->_ndr_size_dependent_files;
9102 info3.dependent_files = r->dependent_files;
9103
9104 info_ctr.level = 3;
9105 info_ctr.info.info3 = &info3;
9106
9107 if (ex) {
9108 torture_assert(tctx,
9109 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
9110 "failed to test AddPrinterDriverEx level 3");
9111 } else {
9112 torture_assert(tctx,
9113 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_OK),
9114 "failed to test AddPrinterDriver level 3");
9115 }
9116
9117 torture_assert(tctx,
9118 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 3, r->driver_name, &info),
9119 "failed to find added printer driver");
9120
9121 if (remote_driver_dir) {
9122 int i;
9123 ASSERT_DRIVER_PATH(tctx, info.info3.driver_path, remote_driver_dir, "unexpected path");
9124 ASSERT_DRIVER_PATH(tctx, info.info3.data_file, remote_driver_dir, "unexpected path");
9125 ASSERT_DRIVER_PATH(tctx, info.info3.config_file, remote_driver_dir, "unexpected path");
9126 ASSERT_DRIVER_PATH(tctx, info.info3.help_file, remote_driver_dir, "unexpected path");
9127 for (i=0; info.info3.dependent_files && info.info3.dependent_files[i] != NULL; i++) {
9128 ASSERT_DRIVER_PATH(tctx, info.info3.dependent_files[i], remote_driver_dir, "unexpected path");
9129 }
9130 }
9131
9132 return true;
9133 }
9134
9135 static bool test_AddPrinterDriver_args_level_4(struct torture_context *tctx,
9136 struct dcerpc_binding_handle *b,
9137 const char *server_name,
9138 struct spoolss_AddDriverInfo8 *r,
9139 uint32_t flags,
9140 bool ex,
9141 const char *remote_driver_dir)
9142 {
9143 struct spoolss_AddDriverInfoCtr info_ctr;
9144 struct spoolss_AddDriverInfo4 info4;
9145 union spoolss_DriverInfo info;
9146
9147 info4.version = r->version;
9148 info4.driver_name = r->driver_name;
9149 info4.architecture = r->architecture;
9150 info4.driver_path = r->driver_path;
9151 info4.data_file = r->data_file;
9152 info4.config_file = r->config_file;
9153 info4.help_file = r->help_file;
9154 info4.monitor_name = r->monitor_name;
9155 info4.default_datatype = r->default_datatype;
9156 info4._ndr_size_dependent_files = r->_ndr_size_dependent_files;
9157 info4.dependent_files = r->dependent_files;
9158 info4._ndr_size_previous_names = r->_ndr_size_previous_names;
9159 info4.previous_names = r->previous_names;
9160
9161 info_ctr.level = 4;
9162 info_ctr.info.info4 = &info4;
9163
9164 if (ex) {
9165 torture_assert(tctx,
9166 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
9167 "failed to test AddPrinterDriverEx level 4");
9168 } else {
9169 torture_assert(tctx,
9170 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_OK),
9171 "failed to test AddPrinterDriver level 4");
9172 }
9173
9174 torture_assert(tctx,
9175 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 4, r->driver_name, &info),
9176 "failed to find added printer driver");
9177
9178 if (remote_driver_dir) {
9179 int i;
9180 ASSERT_DRIVER_PATH(tctx, info.info4.driver_path, remote_driver_dir, "unexpected path");
9181 ASSERT_DRIVER_PATH(tctx, info.info4.data_file, remote_driver_dir, "unexpected path");
9182 ASSERT_DRIVER_PATH(tctx, info.info4.config_file, remote_driver_dir, "unexpected path");
9183 ASSERT_DRIVER_PATH(tctx, info.info4.help_file, remote_driver_dir, "unexpected path");
9184 for (i=0; info.info4.dependent_files && info.info4.dependent_files[i] != NULL; i++) {
9185 ASSERT_DRIVER_PATH(tctx, info.info4.dependent_files[i], remote_driver_dir, "unexpected path");
9186 }
9187 }
9188
9189 return true;
9190 }
9191
9192 static bool test_AddPrinterDriver_args_level_6(struct torture_context *tctx,
9193 struct dcerpc_binding_handle *b,
9194 const char *server_name,
9195 struct spoolss_AddDriverInfo8 *r,
9196 uint32_t flags,
9197 bool ex,
9198 const char *remote_driver_dir)
9199 {
9200 struct spoolss_AddDriverInfoCtr info_ctr;
9201 struct spoolss_AddDriverInfo6 info6;
9202 union spoolss_DriverInfo info;
9203
9204 info6.version = r->version;
9205 info6.driver_name = r->driver_name;
9206 info6.architecture = r->architecture;
9207 info6.driver_path = r->driver_path;
9208 info6.data_file = r->data_file;
9209 info6.config_file = r->config_file;
9210 info6.help_file = r->help_file;
9211 info6.monitor_name = r->monitor_name;
9212 info6.default_datatype = r->default_datatype;
9213 info6._ndr_size_dependent_files = r->_ndr_size_dependent_files;
9214 info6.dependent_files = r->dependent_files;
9215 info6._ndr_size_previous_names = r->_ndr_size_previous_names;
9216 info6.previous_names = r->previous_names;
9217 info6.driver_date = r->driver_date;
9218 info6.driver_version = r->driver_version;
9219 info6.manufacturer_name = r->manufacturer_name;
9220 info6.manufacturer_url = r->manufacturer_url;
9221 info6.hardware_id = r->hardware_id;
9222 info6.provider = r->provider;
9223
9224 info_ctr.level = 6;
9225 info_ctr.info.info6 = &info6;
9226
9227 if (ex) {
9228 torture_assert(tctx,
9229 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
9230 "failed to test AddPrinterDriverEx level 6");
9231 } else {
9232 torture_assert(tctx,
9233 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_UNKNOWN_LEVEL),
9234 "failed to test AddPrinterDriver level 6");
9235 }
9236
9237 /* spoolss_AddPrinterDriver does not deal with level 6 or 8 - gd */
9238
9239 if (!ex) {
9240 return true;
9241 }
9242
9243 torture_assert(tctx,
9244 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 6, r->driver_name, &info),
9245 "failed to find added printer driver");
9246
9247 if (remote_driver_dir) {
9248 int i;
9249 ASSERT_DRIVER_PATH(tctx, info.info6.driver_path, remote_driver_dir, "unexpected path");
9250 ASSERT_DRIVER_PATH(tctx, info.info6.data_file, remote_driver_dir, "unexpected path");
9251 ASSERT_DRIVER_PATH(tctx, info.info6.config_file, remote_driver_dir, "unexpected path");
9252 ASSERT_DRIVER_PATH(tctx, info.info6.help_file, remote_driver_dir, "unexpected path");
9253 for (i=0; info.info6.dependent_files && info.info6.dependent_files[i] != NULL; i++) {
9254 ASSERT_DRIVER_PATH(tctx, info.info6.dependent_files[i], remote_driver_dir, "unexpected path");
9255 }
9256 }
9257
9258 torture_assert_nttime_equal(tctx, info.info6.driver_date, info6.driver_date, "driverdate mismatch");
9259 torture_assert_u64_equal(tctx, info.info6.driver_version, info6.driver_version, "driverversion mismatch");
9260
9261 return true;
9262 }
9263
9264 static bool test_AddPrinterDriver_args_level_8(struct torture_context *tctx,
9265 struct dcerpc_binding_handle *b,
9266 const char *server_name,
9267 struct spoolss_AddDriverInfo8 *r,
9268 uint32_t flags,
9269 bool ex,
9270 const char *remote_driver_dir)
9271 {
9272 struct spoolss_AddDriverInfoCtr info_ctr;
9273 union spoolss_DriverInfo info;
9274
9275 info_ctr.level = 8;
9276 info_ctr.info.info8 = r;
9277
9278 if (ex) {
9279 torture_assert(tctx,
9280 test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_OK),
9281 "failed to test AddPrinterDriverEx level 8");
9282 } else {
9283 torture_assert(tctx,
9284 test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_UNKNOWN_LEVEL),
9285 "failed to test AddPrinterDriver level 8");
9286 }
9287
9288 /* spoolss_AddPrinterDriver does not deal with level 6 or 8 - gd */
9289
9290 if (!ex) {
9291 return true;
9292 }
9293
9294 torture_assert(tctx,
9295 test_EnumPrinterDrivers_findone(tctx, b, server_name, r->architecture, 8, r->driver_name, &info),
9296 "failed to find added printer driver");
9297
9298 if (remote_driver_dir) {
9299 int i;
9300 ASSERT_DRIVER_PATH(tctx, info.info8.driver_path, remote_driver_dir, "unexpected path");
9301 ASSERT_DRIVER_PATH(tctx, info.info8.data_file, remote_driver_dir, "unexpected path");
9302 ASSERT_DRIVER_PATH(tctx, info.info8.config_file, remote_driver_dir, "unexpected path");
9303 ASSERT_DRIVER_PATH(tctx, info.info8.help_file, remote_driver_dir, "unexpected path");
9304 for (i=0; info.info8.dependent_files && info.info8.dependent_files[i] != NULL; i++) {
9305 ASSERT_DRIVER_PATH(tctx, info.info8.dependent_files[i], remote_driver_dir, "unexpected path");
9306 }
9307 }
9308
9309 torture_assert_nttime_equal(tctx, info.info8.driver_date, r->driver_date, "driverdate mismatch");
9310 torture_assert_u64_equal(tctx, info.info8.driver_version, r->driver_version, "driverversion mismatch");
9311
9312 return true;
9313 }
9314
9315 #undef ASSERT_DRIVER_PATH
9316
9317 static bool test_DeletePrinterDriver_exp(struct torture_context *tctx,
9318 struct dcerpc_binding_handle *b,
9319 const char *server,
9320 const char *driver,
9321 const char *environment,
9322 WERROR expected_result)
9323 {
9324 struct spoolss_DeletePrinterDriver r;
9325
9326 r.in.server = server;
9327 r.in.architecture = environment;
9328 r.in.driver = driver;
9329
9330 torture_comment(tctx, "Testing DeletePrinterDriver(%s)\n", driver);
9331
9332 torture_assert_ntstatus_ok(tctx,
9333 dcerpc_spoolss_DeletePrinterDriver_r(b, tctx, &r),
9334 "DeletePrinterDriver failed");
9335 torture_assert_werr_equal(tctx, r.out.result, expected_result,
9336 "DeletePrinterDriver failed with unexpected result");
9337
9338 return true;
9339 }
9340
9341 static bool test_DeletePrinterDriverEx_exp(struct torture_context *tctx,
9342 struct dcerpc_binding_handle *b,
9343 const char *server,
9344 const char *driver,
9345 const char *environment,
9346 uint32_t delete_flags,
9347 uint32_t version,
9348 WERROR expected_result)
9349 {
9350 struct spoolss_DeletePrinterDriverEx r;
9351
9352 r.in.server = server;
9353 r.in.architecture = environment;
9354 r.in.driver = driver;
9355 r.in.delete_flags = delete_flags;
9356 r.in.version = version;
9357
9358 torture_comment(tctx, "Testing DeletePrinterDriverEx(%s)\n", driver);
9359
9360 torture_assert_ntstatus_ok(tctx,
9361 dcerpc_spoolss_DeletePrinterDriverEx_r(b, tctx, &r),
9362 "DeletePrinterDriverEx failed");
9363 torture_assert_werr_equal(tctx, r.out.result, expected_result,
9364 "DeletePrinterDriverEx failed with unexpected result");
9365
9366 return true;
9367 }
9368
9369 static bool test_DeletePrinterDriver(struct torture_context *tctx,
9370 struct dcerpc_binding_handle *b,
9371 const char *server_name,
9372 const char *driver,
9373 const char *environment)
9374 {
9375 torture_assert(tctx,
9376 test_DeletePrinterDriver_exp(tctx, b, server_name, driver, "FOOBAR", WERR_INVALID_ENVIRONMENT),
9377 "failed to delete driver");
9378
9379 torture_assert(tctx,
9380 test_DeletePrinterDriver_exp(tctx, b, server_name, driver, environment, WERR_OK),
9381 "failed to delete driver");
9382
9383 if (test_EnumPrinterDrivers_findone(tctx, b, server_name, environment, 1, driver, NULL)) {
9384 torture_fail(tctx, "deleted driver still enumerated");
9385 }
9386
9387 torture_assert(tctx,
9388 test_DeletePrinterDriver_exp(tctx, b, server_name, driver, environment, WERR_UNKNOWN_PRINTER_DRIVER),
9389 "2nd delete failed");
9390
9391 return true;
9392 }
9393
9394 static bool test_DeletePrinterDriverEx(struct torture_context *tctx,
9395 struct dcerpc_binding_handle *b,
9396 const char *server_name,
9397 const char *driver,
9398 const char *environment,
9399 uint32_t delete_flags,
9400 uint32_t version)
9401 {
9402 torture_assert(tctx,
9403 test_DeletePrinterDriverEx_exp(tctx, b, server_name, driver, "FOOBAR", delete_flags, version, WERR_INVALID_ENVIRONMENT),
9404 "failed to delete driver");
9405
9406 torture_assert(tctx,
9407 test_DeletePrinterDriverEx_exp(tctx, b, server_name, driver, environment, delete_flags, version, WERR_OK),
9408 "failed to delete driver");
9409
9410 if (test_EnumPrinterDrivers_findone(tctx, b, server_name, environment, 1, driver, NULL)) {
9411 torture_fail(tctx, "deleted driver still enumerated");
9412 }
9413
9414 torture_assert(tctx,
9415 test_DeletePrinterDriverEx_exp(tctx, b, server_name, driver, environment, delete_flags, version, WERR_UNKNOWN_PRINTER_DRIVER),
9416 "2nd delete failed");
9417
9418 return true;
9419 }
9420
9421 static bool test_PrinterDriver_args(struct torture_context *tctx,
9422 struct dcerpc_binding_handle *b,
9423 const char *server_name,
9424 uint32_t level,
9425 struct spoolss_AddDriverInfo8 *r,
9426 uint32_t add_flags,
9427 uint32_t delete_flags,
9428 uint32_t delete_version,
9429 bool ex,
9430 const char *remote_driver_dir)
9431 {
9432 bool ret = true;
9433
9434 switch (level) {
9435 case 1:
9436 ret = test_AddPrinterDriver_args_level_1(tctx, b, server_name, r, add_flags, ex, remote_driver_dir);
9437 break;
9438 case 2:
9439 ret = test_AddPrinterDriver_args_level_2(tctx, b, server_name, r, add_flags, ex, remote_driver_dir);
9440 break;
9441 case 3:
9442 ret = test_AddPrinterDriver_args_level_3(tctx, b, server_name, r, add_flags, ex, remote_driver_dir);
9443 break;
9444 case 4:
9445 ret = test_AddPrinterDriver_args_level_4(tctx, b, server_name, r, add_flags, ex, remote_driver_dir);
9446 break;
9447 case 6:
9448 ret = test_AddPrinterDriver_args_level_6(tctx, b, server_name, r, add_flags, ex, remote_driver_dir);
9449 break;
9450 case 8:
9451 ret = test_AddPrinterDriver_args_level_8(tctx, b, server_name, r, add_flags, ex, remote_driver_dir);
9452 break;
9453 default:
9454 return false;
9455 }
9456
9457 if (ret == false) {
9458 return ret;
9459 }
9460
9461 if (level == 1) {
9462 return ret;
9463 }
9464
9465 /* spoolss_AddPrinterDriver does not deal with level 6 or 8 - gd */
9466
9467 if (!ex && (level == 6 || level == 8)) {
9468 return ret;
9469 }
9470
9471 {
9472 struct dcerpc_pipe *p2;
9473 struct policy_handle hive_handle;
9474 struct dcerpc_binding_handle *b2;
9475
9476 torture_assert_ntstatus_ok(tctx,
9477 torture_rpc_connection(tctx, &p2, &ndr_table_winreg),
9478 "could not open winreg pipe");
9479 b2 = p2->binding_handle;
9480
9481 torture_assert(tctx, test_winreg_OpenHKLM(tctx, b2, &hive_handle), "");
9482
9483 ret = test_GetDriverInfo_winreg(tctx, b, NULL, NULL, r->driver_name, r->architecture, r->version, b2, &hive_handle, server_name);
9484
9485 test_winreg_CloseKey(tctx, b2, &hive_handle);
9486
9487 talloc_free(p2);
9488 }
9489
9490 if (ex) {
9491 return test_DeletePrinterDriverEx(tctx, b, server_name, r->driver_name, r->architecture, delete_flags, r->version);
9492 } else {
9493 return test_DeletePrinterDriver(tctx, b, server_name, r->driver_name, r->architecture);
9494 }
9495 }
9496
9497 static bool fillup_printserver_info(struct torture_context *tctx,
9498 struct dcerpc_pipe *p,
9499 struct torture_driver_context *d)
9500 {
9501 struct policy_handle server_handle;
9502 struct dcerpc_binding_handle *b = p->binding_handle;
9503 const char *server_name_slash = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
9504
9505 torture_assert(tctx,
9506 test_OpenPrinter_server(tctx, p, &server_handle),
9507 "failed to open printserver");
9508 torture_assert(tctx,
9509 test_get_environment(tctx, b, &server_handle, &d->remote.environment),
9510 "failed to get environment");
9511 torture_assert(tctx,
9512 test_ClosePrinter(tctx, b, &server_handle),
9513 "failed to close printserver");
9514
9515 torture_assert(tctx,
9516 test_GetPrinterDriverDirectory_getdir(tctx, b, server_name_slash,
9517 d->local.environment ? d->local.environment : d->remote.environment,
9518 &d->remote.driver_directory),
9519 "failed to get driver directory");
9520
9521 return true;
9522 }
9523
9524 static const char *driver_directory_dir(const char *driver_directory)
9525 {
9526 char *p;
9527
9528 p = strrchr(driver_directory, '\\');
9529 if (p) {
9530 return p+1;
9531 }
9532
9533 return NULL;
9534 }
9535
9536 static const char *driver_directory_share(struct torture_context *tctx,
9537 const char *driver_directory)
9538 {
9539 const char *p;
9540 char *tok;
9541
9542 if (driver_directory[0] == '\\' && driver_directory[1] == '\\') {
9543 driver_directory += 2;
9544 }
9545
9546 p = talloc_strdup(tctx, driver_directory);
9547
9548 torture_assert(tctx,
9549 next_token_talloc(tctx, &p, &tok, "\\"),
9550 "cannot explode uri");
9551 torture_assert(tctx,
9552 next_token_talloc(tctx, &p, &tok, "\\"),
9553 "cannot explode uri");
9554
9555 return tok;
9556 }
9557
9558 static bool upload_printer_driver_file(struct torture_context *tctx,
9559 struct smbcli_state *cli,
9560 struct torture_driver_context *d,
9561 const char *file_name)
9562 {
9563 XFILE *f;
9564 int fnum;
9565 uint8_t *buf;
9566 int maxwrite = 64512;
9567 off_t nread = 0;
9568 size_t start = 0;
9569 const char *remote_dir = driver_directory_dir(d->remote.driver_directory);
9570 const char *local_name = talloc_asprintf(tctx, "%s/%s", d->local.driver_directory, file_name);
9571 const char *remote_name = talloc_asprintf(tctx, "%s\\%s", remote_dir, file_name);
9572
9573 if (!file_name || strlen(file_name) == 0) {
9574 return true;
9575 }
9576
9577 torture_comment(tctx, "Uploading %s to %s\n", local_name, remote_name);
9578
9579 fnum = smbcli_open(cli->tree, remote_name, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE);
9580 if (fnum == -1) {
9581 torture_fail(tctx, talloc_asprintf(tctx, "failed to open remote file: %s\n", remote_name));
9582 }
9583
9584 f = x_fopen(local_name, O_RDONLY, 0);
9585 if (f == NULL) {
9586 torture_fail(tctx, talloc_asprintf(tctx, "failed to open local file: %s\n", local_name));
9587 }
9588
9589 buf = talloc_array(tctx, uint8_t, maxwrite);
9590 if (!buf) {
9591 x_fclose(f);
9592 return false;
9593 }
9594
9595 while (!x_feof(f)) {
9596 int n = maxwrite;
9597 int ret;
9598
9599 if ((n = x_fread(buf, 1, n, f)) < 1) {
9600 if((n == 0) && x_feof(f))
9601 break; /* Empty local file. */
9602
9603 torture_warning(tctx,
9604 "failed to read file: %s\n", strerror(errno));
9605 break;
9606 }
9607
9608 ret = smbcli_write(cli->tree, fnum, 0, buf, nread + start, n);
9609
9610 if (n != ret) {
9611 torture_warning(tctx,
9612 "failed to write file: %s\n", smbcli_errstr(cli->tree));
9613 break;
9614 }
9615
9616 nread += n;
9617 }
9618
9619 x_fclose(f);
9620
9621 torture_assert_ntstatus_ok(tctx,
9622 smbcli_close(cli->tree, fnum),
9623 "failed to close file");
9624
9625 return true;
9626 }
9627
9628 static bool connect_printer_driver_share(struct torture_context *tctx,
9629 const char *server_name,
9630 const char *share_name,
9631 struct smbcli_state **cli)
9632 {
9633 struct smbcli_options smb_options;
9634 struct smbcli_session_options smb_session_options;
9635
9636 torture_comment(tctx, "Connecting printer driver share '%s' on '%s'\n",
9637 share_name, server_name);
9638
9639 lpcfg_smbcli_options(tctx->lp_ctx, &smb_options);
9640 lpcfg_smbcli_session_options(tctx->lp_ctx, &smb_session_options);
9641
9642 torture_assert_ntstatus_ok(tctx,
9643 smbcli_full_connection(tctx, cli, server_name,
9644 lpcfg_smb_ports(tctx->lp_ctx),
9645 share_name, NULL,
9646 lpcfg_socket_options(tctx->lp_ctx),
9647 cmdline_credentials,
9648 lpcfg_resolve_context(tctx->lp_ctx),
9649 tctx->ev,
9650 &smb_options,
9651 &smb_session_options,
9652 lpcfg_gensec_settings(tctx, tctx->lp_ctx)),
9653 "failed to open driver share");
9654
9655 return true;
9656 }
9657
9658 static bool upload_printer_driver(struct torture_context *tctx,
9659 const char *server_name,
9660 struct torture_driver_context *d)
9661 {
9662 struct smbcli_state *cli;
9663 const char *share_name = driver_directory_share(tctx, d->remote.driver_directory);
9664 int i;
9665
9666 torture_assert(tctx,
9667 connect_printer_driver_share(tctx, server_name, share_name, &cli),
9668 "failed to connect to driver share");
9669
9670 torture_comment(tctx, "Uploading printer driver files to \\\\%s\\%s\n",
9671 server_name, share_name);
9672
9673 torture_assert(tctx,
9674 upload_printer_driver_file(tctx, cli, d, d->info8.driver_path),
9675 "failed to upload driver_path");
9676 torture_assert(tctx,
9677 upload_printer_driver_file(tctx, cli, d, d->info8.data_file),
9678 "failed to upload data_file");
9679 torture_assert(tctx,
9680 upload_printer_driver_file(tctx, cli, d, d->info8.config_file),
9681 "failed to upload config_file");
9682 torture_assert(tctx,
9683 upload_printer_driver_file(tctx, cli, d, d->info8.help_file),
9684 "failed to upload help_file");
9685 if (d->info8.dependent_files) {
9686 for (i=0; d->info8.dependent_files->string && d->info8.dependent_files->string[i] != NULL; i++) {
9687 torture_assert(tctx,
9688 upload_printer_driver_file(tctx, cli, d, d->info8.dependent_files->string[i]),
9689 "failed to upload dependent_files");
9690 }
9691 }
9692
9693 talloc_free(cli);
9694
9695 return true;
9696 }
9697
9698 static bool check_printer_driver_file(struct torture_context *tctx,
9699 struct smbcli_state *cli,
9700 struct torture_driver_context *d,
9701 const char *file_name)
9702 {
9703 const char *remote_arch_dir = driver_directory_dir(d->remote.driver_directory);
9704 const char *remote_name = talloc_asprintf(tctx, "%s\\%d\\%s",
9705 remote_arch_dir,
9706 d->info8.version,
9707 file_name);
9708 int fnum;
9709
9710 torture_assert(tctx, (file_name && strlen(file_name) != 0), "invalid filename");
9711
9712 torture_comment(tctx, "checking for driver file at %s\n", remote_name);
9713
9714 fnum = smbcli_open(cli->tree, remote_name, O_RDONLY, DENY_NONE);
9715 if (fnum == -1) {
9716 return false;
9717 }
9718
9719 torture_assert_ntstatus_ok(tctx,
9720 smbcli_close(cli->tree, fnum),
9721 "failed to close driver file");
9722
9723 return true;
9724 }
9725
9726 static bool check_printer_driver_files(struct torture_context *tctx,
9727 const char *server_name,
9728 struct torture_driver_context *d,
9729 bool expect_exist)
9730 {
9731 struct smbcli_state *cli;
9732 const char *share_name = driver_directory_share(tctx, d->remote.driver_directory);
9733 int i;
9734
9735 torture_assert(tctx,
9736 connect_printer_driver_share(tctx, server_name, share_name, &cli),
9737 "failed to connect to driver share");
9738
9739 torture_comment(tctx, "checking %sexistent driver files at \\\\%s\\%s\n",
9740 (expect_exist ? "": "non-"),
9741 server_name, share_name);
9742
9743 if (d->info8.driver_path && d->info8.driver_path[0]) {
9744 torture_assert(tctx,
9745 check_printer_driver_file(tctx, cli, d, d->info8.driver_path) == expect_exist,
9746 "failed driver_path check");
9747 }
9748 if (d->info8.data_file && d->info8.data_file[0]) {
9749 torture_assert(tctx,
9750 check_printer_driver_file(tctx, cli, d, d->info8.data_file) == expect_exist,
9751 "failed data_file check");
9752 }
9753 if (d->info8.config_file && d->info8.config_file[0]) {
9754 torture_assert(tctx,
9755 check_printer_driver_file(tctx, cli, d, d->info8.config_file) == expect_exist,
9756 "failed config_file check");
9757 }
9758 if (d->info8.help_file && d->info8.help_file[0]) {
9759 torture_assert(tctx,
9760 check_printer_driver_file(tctx, cli, d, d->info8.help_file) == expect_exist,
9761 "failed help_file check");
9762 }
9763 if (d->info8.dependent_files) {
9764 for (i=0; d->info8.dependent_files->string && d->info8.dependent_files->string[i] != NULL; i++) {
9765 torture_assert(tctx,
9766 check_printer_driver_file(tctx, cli, d, d->info8.dependent_files->string[i]) == expect_exist,
9767 "failed dependent_files check");
9768 }
9769 }
9770
9771 talloc_free(cli);
9772
9773 return true;
9774 }
9775
9776 static bool remove_printer_driver_file(struct torture_context *tctx,
9777 struct smbcli_state *cli,
9778 struct torture_driver_context *d,
9779 const char *file_name)
9780 {
9781 const char *remote_name;
9782 const char *remote_dir = driver_directory_dir(d->remote.driver_directory);
9783
9784 if (!file_name || strlen(file_name) == 0) {
9785 return true;
9786 }
9787
9788 remote_name = talloc_asprintf(tctx, "%s\\%s", remote_dir, file_name);
9789
9790 torture_comment(tctx, "Removing %s\n", remote_name);
9791
9792 torture_assert_ntstatus_ok(tctx,
9793 smbcli_unlink(cli->tree, remote_name),
9794 "failed to unlink");
9795
9796 return true;
9797 }
9798
9799 static bool remove_printer_driver(struct torture_context *tctx,
9800 const char *server_name,
9801 struct torture_driver_context *d)
9802 {
9803 struct smbcli_state *cli;
9804 const char *share_name = driver_directory_share(tctx, d->remote.driver_directory);
9805 int i;
9806
9807 torture_assert(tctx,
9808 connect_printer_driver_share(tctx, server_name, share_name, &cli),
9809 "failed to connect to driver share");
9810
9811 torture_comment(tctx, "Removing printer driver files from \\\\%s\\%s\n",
9812 server_name, share_name);
9813
9814 torture_assert(tctx,
9815 remove_printer_driver_file(tctx, cli, d, d->info8.driver_path),
9816 "failed to remove driver_path");
9817 torture_assert(tctx,
9818 remove_printer_driver_file(tctx, cli, d, d->info8.data_file),
9819 "failed to remove data_file");
9820 if (!strequal(d->info8.config_file, d->info8.driver_path)) {
9821 torture_assert(tctx,
9822 remove_printer_driver_file(tctx, cli, d, d->info8.config_file),
9823 "failed to remove config_file");
9824 }
9825 torture_assert(tctx,
9826 remove_printer_driver_file(tctx, cli, d, d->info8.help_file),
9827 "failed to remove help_file");
9828 if (d->info8.dependent_files) {
9829 for (i=0; d->info8.dependent_files->string && d->info8.dependent_files->string[i] != NULL; i++) {
9830 if (strequal(d->info8.dependent_files->string[i], d->info8.driver_path) ||
9831 strequal(d->info8.dependent_files->string[i], d->info8.data_file) ||
9832 strequal(d->info8.dependent_files->string[i], d->info8.config_file) ||
9833 strequal(d->info8.dependent_files->string[i], d->info8.help_file)) {
9834 continue;
9835 }
9836 torture_assert(tctx,
9837 remove_printer_driver_file(tctx, cli, d, d->info8.dependent_files->string[i]),
9838 "failed to remove dependent_files");
9839 }
9840 }
9841
9842 talloc_free(cli);
9843
9844 return true;
9845
9846 }
9847
9848 static bool test_add_driver_arg(struct torture_context *tctx,
9849 struct dcerpc_pipe *p,
9850 struct torture_driver_context *d)
9851 {
9852 bool ret = true;
9853 struct dcerpc_binding_handle *b = p->binding_handle;
9854 const char *server_name_slash = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
9855 uint32_t levels[] = { 1, 2, 3, 4, 6, 8 };
9856 int i;
9857 struct spoolss_AddDriverInfo8 info8;
9858 uint32_t add_flags = APD_COPY_NEW_FILES;
9859 uint32_t delete_flags = 0;
9860
9861 ZERO_STRUCT(info8);
9862
9863 torture_comment(tctx, "Testing PrinterDriver%s '%s' for environment '%s'\n",
9864 d->ex ? "Ex" : "", d->info8.driver_name, d->local.environment);
9865
9866 torture_assert(tctx,
9867 fillup_printserver_info(tctx, p, d),
9868 "failed to fillup printserver info");
9869
9870 if (!directory_exist(d->local.driver_directory)) {
9871 torture_skip(tctx, "Skipping Printer Driver test as no local driver is available");
9872 }
9873
9874 torture_assert(tctx,
9875 upload_printer_driver(tctx, dcerpc_server_name(p), d),
9876 "failed to upload printer driver");
9877
9878 info8 = d->info8;
9879 if (d->info8.dependent_files) {
9880 info8.dependent_files = talloc_zero(tctx, struct spoolss_StringArray);
9881 if (d->info8.dependent_files->string) {
9882 for (i=0; d->info8.dependent_files->string[i] != NULL; i++) {
9883 }
9884 info8.dependent_files->string = talloc_zero_array(info8.dependent_files, const char *, i+1);
9885 for (i=0; d->info8.dependent_files->string[i] != NULL; i++) {
9886 info8.dependent_files->string[i] = talloc_strdup(info8.dependent_files->string, d->info8.dependent_files->string[i]);
9887 }
9888 }
9889 }
9890 info8.architecture = d->local.environment;
9891
9892 for (i=0; i < ARRAY_SIZE(levels); i++) {
9893
9894 if (torture_setting_bool(tctx, "samba3", false)) {
9895 switch (levels[i]) {
9896 case 2:
9897 case 4:
9898 case 8:
9899 torture_comment(tctx, "skipping level %d against samba\n", levels[i]);
9900 continue;
9901 default:
9902 break;
9903 }
9904 }
9905 if (torture_setting_bool(tctx, "w2k3", false)) {
9906 switch (levels[i]) {
9907 case 8:
9908 torture_comment(tctx, "skipping level %d against w2k3\n", levels[i]);
9909 continue;
9910 default:
9911 break;
9912 }
9913 }
9914
9915 torture_comment(tctx,
9916 "Testing PrinterDriver%s '%s' add & delete level %d\n",
9917 d->ex ? "Ex" : "", info8.driver_name, levels[i]);
9918
9919 ret &= test_PrinterDriver_args(tctx, b, server_name_slash, levels[i], &info8, add_flags, delete_flags, d->info8.version, d->ex, d->remote.driver_directory);
9920 }
9921
9922 info8.driver_path = talloc_asprintf(tctx, "%s\\%s", d->remote.driver_directory, d->info8.driver_path);
9923 info8.data_file = talloc_asprintf(tctx, "%s\\%s", d->remote.driver_directory, d->info8.data_file);
9924 if (d->info8.config_file) {
9925 info8.config_file = talloc_asprintf(tctx, "%s\\%s", d->remote.driver_directory, d->info8.config_file);
9926 }
9927 if (d->info8.help_file) {
9928 info8.help_file = talloc_asprintf(tctx, "%s\\%s", d->remote.driver_directory, d->info8.help_file);
9929 }
9930 if (d->info8.dependent_files && d->info8.dependent_files->string) {
9931 for (i=0; d->info8.dependent_files->string[i] != NULL; i++) {
9932 info8.dependent_files->string[i] = talloc_asprintf(tctx, "%s\\%s", d->remote.driver_directory, d->info8.dependent_files->string[i]);
9933 }
9934 }
9935
9936 for (i=0; i < ARRAY_SIZE(levels); i++) {
9937
9938 if (torture_setting_bool(tctx, "samba3", false)) {
9939 switch (levels[i]) {
9940 case 2:
9941 case 4:
9942 case 8:
9943 torture_comment(tctx, "skipping level %d against samba\n", levels[i]);
9944 continue;
9945 default:
9946 break;
9947 }
9948 }
9949 if (torture_setting_bool(tctx, "w2k3", false)) {
9950 switch (levels[i]) {
9951 case 8:
9952 torture_comment(tctx, "skipping level %d against w2k3\n", levels[i]);
9953 continue;
9954 default:
9955 break;
9956 }
9957 }
9958
9959 torture_comment(tctx,
9960 "Testing PrinterDriver%s '%s' add & delete level %d (full unc paths)\n",
9961 d->ex ? "Ex" : "", info8.driver_name, levels[i]);
9962
9963 ret &= test_PrinterDriver_args(tctx, b, server_name_slash, levels[i], &info8, add_flags, delete_flags, d->info8.version, d->ex, d->remote.driver_directory);
9964 }
9965
9966 torture_assert(tctx,
9967 remove_printer_driver(tctx, dcerpc_server_name(p), d),
9968 "failed to remove printer driver");
9969
9970 torture_comment(tctx, "\n");
9971
9972 return ret;
9973 }
9974
9975 static bool test_add_driver_ex_64(struct torture_context *tctx,
9976 struct dcerpc_pipe *p)
9977 {
9978 struct torture_driver_context *d;
9979
9980 d = talloc_zero(tctx, struct torture_driver_context);
9981
9982 d->info8.version = SPOOLSS_DRIVER_VERSION_200X;
9983 d->info8.driver_name = TORTURE_DRIVER_EX;
9984 d->info8.architecture = NULL;
9985 d->info8.driver_path = talloc_strdup(d, "pscript5.dll");
9986 d->info8.data_file = talloc_strdup(d, "cups6.ppd");
9987 d->info8.config_file = talloc_strdup(d, "cupsui6.dll");
9988 d->local.environment = talloc_strdup(d, "Windows x64");
9989 d->local.driver_directory = talloc_strdup(d, "/usr/share/cups/drivers/x64");
9990 d->ex = true;
9991
9992 return test_add_driver_arg(tctx, p, d);
9993 }
9994
9995 static bool test_add_driver_ex_32(struct torture_context *tctx,
9996 struct dcerpc_pipe *p)
9997 {
9998 struct torture_driver_context *d;
9999
10000 d = talloc_zero(tctx, struct torture_driver_context);
10001
10002 d->info8.version = SPOOLSS_DRIVER_VERSION_200X;
10003 d->info8.driver_name = TORTURE_DRIVER_EX;
10004 d->info8.architecture = NULL;
10005 d->info8.driver_path = talloc_strdup(d, "pscript5.dll");
10006 d->info8.data_file = talloc_strdup(d, "cups6.ppd");
10007 d->info8.config_file = talloc_strdup(d, "cupsui6.dll");
10008 d->local.environment = talloc_strdup(d, "Windows NT x86");
10009 d->local.driver_directory = talloc_strdup(d, "/usr/share/cups/drivers/i386");
10010 d->ex = true;
10011
10012 return test_add_driver_arg(tctx, p, d);
10013 }
10014
10015 static bool test_add_driver_64(struct torture_context *tctx,
10016 struct dcerpc_pipe *p)
10017 {
10018 struct torture_driver_context *d;
10019
10020 d = talloc_zero(tctx, struct torture_driver_context);
10021
10022 d->info8.version = SPOOLSS_DRIVER_VERSION_200X;
10023 d->info8.driver_name = TORTURE_DRIVER;
10024 d->info8.architecture = NULL;
10025 d->info8.driver_path = talloc_strdup(d, "pscript5.dll");
10026 d->info8.data_file = talloc_strdup(d, "cups6.ppd");
10027 d->info8.config_file = talloc_strdup(d, "cupsui6.dll");
10028 d->local.environment = talloc_strdup(d, "Windows x64");
10029 d->local.driver_directory = talloc_strdup(d, "/usr/share/cups/drivers/x64");
10030 d->ex = false;
10031
10032 return test_add_driver_arg(tctx, p, d);
10033 }
10034
10035 static bool test_add_driver_32(struct torture_context *tctx,
10036 struct dcerpc_pipe *p)
10037 {
10038 struct torture_driver_context *d;
10039
10040 d = talloc_zero(tctx, struct torture_driver_context);
10041
10042 d->info8.version = SPOOLSS_DRIVER_VERSION_200X;
10043 d->info8.driver_name = TORTURE_DRIVER;
10044 d->info8.architecture = NULL;
10045 d->info8.driver_path = talloc_strdup(d, "pscript5.dll");
10046 d->info8.data_file = talloc_strdup(d, "cups6.ppd");
10047 d->info8.config_file = talloc_strdup(d, "cupsui6.dll");
10048 d->local.environment = talloc_strdup(d, "Windows NT x86");
10049 d->local.driver_directory = talloc_strdup(d, "/usr/share/cups/drivers/i386");
10050 d->ex = false;
10051
10052 return test_add_driver_arg(tctx, p, d);
10053 }
10054
10055 static bool test_add_driver_adobe(struct torture_context *tctx,
10056 struct dcerpc_pipe *p)
10057 {
10058 struct torture_driver_context *d;
10059
10060 if (!torture_setting_bool(tctx, "samba3", false)) {
10061 torture_skip(tctx, "skipping adobe test which only works against samba3");
10062 }
10063
10064 d = talloc_zero(tctx, struct torture_driver_context);
10065
10066 d->info8.version = SPOOLSS_DRIVER_VERSION_9X;
10067 d->info8.driver_name = TORTURE_DRIVER_ADOBE;
10068 d->info8.architecture = NULL;
10069 d->info8.driver_path = talloc_strdup(d, "ADOBEPS4.DRV");
10070 d->info8.data_file = talloc_strdup(d, "DEFPRTR2.PPD");
10071 d->info8.config_file = talloc_strdup(d, "ADOBEPS4.DRV");
10072 #if 0
10073 d->info8.help_file = talloc_strdup(d, "ADOBEPS4.HLP");
10074 d->info8.monitor_name = talloc_strdup(d, "PSMON.DLL");
10075 #endif
10076 d->local.environment = talloc_strdup(d, "Windows 4.0");
10077 d->local.driver_directory = talloc_strdup(d, "/usr/share/cups/drivers/adobe/");
10078 d->ex = false;
10079
10080 return test_add_driver_arg(tctx, p, d);
10081 }
10082
10083 static bool test_add_driver_adobe_cupsaddsmb(struct torture_context *tctx,
10084 struct dcerpc_pipe *p)
10085 {
10086 struct torture_driver_context *d;
10087 struct spoolss_StringArray *a;
10088
10089 if (!torture_setting_bool(tctx, "samba3", false)) {
10090 torture_skip(tctx, "skipping cupsaddsmb test which only works against samba3");
10091 }
10092
10093 d = talloc_zero(tctx, struct torture_driver_context);
10094
10095 d->info8.version = SPOOLSS_DRIVER_VERSION_9X;
10096 d->info8.driver_name = TORTURE_DRIVER_ADOBE_CUPSADDSMB;
10097 d->info8.architecture = NULL;
10098 d->info8.driver_path = talloc_strdup(d, "ADOBEPS4.DRV");
10099 d->info8.data_file = talloc_strdup(d, "DEFPRTR2.PPD");
10100 d->info8.config_file = NULL;
10101 d->info8.help_file = talloc_strdup(d, "ADOBEPS4.HLP");
10102 d->info8.monitor_name = talloc_strdup(d, "PSMON.DLL");
10103 d->info8.default_datatype = talloc_strdup(d, "RAW");
10104
10105 a = talloc_zero(d, struct spoolss_StringArray);
10106 a->string = talloc_zero_array(a, const char *, 7);
10107 a->string[0] = talloc_strdup(a->string, "ADOBEPS4.DRV");
10108 a->string[1] = talloc_strdup(a->string, "DEFPRTR2.PPD");
10109 a->string[2] = talloc_strdup(a->string, "ADOBEPS4.HLP");
10110 a->string[3] = talloc_strdup(a->string, "PSMON.DLL");
10111 a->string[4] = talloc_strdup(a->string, "ADFONTS.MFM");
10112 a->string[5] = talloc_strdup(a->string, "ICONLIB.DLL");
10113
10114 d->info8.dependent_files = a;
10115 d->local.environment = talloc_strdup(d, "Windows 4.0");
10116 d->local.driver_directory = talloc_strdup(d, "/usr/share/cups/drivers/adobe/");
10117 d->ex = false;
10118
10119 return test_add_driver_arg(tctx, p, d);
10120 }
10121
10122 static bool test_add_driver_timestamps(struct torture_context *tctx,
10123 struct dcerpc_pipe *p)
10124 {
10125 struct torture_driver_context *d;
10126 struct timeval t = timeval_current();
10127
10128 d = talloc_zero(tctx, struct torture_driver_context);
10129
10130 d->info8.version = SPOOLSS_DRIVER_VERSION_200X;
10131 d->info8.driver_name = TORTURE_DRIVER_TIMESTAMPS;
10132 d->info8.architecture = NULL;
10133 d->info8.driver_path = talloc_strdup(d, "pscript5.dll");
10134 d->info8.data_file = talloc_strdup(d, "cups6.ppd");
10135 d->info8.config_file = talloc_strdup(d, "cupsui6.dll");
10136 d->info8.driver_date = timeval_to_nttime(&t);
10137 d->local.environment = talloc_strdup(d, "Windows NT x86");
10138 d->local.driver_directory = talloc_strdup(d, "/usr/share/cups/drivers/i386");
10139 d->ex = true;
10140
10141 torture_assert(tctx,
10142 test_add_driver_arg(tctx, p, d),
10143 "");
10144
10145 unix_to_nt_time(&d->info8.driver_date, 1);
10146
10147 torture_assert(tctx,
10148 test_add_driver_arg(tctx, p, d),
10149 "");
10150
10151 return true;
10152 }
10153
10154 static bool test_multiple_drivers(struct torture_context *tctx,
10155 struct dcerpc_pipe *p)
10156 {
10157 struct torture_driver_context *d;
10158 struct dcerpc_binding_handle *b = p->binding_handle;
10159 const char *server_name_slash = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
10160 int i;
10161 struct spoolss_AddDriverInfo8 info8;
10162 uint32_t add_flags = APD_COPY_NEW_FILES;
10163 uint32_t delete_flags = 0;
10164
10165 d = talloc_zero(tctx, struct torture_driver_context);
10166
10167 d->info8.version = SPOOLSS_DRIVER_VERSION_200X;
10168 d->info8.driver_path = talloc_strdup(d, "pscript5.dll");
10169 d->info8.data_file = talloc_strdup(d, "cups6.ppd");
10170 d->info8.config_file = talloc_strdup(d, "cupsui6.dll");
10171 d->local.environment = talloc_strdup(d, "Windows NT x86");
10172 d->local.driver_directory = talloc_strdup(d, "/usr/share/cups/drivers/i386");
10173 d->ex = true;
10174
10175 torture_assert(tctx,
10176 fillup_printserver_info(tctx, p, d),
10177 "failed to fillup printserver info");
10178
10179 if (!directory_exist(d->local.driver_directory)) {
10180 torture_skip(tctx, "Skipping Printer Driver test as no local driver is available");
10181 }
10182
10183 torture_assert(tctx,
10184 upload_printer_driver(tctx, dcerpc_server_name(p), d),
10185 "failed to upload printer driver");
10186
10187 info8 = d->info8;
10188 info8.architecture = d->local.environment;
10189
10190 for (i=0; i < 3; i++) {
10191 info8.driver_name = talloc_asprintf(d, "torture_test_driver_%d", i);
10192
10193 torture_assert(tctx,
10194 test_AddPrinterDriver_args_level_3(tctx, b, server_name_slash, &info8, add_flags, true, NULL),
10195 "failed to add driver");
10196 }
10197
10198 torture_assert(tctx,
10199 test_DeletePrinterDriverEx(tctx, b, server_name_slash, "torture_test_driver_0", info8.architecture, delete_flags, info8.version),
10200 "failed to delete driver");
10201
10202 torture_assert(tctx,
10203 test_EnumPrinterDrivers_findone(tctx, b, server_name_slash, info8.architecture, 3, "torture_test_driver_1", NULL),
10204 "torture_test_driver_1 no longer on the server");
10205
10206 torture_assert(tctx,
10207 test_EnumPrinterDrivers_findone(tctx, b, server_name_slash, info8.architecture, 3, "torture_test_driver_2", NULL),
10208 "torture_test_driver_2 no longer on the server");
10209
10210 torture_assert(tctx,
10211 test_DeletePrinterDriverEx(tctx, b, server_name_slash, "torture_test_driver_1", info8.architecture, delete_flags, info8.version),
10212 "failed to delete driver");
10213
10214 torture_assert(tctx,
10215 test_EnumPrinterDrivers_findone(tctx, b, server_name_slash, info8.architecture, 3, "torture_test_driver_2", NULL),
10216 "torture_test_driver_2 no longer on the server");
10217
10218 torture_assert(tctx,
10219 test_DeletePrinterDriverEx(tctx, b, server_name_slash, "torture_test_driver_2", info8.architecture, delete_flags, info8.version),
10220 "failed to delete driver");
10221
10222 torture_assert(tctx,
10223 remove_printer_driver(tctx, dcerpc_server_name(p), d),
10224 "failed to remove printer driver");
10225
10226 return true;
10227 }
10228
10229 static bool test_del_driver_all_files(struct torture_context *tctx,
10230 struct dcerpc_pipe *p)
10231 {
10232 struct torture_driver_context *d;
10233 struct spoolss_StringArray *a;
10234 uint32_t add_flags = APD_COPY_NEW_FILES;
10235 uint32_t delete_flags = DPD_DELETE_ALL_FILES;
10236 struct dcerpc_binding_handle *b = p->binding_handle;
10237 const char *server_name_slash = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
10238
10239 d = talloc_zero(tctx, struct torture_driver_context);
10240
10241 d->ex = true;
10242 d->info8.version = SPOOLSS_DRIVER_VERSION_200X;
10243 d->info8.driver_name = TORTURE_DRIVER_DELETER;
10244 d->info8.architecture = NULL;
10245 d->info8.driver_path = talloc_strdup(d, "pscript5.dll");
10246 d->info8.data_file = talloc_strdup(d, "cups6.ppd");
10247 d->info8.config_file = talloc_strdup(d, "cupsui6.dll");
10248 d->info8.help_file = talloc_strdup(d, "pscript.hlp");
10249 d->local.environment = talloc_strdup(d, SPOOLSS_ARCHITECTURE_x64);
10250 d->local.driver_directory = talloc_strdup(d, "/usr/share/cups/drivers/x64");
10251
10252 a = talloc_zero(d, struct spoolss_StringArray);
10253 a->string = talloc_zero_array(a, const char *, 3);
10254 a->string[0] = talloc_strdup(a->string, "cups6.inf");
10255 a->string[1] = talloc_strdup(a->string, "cups6.ini");
10256
10257 d->info8.dependent_files = a;
10258 d->info8.architecture = d->local.environment;
10259
10260 torture_assert(tctx,
10261 fillup_printserver_info(tctx, p, d),
10262 "failed to fillup printserver info");
10263
10264 if (!directory_exist(d->local.driver_directory)) {
10265 torture_skip(tctx, "Skipping Printer Driver test as no local driver is available");
10266 }
10267
10268 torture_assert(tctx,
10269 upload_printer_driver(tctx, dcerpc_server_name(p), d),
10270 "failed to upload printer driver");
10271
10272 torture_assert(tctx,
10273 test_AddPrinterDriver_args_level_3(tctx, b, server_name_slash, &d->info8, add_flags, true, NULL),
10274 "failed to add driver");
10275
10276 torture_assert(tctx,
10277 test_DeletePrinterDriverEx(tctx, b, server_name_slash,
10278 d->info8.driver_name,
10279 d->local.environment,
10280 delete_flags,
10281 d->info8.version),
10282 "failed to delete driver");
10283
10284 torture_assert(tctx,
10285 check_printer_driver_files(tctx, dcerpc_server_name(p), d, false),
10286 "printer driver file check failed");
10287
10288 talloc_free(d);
10289 return true;
10290 }
10291
10292 static bool test_del_driver_unused_files(struct torture_context *tctx,
10293 struct dcerpc_pipe *p)
10294 {
10295 struct torture_driver_context *d1;
10296 struct torture_driver_context *d2;
10297 uint32_t add_flags = APD_COPY_NEW_FILES;
10298 struct dcerpc_binding_handle *b = p->binding_handle;
10299 const char *server_name_slash = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
10300
10301 d1 = talloc_zero(tctx, struct torture_driver_context);
10302 d1->ex = true;
10303 d1->info8.version = SPOOLSS_DRIVER_VERSION_200X;
10304 d1->info8.driver_name = TORTURE_DRIVER_DELETER;
10305 d1->info8.architecture = NULL;
10306 d1->info8.driver_path = talloc_strdup(d1, "pscript5.dll");
10307 d1->info8.data_file = talloc_strdup(d1, "cups6.ppd");
10308 d1->info8.config_file = talloc_strdup(d1, "cupsui6.dll");
10309 d1->info8.help_file = talloc_strdup(d1, "pscript.hlp");
10310 d1->local.environment = talloc_strdup(d1, SPOOLSS_ARCHITECTURE_x64);
10311 d1->local.driver_directory = talloc_strdup(d1, "/usr/share/cups/drivers/x64");
10312 d1->info8.architecture = d1->local.environment;
10313
10314 d2 = talloc_zero(tctx, struct torture_driver_context);
10315 d2->ex = true;
10316 d2->info8.version = SPOOLSS_DRIVER_VERSION_200X;
10317 d2->info8.driver_name = TORTURE_DRIVER_DELETERIN;
10318 d2->info8.architecture = NULL;
10319 d2->info8.driver_path = talloc_strdup(d2, "pscript5.dll"); /* overlapping */
10320 d2->info8.data_file = talloc_strdup(d2, "cupsps6.dll");
10321 d2->info8.config_file = talloc_strdup(d2, "cups6.ini");
10322 d2->info8.help_file = talloc_strdup(d2, "pscript.hlp"); /* overlapping */
10323 d2->local.environment = talloc_strdup(d2, SPOOLSS_ARCHITECTURE_x64);
10324 d2->local.driver_directory = talloc_strdup(d2, "/usr/share/cups/drivers/x64");
10325 d2->info8.architecture = d2->local.environment;
10326
10327 torture_assert(tctx,
10328 fillup_printserver_info(tctx, p, d1),
10329 "failed to fillup printserver info");
10330 torture_assert(tctx,
10331 fillup_printserver_info(tctx, p, d2),
10332 "failed to fillup printserver info");
10333
10334 if (!directory_exist(d1->local.driver_directory)) {
10335 torture_skip(tctx, "Skipping Printer Driver test as no local driver is available");
10336 }
10337
10338 torture_assert(tctx,
10339 upload_printer_driver(tctx, dcerpc_server_name(p), d1),
10340 "failed to upload printer driver");
10341 torture_assert(tctx,
10342 test_AddPrinterDriver_args_level_3(tctx, b, server_name_slash, &d1->info8, add_flags, true, NULL),
10343 "failed to add driver");
10344
10345 torture_assert(tctx,
10346 upload_printer_driver(tctx, dcerpc_server_name(p), d2),
10347 "failed to upload printer driver");
10348 torture_assert(tctx,
10349 test_AddPrinterDriver_args_level_3(tctx, b, server_name_slash, &d2->info8, add_flags, true, NULL),
10350 "failed to add driver");
10351
10352 /* some files are in use by a separate driver, should fail */
10353 torture_assert(tctx,
10354 test_DeletePrinterDriverEx_exp(tctx, b, server_name_slash,
10355 d1->info8.driver_name,
10356 d1->local.environment,
10357 DPD_DELETE_ALL_FILES,
10358 d1->info8.version,
10359 WERR_PRINTER_DRIVER_IN_USE),
10360 "invalid delete driver response");
10361
10362 /* should only delete files not in use by other driver */
10363 torture_assert(tctx,
10364 test_DeletePrinterDriverEx_exp(tctx, b, server_name_slash,
10365 d1->info8.driver_name,
10366 d1->local.environment,
10367 DPD_DELETE_UNUSED_FILES,
10368 d1->info8.version,
10369 WERR_OK),
10370 "failed to delete driver (unused files)");
10371
10372 /* check non-overlapping were deleted */
10373 d1->info8.driver_path = NULL;
10374 d1->info8.help_file = NULL;
10375 torture_assert(tctx,
10376 check_printer_driver_files(tctx, dcerpc_server_name(p), d1, false),
10377 "printer driver file check failed");
10378 /* d2 files should be uneffected */
10379 torture_assert(tctx,
10380 check_printer_driver_files(tctx, dcerpc_server_name(p), d2, true),
10381 "printer driver file check failed");
10382
10383 torture_assert(tctx,
10384 test_DeletePrinterDriverEx_exp(tctx, b, server_name_slash,
10385 d2->info8.driver_name,
10386 d2->local.environment,
10387 DPD_DELETE_ALL_FILES,
10388 d2->info8.version,
10389 WERR_OK),
10390 "failed to delete driver");
10391
10392 torture_assert(tctx,
10393 check_printer_driver_files(tctx, dcerpc_server_name(p), d2, false),
10394 "printer driver file check failed");
10395
10396 talloc_free(d1);
10397 talloc_free(d2);
10398 return true;
10399 }
10400
10401 struct torture_suite *torture_rpc_spoolss_driver(TALLOC_CTX *mem_ctx)
10402 {
10403 struct torture_suite *suite = torture_suite_create(mem_ctx, "spoolss.driver");
10404
10405 struct torture_rpc_tcase *tcase = torture_suite_add_rpc_iface_tcase(suite,
10406 "driver", &ndr_table_spoolss);
10407 torture_rpc_tcase_add_test(tcase, "add_driver_64", test_add_driver_64);
10408 torture_rpc_tcase_add_test(tcase, "add_driver_ex_64", test_add_driver_ex_64);
10409
10410 torture_rpc_tcase_add_test(tcase, "add_driver_32", test_add_driver_32);
10411 torture_rpc_tcase_add_test(tcase, "add_driver_ex_32", test_add_driver_ex_32);
10412
10413 torture_rpc_tcase_add_test(tcase, "add_driver_adobe", test_add_driver_adobe);
10414
10415 torture_rpc_tcase_add_test(tcase, "add_driver_adobe_cupsaddsmb", test_add_driver_adobe_cupsaddsmb);
10416
10417 torture_rpc_tcase_add_test(tcase, "add_driver_timestamps", test_add_driver_timestamps);
10418
10419 torture_rpc_tcase_add_test(tcase, "multiple_drivers", test_multiple_drivers);
10420
10421 torture_rpc_tcase_add_test(tcase, "del_driver_all_files", test_del_driver_all_files);
10422
10423 torture_rpc_tcase_add_test(tcase, "del_driver_unused_files", test_del_driver_unused_files);
10424
10425 return suite;
10426 }
reg import