source: vendor/current/testprogs/win32/spoolss/testspoolss.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 49.9 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 test suite for spoolss rpc operations
4
5 Copyright (C) Guenther Deschner 2009-2010
6
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.
11
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.
16
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/>.
19*/
20
21/****************************************************************************
22****************************************************************************/
23
24#include "testspoolss.h"
25#include "string.h"
26#include "torture.h"
27
28/****************************************************************************
29****************************************************************************/
30
31static BOOL test_OpenPrinter(struct torture_context *tctx,
32 LPSTR printername,
33 LPPRINTER_DEFAULTS defaults,
34 LPHANDLE handle)
35{
36 torture_comment(tctx, "Testing OpenPrinter(%s)", printername);
37
38 if (!OpenPrinter(printername, handle, defaults)) {
39 char tmp[1024];
40 sprintf(tmp, "failed to open printer %s, error was: 0x%08x\n",
41 printername, GetLastError());
42 torture_fail(tctx, tmp);
43 }
44
45 return TRUE;
46}
47
48/****************************************************************************
49****************************************************************************/
50
51static BOOL test_ClosePrinter(struct torture_context *tctx,
52 HANDLE handle)
53{
54 torture_comment(tctx, "Testing ClosePrinter");
55
56 if (!ClosePrinter(handle)) {
57 char tmp[1024];
58 sprintf(tmp, "failed to close printer, error was: %s\n",
59 errstr(GetLastError()));
60 torture_fail(tctx, tmp);
61 }
62
63 return TRUE;
64}
65
66
67/****************************************************************************
68****************************************************************************/
69
70static BOOL test_EnumPrinters(struct torture_context *tctx,
71 LPSTR servername)
72{
73 DWORD levels[] = { 1, 2, 5 };
74 DWORD success[] = { 1, 1, 1 };
75 DWORD i;
76 DWORD flags = PRINTER_ENUM_NAME;
77 LPBYTE buffer = NULL;
78
79 for (i=0; i < ARRAY_SIZE(levels); i++) {
80
81 DWORD needed = 0;
82 DWORD returned = 0;
83 DWORD err = 0;
84 char tmp[1024];
85
86 torture_comment(tctx, "Testing EnumPrinters level %d", levels[i]);
87
88 EnumPrinters(flags, servername, levels[i], NULL, 0, &needed, &returned);
89 err = GetLastError();
90 if (err == ERROR_INSUFFICIENT_BUFFER) {
91 err = 0;
92 buffer = malloc(needed);
93 torture_assert(tctx, buffer, "malloc failed");
94 if (!EnumPrinters(flags, servername, levels[i], buffer, needed, &needed, &returned)) {
95 err = GetLastError();
96 }
97 }
98 if (err) {
99 sprintf(tmp, "EnumPrinters failed level %d on [%s] (buffer size = %d), error: %s\n",
100 levels[i], servername, needed, errstr(err));
101 if (success[i]) {
102 torture_fail(tctx, tmp);
103 } else {
104 torture_warning(tctx, tmp);
105 }
106 }
107
108 if (tctx->print) {
109 print_printer_info_bylevel(levels[i], buffer, returned);
110 }
111
112 free(buffer);
113 buffer = NULL;
114 }
115
116 return TRUE;
117}
118
119/****************************************************************************
120****************************************************************************/
121
122static BOOL test_EnumDrivers(struct torture_context *tctx,
123 LPSTR servername,
124 LPSTR architecture)
125{
126 DWORD levels[] = { 1, 2, 3, 4, 5, 6 };
127 DWORD success[] = { 1, 1, 1, 1, 1, 1 };
128 DWORD i;
129 LPBYTE buffer = NULL;
130
131 for (i=0; i < ARRAY_SIZE(levels); i++) {
132
133 DWORD needed = 0;
134 DWORD returned = 0;
135 DWORD err = 0;
136 char tmp[1024];
137
138 torture_comment(tctx, "Testing EnumPrinterDrivers(%s) level %d",
139 architecture, levels[i]);
140
141 EnumPrinterDrivers(servername, architecture, levels[i], NULL, 0, &needed, &returned);
142 err = GetLastError();
143 if (err == ERROR_INSUFFICIENT_BUFFER) {
144 err = 0;
145 buffer = malloc(needed);
146 torture_assert(tctx, buffer, "malloc failed");
147 if (!EnumPrinterDrivers(servername, architecture, levels[i], buffer, needed, &needed, &returned)) {
148 err = GetLastError();
149 }
150 }
151 if (err) {
152 sprintf(tmp, "EnumPrinterDrivers failed level %d on [%s] (buffer size = %d), error: %s\n",
153 levels[i], servername, needed, errstr(err));
154 if (success[i]) {
155 torture_fail(tctx, tmp);
156 } else {
157 torture_warning(tctx, tmp);
158 }
159 }
160
161 if (tctx->print) {
162 print_driver_info_bylevel(levels[i], buffer, returned);
163 }
164
165 free(buffer);
166 buffer = NULL;
167 }
168
169 return TRUE;
170}
171
172/****************************************************************************
173****************************************************************************/
174
175static BOOL test_GetForm(struct torture_context *tctx,
176 LPSTR servername,
177 HANDLE handle,
178 LPSTR formname)
179{
180 DWORD levels[] = { 1, 2 };
181 DWORD success[] = { 1, 0 };
182 DWORD i;
183 LPBYTE buffer = NULL;
184
185 for (i=0; i < ARRAY_SIZE(levels); i++) {
186
187 DWORD needed = 0;
188 DWORD err = 0;
189 char tmp[1024];
190
191 torture_comment(tctx, "Testing GetForm(%s) level %d", formname, levels[i]);
192
193 GetForm(handle, formname, levels[i], NULL, 0, &needed);
194 err = GetLastError();
195 if (err == ERROR_INSUFFICIENT_BUFFER) {
196 err = 0;
197 buffer = malloc(needed);
198 torture_assert(tctx, buffer, "malloc failed");
199 if (!GetForm(handle, formname, levels[i], buffer, needed, &needed)) {
200 err = GetLastError();
201 }
202 }
203 if (err) {
204 sprintf(tmp, "GetForm failed level %d on [%s] (buffer size = %d), error: %s\n",
205 levels[i], servername, needed, errstr(err));
206 if (success[i]) {
207 torture_fail(tctx, tmp);
208 } else {
209 torture_warning(tctx, tmp);
210 }
211 }
212
213 if (tctx->print) {
214 print_form_info_bylevel(levels[i], buffer, 1);
215 }
216
217 free(buffer);
218 buffer = NULL;
219 }
220
221 return TRUE;
222}
223
224/****************************************************************************
225****************************************************************************/
226
227static BOOL test_EnumForms(struct torture_context *tctx,
228 LPSTR servername,
229 HANDLE handle)
230{
231 DWORD levels[] = { 1, 2 };
232 DWORD success[] = { 1, 1 };
233 DWORD i;
234 LPBYTE buffer = NULL;
235
236 for (i=0; i < ARRAY_SIZE(levels); i++) {
237
238 DWORD needed = 0;
239 DWORD returned = 0;
240 DWORD err = 0;
241 char tmp[1024];
242
243 torture_comment(tctx, "Testing EnumForms level %d", levels[i]);
244
245 if (tctx->samba3 && levels[i] == 2) {
246 torture_comment(tctx, "skipping level %d enum against samba\n", levels[i]);
247 continue;
248 }
249
250 EnumForms(handle, levels[i], NULL, 0, &needed, &returned);
251 err = GetLastError();
252 if (err == ERROR_INSUFFICIENT_BUFFER) {
253 err = 0;
254 buffer = malloc(needed);
255 torture_assert(tctx, buffer, "malloc failed");
256 if (!EnumForms(handle, levels[i], buffer, needed, &needed, &returned)) {
257 err = GetLastError();
258 }
259 }
260 if (err) {
261 sprintf(tmp, "EnumForms failed level %d on [%s] (buffer size = %d), error: %s\n",
262 levels[i], servername, needed, errstr(err));
263 if (success[i]) {
264 torture_fail(tctx, tmp);
265 } else {
266 torture_warning(tctx, tmp);
267 }
268 }
269
270 if (tctx->print) {
271 print_form_info_bylevel(levels[i], buffer, returned);
272 }
273
274 free(buffer);
275 buffer = NULL;
276 }
277
278 return TRUE;
279}
280
281/****************************************************************************
282****************************************************************************/
283
284static BOOL test_EnumPorts(struct torture_context *tctx,
285 LPSTR servername)
286{
287 DWORD levels[] = { 1, 2 };
288 DWORD success[] = { 1, 1 };
289 DWORD i;
290 LPBYTE buffer = NULL;
291
292 for (i=0; i < ARRAY_SIZE(levels); i++) {
293
294 DWORD needed = 0;
295 DWORD returned = 0;
296 DWORD err = 0;
297 char tmp[1024];
298
299 torture_comment(tctx, "Testing EnumPorts level %d", levels[i]);
300
301 EnumPorts(servername, levels[i], NULL, 0, &needed, &returned);
302 err = GetLastError();
303 if (err == ERROR_INSUFFICIENT_BUFFER) {
304 err = 0;
305 buffer = malloc(needed);
306 torture_assert(tctx, buffer, "malloc failed");
307 if (!EnumPorts(servername, levels[i], buffer, needed, &needed, &returned)) {
308 err = GetLastError();
309 }
310 }
311 if (err) {
312 sprintf(tmp, "EnumPorts failed level %d on [%s] (buffer size = %d), error: %s\n",
313 levels[i], servername, needed, errstr(err));
314 if (success[i]) {
315 torture_fail(tctx, tmp);
316 } else {
317 torture_warning(tctx, tmp);
318 }
319 }
320
321 if (tctx->print) {
322 print_port_info_bylevel(levels[i], buffer, returned);
323 }
324
325 free(buffer);
326 buffer = NULL;
327 }
328
329 return TRUE;
330}
331
332/****************************************************************************
333****************************************************************************/
334
335static BOOL test_EnumMonitors(struct torture_context *tctx,
336 LPSTR servername)
337{
338 DWORD levels[] = { 1, 2 };
339 DWORD success[] = { 1, 1 };
340 DWORD i;
341 LPBYTE buffer = NULL;
342
343 for (i=0; i < ARRAY_SIZE(levels); i++) {
344
345 DWORD needed = 0;
346 DWORD returned = 0;
347 DWORD err = 0;
348 char tmp[1024];
349
350 torture_comment(tctx, "Testing EnumMonitors level %d", levels[i]);
351
352 EnumMonitors(servername, levels[i], NULL, 0, &needed, &returned);
353 err = GetLastError();
354 if (err == ERROR_INSUFFICIENT_BUFFER) {
355 err = 0;
356 buffer = malloc(needed);
357 torture_assert(tctx, buffer, "malloc failed");
358 if (!EnumMonitors(servername, levels[i], buffer, needed, &needed, &returned)) {
359 err = GetLastError();
360 }
361 }
362 if (err) {
363 sprintf(tmp, "EnumMonitors failed level %d on [%s] (buffer size = %d), error: %s\n",
364 levels[i], servername, needed, errstr(err));
365 if (success[i]) {
366 torture_fail(tctx, tmp);
367 } else {
368 torture_warning(tctx, tmp);
369 }
370 }
371
372 if (tctx->print) {
373 print_monitor_info_bylevel(levels[i], buffer, returned);
374 }
375
376 free(buffer);
377 buffer = NULL;
378 }
379
380 return TRUE;
381}
382
383/****************************************************************************
384****************************************************************************/
385
386static BOOL test_EnumPrintProcessors(struct torture_context *tctx,
387 LPSTR servername,
388 LPSTR architecture)
389{
390 DWORD levels[] = { 1 };
391 DWORD success[] = { 1 };
392 DWORD i;
393 LPBYTE buffer = NULL;
394
395 for (i=0; i < ARRAY_SIZE(levels); i++) {
396
397 DWORD needed = 0;
398 DWORD returned = 0;
399 DWORD err = 0;
400 char tmp[1024];
401
402 torture_comment(tctx, "Testing EnumPrintProcessors(%s) level %d", architecture, levels[i]);
403
404 EnumPrintProcessors(servername, architecture, levels[i], NULL, 0, &needed, &returned);
405 err = GetLastError();
406 if (err == ERROR_INSUFFICIENT_BUFFER) {
407 err = 0;
408 buffer = malloc(needed);
409 torture_assert(tctx, buffer, "malloc failed");
410 if (!EnumPrintProcessors(servername, architecture, levels[i], buffer, needed, &needed, &returned)) {
411 err = GetLastError();
412 }
413 }
414 if (err) {
415 sprintf(tmp, "EnumPrintProcessors failed level %d on [%s] (buffer size = %d), error: %s\n",
416 levels[i], servername, needed, errstr(err));
417 if (success[i]) {
418 torture_fail(tctx, tmp);
419 } else {
420 torture_warning(tctx, tmp);
421 }
422 }
423
424 if (tctx->print) {
425 print_printprocessor_info_bylevel(levels[i], buffer, returned);
426 }
427
428 free(buffer);
429 buffer = NULL;
430 }
431
432 return TRUE;
433}
434
435/****************************************************************************
436****************************************************************************/
437
438static BOOL test_EnumPrintProcessorDatatypes(struct torture_context *tctx,
439 LPSTR servername)
440{
441 DWORD levels[] = { 1 };
442 DWORD success[] = { 1 };
443 DWORD i;
444 LPBYTE buffer = NULL;
445
446 for (i=0; i < ARRAY_SIZE(levels); i++) {
447
448 DWORD needed = 0;
449 DWORD returned = 0;
450 DWORD err = 0;
451 char tmp[1024];
452
453 torture_comment(tctx, "Testing EnumPrintProcessorDatatypes level %d", levels[i]);
454
455 EnumPrintProcessorDatatypes(servername, "winprint", levels[i], NULL, 0, &needed, &returned);
456 err = GetLastError();
457 if (err == ERROR_INSUFFICIENT_BUFFER) {
458 err = 0;
459 buffer = malloc(needed);
460 torture_assert(tctx, buffer, "malloc failed");
461 if (!EnumPrintProcessorDatatypes(servername, "winprint", levels[i], buffer, needed, &needed, &returned)) {
462 err = GetLastError();
463 }
464 }
465 if (err) {
466 sprintf(tmp, "EnumPrintProcessorDatatypes failed level %d on [%s] (buffer size = %d), error: %s\n",
467 levels[i], servername, needed, errstr(err));
468 if (success[i]) {
469 torture_fail(tctx, tmp);
470 } else {
471 torture_warning(tctx, tmp);
472 }
473 }
474
475 if (tctx->print) {
476 print_datatypes_info_bylevel(levels[i], buffer, returned);
477 }
478
479 free(buffer);
480 buffer = NULL;
481 }
482
483 return TRUE;
484}
485
486/****************************************************************************
487****************************************************************************/
488
489static BOOL test_EnumPrinterKey(struct torture_context *tctx,
490 LPSTR servername,
491 HANDLE handle,
492 LPCSTR key)
493{
494 LPSTR buffer = NULL;
495 DWORD needed = 0;
496 DWORD err = 0;
497 char tmp[1024];
498
499 torture_comment(tctx, "Testing EnumPrinterKey(%s)", key);
500
501 err = EnumPrinterKey(handle, key, NULL, 0, &needed);
502 if (err == ERROR_MORE_DATA) {
503 buffer = (LPTSTR)malloc(needed);
504 torture_assert(tctx, buffer, "malloc failed");
505 err = EnumPrinterKey(handle, key, buffer, needed, &needed);
506 }
507 if (err) {
508 sprintf(tmp, "EnumPrinterKey(%s) failed on [%s] (buffer size = %d), error: %s\n",
509 key, servername, needed, errstr(err));
510 torture_fail(tctx, tmp);
511 }
512
513 if (tctx->print) {
514 print_printer_keys(buffer);
515 }
516
517 free(buffer);
518
519 return TRUE;
520}
521
522/****************************************************************************
523****************************************************************************/
524
525static BOOL test_GetPrinter(struct torture_context *tctx,
526 LPSTR printername,
527 HANDLE handle)
528{
529 DWORD levels[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
530 DWORD success[] = { 1, 1, 1, 1, 1, 1, 1, 1 };
531 DWORD i;
532 LPBYTE buffer = NULL;
533
534 for (i=0; i < ARRAY_SIZE(levels); i++) {
535
536 DWORD needed = 0;
537 DWORD err = 0;
538 char tmp[1024];
539
540 torture_comment(tctx, "Testing GetPrinter level %d", levels[i]);
541
542 GetPrinter(handle, levels[i], NULL, 0, &needed);
543 err = GetLastError();
544 if (err == ERROR_INSUFFICIENT_BUFFER) {
545 err = 0;
546 buffer = malloc(needed);
547 torture_assert(tctx, buffer, "malloc failed");
548 if (!GetPrinter(handle, levels[i], buffer, needed, &needed)) {
549 err = GetLastError();
550 }
551 }
552 if (err) {
553 sprintf(tmp, "GetPrinter failed level %d on [%s] (buffer size = %d), error: %s\n",
554 levels[i], printername, needed, errstr(err));
555 if (success[i]) {
556 torture_fail(tctx, tmp);
557 } else {
558 torture_warning(tctx, tmp);
559 }
560 }
561
562 if (tctx->print) {
563 print_printer_info_bylevel(levels[i], buffer, 1);
564 }
565
566 free(buffer);
567 buffer = NULL;
568 }
569
570 return TRUE;
571}
572
573/****************************************************************************
574****************************************************************************/
575
576static BOOL test_GetPrinterDriver(struct torture_context *tctx,
577 LPSTR printername,
578 LPSTR architecture,
579 HANDLE handle)
580{
581 DWORD levels[] = { 1, 2, 3, 4, 5, 6, 8 };
582 DWORD success[] = { 1, 1, 1, 1, 1, 1, 1 };
583 DWORD i;
584 LPBYTE buffer = NULL;
585
586 for (i=0; i < ARRAY_SIZE(levels); i++) {
587
588 DWORD needed = 0;
589 DWORD err = 0;
590 char tmp[1024];
591
592 torture_comment(tctx, "Testing GetPrinterDriver(%s) level %d",
593 architecture, levels[i]);
594
595 GetPrinterDriver(handle, architecture, levels[i], NULL, 0, &needed);
596 err = GetLastError();
597 if (err == ERROR_INSUFFICIENT_BUFFER) {
598 err = 0;
599 buffer = malloc(needed);
600 torture_assert(tctx, buffer, "malloc failed");
601 if (!GetPrinterDriver(handle, architecture, levels[i], buffer, needed, &needed)) {
602 err = GetLastError();
603 }
604 }
605 if (err) {
606 sprintf(tmp, "GetPrinterDriver failed level %d on [%s] (buffer size = %d), error: %s\n",
607 levels[i], printername, needed, errstr(err));
608 if (success[i]) {
609 torture_fail(tctx, tmp);
610 } else {
611 torture_warning(tctx, tmp);
612 }
613 }
614
615 if (tctx->print) {
616 print_driver_info_bylevel(levels[i], buffer, 1);
617 }
618
619 free(buffer);
620 buffer = NULL;
621 }
622
623 return TRUE;
624}
625
626
627/****************************************************************************
628****************************************************************************/
629
630static BOOL test_EnumJobs(struct torture_context *tctx,
631 LPSTR printername,
632 HANDLE handle)
633{
634 DWORD levels[] = { 1, 2, 3, 4 };
635 DWORD success[] = { 1, 1, 1, 1 };
636 DWORD i;
637 LPBYTE buffer = NULL;
638
639 for (i=0; i < ARRAY_SIZE(levels); i++) {
640
641 DWORD needed = 0;
642 DWORD returned = 0;
643 DWORD err = 0;
644 char tmp[1024];
645
646 torture_comment(tctx, "Testing EnumJobs level %d", levels[i]);
647
648 if (tctx->samba3 && levels[i] == 4) {
649 torture_comment(tctx, "skipping level %d enum against samba\n", levels[i]);
650 continue;
651 }
652
653 EnumJobs(handle, 0, 100, levels[i], NULL, 0, &needed, &returned);
654 err = GetLastError();
655 if (err == ERROR_INSUFFICIENT_BUFFER) {
656 err = 0;
657 buffer = malloc(needed);
658 torture_assert(tctx, buffer, "malloc failed");
659 if (!EnumJobs(handle, 0, 100, levels[i], buffer, needed, &needed, &returned)) {
660 err = GetLastError();
661 }
662 }
663 if (err) {
664 sprintf(tmp, "EnumJobs failed level %d on [%s] (buffer size = %d), error: %s\n",
665 levels[i], printername, needed, errstr(err));
666 if (success[i]) {
667 torture_fail(tctx, tmp);
668 } else {
669 torture_warning(tctx, tmp);
670 }
671 }
672
673 if (tctx->print) {
674 print_job_info_bylevel(levels[i], buffer, returned);
675 }
676
677 free(buffer);
678 buffer = NULL;
679 }
680
681 return TRUE;
682}
683
684/****************************************************************************
685****************************************************************************/
686
687static BOOL test_EnumPrinterData(struct torture_context *tctx,
688 LPSTR servername,
689 HANDLE handle)
690{
691 DWORD err = 0;
692 LPTSTR value_name;
693 LPBYTE data;
694 DWORD index = 0;
695 DWORD type;
696 DWORD value_offered = 0, value_needed;
697 DWORD data_offered = 0, data_needed;
698 char tmp[1024];
699
700 torture_comment(tctx, "Testing EnumPrinterData(%d) (value offered: %d, data_offered: %d)\n",
701 index, value_offered, data_offered);
702
703 err = EnumPrinterData(handle, 0, NULL, 0, &value_needed, NULL, NULL, 0, &data_needed);
704 if (err) {
705 sprintf(tmp, "EnumPrinterData(%d) failed on [%s] (value size = %d, data size = %d), error: %s\n",
706 index, servername, value_offered, data_offered, errstr(err));
707 torture_fail(tctx, tmp);
708 }
709
710 value_name = malloc(value_needed);
711 torture_assert(tctx, value_name, "malloc failed");
712 data = malloc(data_needed);
713 torture_assert(tctx, data, "malloc failed");
714
715 value_offered = value_needed;
716 data_offered = data_needed;
717
718 do {
719
720 value_needed = 0;
721 data_needed = 0;
722
723 torture_comment(tctx, "Testing EnumPrinterData(%d) (value offered: %d, data_offered: %d)\n",
724 index, value_offered, data_offered);
725
726 err = EnumPrinterData(handle, index++, value_name, value_offered, &value_needed, &type, data, data_offered, &data_needed);
727 if (err == ERROR_NO_MORE_ITEMS) {
728 break;
729 }
730 if (err) {
731 sprintf(tmp, "EnumPrinterData(%d) failed on [%s] (value size = %d, data size = %d), error: %s\n",
732 index, servername, value_offered, data_offered, errstr(err));
733 torture_fail(tctx, tmp);
734 }
735
736 if (tctx->print) {
737 print_printer_data(NULL, value_name, data_needed, data, type);
738 }
739
740 } while (err != ERROR_NO_MORE_ITEMS);
741
742 free(value_name);
743 free(data);
744
745 return TRUE;
746}
747
748/****************************************************************************
749****************************************************************************/
750
751static BOOL test_EnumPrinterDataEx(struct torture_context *tctx,
752 LPSTR servername,
753 LPSTR keyname,
754 HANDLE handle,
755 LPBYTE *buffer_p,
756 DWORD *returned_p)
757{
758 LPBYTE buffer = NULL;
759 DWORD needed = 0;
760 DWORD returned = 0;
761 DWORD err = 0;
762 char tmp[1024];
763
764 torture_comment(tctx, "Testing EnumPrinterDataEx(%s)", keyname);
765
766 err = EnumPrinterDataEx(handle, keyname, NULL, 0, &needed, &returned);
767 if (err == ERROR_MORE_DATA) {
768 buffer = malloc(needed);
769 torture_assert(tctx, buffer, "malloc failed");
770 err = EnumPrinterDataEx(handle, keyname, buffer, needed, &needed, &returned);
771 }
772 if (err) {
773 sprintf(tmp, "EnumPrinterDataEx(%s) failed on [%s] (buffer size = %d), error: %s\n",
774 keyname, servername, needed, errstr(err));
775 torture_fail(tctx, tmp);
776 }
777
778 if (tctx->print) {
779 DWORD i;
780 LPPRINTER_ENUM_VALUES v = (LPPRINTER_ENUM_VALUES)buffer;
781 for (i=0; i < returned; i++) {
782 print_printer_enum_values(&v[i]);
783 }
784 }
785
786 if (returned_p) {
787 *returned_p = returned;
788 }
789
790 if (buffer_p) {
791 *buffer_p = buffer;
792 } else {
793 free(buffer);
794 }
795
796 return TRUE;
797}
798
799/****************************************************************************
800****************************************************************************/
801
802static BOOL test_devicemode_equal(struct torture_context *tctx,
803 const DEVMODE *d1,
804 const DEVMODE *d2)
805{
806 if (d1 == d2) {
807 return TRUE;
808 }
809
810 if (!d1 || !d2) {
811 torture_comment(tctx, "%s\n", __location__);
812 return FALSE;
813 }
814
815 torture_assert_str_equal(tctx, (const char *)d1->dmDeviceName, (const char *)d2->dmDeviceName, "dmDeviceName mismatch");
816 torture_assert_int_equal(tctx, d1->dmSpecVersion, d2->dmSpecVersion, "dmSpecVersion mismatch");
817 torture_assert_int_equal(tctx, d1->dmDriverVersion, d2->dmDriverVersion, "dmDriverVersion mismatch");
818 torture_assert_int_equal(tctx, d1->dmSize, d2->dmSize, "size mismatch");
819 torture_assert_int_equal(tctx, d1->dmDriverExtra, d2->dmDriverExtra, "dmDriverExtra mismatch");
820 torture_assert_int_equal(tctx, d1->dmFields, d2->dmFields, "dmFields mismatch");
821
822 torture_assert_int_equal(tctx, d1->dmOrientation, d2->dmOrientation, "dmOrientation mismatch");
823 torture_assert_int_equal(tctx, d1->dmPaperSize, d2->dmPaperSize, "dmPaperSize mismatch");
824 torture_assert_int_equal(tctx, d1->dmPaperLength, d2->dmPaperLength, "dmPaperLength mismatch");
825 torture_assert_int_equal(tctx, d1->dmPaperWidth, d2->dmPaperWidth, "dmPaperWidth mismatch");
826 torture_assert_int_equal(tctx, d1->dmScale, d2->dmScale, "dmScale mismatch");
827 torture_assert_int_equal(tctx, d1->dmCopies, d2->dmCopies, "dmCopies mismatch");
828 torture_assert_int_equal(tctx, d1->dmDefaultSource, d2->dmDefaultSource, "dmDefaultSource mismatch");
829 torture_assert_int_equal(tctx, d1->dmPrintQuality, d2->dmPrintQuality, "dmPrintQuality mismatch");
830
831 torture_assert_int_equal(tctx, d1->dmColor, d2->dmColor, "dmColor mismatch");
832 torture_assert_int_equal(tctx, d1->dmDuplex, d2->dmDuplex, "dmDuplex mismatch");
833 torture_assert_int_equal(tctx, d1->dmYResolution, d2->dmYResolution, "dmYResolution mismatch");
834 torture_assert_int_equal(tctx, d1->dmTTOption, d2->dmTTOption, "dmTTOption mismatch");
835 torture_assert_int_equal(tctx, d1->dmCollate, d2->dmCollate, "dmCollate mismatch");
836 torture_assert_str_equal(tctx, (const char *)d1->dmFormName, (const char *)d2->dmFormName, "dmFormName mismatch");
837 torture_assert_int_equal(tctx, d1->dmLogPixels, d2->dmLogPixels, "dmLogPixels mismatch");
838 torture_assert_int_equal(tctx, d1->dmBitsPerPel, d2->dmBitsPerPel, "dmBitsPerPel mismatch");
839 torture_assert_int_equal(tctx, d1->dmPelsWidth, d2->dmPelsWidth, "dmPelsWidth mismatch");
840 torture_assert_int_equal(tctx, d1->dmPelsHeight, d2->dmPelsHeight, "dmPelsHeight mismatch");
841
842 torture_assert_int_equal(tctx, d1->dmDisplayFlags, d2->dmDisplayFlags, "dmDisplayFlags mismatch");
843 /* or dmNup ? */
844 torture_assert_int_equal(tctx, d1->dmDisplayFrequency, d2->dmDisplayFrequency, "dmDisplayFrequency mismatch");
845
846 torture_assert_int_equal(tctx, d1->dmICMMethod, d2->dmICMMethod, "dmICMMethod mismatch");
847 torture_assert_int_equal(tctx, d1->dmICMIntent, d2->dmICMIntent, "dmICMIntent mismatch");
848 torture_assert_int_equal(tctx, d1->dmMediaType, d2->dmMediaType, "dmMediaType mismatch");
849 torture_assert_int_equal(tctx, d1->dmDitherType, d2->dmDitherType, "dmDitherType mismatch");
850 torture_assert_int_equal(tctx, d1->dmReserved1, d2->dmReserved1, "dmReserved1 mismatch");
851 torture_assert_int_equal(tctx, d1->dmReserved2, d2->dmReserved2, "reserved2 mismatch");
852
853 torture_assert_int_equal(tctx, d1->dmPanningWidth, d2->dmPanningWidth, "dmPanningWidth mismatch");
854 torture_assert_int_equal(tctx, d1->dmPanningHeight, d2->dmPanningHeight, "dmPanningHeight mismatch");
855
856 /* torture_assert_mem_equal(tctx, d1 + d1->dmSize, d2 + d2->dmSize, d1->dmDriverExtra, "private extra data mismatch"); */
857
858 return TRUE;
859}
860
861/****************************************************************************
862****************************************************************************/
863
864static BOOL test_DeviceModes(struct torture_context *tctx,
865 LPSTR printername,
866 HANDLE handle)
867{
868 PPRINTER_INFO_2 info2 = NULL;
869 PPRINTER_INFO_8 info8 = NULL;
870 DWORD needed = 0;
871 DWORD err = 0;
872 char tmp[1024];
873
874 torture_comment(tctx, "Testing DeviceModes");
875
876 torture_comment(tctx, "Testing GetPrinter level %d", 2);
877
878 GetPrinter(handle, 2, NULL, 0, &needed);
879 err = GetLastError();
880 if (err == ERROR_INSUFFICIENT_BUFFER) {
881 err = 0;
882 info2 = (PPRINTER_INFO_2)malloc(needed);
883 torture_assert(tctx, (LPBYTE)info2, "malloc failed");
884 if (!GetPrinter(handle, 2, (LPBYTE)info2, needed, &needed)) {
885 err = GetLastError();
886 }
887 }
888 if (err) {
889 sprintf(tmp, "GetPrinter failed level %d on [%s] (buffer size = %d), error: %s\n",
890 2, printername, needed, errstr(err));
891 torture_fail(tctx, tmp);
892 }
893
894 if (tctx->print) {
895 print_printer_info_2(info2);
896 }
897
898 torture_comment(tctx, "Testing GetPrinter level %d", 8);
899
900 GetPrinter(handle, 8, NULL, 0, &needed);
901 err = GetLastError();
902 if (err == ERROR_INSUFFICIENT_BUFFER) {
903 err = 0;
904 info8 = (PPRINTER_INFO_8)malloc(needed);
905 torture_assert(tctx, (LPBYTE)info8, "malloc failed");
906 if (!GetPrinter(handle, 8, (LPBYTE)info8, needed, &needed)) {
907 err = GetLastError();
908 }
909 }
910 if (err) {
911 sprintf(tmp, "GetPrinter failed level %d on [%s] (buffer size = %d), error: %s\n",
912 8, printername, needed, errstr(err));
913 torture_fail(tctx, tmp);
914 }
915
916 if (tctx->print) {
917 print_printer_info_8(info8);
918 }
919
920 torture_assert(tctx, test_devicemode_equal(tctx, info2->pDevMode, info8->pDevMode), "");
921
922 free(info2);
923 free(info8);
924
925 return TRUE;
926}
927
928/****************************************************************************
929****************************************************************************/
930
931static BOOL test_GetJob(struct torture_context *tctx,
932 LPSTR printername,
933 HANDLE handle,
934 DWORD job_id)
935{
936 DWORD levels[] = { 1, 2, 3, 4 };
937 DWORD success[] = { 1, 1, 1, 1 };
938 DWORD i;
939 LPBYTE buffer = NULL;
940
941 for (i=0; i < ARRAY_SIZE(levels); i++) {
942
943 DWORD needed = 0;
944 DWORD err = 0;
945 char tmp[1024];
946
947 torture_comment(tctx, "Testing GetJob(%d) level %d", job_id, levels[i]);
948
949 if (tctx->samba3 && (levels[i] == 4) || (levels[i] == 3)) {
950 torture_comment(tctx, "skipping level %d getjob against samba\n", levels[i]);
951 continue;
952 }
953
954 GetJob(handle, job_id, levels[i], NULL, 0, &needed);
955 err = GetLastError();
956 if (err == ERROR_INSUFFICIENT_BUFFER) {
957 err = 0;
958 buffer = malloc(needed);
959 torture_assert(tctx, buffer, "malloc failed");
960 if (!GetJob(handle, job_id, levels[i], buffer, needed, &needed)) {
961 err = GetLastError();
962 }
963 }
964 if (err) {
965 sprintf(tmp, "GetJob failed level %d on [%s] (buffer size = %d), error: %s\n",
966 levels[i], printername, needed, errstr(err));
967 if (success[i]) {
968 torture_fail(tctx, tmp);
969 } else {
970 torture_warning(tctx, tmp);
971 }
972 }
973
974 if (tctx->print) {
975 print_job_info_bylevel(levels[i], buffer, 1);
976 }
977
978 free(buffer);
979 buffer = NULL;
980 }
981
982 return TRUE;
983}
984
985/****************************************************************************
986****************************************************************************/
987
988static BOOL test_EachJob(struct torture_context *tctx,
989 LPSTR printername,
990 HANDLE handle)
991{
992 DWORD i;
993 PJOB_INFO_1 buffer = NULL;
994 DWORD needed = 0;
995 DWORD returned = 0;
996 DWORD err = 0;
997 DWORD level = 1;
998 char tmp[1024];
999 BOOL ret = TRUE;
1000
1001 torture_comment(tctx, "Testing Each PrintJob %d");
1002
1003 EnumJobs(handle, 0, 100, level, NULL, 0, &needed, &returned);
1004 err = GetLastError();
1005 if (err == ERROR_INSUFFICIENT_BUFFER) {
1006 err = 0;
1007 buffer = (PJOB_INFO_1)malloc(needed);
1008 torture_assert(tctx, buffer, "malloc failed");
1009 if (!EnumJobs(handle, 0, 100, level, (LPBYTE)buffer, needed, &needed, &returned)) {
1010 err = GetLastError();
1011 }
1012 }
1013 if (err) {
1014 sprintf(tmp, "EnumJobs failed level %d on [%s] (buffer size = %d), error: %s\n",
1015 level, printername, needed, errstr(err));
1016 torture_fail(tctx, tmp);
1017 }
1018
1019 if (tctx->print) {
1020 print_job_info_bylevel(level, (LPBYTE)buffer, returned);
1021 }
1022
1023 for (i=0; i < returned; i++) {
1024 ret = test_GetJob(tctx, printername, handle, buffer[i].JobId);
1025 }
1026
1027 free(buffer);
1028
1029 return ret;
1030
1031}
1032
1033/****************************************************************************
1034****************************************************************************/
1035
1036static BOOL test_OnePrinter(struct torture_context *tctx,
1037 LPSTR printername,
1038 LPSTR architecture,
1039 LPPRINTER_DEFAULTS defaults)
1040{
1041 HANDLE handle;
1042 BOOL ret = TRUE;
1043
1044 torture_comment(tctx, "Testing Printer %s", printername);
1045
1046 ret &= test_OpenPrinter(tctx, printername, defaults, &handle);
1047 ret &= test_GetPrinter(tctx, printername, handle);
1048 ret &= test_GetPrinterDriver(tctx, printername, architecture, handle);
1049 ret &= test_EnumForms(tctx, printername, handle);
1050 ret &= test_EnumJobs(tctx, printername, handle);
1051 ret &= test_EachJob(tctx, printername, handle);
1052 ret &= test_EnumPrinterKey(tctx, printername, handle, "");
1053 ret &= test_EnumPrinterKey(tctx, printername, handle, "PrinterDriverData");
1054 ret &= test_EnumPrinterData(tctx, printername, handle);
1055 ret &= test_EnumPrinterDataEx(tctx, printername, "PrinterDriverData", handle, NULL, NULL);
1056 ret &= test_DeviceModes(tctx, printername, handle);
1057#if 0
1058 /* don't run these at the moment, behaviour is PrinterData API calls (not
1059 * dcerpc calls) is almost unpredictable - gd */
1060 ret &= test_PrinterData(tctx, printername, handle);
1061 ret &= test_PrinterDataW(tctx, printername, handle);
1062#endif
1063 ret &= test_ClosePrinter(tctx, handle);
1064
1065 return ret;
1066}
1067
1068/****************************************************************************
1069****************************************************************************/
1070
1071static BOOL test_EachPrinter(struct torture_context *tctx,
1072 LPSTR servername,
1073 LPSTR architecture,
1074 LPPRINTER_DEFAULTS defaults)
1075{
1076 DWORD needed = 0;
1077 DWORD returned = 0;
1078 DWORD err = 0;
1079 char tmp[1024];
1080 DWORD i;
1081 DWORD flags = PRINTER_ENUM_NAME;
1082 PPRINTER_INFO_1 buffer = NULL;
1083 BOOL ret = TRUE;
1084
1085 torture_comment(tctx, "Testing EnumPrinters level %d", 1);
1086
1087 EnumPrinters(flags, servername, 1, NULL, 0, &needed, &returned);
1088 err = GetLastError();
1089 if (err == ERROR_INSUFFICIENT_BUFFER) {
1090 err = 0;
1091 buffer = (PPRINTER_INFO_1)malloc(needed);
1092 torture_assert(tctx, buffer, "malloc failed");
1093 if (!EnumPrinters(flags, servername, 1, (LPBYTE)buffer, needed, &needed, &returned)) {
1094 err = GetLastError();
1095 }
1096 }
1097 if (err) {
1098 sprintf(tmp, "EnumPrinters failed level %d on [%s] (buffer size = %d), error: %s\n",
1099 1, servername, needed, errstr(err));
1100 torture_fail(tctx, tmp);
1101 }
1102
1103 for (i=0; i < returned; i++) {
1104 ret &= test_OnePrinter(tctx, buffer[i].pName, architecture, defaults);
1105 }
1106
1107 free(buffer);
1108
1109 return ret;
1110}
1111
1112/****************************************************************************
1113****************************************************************************/
1114
1115static BOOL test_GetPrintProcessorDirectory(struct torture_context *tctx,
1116 LPSTR servername,
1117 LPSTR architecture)
1118{
1119 DWORD levels[] = { 1 };
1120 DWORD success[] = { 1 };
1121 DWORD i;
1122 LPBYTE buffer = NULL;
1123
1124 for (i=0; i < ARRAY_SIZE(levels); i++) {
1125
1126 DWORD needed = 0;
1127 DWORD err = 0;
1128 char tmp[1024];
1129
1130 torture_comment(tctx, "Testing GetPrintProcessorDirectory(%s) level %d",
1131 architecture, levels[i]);
1132
1133 GetPrintProcessorDirectory(servername, architecture, levels[i], NULL, 0, &needed);
1134 err = GetLastError();
1135 if (err == ERROR_INSUFFICIENT_BUFFER) {
1136 err = 0;
1137 buffer = malloc(needed);
1138 torture_assert(tctx, buffer, "malloc failed");
1139 if (!GetPrintProcessorDirectory(servername, architecture, levels[i], buffer, needed, &needed)) {
1140 err = GetLastError();
1141 }
1142 }
1143 if (err) {
1144 sprintf(tmp, "GetPrintProcessorDirectory failed level %d on [%s] (buffer size = %d), error: %s\n",
1145 levels[i], servername, needed, errstr(err));
1146 if (success[i]) {
1147 torture_fail(tctx, tmp);
1148 } else {
1149 torture_warning(tctx, tmp);
1150 }
1151 }
1152
1153 if (tctx->print) {
1154 printf("\tPrint Processor Directory\t= %s\n\n", (LPSTR)buffer);
1155 }
1156
1157 free(buffer);
1158 buffer = NULL;
1159 }
1160
1161 return TRUE;
1162}
1163
1164/****************************************************************************
1165****************************************************************************/
1166
1167static BOOL test_GetPrinterDriverDirectory(struct torture_context *tctx,
1168 LPSTR servername,
1169 LPSTR architecture)
1170{
1171 DWORD levels[] = { 1 };
1172 DWORD success[] = { 1 };
1173 DWORD i;
1174 LPBYTE buffer = NULL;
1175
1176 for (i=0; i < ARRAY_SIZE(levels); i++) {
1177
1178 DWORD needed = 0;
1179 DWORD err = 0;
1180 char tmp[1024];
1181
1182 torture_comment(tctx, "Testing GetPrinterDriverDirectory(%s) level %d",
1183 architecture, levels[i]);
1184
1185 GetPrinterDriverDirectory(servername, architecture, levels[i], NULL, 0, &needed);
1186 err = GetLastError();
1187 if (err == ERROR_INSUFFICIENT_BUFFER) {
1188 err = 0;
1189 buffer = malloc(needed);
1190 torture_assert(tctx, buffer, "malloc failed");
1191 if (!GetPrinterDriverDirectory(servername, architecture, levels[i], buffer, needed, &needed)) {
1192 err = GetLastError();
1193 }
1194 }
1195 if (err) {
1196 sprintf(tmp, "GetPrinterDriverDirectory failed level %d on [%s] (buffer size = %d), error: %s\n",
1197 levels[i], servername, needed, errstr(err));
1198 if (success[i]) {
1199 torture_fail(tctx, tmp);
1200 } else {
1201 torture_warning(tctx, tmp);
1202 }
1203 }
1204
1205 if (tctx->print) {
1206 printf("\tPrinter Driver Directory\t= %s\n\n", (LPSTR)buffer);
1207 }
1208
1209 free(buffer);
1210 buffer = NULL;
1211 }
1212
1213 return TRUE;
1214}
1215
1216/****************************************************************************
1217****************************************************************************/
1218
1219static BOOL test_GetPrinterData(struct torture_context *tctx,
1220 LPSTR servername,
1221 LPSTR valuename,
1222 HANDLE handle,
1223 DWORD *type_p,
1224 LPBYTE *buffer_p,
1225 DWORD *size_p)
1226{
1227 LPBYTE buffer = NULL;
1228 DWORD needed = 0;
1229 DWORD type;
1230 DWORD err = 0;
1231 char tmp[1024];
1232
1233 torture_comment(tctx, "Testing GetPrinterData(%s)", valuename);
1234
1235 err = GetPrinterData(handle, valuename, &type, NULL, 0, &needed);
1236 if (err == ERROR_MORE_DATA) {
1237 buffer = (LPBYTE)malloc(needed);
1238 torture_assert(tctx, buffer, "malloc failed");
1239 err = GetPrinterData(handle, valuename, &type, buffer, needed, &needed);
1240 }
1241 if (err) {
1242 sprintf(tmp, "GetPrinterData(%s) failed on [%s] (buffer size = %d), error: %s\n",
1243 valuename, servername, needed, errstr(err));
1244 torture_fail(tctx, tmp);
1245 }
1246
1247 if (tctx->print) {
1248 print_printer_data("PrinterDriverData", valuename, needed, buffer, type);
1249 }
1250
1251 if (type_p) {
1252 *type_p = type;
1253 }
1254
1255 if (size_p) {
1256 *size_p = needed;
1257 }
1258
1259 if (buffer_p) {
1260 *buffer_p = buffer;
1261 } else {
1262 free(buffer);
1263 }
1264
1265 return TRUE;
1266}
1267
1268/****************************************************************************
1269****************************************************************************/
1270
1271static BOOL test_GetPrinterDataEx(struct torture_context *tctx,
1272 LPSTR servername,
1273 LPSTR keyname,
1274 LPSTR valuename,
1275 HANDLE handle,
1276 DWORD *type_p,
1277 LPBYTE *buffer_p,
1278 DWORD *size_p)
1279{
1280 LPBYTE buffer = NULL;
1281 DWORD needed = 0;
1282 DWORD type;
1283 DWORD err = 0;
1284 char tmp[1024];
1285
1286 torture_comment(tctx, "Testing GetPrinterDataEx(%s - %s)", keyname, valuename);
1287
1288 err = GetPrinterDataEx(handle, keyname, valuename, &type, NULL, 0, &needed);
1289 if (err == ERROR_MORE_DATA) {
1290 buffer = (LPBYTE)malloc(needed);
1291 torture_assert(tctx, buffer, "malloc failed");
1292 err = GetPrinterDataEx(handle, keyname, valuename, &type, buffer, needed, &needed);
1293 }
1294 if (err) {
1295 sprintf(tmp, "GetPrinterDataEx(%s) failed on [%s] (buffer size = %d), error: %s\n",
1296 valuename, servername, needed, errstr(err));
1297 torture_fail(tctx, tmp);
1298 }
1299
1300 if (tctx->print) {
1301 print_printer_data(keyname, valuename, needed, buffer, type);
1302 }
1303
1304 if (type_p) {
1305 *type_p = type;
1306 }
1307
1308 if (size_p) {
1309 *size_p = needed;
1310 }
1311
1312 if (buffer_p) {
1313 *buffer_p = buffer;
1314 } else {
1315 free(buffer);
1316 }
1317
1318 return TRUE;
1319}
1320
1321/****************************************************************************
1322****************************************************************************/
1323
1324static BOOL test_GetPrinterDataExW(struct torture_context *tctx,
1325 LPSTR servername,
1326 LPCWSTR keyname,
1327 LPCWSTR valuename,
1328 HANDLE handle,
1329 DWORD *type_p,
1330 LPBYTE *buffer_p,
1331 DWORD *size_p)
1332{
1333 LPBYTE buffer = NULL;
1334 DWORD needed = 0;
1335 DWORD type;
1336 DWORD err = 0;
1337 char tmp[1024];
1338
1339 torture_comment(tctx, "Testing GetPrinterDataExW(%ls - %ls)", keyname, valuename);
1340
1341 err = GetPrinterDataExW(handle, keyname, valuename, &type, NULL, 0, &needed);
1342 if (err == ERROR_MORE_DATA) {
1343 buffer = (LPBYTE)malloc(needed);
1344 torture_assert(tctx, buffer, "malloc failed");
1345 err = GetPrinterDataExW(handle, keyname, valuename, &type, buffer, needed, &needed);
1346 }
1347 if (err) {
1348 sprintf(tmp, "GetPrinterDataExW(%ls) failed on [%s] (buffer size = %d), error: %s\n",
1349 valuename, servername, needed, errstr(err));
1350 torture_fail(tctx, tmp);
1351 }
1352
1353 if (tctx->print) {
1354 print_printer_dataw(keyname, valuename, needed, buffer, type);
1355 }
1356
1357 if (type_p) {
1358 *type_p = type;
1359 }
1360
1361 if (size_p) {
1362 *size_p = needed;
1363 }
1364
1365 if (buffer_p) {
1366 *buffer_p = buffer;
1367 } else {
1368 free(buffer);
1369 }
1370
1371 return TRUE;
1372}
1373
1374
1375/****************************************************************************
1376****************************************************************************/
1377
1378static BOOL test_DeletePrinterDataEx(struct torture_context *tctx,
1379 LPSTR servername,
1380 LPSTR keyname,
1381 LPSTR valuename,
1382 HANDLE handle)
1383{
1384 DWORD err = 0;
1385 char tmp[1024];
1386
1387 torture_comment(tctx, "Testing DeletePrinterDataEx(%s - %s)", keyname, valuename);
1388
1389 err = DeletePrinterDataEx(handle, keyname, valuename);
1390 if (err) {
1391 sprintf(tmp, "DeletePrinterDataEx(%s - %s) failed on [%s], error: %s\n",
1392 keyname, valuename, servername, errstr(err));
1393 torture_fail(tctx, tmp);
1394 }
1395
1396 return TRUE;
1397}
1398
1399/****************************************************************************
1400****************************************************************************/
1401
1402static BOOL test_DeletePrinterDataExW(struct torture_context *tctx,
1403 LPSTR servername,
1404 LPCWSTR keyname,
1405 LPCWSTR valuename,
1406 HANDLE handle)
1407{
1408 DWORD err = 0;
1409 char tmp[1024];
1410
1411 torture_comment(tctx, "Testing DeletePrinterDataExW(%ls - %ls)", keyname, valuename);
1412
1413 err = DeletePrinterDataExW(handle, keyname, valuename);
1414 if (err) {
1415 sprintf(tmp, "DeletePrinterDataExW(%ls - %ls) failed on [%s], error: %s\n",
1416 keyname, valuename, servername, errstr(err));
1417 torture_fail(tctx, tmp);
1418 }
1419
1420 return TRUE;
1421}
1422
1423
1424/****************************************************************************
1425****************************************************************************/
1426
1427static BOOL test_DeletePrinterKey(struct torture_context *tctx,
1428 LPSTR servername,
1429 LPSTR keyname,
1430 HANDLE handle)
1431{
1432 DWORD err = 0;
1433 char tmp[1024];
1434
1435 torture_comment(tctx, "Testing DeletePrinterKey(%s)", keyname);
1436
1437 err = DeletePrinterKey(handle, keyname);
1438 if (err) {
1439 sprintf(tmp, "DeletePrinterKey(%s) failed on [%s], error: %s\n",
1440 keyname, servername, errstr(err));
1441 torture_fail(tctx, tmp);
1442 }
1443
1444 return TRUE;
1445}
1446
1447/****************************************************************************
1448****************************************************************************/
1449
1450static BOOL test_DeletePrinterKeyW(struct torture_context *tctx,
1451 LPSTR servername,
1452 LPCWSTR keyname,
1453 HANDLE handle)
1454{
1455 DWORD err = 0;
1456 char tmp[1024];
1457
1458 torture_comment(tctx, "Testing DeletePrinterKeyW(%ls)", keyname);
1459
1460 err = DeletePrinterKeyW(handle, keyname);
1461 if (err) {
1462 sprintf(tmp, "DeletePrinterKeyW(%ls) failed on [%s], error: %s\n",
1463 keyname, servername, errstr(err));
1464 torture_fail(tctx, tmp);
1465 }
1466
1467 return TRUE;
1468}
1469
1470/****************************************************************************
1471****************************************************************************/
1472
1473static BOOL test_SetPrinterDataEx(struct torture_context *tctx,
1474 LPSTR servername,
1475 LPSTR keyname,
1476 LPSTR valuename,
1477 HANDLE handle,
1478 DWORD type,
1479 LPBYTE buffer,
1480 DWORD offered)
1481{
1482 DWORD err = 0;
1483 char tmp[1024];
1484
1485 torture_comment(tctx, "Testing SetPrinterDataEx(%s - %s)", keyname, valuename);
1486
1487 err = SetPrinterDataEx(handle, keyname, valuename, type, buffer, offered);
1488 if (err) {
1489 sprintf(tmp, "SetPrinterDataEx(%s) failed on [%s] (buffer size = %d), error: %s\n",
1490 valuename, servername, offered, errstr(err));
1491 torture_fail(tctx, tmp);
1492 }
1493
1494 return TRUE;
1495}
1496
1497/****************************************************************************
1498****************************************************************************/
1499
1500static BOOL test_SetPrinterDataExW(struct torture_context *tctx,
1501 LPCSTR servername,
1502 LPCWSTR keyname,
1503 LPCWSTR valuename,
1504 HANDLE handle,
1505 DWORD type,
1506 LPBYTE buffer,
1507 DWORD offered)
1508{
1509 DWORD err = 0;
1510 char tmp[1024];
1511
1512 torture_comment(tctx, "Testing SetPrinterDataExW(%ls - %ls)", keyname, valuename);
1513
1514 err = SetPrinterDataExW(handle, keyname, valuename, type, buffer, offered);
1515 if (err) {
1516 sprintf(tmp, "SetPrinterDataExW(%ls) failed on [%s] (buffer size = %d), error: %s\n",
1517 valuename, servername, offered, errstr(err));
1518 torture_fail(tctx, tmp);
1519 }
1520
1521 return TRUE;
1522}
1523
1524
1525/****************************************************************************
1526****************************************************************************/
1527
1528static BOOL test_PrinterData_Server(struct torture_context *tctx,
1529 LPSTR servername,
1530 HANDLE handle)
1531{
1532 BOOL ret = TRUE;
1533 DWORD i;
1534 DWORD type, type_ex;
1535 LPBYTE buffer, buffer_ex;
1536 DWORD size, size_ex;
1537 LPSTR valuenames[] = {
1538 SPLREG_DEFAULT_SPOOL_DIRECTORY,
1539 SPLREG_MAJOR_VERSION,
1540 SPLREG_MINOR_VERSION,
1541 SPLREG_DS_PRESENT,
1542 SPLREG_DNS_MACHINE_NAME,
1543 SPLREG_ARCHITECTURE,
1544 SPLREG_OS_VERSION
1545 };
1546
1547 for (i=0; i < ARRAY_SIZE(valuenames); i++) {
1548 ret &= test_GetPrinterData(tctx, servername, valuenames[i], handle, &type, &buffer, &size);
1549 ret &= test_GetPrinterDataEx(tctx, servername, "random", valuenames[i], handle, &type_ex, &buffer_ex, &size_ex);
1550 torture_assert_int_equal(tctx, type, type_ex, "type mismatch");
1551 torture_assert_int_equal(tctx, size, size_ex, "size mismatch");
1552 torture_assert_mem_equal(tctx, buffer, buffer_ex, size, "buffer mismatch");
1553 free(buffer);
1554 free(buffer_ex);
1555 }
1556
1557 return ret;
1558}
1559
1560/****************************************************************************
1561****************************************************************************/
1562
1563static BOOL PrinterDataEqual(struct torture_context *tctx,
1564 DWORD type1, DWORD type2,
1565 DWORD size1, DWORD size2,
1566 LPBYTE buffer1, LPBYTE buffer2)
1567{
1568 torture_assert_int_equal(tctx, type1, type2, "type mismatch");
1569 torture_assert_int_equal(tctx, size1, size2, "size mismatch");
1570 torture_assert_mem_equal(tctx, buffer1, buffer2, size1, "buffer mismatch");
1571
1572 return TRUE;
1573}
1574
1575/****************************************************************************
1576****************************************************************************/
1577
1578static BOOL test_PrinterData(struct torture_context *tctx,
1579 LPSTR printername,
1580 HANDLE handle)
1581{
1582 char tmp[1024];
1583 LPSTR keyname = "torture_key";
1584 LPSTR valuename = "torture_value";
1585 BOOL ret = TRUE;
1586 DWORD types[] = {
1587 REG_SZ,
1588 REG_DWORD,
1589 REG_BINARY
1590 };
1591 DWORD value = 12345678;
1592 LPSTR str = "abcdefghijklmnopqrstuvwxzy";
1593 DWORD t, s;
1594
1595 for (t=0; t < ARRAY_SIZE(types); t++) {
1596 for (s=0; s < strlen(str); s++) {
1597
1598 DWORD type, type_ex;
1599 LPBYTE buffer, buffer_ex;
1600 DWORD size, size_ex;
1601
1602 if (types[t] == REG_DWORD) {
1603 s = 0xffff;
1604 }
1605
1606 switch (types[t]) {
1607 case REG_BINARY:
1608 buffer = malloc(s);
1609 memcpy(buffer, str, s);
1610 size = s;
1611 break;
1612 case REG_DWORD:
1613 buffer = malloc(4);
1614 memcpy(buffer, &value, 4);
1615 size = 4;
1616 break;
1617 case REG_SZ:
1618 buffer = malloc(s);
1619 memcpy(buffer, str, s);
1620 size = s;
1621 break;
1622 default:
1623 sprintf(tmp, "type %d untested\n", types[t]);
1624 torture_fail(tctx, tmp);
1625 break;
1626 }
1627
1628 type = types[t];
1629
1630 torture_comment(tctx, "Testing PrinterData (type: %s, size: 0x%08x)", reg_type_str(type), size);
1631
1632 torture_assert(tctx,
1633 test_SetPrinterDataEx(tctx, printername, keyname, valuename, handle, type, buffer, size),
1634 "failed to call SetPrinterDataEx");
1635 torture_assert(tctx,
1636 test_GetPrinterDataEx(tctx, printername, keyname, valuename, handle, &type_ex, &buffer_ex, &size_ex),
1637 "failed to call GetPrinterDataEx");
1638
1639 if (!PrinterDataEqual(tctx, type_ex, type, size_ex, size, buffer_ex, buffer)) {
1640 torture_warning(tctx, "GetPrinterDataEx does not return the same info as we set with SetPrinterDataEx");
1641 ret = FALSE;
1642 }
1643 ret &= test_DeletePrinterDataEx(tctx, printername, keyname, valuename, handle);
1644 ret &= test_DeletePrinterKey(tctx, printername, keyname, handle);
1645
1646 free(buffer);
1647 free(buffer_ex);
1648 }
1649 }
1650
1651 return ret;
1652}
1653
1654/****************************************************************************
1655****************************************************************************/
1656
1657static BOOL test_PrinterDataW(struct torture_context *tctx,
1658 LPSTR printername,
1659 HANDLE handle)
1660{
1661 char tmp[1024];
1662 LPCWSTR keyname = L"torture_key";
1663 LPCWSTR valuename = L"torture_value";
1664 BOOL ret = TRUE;
1665 DWORD types[] = {
1666 REG_SZ,
1667 REG_DWORD,
1668 REG_BINARY
1669 };
1670 DWORD value = 12345678;
1671 LPSTR str = "abcdefghijklmnopqrstuvwxzy";
1672 DWORD t, s;
1673
1674 for (t=0; t < ARRAY_SIZE(types); t++) {
1675 for (s=0; s < strlen(str); s++) {
1676
1677 DWORD type, type_ex;
1678 LPBYTE buffer, buffer_ex;
1679 DWORD size, size_ex;
1680
1681 if (types[t] == REG_DWORD) {
1682 s = 0xffff;
1683 }
1684
1685 switch (types[t]) {
1686 case REG_BINARY:
1687 buffer = malloc(s);
1688 memcpy(buffer, str, s);
1689 size = s;
1690 break;
1691 case REG_DWORD:
1692 buffer = malloc(4);
1693 memcpy(buffer, &value, 4);
1694 size = 4;
1695 break;
1696 case REG_SZ:
1697 buffer = malloc(s);
1698 memcpy(buffer, str, s);
1699 size = s;
1700 break;
1701 default:
1702 sprintf(tmp, "type %d untested\n", types[t]);
1703 torture_fail(tctx, tmp);
1704 break;
1705 }
1706
1707 type = types[t];
1708
1709 torture_comment(tctx, "Testing PrinterDataW (type: %s, size: 0x%08x)", reg_type_str(type), size);
1710
1711 torture_assert(tctx,
1712 test_SetPrinterDataExW(tctx, printername, keyname, valuename, handle, type, buffer, size),
1713 "failed to call SetPrinterDataExW");
1714 torture_assert(tctx,
1715 test_GetPrinterDataExW(tctx, printername, keyname, valuename, handle, &type_ex, &buffer_ex, &size_ex),
1716 "failed to call GetPrinterDataExW");
1717
1718 if (!PrinterDataEqual(tctx, type_ex, type, size_ex, size, buffer_ex, buffer)) {
1719 torture_warning(tctx, "GetPrinterDataExW does not return the same info as we set with SetPrinterDataExW");
1720 ret = FALSE;
1721 }
1722 ret &= test_DeletePrinterDataExW(tctx, printername, keyname, valuename, handle);
1723 ret &= test_DeletePrinterKeyW(tctx, printername, keyname, handle);
1724
1725 free(buffer);
1726 free(buffer_ex);
1727 }
1728 }
1729
1730 return ret;
1731}
1732
1733/****************************************************************************
1734****************************************************************************/
1735
1736const char *get_string_param(const char *str)
1737{
1738 const char *p;
1739
1740 p = strchr(str, '=');
1741 if (!p) {
1742 return NULL;
1743 }
1744
1745 return (p+1);
1746}
1747
1748/****************************************************************************
1749****************************************************************************/
1750
1751int main(int argc, char *argv[])
1752{
1753 BOOL ret = FALSE;
1754 LPSTR servername;
1755 LPSTR architecture = "Windows NT x86";
1756 HANDLE server_handle;
1757 PRINTER_DEFAULTS defaults_admin, defaults_use;
1758 struct torture_context *tctx;
1759 int i;
1760
1761 if (argc < 2) {
1762 fprintf(stderr, "usage: %s <name> [print] [samba3] [architecture=ARCHITECTURE]\n\n", argv[0]);
1763 fprintf(stderr, "\t<name> can be a server or printer name URI\n");
1764 fprintf(stderr, "\t[print] will print all data that has been retrieved\n");
1765 fprintf(stderr, "\t from the printserver\n");
1766 fprintf(stderr, "\t[samba3] will skip some tests samba servers are known\n");
1767 fprintf(stderr, "\t not to have implemented\n");
1768 fprintf(stderr, "\t[architecture=X] allows one to define a specific\n");
1769 fprintf(stderr, "\t architecture to test with. choose between:\n");
1770 fprintf(stderr, "\t \"Windows NT x86\" or \"Windows x64\"\n");
1771 exit(-1);
1772 }
1773
1774 tctx = malloc(sizeof(struct torture_context));
1775 if (!tctx) {
1776 fprintf(stderr, "out of memory\n");
1777 exit(-1);
1778 }
1779 memset(tctx, '\0', sizeof(*tctx));
1780
1781 servername = argv[1];
1782
1783 for (i=1; i < argc; i++) {
1784 if (strcmp(argv[i], "print") == 0) {
1785 tctx->print = TRUE;
1786 }
1787 if (strcmp(argv[i], "samba3") == 0) {
1788 tctx->samba3 = TRUE;
1789 }
1790 if (strncmp(argv[i], "architecture", strlen("architecture")) == 0) {
1791 architecture = get_string_param(argv[i]);
1792 }
1793 }
1794
1795 printf("Running testsuite with architecture: %s\n", architecture);
1796
1797 defaults_admin.pDatatype = NULL;
1798 defaults_admin.pDevMode = NULL;
1799 defaults_admin.DesiredAccess = PRINTER_ACCESS_ADMINISTER;
1800
1801 defaults_use.pDatatype = NULL;
1802 defaults_use.pDevMode = NULL;
1803 defaults_use.DesiredAccess = PRINTER_ACCESS_USE;
1804
1805 if ((servername[0] == '\\') && (servername[1] == '\\')) {
1806 LPSTR p = servername+2;
1807 LPSTR p2;
1808 if ((p2 = strchr(p, '\\')) != NULL) {
1809 ret = test_OnePrinter(tctx, servername, architecture, &defaults_admin);
1810 goto done;
1811 }
1812 }
1813
1814 ret &= test_EnumPrinters(tctx, servername);
1815 ret &= test_EnumDrivers(tctx, servername, architecture);
1816 ret &= test_OpenPrinter(tctx, servername, NULL, &server_handle);
1817/* ret &= test_EnumPrinterKey(tctx, servername, server_handle, ""); */
1818 ret &= test_PrinterData_Server(tctx, servername, server_handle);
1819 ret &= test_EnumForms(tctx, servername, server_handle);
1820 ret &= test_ClosePrinter(tctx, server_handle);
1821 ret &= test_EnumPorts(tctx, servername);
1822 ret &= test_EnumMonitors(tctx, servername);
1823 ret &= test_EnumPrintProcessors(tctx, servername, architecture);
1824 ret &= test_EnumPrintProcessorDatatypes(tctx, servername);
1825 ret &= test_GetPrintProcessorDirectory(tctx, servername, architecture);
1826 ret &= test_GetPrinterDriverDirectory(tctx, servername, architecture);
1827 ret &= test_EachPrinter(tctx, servername, architecture, &defaults_admin);
1828
1829 done:
1830 if (!ret) {
1831 if (tctx->last_reason) {
1832 fprintf(stderr, "failed: %s\n", tctx->last_reason);
1833 }
1834 free(tctx);
1835 return -1;
1836 }
1837
1838 printf("%s run successfully\n", argv[0]);
1839
1840 free(tctx);
1841 return 0;
1842}
Note: See TracBrowser for help on using the repository browser.