← Back to branch summary

~ubuntu-branches/ubuntu/vivid/samba/vivid

« back to all changes in this revision

Viewing changes to testprogs/win32/spoolss/testspoolss.c

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access.
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
testprogs/win32/spoolss/testspoolss.c
 
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
 
 
31
static 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
 
 
51
static 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
 
 
70
static 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
 
 
122
static 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
 
 
175
static 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
 
 
227
static 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
 
 
284
static 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
 
 
335
static 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
 
 
386
static 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
 
 
438
static 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
 
 
489
static 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
 
 
525
static 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
 
 
576
static 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
 
 
630
static 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
 
 
687
static 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
 
 
751
static 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
 
 
802
static 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
 
 
864
static 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
 
 
931
static 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
 
 
988
static 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
 
 
1036
static 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
        /* dont 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
 
 
1071
static 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
 
 
1115
static 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
 
 
1167
static 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
 
 
1219
static 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
 
 
1271
static 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
 
 
1324
static 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
 
 
1378
static 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
 
 
1402
static 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
 
 
1427
static 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
 
 
1450
static 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
 
 
1473
static 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
 
 
1500
static 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
 
 
1528
static 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
 
 
1563
static 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
 
 
1578
static 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
 
 
1657
static 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
 
 
1736
const 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
 
 
1751
int 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 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
}