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