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