2 Unix SMB/CIFS implementation.
3 test suite for spoolss rpc operations as performed by various win versions
5 Copyright (C) Kai Blin 2007
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 #include "torture/torture.h"
23 #include "torture/rpc/rpc.h"
24 #include "librpc/gen_ndr/ndr_spoolss_c.h"
25 #include "rpc_server/dcerpc_server.h"
26 #include "librpc/gen_ndr/ndr_misc.h"
27 #include "ntvfs/ntvfs.h"
28 #include "param/param.h"
30 struct test_spoolss_win_context {
32 uint32_t printer_count;
33 union spoolss_PrinterInfo *printer_info;
34 union spoolss_PrinterInfo *current_info;
37 const char **printer_keys;
39 bool printer_has_driver;
42 /* This is a convenience function for all OpenPrinterEx calls */
43 static bool test_OpenPrinterEx(struct torture_context *tctx,
44 struct dcerpc_pipe *p,
45 struct policy_handle *handle,
46 const char *printer_name,
50 struct spoolss_OpenPrinterEx op;
51 struct spoolss_UserLevel1 ul_1;
53 torture_comment(tctx, "Opening printer '%s'\n", printer_name);
55 op.in.printername = talloc_strdup(tctx, printer_name);
56 op.in.datatype = NULL;
57 op.in.devmode_ctr.devmode = NULL;
58 op.in.access_mask = access_mask;
60 op.in.userlevel.level1 = &ul_1;
61 op.out.handle = handle;
64 ul_1.client = "\\clientname";
65 ul_1.user = "username";
69 ul_1.processor = 4567;
71 status = dcerpc_spoolss_OpenPrinterEx(p, tctx, &op);
72 torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
73 torture_assert_werr_ok(tctx, op.out.result, "OpenPrinterEx failed");
78 static bool test_OpenPrinterAsAdmin(struct torture_context *tctx,
79 struct dcerpc_pipe *p,
80 const char *printername)
83 struct spoolss_OpenPrinterEx op;
84 struct spoolss_ClosePrinter cp;
85 struct spoolss_UserLevel1 ul_1;
86 struct policy_handle handle;
89 ul_1.client = "\\clientname";
90 ul_1.user = "username";
94 ul_1.processor = 4567;
96 op.in.printername = talloc_strdup(tctx, printername);
97 op.in.datatype = NULL;
98 op.in.devmode_ctr.devmode = NULL;
99 op.in.access_mask = SERVER_ALL_ACCESS;
101 op.in.userlevel.level1 = &ul_1;
102 op.out.handle = &handle;
104 cp.in.handle = &handle;
105 cp.out.handle = &handle;
107 torture_comment(tctx, "Testing OpenPrinterEx(%s) with admin rights\n",
110 status = dcerpc_spoolss_OpenPrinterEx(p, tctx, &op);
112 if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(op.out.result)) {
113 status = dcerpc_spoolss_ClosePrinter(p, tctx, &cp);
114 torture_assert_ntstatus_ok(tctx, status, "ClosePrinter failed");
121 static bool test_ClosePrinter(struct torture_context *tctx,
122 struct dcerpc_pipe *p,
123 struct policy_handle *handle);
125 /* This replicates the opening sequence of OpenPrinterEx calls XP does */
126 static bool test_OpenPrinterSequence(struct torture_context *tctx,
127 struct dcerpc_pipe *p,
128 struct policy_handle *handle)
131 char *printername = talloc_asprintf(tctx, "\\\\%s",
132 dcerpc_server_name(p));
134 /* First, see if we can open the printer read_only */
135 ret = test_OpenPrinterEx(tctx, p, handle, printername, 0);
136 torture_assert(tctx, ret == true, "OpenPrinterEx failed.");
138 ret = test_ClosePrinter(tctx, p, handle);
139 torture_assert(tctx, ret, "ClosePrinter failed");
141 /* Now let's see if we have admin rights to it. */
142 ret = test_OpenPrinterAsAdmin(tctx, p, printername);
143 torture_assert(tctx, ret == true,
144 "OpenPrinterEx as admin failed unexpectedly.");
146 ret = test_OpenPrinterEx(tctx, p, handle, printername, SERVER_EXECUTE);
147 torture_assert(tctx, ret == true, "OpenPrinterEx failed.");
152 static bool test_GetPrinterData(struct torture_context *tctx,
153 struct dcerpc_pipe *p,
154 struct policy_handle *handle,
155 const char *value_name,
156 WERROR expected_werr,
157 uint32_t expected_value)
160 struct spoolss_GetPrinterData gpd;
162 enum winreg_Type type;
163 union spoolss_PrinterData data;
165 torture_comment(tctx, "Testing GetPrinterData(%s).\n", value_name);
166 gpd.in.handle = handle;
167 gpd.in.value_name = value_name;
169 gpd.out.needed = &needed;
170 gpd.out.type = &type;
171 gpd.out.data = &data;
173 status = dcerpc_spoolss_GetPrinterData(p, tctx, &gpd);
174 torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed.");
175 torture_assert_werr_equal(tctx, gpd.out.result, expected_werr,
176 "GetPrinterData did not return expected error value.");
178 if (W_ERROR_IS_OK(expected_werr)) {
179 torture_assert_int_equal(tctx, data.value,
181 talloc_asprintf(tctx, "GetPrinterData for %s did not return expected value.", value_name));
186 static bool test_EnumPrinters(struct torture_context *tctx,
187 struct dcerpc_pipe *p,
188 struct test_spoolss_win_context *ctx,
189 uint32_t initial_blob_size)
192 struct spoolss_EnumPrinters ep;
193 DATA_BLOB blob = data_blob_talloc_zero(ctx, initial_blob_size);
196 union spoolss_PrinterInfo *info;
198 ep.in.flags = PRINTER_ENUM_NAME;
199 ep.in.server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
201 ep.in.buffer = &blob;
202 ep.in.offered = initial_blob_size;
203 ep.out.needed = &needed;
204 ep.out.count = &count;
207 status = dcerpc_spoolss_EnumPrinters(p, ctx, &ep);
208 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed.");
210 if (W_ERROR_EQUAL(ep.out.result, WERR_INSUFFICIENT_BUFFER)) {
211 blob = data_blob_talloc_zero(ctx, needed);
212 ep.in.buffer = &blob;
213 ep.in.offered = needed;
214 status = dcerpc_spoolss_EnumPrinters(p, ctx, &ep);
215 torture_assert_ntstatus_ok(tctx, status,"EnumPrinters failed.");
218 torture_assert_werr_ok(tctx, ep.out.result, "EnumPrinters failed.");
220 ctx->printer_count = count;
221 ctx->printer_info = info;
223 torture_comment(tctx, "Found %d printer(s).\n", ctx->printer_count);
228 static bool test_GetPrinter(struct torture_context *tctx,
229 struct dcerpc_pipe *p,
230 struct policy_handle *handle,
231 struct test_spoolss_win_context *ctx,
233 uint32_t initial_blob_size)
236 struct spoolss_GetPrinter gp;
237 DATA_BLOB blob = data_blob_talloc_zero(ctx, initial_blob_size);
240 torture_comment(tctx, "Test GetPrinter level %d\n", level);
242 gp.in.handle = handle;
244 gp.in.buffer = (initial_blob_size == 0)?NULL:&blob;
245 gp.in.offered = initial_blob_size;
246 gp.out.needed = &needed;
248 status = dcerpc_spoolss_GetPrinter(p, tctx, &gp);
249 torture_assert_ntstatus_ok(tctx, status, "GetPrinter failed");
251 if (W_ERROR_EQUAL(gp.out.result, WERR_INSUFFICIENT_BUFFER)) {
252 blob = data_blob_talloc_zero(ctx, needed);
253 gp.in.buffer = &blob;
254 gp.in.offered = needed;
255 status = dcerpc_spoolss_GetPrinter(p, tctx, &gp);
256 torture_assert_ntstatus_ok(tctx, status, "GetPrinter failed");
259 torture_assert_werr_ok(tctx, gp.out.result, "GetPrinter failed");
261 ctx->current_info = gp.out.info;
263 if (level == 2 && gp.out.info) {
264 ctx->printer_has_driver = gp.out.info->info2.drivername &&
265 strlen(gp.out.info->info2.drivername);
271 static bool test_EnumJobs(struct torture_context *tctx,
272 struct dcerpc_pipe *p,
273 struct policy_handle *handle)
276 struct spoolss_EnumJobs ej;
277 DATA_BLOB blob = data_blob_talloc_zero(tctx, 1024);
280 union spoolss_JobInfo *info;
282 torture_comment(tctx, "Test EnumJobs\n");
284 ej.in.handle = handle;
286 ej.in.buffer = &blob;
287 ej.in.offered = 1024;
288 ej.out.needed = &needed;
289 ej.out.count = &count;
292 status = dcerpc_spoolss_EnumJobs(p, tctx, &ej);
293 torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
294 if (W_ERROR_EQUAL(ej.out.result, WERR_INSUFFICIENT_BUFFER)) {
295 blob = data_blob_talloc_zero(tctx, needed);
296 ej.in.offered = needed;
297 ej.in.buffer = &blob;
298 status = dcerpc_spoolss_EnumJobs(p, tctx, &ej);
299 torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
301 torture_assert_werr_ok(tctx, ej.out.result, "EnumJobs failed");
306 static bool test_GetPrinterDriver2(struct torture_context *tctx,
307 struct dcerpc_pipe *p,
308 struct test_spoolss_win_context *ctx,
309 struct policy_handle *handle)
312 struct spoolss_GetPrinterDriver2 gpd2;
313 DATA_BLOB blob = data_blob_talloc_zero(tctx, 87424);
315 uint32_t server_major_version;
316 uint32_t server_minor_version;
318 torture_comment(tctx, "Testing GetPrinterDriver2\n");
320 gpd2.in.handle = handle;
321 gpd2.in.architecture = "Windows NT x86";
323 gpd2.in.buffer = &blob;
324 gpd2.in.offered = 87424;
325 gpd2.in.client_major_version = 3;
326 gpd2.in.client_minor_version = 0;
327 gpd2.out.needed = &needed;
328 gpd2.out.server_major_version = &server_major_version;
329 gpd2.out.server_minor_version = &server_minor_version;
331 status = dcerpc_spoolss_GetPrinterDriver2(p, tctx, &gpd2);
332 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDriver2 failed");
334 if (ctx->printer_has_driver) {
335 torture_assert_werr_ok(tctx, gpd2.out.result,
336 "GetPrinterDriver2 failed.");
342 static bool test_EnumForms(struct torture_context *tctx,
343 struct dcerpc_pipe *p,
344 struct policy_handle *handle,
345 uint32_t initial_blob_size)
348 struct spoolss_EnumForms ef;
349 DATA_BLOB blob = data_blob_talloc_zero(tctx, initial_blob_size);
352 union spoolss_FormInfo *info;
354 torture_comment(tctx, "Testing EnumForms\n");
356 ef.in.handle = handle;
358 ef.in.buffer = (initial_blob_size == 0)?NULL:&blob;
359 ef.in.offered = initial_blob_size;
360 ef.out.needed = &needed;
361 ef.out.count = &count;
364 status = dcerpc_spoolss_EnumForms(p, tctx, &ef);
365 torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
367 if (W_ERROR_EQUAL(ef.out.result, WERR_INSUFFICIENT_BUFFER)) {
368 blob = data_blob_talloc_zero(tctx, needed);
369 ef.in.buffer = &blob;
370 ef.in.offered = needed;
371 status = dcerpc_spoolss_EnumForms(p, tctx, &ef);
372 torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
375 torture_assert_werr_ok(tctx, ef.out.result, "EnumForms failed");
380 static bool test_EnumPrinterKey(struct torture_context *tctx,
381 struct dcerpc_pipe *p,
382 struct policy_handle *handle,
384 struct test_spoolss_win_context *ctx)
387 struct spoolss_EnumPrinterKey epk;
389 uint16_t *key_buffer;
391 torture_comment(tctx, "Testing EnumPrinterKey(%s)\n", key);
393 key_buffer = talloc_zero_array(tctx, uint16_t, 0);
395 epk.in.handle = handle;
396 epk.in.key_name = talloc_strdup(tctx, key);
398 epk.out.needed = &needed;
399 epk.out.key_buffer = key_buffer;
401 status = dcerpc_spoolss_EnumPrinterKey(p, tctx, &epk);
402 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterKey failed");
405 if (W_ERROR_EQUAL(epk.out.result, WERR_MORE_DATA)) {
406 epk.in.offered = needed;
407 key_buffer = talloc_zero_array(tctx, uint16_t, needed/2);
408 epk.out.key_buffer = key_buffer;
409 status = dcerpc_spoolss_EnumPrinterKey(p, tctx, &epk);
410 torture_assert_ntstatus_ok(tctx, status,
411 "EnumPrinterKey failed");
414 torture_assert_werr_ok(tctx, epk.out.result, "EnumPrinterKey failed");
417 union winreg_Data data;
418 enum ndr_err_code ndr_err;
419 DATA_BLOB blob = data_blob_const(key_buffer, needed);
420 ndr_err = ndr_pull_union_blob(&blob, tctx, lp_iconv_convenience(tctx->lp_ctx),
422 (ndr_pull_flags_fn_t)ndr_pull_winreg_Data);
423 torture_assert_ndr_success(tctx, ndr_err, "failed to pull REG_MULTI_SZ");
424 ctx->printer_keys = data.string_array;
430 static bool test_EnumPrinterDataEx(struct torture_context *tctx,
431 struct dcerpc_pipe *p,
432 struct policy_handle *handle,
434 uint32_t initial_blob_size,
435 WERROR expected_error)
438 struct spoolss_EnumPrinterDataEx epde;
439 struct spoolss_PrinterEnumValues *info;
443 torture_comment(tctx, "Testing EnumPrinterDataEx(%s)\n", key);
445 epde.in.handle = handle;
446 epde.in.key_name = talloc_strdup(tctx, key);
448 epde.out.needed = &needed;
449 epde.out.count = &count;
450 epde.out.info = &info;
452 status = dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &epde);
453 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDataEx failed.");
454 if (W_ERROR_EQUAL(epde.out.result, WERR_MORE_DATA)) {
455 epde.in.offered = needed;
456 status = dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &epde);
457 torture_assert_ntstatus_ok(tctx, status,
458 "EnumPrinterDataEx failed.");
461 torture_assert_werr_equal(tctx, epde.out.result, expected_error,
462 "EnumPrinterDataEx failed.");
467 static bool test_ClosePrinter(struct torture_context *tctx,
468 struct dcerpc_pipe *p,
469 struct policy_handle *handle)
472 struct spoolss_ClosePrinter cp;
474 cp.in.handle = handle;
475 cp.out.handle = handle;
477 status = dcerpc_spoolss_ClosePrinter(p, tctx, &cp);
478 torture_assert_ntstatus_ok(tctx, status, "ClosePrinter failed");
483 static bool test_WinXP(struct torture_context *tctx, struct dcerpc_pipe *p)
486 struct test_spoolss_win_context *ctx, *tmp_ctx;
487 struct policy_handle handle01, handle02, handle03, handle04;
488 /* Sometimes a handle stays unused. In order to make this clear in the
489 * code, the unused_handle structures are used for that. */
490 struct policy_handle unused_handle1, unused_handle2;
494 ntvfs_init(tctx->lp_ctx);
496 ctx = talloc_zero(tctx, struct test_spoolss_win_context);
497 tmp_ctx = talloc_zero(tctx, struct test_spoolss_win_context);
499 ret &= test_OpenPrinterSequence(tctx, p, &handle01);
500 ret &= test_GetPrinterData(tctx, p, &handle01,"UISingleJobStatusString",
501 WERR_INVALID_PARAM, 0);
502 torture_comment(tctx, "Skip RemoteFindNextPrinterChangeNotifyEx test\n");
504 server_name = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p));
505 ret &= test_OpenPrinterEx(tctx, p, &unused_handle1, server_name, 0);
507 ret &= test_EnumPrinters(tctx, p, ctx, 1024);
509 ret &= test_OpenPrinterEx(tctx, p, &handle02, server_name, 0);
510 ret &= test_GetPrinterData(tctx, p, &handle02, "MajorVersion", WERR_OK,
512 ret &= test_ClosePrinter(tctx, p, &handle02);
514 /* If no printers were found, skip all tests that need a printer */
515 if (ctx->printer_count == 0) {
519 ret &= test_OpenPrinterEx(tctx, p, &handle02,
520 ctx->printer_info[0].info2.printername,
522 ret &= test_GetPrinter(tctx, p, &handle02, ctx, 2, 0);
524 torture_assert_str_equal(tctx, ctx->current_info->info2.printername,
525 ctx->printer_info[0].info2.printername,
526 "GetPrinter returned unexpected printername");
527 /*FIXME: Test more components of the PrinterInfo2 struct */
529 ret &= test_OpenPrinterEx(tctx, p, &handle03,
530 ctx->printer_info[0].info2.printername, 0);
531 ret &= test_GetPrinter(tctx, p, &handle03, ctx, 0, 1164);
532 ret &= test_GetPrinter(tctx, p, &handle03, ctx, 2, 0);
534 ret &= test_OpenPrinterEx(tctx, p, &handle04,
535 ctx->printer_info[0].info2.printername, 0);
536 ret &= test_GetPrinter(tctx, p, &handle04, ctx, 2, 0);
537 ret &= test_ClosePrinter(tctx, p, &handle04);
539 ret &= test_OpenPrinterEx(tctx, p, &handle04,
540 ctx->printer_info[0].info2.printername, 0);
541 ret &= test_GetPrinter(tctx, p, &handle04, ctx, 2, 4096);
542 ret &= test_ClosePrinter(tctx, p, &handle04);
544 ret &= test_OpenPrinterAsAdmin(tctx, p,
545 ctx->printer_info[0].info2.printername);
547 ret &= test_OpenPrinterEx(tctx, p, &handle04,
548 ctx->printer_info[0].info2.printername, PRINTER_READ);
549 ret &= test_GetPrinterData(tctx, p, &handle04,"UISingleJobStatusString",
551 torture_comment(tctx, "Skip RemoteFindNextPrinterChangeNotifyEx test\n");
553 ret &= test_OpenPrinterEx(tctx, p, &unused_handle2,
554 ctx->printer_info[0].info2.printername, 0);
556 ret &= test_EnumJobs(tctx, p, &handle04);
557 ret &= test_GetPrinter(tctx, p, &handle04, ctx, 2, 4096);
559 ret &= test_ClosePrinter(tctx, p, &unused_handle2);
560 ret &= test_ClosePrinter(tctx, p, &handle04);
562 ret &= test_EnumPrinters(tctx, p, ctx, 1556);
563 ret &= test_GetPrinterDriver2(tctx, p, ctx, &handle03);
564 ret &= test_EnumForms(tctx, p, &handle03, 0);
566 ret &= test_EnumPrinterKey(tctx, p, &handle03, "", ctx);
568 for (i=0; ctx->printer_keys[i] != NULL; i++) {
570 ret &= test_EnumPrinterKey(tctx, p, &handle03,
571 ctx->printer_keys[i],
573 ret &= test_EnumPrinterDataEx(tctx, p, &handle03,
574 ctx->printer_keys[i], 0,
578 ret &= test_EnumPrinterDataEx(tctx, p, &handle03, "", 0,
581 ret &= test_GetPrinter(tctx, p, &handle03, tmp_ctx, 2, 0);
583 ret &= test_OpenPrinterEx(tctx, p, &unused_handle2,
584 ctx->printer_info[0].info2.printername, 0);
585 ret &= test_ClosePrinter(tctx, p, &unused_handle2);
587 ret &= test_GetPrinter(tctx, p, &handle03, tmp_ctx, 2, 2556);
589 ret &= test_OpenPrinterEx(tctx, p, &unused_handle2,
590 ctx->printer_info[0].info2.printername, 0);
591 ret &= test_ClosePrinter(tctx, p, &unused_handle2);
593 ret &= test_OpenPrinterEx(tctx, p, &unused_handle2,
594 ctx->printer_info[0].info2.printername, 0);
595 ret &= test_ClosePrinter(tctx, p, &unused_handle2);
597 ret &= test_GetPrinter(tctx, p, &handle03, tmp_ctx, 7, 0);
599 ret &= test_OpenPrinterEx(tctx, p, &unused_handle2,
600 ctx->printer_info[0].info2.printername, 0);
601 ret &= test_ClosePrinter(tctx, p, &unused_handle2);
603 ret &= test_ClosePrinter(tctx, p, &handle03);
605 ret &= test_OpenPrinterEx(tctx, p, &unused_handle2,
606 ctx->printer_info[0].info2.printername, 0);
607 ret &= test_ClosePrinter(tctx, p, &unused_handle2);
609 ret &= test_OpenPrinterEx(tctx, p, &handle03, server_name, 0);
610 ret &= test_GetPrinterData(tctx, p, &handle03, "W3SvcInstalled",
612 ret &= test_ClosePrinter(tctx, p, &handle03);
614 ret &= test_ClosePrinter(tctx, p, &unused_handle1);
615 ret &= test_ClosePrinter(tctx, p, &handle02);
617 ret &= test_OpenPrinterEx(tctx, p, &handle02,
618 ctx->printer_info[0].info2.sharename, 0);
619 ret &= test_GetPrinter(tctx, p, &handle02, tmp_ctx, 2, 0);
620 ret &= test_ClosePrinter(tctx, p, &handle02);
623 ret &= test_ClosePrinter(tctx, p, &handle01);
625 talloc_free(tmp_ctx);
630 struct torture_suite *torture_rpc_spoolss_win(TALLOC_CTX *mem_ctx)
632 struct torture_suite *suite = torture_suite_create(mem_ctx, "SPOOLSS-WIN");
634 struct torture_rpc_tcase *tcase = torture_suite_add_rpc_iface_tcase(suite,
635 "win", &ndr_table_spoolss);
637 torture_rpc_tcase_add_test(tcase, "testWinXP", test_WinXP);