Debian Codegraph @

source4/torture/rap/printing.c

raw
1 /*
2 Unix SMB/CIFS implementation.
3 test suite for SMB printing operations
4
5 Copyright (C) Guenther Deschner 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 #include "includes.h"
22 #include "libcli/raw/libcliraw.h"
23 #include "libcli/libcli.h"
24 #include "torture/torture.h"
25 #include "torture/util.h"
26 #include "system/filesys.h"
27
28 #include "torture/smbtorture.h"
29 #include "torture/util.h"
30 #include "libcli/rap/rap.h"
31 #include "torture/rap/proto.h"
32 #include "param/param.h"
33
34 /* TODO:
35
36 printing half the file,
37 finding job
38 delete job
39 try writing 2nd half
40
41 SMBsplretq
42
43 */
44
45 #define TORTURE_PRINT_FILE "torture_print_file"
46
47 static bool print_printjob(struct torture_context *tctx,
48 struct smbcli_tree *tree)
49 {
50 int fnum;
51 DATA_BLOB data;
52 ssize_t size_written;
53 const char *str;
54
55 torture_comment(tctx, "creating printjob %s\n", TORTURE_PRINT_FILE);
56
57 fnum = smbcli_open(tree, TORTURE_PRINT_FILE, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE);
58 if (fnum == -1) {
59 torture_fail(tctx, "failed to open file");
60 }
61
62 str = talloc_asprintf(tctx, "TortureTestPage: %d\nData\n",0);
63
64 data = data_blob_string_const(str);
65
66 size_written = smbcli_write(tree, fnum, 0, data.data, 0, data.length);
67 if (size_written != data.length) {
68 torture_fail(tctx, "failed to write file");
69 }
70
71 torture_assert_ntstatus_ok(tctx,
72 smbcli_close(tree, fnum),
73 "failed to close file");
74
75 return true;
76 }
77
78 static bool test_raw_print(struct torture_context *tctx,
79 struct smbcli_state *cli)
80 {
81 return print_printjob(tctx, cli->tree);
82 }
83
84 static bool test_netprintqenum(struct torture_context *tctx,
85 struct smbcli_state *cli)
86 {
87 struct rap_NetPrintQEnum r;
88 int i, q;
89 uint16_t levels[] = { 0, 1, 2, 3, 4, 5 };
90
91 for (i=0; i < ARRAY_SIZE(levels); i++) {
92
93 r.in.level = levels[i];
94 r.in.bufsize = 8192;
95
96 torture_comment(tctx,
97 "Testing rap_NetPrintQEnum level %d\n", r.in.level);
98
99 torture_assert_ntstatus_ok(tctx,
100 smbcli_rap_netprintqenum(cli->tree, tctx, &r),
101 "smbcli_rap_netprintqenum failed");
102 torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
103 "failed to enum printq");
104
105 for (q=0; q<r.out.count; q++) {
106 switch (r.in.level) {
107 case 0:
108 printf("%s\n", r.out.info[q].info0.PrintQName);
109 break;
110 }
111 }
112 }
113
114 return true;
115 }
116
117 static bool test_netprintqgetinfo(struct torture_context *tctx,
118 struct smbcli_state *cli)
119 {
120 struct rap_NetPrintQGetInfo r;
121 struct rap_NetPrintQEnum r_enum;
122 int i, p;
123 uint16_t levels[] = { 0, 1, 2, 3, 4, 5 };
124
125 r.in.level = 0;
126 r.in.bufsize = 0;
127 r.in.PrintQueueName = "";
128
129 torture_assert_ntstatus_ok(tctx,
130 smbcli_rap_netprintqgetinfo(cli->tree, tctx, &r),
131 "smbcli_rap_netprintqgetinfo failed");
132 torture_assert_werr_equal(tctx,
133 W_ERROR(r.out.status),
134 WERR_INVALID_PARAMETER,
135 "smbcli_rap_netprintqgetinfo failed");
136
137 r_enum.in.level = 5;
138 r_enum.in.bufsize = 8192;
139
140 torture_assert_ntstatus_ok(tctx,
141 smbcli_rap_netprintqenum(cli->tree, tctx, &r_enum),
142 "failed to enum printq");
143 torture_assert_werr_ok(tctx, W_ERROR(r_enum.out.status),
144 "failed to enum printq");
145
146 for (p=0; p < r_enum.out.count; p++) {
147
148 for (i=0; i < ARRAY_SIZE(levels); i++) {
149
150 r.in.level = levels[i];
151 r.in.bufsize = 8192;
152 r.in.PrintQueueName = r_enum.out.info[p].info5.PrintQueueName;
153
154 torture_comment(tctx, "Testing rap_NetPrintQGetInfo(%s) level %d\n",
155 r.in.PrintQueueName, r.in.level);
156
157 torture_assert_ntstatus_ok(tctx,
158 smbcli_rap_netprintqgetinfo(cli->tree, tctx, &r),
159 "smbcli_rap_netprintqgetinfo failed");
160 torture_assert_werr_ok(tctx,
161 W_ERROR(r.out.status),
162 "smbcli_rap_netprintqgetinfo failed");
163
164 switch (r.in.level) {
165 case 0:
166 printf("%s\n", r.out.info.info0.PrintQName);
167 break;
168 }
169 }
170 }
171
172 return true;
173 }
174
175 static bool test_netprintjob_pause(struct torture_context *tctx,
176 struct smbcli_state *cli,
177 uint16_t job_id)
178 {
179 struct rap_NetPrintJobPause r;
180
181 r.in.JobID = job_id;
182
183 torture_comment(tctx, "Testing rap_NetPrintJobPause(%d)\n", r.in.JobID);
184
185 torture_assert_ntstatus_ok(tctx,
186 smbcli_rap_netprintjobpause(cli->tree, tctx, &r),
187 "smbcli_rap_netprintjobpause failed");
188
189 return true;
190 }
191
192 static bool test_netprintjob_continue(struct torture_context *tctx,
193 struct smbcli_state *cli,
194 uint16_t job_id)
195 {
196 struct rap_NetPrintJobContinue r;
197
198 r.in.JobID = job_id;
199
200 torture_comment(tctx, "Testing rap_NetPrintJobContinue(%d)\n", r.in.JobID);
201
202 torture_assert_ntstatus_ok(tctx,
203 smbcli_rap_netprintjobcontinue(cli->tree, tctx, &r),
204 "smbcli_rap_netprintjobcontinue failed");
205
206 return true;
207 }
208
209 static bool test_netprintjob_delete(struct torture_context *tctx,
210 struct smbcli_state *cli,
211 uint16_t job_id)
212 {
213 struct rap_NetPrintJobDelete r;
214
215 r.in.JobID = job_id;
216
217 torture_comment(tctx, "Testing rap_NetPrintJobDelete(%d)\n", r.in.JobID);
218
219 torture_assert_ntstatus_ok(tctx,
220 smbcli_rap_netprintjobdelete(cli->tree, tctx, &r),
221 "smbcli_rap_netprintjobdelete failed");
222
223 return true;
224 }
225
226 static bool test_netprintjob(struct torture_context *tctx,
227 struct smbcli_state *cli)
228 {
229 uint16_t job_id = 400;
230
231 torture_assert(tctx,
232 test_netprintjob_pause(tctx, cli, job_id),
233 "failed to pause job");
234 torture_assert(tctx,
235 test_netprintjob_continue(tctx, cli, job_id),
236 "failed to continue job");
237 torture_assert(tctx,
238 test_netprintjob_delete(tctx, cli, job_id),
239 "failed to delete job");
240
241 return true;
242 }
243
244 static bool test_netprintq_pause(struct torture_context *tctx,
245 struct smbcli_state *cli,
246 const char *PrintQueueName)
247 {
248 struct rap_NetPrintQueuePause r;
249
250 r.in.PrintQueueName = PrintQueueName;
251
252 torture_comment(tctx, "Testing rap_NetPrintQueuePause(%s)\n", r.in.PrintQueueName);
253
254 torture_assert_ntstatus_ok(tctx,
255 smbcli_rap_netprintqueuepause(cli->tree, tctx, &r),
256 "smbcli_rap_netprintqueuepause failed");
257 torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
258 "smbcli_rap_netprintqueuepause failed");
259
260 return true;
261 }
262
263 static bool test_netprintq_resume(struct torture_context *tctx,
264 struct smbcli_state *cli,
265 const char *PrintQueueName)
266 {
267 struct rap_NetPrintQueueResume r;
268
269 r.in.PrintQueueName = PrintQueueName;
270
271 torture_comment(tctx, "Testing rap_NetPrintQueueResume(%s)\n", r.in.PrintQueueName);
272
273 torture_assert_ntstatus_ok(tctx,
274 smbcli_rap_netprintqueueresume(cli->tree, tctx, &r),
275 "smbcli_rap_netprintqueueresume failed");
276 torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
277 "smbcli_rap_netprintqueueresume failed");
278
279 return true;
280 }
281
282 static bool test_netprintq(struct torture_context *tctx,
283 struct smbcli_state *cli)
284 {
285 struct rap_NetPrintQEnum r;
286 int i;
287
288 r.in.level = 5;
289 r.in.bufsize = 8192;
290
291 torture_assert_ntstatus_ok(tctx,
292 smbcli_rap_netprintqenum(cli->tree, tctx, &r),
293 "failed to enum printq");
294 torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
295 "failed to enum printq");
296
297 for (i=0; i < r.out.count; i++) {
298
299 const char *printqname = r.out.info[i].info5.PrintQueueName;
300
301 torture_assert(tctx,
302 test_netprintq_pause(tctx, cli, printqname),
303 "failed to pause print queue");
304
305 torture_assert(tctx,
306 test_netprintq_resume(tctx, cli, printqname),
307 "failed to resume print queue");
308 }
309
310 return true;
311 }
312
313 static bool test_netprintjobenum_args(struct torture_context *tctx,
314 struct smbcli_state *cli,
315 const char *PrintQueueName,
316 uint16_t level,
317 uint16_t *count_p,
318 union rap_printj_info **info_p)
319 {
320 struct rap_NetPrintJobEnum r;
321
322 r.in.PrintQueueName = PrintQueueName;
323 r.in.bufsize = 8192;
324 r.in.level = level;
325
326 torture_comment(tctx,
327 "Testing rap_NetPrintJobEnum(%s) level %d\n", r.in.PrintQueueName, r.in.level);
328
329 torture_assert_ntstatus_ok(tctx,
330 smbcli_rap_netprintjobenum(cli->tree, tctx, &r),
331 "smbcli_rap_netprintjobenum failed");
332
333 if (count_p) {
334 *count_p = r.out.count;
335 }
336 if (info_p) {
337 *info_p = r.out.info;
338 }
339
340 return true;
341 }
342
343 static bool test_netprintjobenum_one(struct torture_context *tctx,
344 struct smbcli_state *cli,
345 const char *PrintQueueName)
346 {
347 struct rap_NetPrintJobEnum r;
348 int i;
349 uint16_t levels[] = { 0, 1, 2 };
350
351 r.in.PrintQueueName = PrintQueueName;
352 r.in.bufsize = 8192;
353
354 for (i=0; i < ARRAY_SIZE(levels); i++) {
355
356 r.in.level = levels[i];
357
358 torture_comment(tctx,
359 "Testing rap_NetPrintJobEnum(%s) level %d\n", r.in.PrintQueueName, r.in.level);
360
361 torture_assert_ntstatus_ok(tctx,
362 smbcli_rap_netprintjobenum(cli->tree, tctx, &r),
363 "smbcli_rap_netprintjobenum failed");
364 }
365
366 return true;
367 }
368
369 static bool test_netprintjobgetinfo_byid(struct torture_context *tctx,
370 struct smbcli_state *cli,
371 uint16_t JobID)
372 {
373 struct rap_NetPrintJobGetInfo r;
374 uint16_t levels[] = { 0, 1, 2 };
375 int i;
376
377 r.in.JobID = JobID;
378 r.in.bufsize = 8192;
379
380 for (i=0; i < ARRAY_SIZE(levels); i++) {
381
382 r.in.level = levels[i];
383
384 torture_comment(tctx, "Testing rap_NetPrintJobGetInfo(%d) level %d\n", r.in.JobID, r.in.level);
385
386 torture_assert_ntstatus_ok(tctx,
387 smbcli_rap_netprintjobgetinfo(cli->tree, tctx, &r),
388 "smbcli_rap_netprintjobgetinfo failed");
389 }
390
391 return true;
392 }
393
394 static bool test_netprintjobsetinfo_byid(struct torture_context *tctx,
395 struct smbcli_state *cli,
396 uint16_t JobID)
397 {
398 struct rap_NetPrintJobSetInfo r;
399 uint16_t levels[] = { 0, 1, 2 };
400 int i;
401 const char *comment = "tortured by samba";
402
403 r.in.JobID = JobID;
404 r.in.bufsize = strlen(comment);
405 r.in.ParamNum = RAP_PARAM_JOBCOMMENT;
406 r.in.Param.string = comment;
407
408 for (i=0; i < ARRAY_SIZE(levels); i++) {
409
410 r.in.level = levels[i];
411
412 torture_comment(tctx, "Testing rap_NetPrintJobSetInfo(%d) level %d\n", r.in.JobID, r.in.level);
413
414 torture_assert_ntstatus_ok(tctx,
415 smbcli_rap_netprintjobsetinfo(cli->tree, tctx, &r),
416 "smbcli_rap_netprintjobsetinfo failed");
417 }
418
419 return true;
420 }
421
422
423 static bool test_netprintjobgetinfo_byqueue(struct torture_context *tctx,
424 struct smbcli_state *cli,
425 const char *PrintQueueName)
426 {
427 struct rap_NetPrintJobEnum r;
428 int i;
429
430 r.in.PrintQueueName = PrintQueueName;
431 r.in.bufsize = 8192;
432 r.in.level = 0;
433
434 torture_assert_ntstatus_ok(tctx,
435 smbcli_rap_netprintjobenum(cli->tree, tctx, &r),
436 "failed to enumerate jobs");
437
438 for (i=0; i < r.out.count; i++) {
439
440 torture_assert(tctx,
441 test_netprintjobgetinfo_byid(tctx, cli, r.out.info[i].info0.JobID),
442 "failed to get job info");
443 }
444
445 return true;
446 }
447
448 static bool test_netprintjobsetinfo_byqueue(struct torture_context *tctx,
449 struct smbcli_state *cli,
450 const char *PrintQueueName)
451 {
452 struct rap_NetPrintJobEnum r;
453 int i;
454
455 r.in.PrintQueueName = PrintQueueName;
456 r.in.bufsize = 8192;
457 r.in.level = 0;
458
459 torture_assert_ntstatus_ok(tctx,
460 smbcli_rap_netprintjobenum(cli->tree, tctx, &r),
461 "failed to enumerate jobs");
462
463 for (i=0; i < r.out.count; i++) {
464
465 torture_assert(tctx,
466 test_netprintjobsetinfo_byid(tctx, cli, r.out.info[i].info0.JobID),
467 "failed to set job info");
468 }
469
470 return true;
471 }
472
473 static bool test_netprintjobenum(struct torture_context *tctx,
474 struct smbcli_state *cli)
475 {
476 struct rap_NetPrintQEnum r;
477 int i;
478
479 r.in.level = 5;
480 r.in.bufsize = 8192;
481
482 torture_assert_ntstatus_ok(tctx,
483 smbcli_rap_netprintqenum(cli->tree, tctx, &r),
484 "failed to enum printq");
485 torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
486 "failed to enum printq");
487
488 for (i=0; i < r.out.count; i++) {
489
490 const char *printqname = r.out.info[i].info5.PrintQueueName;
491
492 torture_assert(tctx,
493 test_netprintjobenum_one(tctx, cli, printqname),
494 "failed to enumerate printjobs on print queue");
495 }
496
497 return true;
498 }
499
500 static bool test_netprintjobgetinfo(struct torture_context *tctx,
501 struct smbcli_state *cli)
502 {
503 struct rap_NetPrintQEnum r;
504 int i;
505
506 r.in.level = 5;
507 r.in.bufsize = 8192;
508
509 torture_assert_ntstatus_ok(tctx,
510 smbcli_rap_netprintqenum(cli->tree, tctx, &r),
511 "failed to enum printq");
512 torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
513 "failed to enum printq");
514
515 for (i=0; i < r.out.count; i++) {
516
517 const char *printqname = r.out.info[i].info5.PrintQueueName;
518
519 torture_assert(tctx,
520 test_netprintjobgetinfo_byqueue(tctx, cli, printqname),
521 "failed to enumerate printjobs on print queue");
522 }
523
524 return true;
525 }
526
527 static bool test_netprintjobsetinfo(struct torture_context *tctx,
528 struct smbcli_state *cli)
529 {
530 struct rap_NetPrintQEnum r;
531 int i;
532
533 r.in.level = 5;
534 r.in.bufsize = 8192;
535
536 torture_assert_ntstatus_ok(tctx,
537 smbcli_rap_netprintqenum(cli->tree, tctx, &r),
538 "failed to enum printq");
539 torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
540 "failed to enum printq");
541
542 for (i=0; i < r.out.count; i++) {
543
544 const char *printqname = r.out.info[i].info5.PrintQueueName;
545
546 torture_assert(tctx,
547 test_netprintjobsetinfo_byqueue(tctx, cli, printqname),
548 "failed to set printjobs on print queue");
549 }
550
551 return true;
552 }
553
554 static bool test_netprintdestenum(struct torture_context *tctx,
555 struct smbcli_state *cli)
556 {
557 struct rap_NetPrintDestEnum r;
558 int i;
559 uint16_t levels[] = { 0, 1, 2, 3 };
560
561 for (i=0; i < ARRAY_SIZE(levels); i++) {
562
563 r.in.level = levels[i];
564 r.in.bufsize = 8192;
565
566 torture_comment(tctx,
567 "Testing rap_NetPrintDestEnum level %d\n", r.in.level);
568
569 torture_assert_ntstatus_ok(tctx,
570 smbcli_rap_netprintdestenum(cli->tree, tctx, &r),
571 "smbcli_rap_netprintdestenum failed");
572 }
573
574 return true;
575 }
576
577 static bool test_netprintdestgetinfo_bydest(struct torture_context *tctx,
578 struct smbcli_state *cli,
579 const char *PrintDestName)
580 {
581 struct rap_NetPrintDestGetInfo r;
582 int i;
583 uint16_t levels[] = { 0, 1, 2, 3 };
584
585 for (i=0; i < ARRAY_SIZE(levels); i++) {
586
587 r.in.PrintDestName = PrintDestName;
588 r.in.level = levels[i];
589 r.in.bufsize = 8192;
590
591 torture_comment(tctx,
592 "Testing rap_NetPrintDestGetInfo(%s) level %d\n", r.in.PrintDestName, r.in.level);
593
594 torture_assert_ntstatus_ok(tctx,
595 smbcli_rap_netprintdestgetinfo(cli->tree, tctx, &r),
596 "smbcli_rap_netprintdestgetinfo failed");
597 }
598
599 return true;
600 }
601
602
603 static bool test_netprintdestgetinfo(struct torture_context *tctx,
604 struct smbcli_state *cli)
605 {
606 struct rap_NetPrintDestEnum r;
607 int i;
608
609 r.in.level = 2;
610 r.in.bufsize = 8192;
611
612 torture_comment(tctx,
613 "Testing rap_NetPrintDestEnum level %d\n", r.in.level);
614
615 torture_assert_ntstatus_ok(tctx,
616 smbcli_rap_netprintdestenum(cli->tree, tctx, &r),
617 "smbcli_rap_netprintdestenum failed");
618
619 for (i=0; i < r.out.count; i++) {
620
621 torture_assert(tctx,
622 test_netprintdestgetinfo_bydest(tctx, cli, r.out.info[i].info2.PrinterName),
623 "failed to get printdest info");
624
625 }
626
627 return true;
628 }
629
630 static bool test_rap_print(struct torture_context *tctx,
631 struct smbcli_state *cli)
632 {
633 struct rap_NetPrintQEnum r;
634 int i;
635
636 r.in.level = 5;
637 r.in.bufsize = 8192;
638
639 torture_assert_ntstatus_ok(tctx,
640 smbcli_rap_netprintqenum(cli->tree, tctx, &r),
641 "failed to enum printq");
642 torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
643 "failed to enum printq");
644
645 for (i=0; i < r.out.count; i++) {
646
647 const char *printqname = r.out.info[i].info5.PrintQueueName;
648 struct smbcli_tree *res_queue = NULL;
649 uint16_t num_jobs;
650 union rap_printj_info *job_info;
651 int j;
652
653 torture_assert(tctx,
654 test_netprintq_pause(tctx, cli, printqname),
655 "failed to set printjobs on print queue");
656
657 torture_assert_ntstatus_ok(tctx,
658 torture_second_tcon(tctx, cli->session, printqname, &res_queue),
659 "failed to open 2nd connection");
660
661 torture_assert(tctx,
662 print_printjob(tctx, res_queue),
663 "failed to print job on 2nd connection");
664
665 talloc_free(res_queue);
666
667 torture_assert(tctx,
668 test_netprintjobenum_args(tctx, cli, printqname, 1,
669 &num_jobs, &job_info),
670 "failed to enum printjobs on print queue");
671
672 for (j=0; j < num_jobs; j++) {
673
674 uint16_t job_id = job_info[j].info1.JobID;
675
676 torture_assert(tctx,
677 test_netprintjobgetinfo_byid(tctx, cli, job_id),
678 "failed to getinfo on new printjob");
679
680 torture_assert(tctx,
681 test_netprintjob_delete(tctx, cli, job_id),
682 "failed to delete job");
683 }
684
685 torture_assert(tctx,
686 test_netprintq_resume(tctx, cli, printqname),
687 "failed to resume print queue");
688
689 }
690
691 return true;
692 }
693
694 struct torture_suite *torture_rap_printing(TALLOC_CTX *mem_ctx)
695 {
696 struct torture_suite *suite = torture_suite_create(mem_ctx, "printing");
697
698 torture_suite_add_1smb_test(suite, "raw_print", test_raw_print);
699 torture_suite_add_1smb_test(suite, "rap_print", test_rap_print);
700 torture_suite_add_1smb_test(suite, "rap_printq_enum", test_netprintqenum);
701 torture_suite_add_1smb_test(suite, "rap_printq_getinfo", test_netprintqgetinfo);
702 torture_suite_add_1smb_test(suite, "rap_printq", test_netprintq);
703 torture_suite_add_1smb_test(suite, "rap_printjob_enum", test_netprintjobenum);
704 torture_suite_add_1smb_test(suite, "rap_printjob_getinfo", test_netprintjobgetinfo);
705 torture_suite_add_1smb_test(suite, "rap_printjob_setinfo", test_netprintjobsetinfo);
706 torture_suite_add_1smb_test(suite, "rap_printjob", test_netprintjob);
707 torture_suite_add_1smb_test(suite, "rap_printdest_enum", test_netprintdestenum);
708 torture_suite_add_1smb_test(suite, "rap_printdest_getinfo", test_netprintdestgetinfo);
709
710 return suite;
711 }