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/rpc/rpc.h"
23 #include "librpc/gen_ndr/ndr_spoolss_c.h"
24 #include "librpc/gen_ndr/ndr_misc.h"
25 #include "ntvfs/ntvfs.h"
26 #include "param/param.h"
28 struct test_spoolss_win_context {
30 uint32_t printer_count;
31 union spoolss_PrinterInfo *printer_info;
32 union spoolss_PrinterInfo *current_info;
35 const char **printer_keys;
37 bool printer_has_driver;
40 /* This is a convenience function for all OpenPrinterEx calls */
41 static bool test_OpenPrinterEx(struct torture_context *tctx,
42 struct dcerpc_pipe *p,
43 struct policy_handle *handle,
44 const char *printer_name,
48 struct spoolss_OpenPrinterEx op;
49 struct spoolss_UserLevel1 ul_1;
51 torture_comment(tctx, "Opening printer '%s'\n", printer_name);
53 op.in.printername = talloc_strdup(tctx, printer_name);
54 op.in.datatype = NULL;
55 op.in.devmode_ctr.devmode = NULL;
56 op.in.access_mask = access_mask;
58 op.in.userlevel.level1 = &ul_1;
59 op.out.handle = handle;
62 ul_1.client = "\\clientname";
63 ul_1.user = "username";
67 ul_1.processor = 4567;
69 status = dcerpc_spoolss_OpenPrinterEx(p, tctx, &op);
70 torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
71 torture_assert_werr_ok(tctx, op.out.result, "OpenPrinterEx failed");
76 static bool test_OpenPrinterAsAdmin(struct torture_context *tctx,
77 struct dcerpc_pipe *p,
78 const char *printername)
81 struct spoolss_OpenPrinterEx op;
82 struct spoolss_ClosePrinter cp;
83 struct spoolss_UserLevel1 ul_1;
84 struct policy_handle handle;
87 ul_1.client = "\\clientname";
88 ul_1.user = "username";
92 ul_1.processor = 4567;
94 op.in.printername = talloc_strdup(tctx, printername);
95 op.in.datatype = NULL;
96 op.in.devmode_ctr.devmode = NULL;
97 op.in.access_mask = SERVER_ALL_ACCESS;
99 op.in.userlevel.level1 = &ul_1;
100 op.out.handle = &handle;
102 cp.in.handle = &handle;
103 cp.out.handle = &handle;
105 torture_comment(tctx, "Testing OpenPrinterEx(%s) with admin rights\n",
108 status = dcerpc_spoolss_OpenPrinterEx(p, tctx, &op);
110 if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(op.out.result)) {
111 status = dcerpc_spoolss_ClosePrinter(p, tctx, &cp);
112 torture_assert_ntstatus_ok(tctx, status, "ClosePrinter failed");
119 static bool test_ClosePrinter(struct torture_context *tctx,
120 struct dcerpc_pipe *p,
121 struct policy_handle *handle);
123 /* This replicates the opening sequence of OpenPrinterEx calls XP does */
124 static bool test_OpenPrinterSequence(struct torture_context *tctx,
125 struct dcerpc_pipe *p,
126 struct policy_handle *handle)
129 char *printername = talloc_asprintf(tctx, "\\\\%s",
130 dcerpc_server_name(p));
132 /* First, see if we can open the printer read_only */
133 ret = test_OpenPrinterEx(tctx, p, handle, printername, 0);
134 torture_assert(tctx, ret == true, "OpenPrinterEx failed.");
136 ret = test_ClosePrinter(tctx, p, handle);
137 torture_assert(tctx, ret, "ClosePrinter failed");
139 /* Now let's see if we have admin rights to it. */
140 ret = test_OpenPrinterAsAdmin(tctx, p, printername);
141 torture_assert(tctx, ret == true,
142 "OpenPrinterEx as admin failed unexpectedly.");
144 ret = test_OpenPrinterEx(tctx, p, handle, printername, SERVER_EXECUTE);
145 torture_assert(tctx, ret == true, "OpenPrinterEx failed.");
150 static bool test_GetPrinterData(struct torture_context *tctx,
151 struct dcerpc_pipe *p,
152 struct policy_handle *handle,
153 const char *value_name,
154 WERROR expected_werr,
155 uint32_t expected_value)
158 struct spoolss_GetPrinterData gpd;
160 enum winreg_Type type;
161 union spoolss_PrinterData data;
163 torture_comment(tctx, "Testing GetPrinterData(%s).\n", value_name);
164 gpd.in.handle = handle;
165 gpd.in.value_name = value_name;
167 gpd.out.needed = &needed;
168 gpd.out.type = &type;
169 gpd.out.data = &data;
171 status = dcerpc_spoolss_GetPrinterData(p, tctx, &gpd);
172 torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed.");
173 torture_assert_werr_equal(tctx, gpd.out.result, expected_werr,
174 "GetPrinterData did not return expected error value.");
176 if (W_ERROR_IS_OK(expected_werr)) {
177 torture_assert_int_equal(tctx, data.value,
179 talloc_asprintf(tctx, "GetPrinterData for %s did not return expected value.", value_name));
184 static bool test_EnumPrinters(struct torture_context *tctx,
185 struct dcerpc_pipe *p,
186 struct test_spoolss_win_context *ctx,
187 uint32_t initial_blob_size)
190 struct spoolss_EnumPrinters ep;
191 DATA_BLOB blob = data_blob_talloc_zero(ctx, initial_blob_size);
194 union spoolss_PrinterInfo *info;
196 ep.in.flags = PRINTER_ENUM_NAME;
197 ep.in.server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
199 ep.in.buffer = &blob;
200 ep.in.offered = initial_blob_size;
201 ep.out.needed = &needed;
202 ep.out.count = &count;
205 status = dcerpc_spoolss_EnumPrinters(p, ctx, &ep);
206 torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed.");
208 if (W_ERROR_EQUAL(ep.out.result, WERR_INSUFFICIENT_BUFFER)) {
209 blob = data_blob_talloc_zero(ctx, needed);
210 ep.in.buffer = &blob;
211 ep.in.offered = needed;
212 status = dcerpc_spoolss_EnumPrinters(p, ctx, &ep);
213 torture_assert_ntstatus_ok(tctx, status,"EnumPrinters failed.");
216 torture_assert_werr_ok(tctx, ep.out.result, "EnumPrinters failed.");
218 ctx->printer_count = count;
219 ctx->printer_info = info;
221 torture_comment(tctx, "Found %d printer(s).\n", ctx->printer_count);
226 static bool test_GetPrinter(struct torture_context *tctx,
227 struct dcerpc_pipe *p,
228 struct policy_handle *handle,
229 struct test_spoolss_win_context *ctx,
231 uint32_t initial_blob_size)
234 struct spoolss_GetPrinter gp;
235 DATA_BLOB blob = data_blob_talloc_zero(ctx, initial_blob_size);
238 torture_comment(tctx, "Test GetPrinter level %d\n", level);
240 gp.in.handle = handle;
242 gp.in.buffer = (initial_blob_size == 0)?NULL:&blob;
243 gp.in.offered = initial_blob_size;
244 gp.out.needed = &needed;
246 status = dcerpc_spoolss_GetPrinter(p, tctx, &gp);
247 torture_assert_ntstatus_ok(tctx, status, "GetPrinter failed");
249 if (W_ERROR_EQUAL(gp.out.result, WERR_INSUFFICIENT_BUFFER)) {
250 blob = data_blob_talloc_zero(ctx, needed);
251 gp.in.buffer = &blob;
252 gp.in.offered = needed;
253 status = dcerpc_spoolss_GetPrinter(p, tctx, &gp);
254 torture_assert_ntstatus_ok(tctx, status, "GetPrinter failed");
257 torture_assert_werr_ok(tctx, gp.out.result, "GetPrinter failed");
259 ctx->current_info = gp.out.info;
261 if (level == 2 && gp.out.info) {
262 ctx->printer_has_driver = gp.out.info->info2.drivername &&
263 strlen(gp.out.info->info2.drivername);
269 static bool test_EnumJobs(struct torture_context *tctx,
270 struct dcerpc_pipe *p,
271 struct policy_handle *handle)
274 struct spoolss_EnumJobs ej;
275 DATA_BLOB blob = data_blob_talloc_zero(tctx, 1024);
278 union spoolss_JobInfo *info;
280 torture_comment(tctx, "Test EnumJobs\n");
282 ej.in.handle = handle;
284 ej.in.buffer = &blob;
285 ej.in.offered = 1024;
286 ej.out.needed = &needed;
287 ej.out.count = &count;
290 status = dcerpc_spoolss_EnumJobs(p, tctx, &ej);
291 torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
292 if (W_ERROR_EQUAL(ej.out.result, WERR_INSUFFICIENT_BUFFER)) {
293 blob = data_blob_talloc_zero(tctx, needed);
294 ej.in.offered = needed;
295 ej.in.buffer = &blob;
296 status = dcerpc_spoolss_EnumJobs(p, tctx, &ej);
297 torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
299 torture_assert_werr_ok(tctx, ej.out.result, "EnumJobs failed");
304 static bool test_GetPrinterDriver2(struct torture_context *tctx,
305 struct dcerpc_pipe *p,
306 struct test_spoolss_win_context *ctx,
307 struct policy_handle *handle)
310 struct spoolss_GetPrinterDriver2 gpd2;
311 DATA_BLOB blob = data_blob_talloc_zero(tctx, 87424);
313 uint32_t server_major_version;
314 uint32_t server_minor_version;
316 torture_comment(tctx, "Testing GetPrinterDriver2\n");
318 gpd2.in.handle = handle;
319 gpd2.in.architecture = "Windows NT x86";
321 gpd2.in.buffer = &blob;
322 gpd2.in.offered = 87424;
323 gpd2.in.client_major_version = 3;
324 gpd2.in.client_minor_version = 0;
325 gpd2.out.needed = &needed;
326 gpd2.out.server_major_version = &server_major_version;
327 gpd2.out.server_minor_version = &server_minor_version;
329 status = dcerpc_spoolss_GetPrinterDriver2(p, tctx, &gpd2);
330 torture_assert_ntstatus_ok(tctx, status, "GetPrinterDriver2 failed");
332 if (ctx->printer_has_driver) {
333 torture_assert_werr_ok(tctx, gpd2.out.result,
334 "GetPrinterDriver2 failed.");
340 static bool test_EnumForms(struct torture_context *tctx,
341 struct dcerpc_pipe *p,
342 struct policy_handle *handle,
343 uint32_t initial_blob_size)
346 struct spoolss_EnumForms ef;
347 DATA_BLOB blob = data_blob_talloc_zero(tctx, initial_blob_size);
350 union spoolss_FormInfo *info;
352 torture_comment(tctx, "Testing EnumForms\n");
354 ef.in.handle = handle;
356 ef.in.buffer = (initial_blob_size == 0)?NULL:&blob;
357 ef.in.offered = initial_blob_size;
358 ef.out.needed = &needed;
359 ef.out.count = &count;
362 status = dcerpc_spoolss_EnumForms(p, tctx, &ef);
363 torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
365 if (W_ERROR_EQUAL(ef.out.result, WERR_INSUFFICIENT_BUFFER)) {
366 blob = data_blob_talloc_zero(tctx, needed);
367 ef.in.buffer = &blob;
368 ef.in.offered = needed;
369 status = dcerpc_spoolss_EnumForms(p, tctx, &ef);
370 torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
373 torture_assert_werr_ok(tctx, ef.out.result, "EnumForms failed");
378 static bool test_EnumPrinterKey(struct torture_context *tctx,
379 struct dcerpc_pipe *p,
380 struct policy_handle *handle,
382 struct test_spoolss_win_context *ctx)
385 struct spoolss_EnumPrinterKey epk;
387 struct spoolss_StringArray2 key_buffer;
389 torture_comment(tctx, "Testing EnumPrinterKey(%s)\n", key);
391 epk.in.handle = handle;
392 epk.in.key_name = talloc_strdup(tctx, key);
394 epk.out.needed = &needed;
395 epk.out.key_buffer = &key_buffer;
397 status = dcerpc_spoolss_EnumPrinterKey(p, tctx, &epk);
398 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterKey failed");
400 if (W_ERROR_EQUAL(epk.out.result, WERR_MORE_DATA)) {
401 torture_assert(tctx, (key_buffer._ndr_size == 0),
402 talloc_asprintf(tctx, "EnumPrinterKey did not return 0 _ndr_size (but %d), windows clients would abort here!", key_buffer._ndr_size));
403 epk.in.offered = needed;
404 status = dcerpc_spoolss_EnumPrinterKey(p, tctx, &epk);
405 torture_assert_ntstatus_ok(tctx, status,
406 "EnumPrinterKey failed");
409 torture_assert_werr_ok(tctx, epk.out.result, "EnumPrinterKey failed");
411 torture_assert(tctx, (key_buffer._ndr_size * 2 == needed),
412 talloc_asprintf(tctx, "EnumPrinterKey size mismatch, _ndr_size %d (expected %d)",
413 key_buffer._ndr_size, needed/2));
415 ctx->printer_keys = key_buffer.string;
420 static bool test_EnumPrinterDataEx(struct torture_context *tctx,
421 struct dcerpc_pipe *p,
422 struct policy_handle *handle,
424 uint32_t initial_blob_size,
425 WERROR expected_error)
428 struct spoolss_EnumPrinterDataEx epde;
429 struct spoolss_PrinterEnumValues *info;
433 torture_comment(tctx, "Testing EnumPrinterDataEx(%s)\n", key);
435 epde.in.handle = handle;
436 epde.in.key_name = talloc_strdup(tctx, key);
438 epde.out.needed = &needed;
439 epde.out.count = &count;
440 epde.out.info = &info;
442 status = dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &epde);
443 torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDataEx failed.");
444 if (W_ERROR_EQUAL(epde.out.result, WERR_MORE_DATA)) {
445 epde.in.offered = needed;
446 status = dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &epde);
447 torture_assert_ntstatus_ok(tctx, status,
448 "EnumPrinterDataEx failed.");
451 torture_assert_werr_equal(tctx, epde.out.result, expected_error,
452 "EnumPrinterDataEx failed.");
457 static bool test_ClosePrinter(struct torture_context *tctx,
458 struct dcerpc_pipe *p,
459 struct policy_handle *handle)
462 struct spoolss_ClosePrinter cp;
464 cp.in.handle = handle;
465 cp.out.handle = handle;
467 status = dcerpc_spoolss_ClosePrinter(p, tctx, &cp);
468 torture_assert_ntstatus_ok(tctx, status, "ClosePrinter failed");
473 static bool test_WinXP(struct torture_context *tctx, struct dcerpc_pipe *p)
476 struct test_spoolss_win_context *ctx, *tmp_ctx;
477 struct policy_handle handle01, handle02, handle03, handle04;
478 /* Sometimes a handle stays unused. In order to make this clear in the
479 * code, the unused_handle structures are used for that. */
480 struct policy_handle unused_handle1, unused_handle2;
484 ntvfs_init(tctx->lp_ctx);
486 ctx = talloc_zero(tctx, struct test_spoolss_win_context);
487 tmp_ctx = talloc_zero(tctx, struct test_spoolss_win_context);
489 ret &= test_OpenPrinterSequence(tctx, p, &handle01);
490 ret &= test_GetPrinterData(tctx, p, &handle01,"UISingleJobStatusString",
491 WERR_INVALID_PARAM, 0);
492 torture_comment(tctx, "Skip RemoteFindNextPrinterChangeNotifyEx test\n");
494 server_name = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p));
495 ret &= test_OpenPrinterEx(tctx, p, &unused_handle1, server_name, 0);
497 ret &= test_EnumPrinters(tctx, p, ctx, 1024);
499 ret &= test_OpenPrinterEx(tctx, p, &handle02, server_name, 0);
500 ret &= test_GetPrinterData(tctx, p, &handle02, "MajorVersion", WERR_OK,
502 ret &= test_ClosePrinter(tctx, p, &handle02);
504 /* If no printers were found, skip all tests that need a printer */
505 if (ctx->printer_count == 0) {
509 ret &= test_OpenPrinterEx(tctx, p, &handle02,
510 ctx->printer_info[0].info2.printername,
512 ret &= test_GetPrinter(tctx, p, &handle02, ctx, 2, 0);
514 torture_assert_str_equal(tctx, ctx->current_info->info2.printername,
515 ctx->printer_info[0].info2.printername,
516 "GetPrinter returned unexpected printername");
517 /*FIXME: Test more components of the PrinterInfo2 struct */
519 ret &= test_OpenPrinterEx(tctx, p, &handle03,
520 ctx->printer_info[0].info2.printername, 0);
521 ret &= test_GetPrinter(tctx, p, &handle03, ctx, 0, 1164);
522 ret &= test_GetPrinter(tctx, p, &handle03, ctx, 2, 0);
524 ret &= test_OpenPrinterEx(tctx, p, &handle04,
525 ctx->printer_info[0].info2.printername, 0);
526 ret &= test_GetPrinter(tctx, p, &handle04, ctx, 2, 0);
527 ret &= test_ClosePrinter(tctx, p, &handle04);
529 ret &= test_OpenPrinterEx(tctx, p, &handle04,
530 ctx->printer_info[0].info2.printername, 0);
531 ret &= test_GetPrinter(tctx, p, &handle04, ctx, 2, 4096);
532 ret &= test_ClosePrinter(tctx, p, &handle04);
534 ret &= test_OpenPrinterAsAdmin(tctx, p,
535 ctx->printer_info[0].info2.printername);
537 ret &= test_OpenPrinterEx(tctx, p, &handle04,
538 ctx->printer_info[0].info2.printername, PRINTER_READ);
539 ret &= test_GetPrinterData(tctx, p, &handle04,"UISingleJobStatusString",
541 torture_comment(tctx, "Skip RemoteFindNextPrinterChangeNotifyEx test\n");
543 ret &= test_OpenPrinterEx(tctx, p, &unused_handle2,
544 ctx->printer_info[0].info2.printername, 0);
546 ret &= test_EnumJobs(tctx, p, &handle04);
547 ret &= test_GetPrinter(tctx, p, &handle04, ctx, 2, 4096);
549 ret &= test_ClosePrinter(tctx, p, &unused_handle2);
550 ret &= test_ClosePrinter(tctx, p, &handle04);
552 ret &= test_EnumPrinters(tctx, p, ctx, 1556);
553 ret &= test_GetPrinterDriver2(tctx, p, ctx, &handle03);
554 ret &= test_EnumForms(tctx, p, &handle03, 0);
556 ret &= test_EnumPrinterKey(tctx, p, &handle03, "", ctx);
558 for (i=0; ctx->printer_keys && ctx->printer_keys[i] != NULL; i++) {
560 ret &= test_EnumPrinterKey(tctx, p, &handle03,
561 ctx->printer_keys[i],
563 ret &= test_EnumPrinterDataEx(tctx, p, &handle03,
564 ctx->printer_keys[i], 0,
568 ret &= test_EnumPrinterDataEx(tctx, p, &handle03, "", 0,
571 ret &= test_GetPrinter(tctx, p, &handle03, tmp_ctx, 2, 0);
573 ret &= test_OpenPrinterEx(tctx, p, &unused_handle2,
574 ctx->printer_info[0].info2.printername, 0);
575 ret &= test_ClosePrinter(tctx, p, &unused_handle2);
577 ret &= test_GetPrinter(tctx, p, &handle03, tmp_ctx, 2, 2556);
579 ret &= test_OpenPrinterEx(tctx, p, &unused_handle2,
580 ctx->printer_info[0].info2.printername, 0);
581 ret &= test_ClosePrinter(tctx, p, &unused_handle2);
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, 7, 0);
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_ClosePrinter(tctx, p, &handle03);
595 ret &= test_OpenPrinterEx(tctx, p, &unused_handle2,
596 ctx->printer_info[0].info2.printername, 0);
597 ret &= test_ClosePrinter(tctx, p, &unused_handle2);
599 ret &= test_OpenPrinterEx(tctx, p, &handle03, server_name, 0);
600 ret &= test_GetPrinterData(tctx, p, &handle03, "W3SvcInstalled",
602 ret &= test_ClosePrinter(tctx, p, &handle03);
604 ret &= test_ClosePrinter(tctx, p, &unused_handle1);
605 ret &= test_ClosePrinter(tctx, p, &handle02);
607 ret &= test_OpenPrinterEx(tctx, p, &handle02,
608 ctx->printer_info[0].info2.sharename, 0);
609 ret &= test_GetPrinter(tctx, p, &handle02, tmp_ctx, 2, 0);
610 ret &= test_ClosePrinter(tctx, p, &handle02);
613 ret &= test_ClosePrinter(tctx, p, &handle01);
615 talloc_free(tmp_ctx);
620 struct torture_suite *torture_rpc_spoolss_win(TALLOC_CTX *mem_ctx)
622 struct torture_suite *suite = torture_suite_create(mem_ctx, "SPOOLSS-WIN");
624 struct torture_rpc_tcase *tcase = torture_suite_add_rpc_iface_tcase(suite,
625 "win", &ndr_table_spoolss);
627 torture_rpc_tcase_add_test(tcase, "testWinXP", test_WinXP);