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