source: trunk/server/source3/rpc_client/cli_spoolss.c@ 953

Last change on this file since 953 was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 26.2 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 RPC pipe client
4
5 Copyright (C) Gerald Carter 2001-2005,
6 Copyright (C) Tim Potter 2000-2002,
7 Copyright (C) Andrew Tridgell 1994-2000,
8 Copyright (C) Jean-Francois Micouleau 1999-2000.
9 Copyright (C) Jeremy Allison 2005.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>.
23*/
24
25#include "includes.h"
26#include "rpc_client/rpc_client.h"
27#include "../librpc/gen_ndr/ndr_spoolss_c.h"
28#include "rpc_client/cli_spoolss.h"
29
30/**********************************************************************
31 convencience wrapper around rpccli_spoolss_OpenPrinterEx
32**********************************************************************/
33
34WERROR rpccli_spoolss_openprinter_ex(struct rpc_pipe_client *cli,
35 TALLOC_CTX *mem_ctx,
36 const char *printername,
37 uint32_t access_desired,
38 struct policy_handle *handle)
39{
40 NTSTATUS status;
41 WERROR werror;
42 struct spoolss_DevmodeContainer devmode_ctr;
43 union spoolss_UserLevel userlevel;
44 struct spoolss_UserLevel1 level1;
45 struct dcerpc_binding_handle *b = cli->binding_handle;
46
47 ZERO_STRUCT(devmode_ctr);
48
49 level1.size = 28;
50 level1.client = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
51 W_ERROR_HAVE_NO_MEMORY(level1.client);
52 level1.user = cli->auth->user_name;
53 level1.build = 1381;
54 level1.major = 2;
55 level1.minor = 0;
56 level1.processor = 0;
57
58 userlevel.level1 = &level1;
59
60 status = dcerpc_spoolss_OpenPrinterEx(b, mem_ctx,
61 printername,
62 NULL,
63 devmode_ctr,
64 access_desired,
65 1, /* level */
66 userlevel,
67 handle,
68 &werror);
69
70 if (!NT_STATUS_IS_OK(status)) {
71 return ntstatus_to_werror(status);
72 }
73
74 if (!W_ERROR_IS_OK(werror)) {
75 return werror;
76 }
77
78 return WERR_OK;
79}
80
81/**********************************************************************
82 convencience wrapper around rpccli_spoolss_GetPrinterDriver
83**********************************************************************/
84
85WERROR rpccli_spoolss_getprinterdriver(struct rpc_pipe_client *cli,
86 TALLOC_CTX *mem_ctx,
87 struct policy_handle *handle,
88 const char *architecture,
89 uint32_t level,
90 uint32_t offered,
91 union spoolss_DriverInfo *info)
92{
93 NTSTATUS status;
94 WERROR werror;
95 uint32_t needed;
96 DATA_BLOB buffer;
97 struct dcerpc_binding_handle *b = cli->binding_handle;
98
99 if (offered > 0) {
100 buffer = data_blob_talloc_zero(mem_ctx, offered);
101 W_ERROR_HAVE_NO_MEMORY(buffer.data);
102 }
103
104 status = dcerpc_spoolss_GetPrinterDriver(b, mem_ctx,
105 handle,
106 architecture,
107 level,
108 (offered > 0) ? &buffer : NULL,
109 offered,
110 info,
111 &needed,
112 &werror);
113 if (!NT_STATUS_IS_OK(status)) {
114 return ntstatus_to_werror(status);
115 }
116 if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
117 offered = needed;
118 buffer = data_blob_talloc_zero(mem_ctx, needed);
119 W_ERROR_HAVE_NO_MEMORY(buffer.data);
120
121 status = dcerpc_spoolss_GetPrinterDriver(b, mem_ctx,
122 handle,
123 architecture,
124 level,
125 &buffer,
126 offered,
127 info,
128 &needed,
129 &werror);
130 }
131 if (!NT_STATUS_IS_OK(status)) {
132 return ntstatus_to_werror(status);
133 }
134
135 return werror;
136}
137
138/**********************************************************************
139 convencience wrapper around rpccli_spoolss_GetPrinterDriver2
140**********************************************************************/
141
142WERROR rpccli_spoolss_getprinterdriver2(struct rpc_pipe_client *cli,
143 TALLOC_CTX *mem_ctx,
144 struct policy_handle *handle,
145 const char *architecture,
146 uint32_t level,
147 uint32_t offered,
148 uint32_t client_major_version,
149 uint32_t client_minor_version,
150 union spoolss_DriverInfo *info,
151 uint32_t *server_major_version,
152 uint32_t *server_minor_version)
153{
154 NTSTATUS status;
155 WERROR werror;
156 uint32_t needed;
157 DATA_BLOB buffer;
158 struct dcerpc_binding_handle *b = cli->binding_handle;
159
160 if (offered > 0) {
161 buffer = data_blob_talloc_zero(mem_ctx, offered);
162 W_ERROR_HAVE_NO_MEMORY(buffer.data);
163 }
164
165 status = dcerpc_spoolss_GetPrinterDriver2(b, mem_ctx,
166 handle,
167 architecture,
168 level,
169 (offered > 0) ? &buffer : NULL,
170 offered,
171 client_major_version,
172 client_minor_version,
173 info,
174 &needed,
175 server_major_version,
176 server_minor_version,
177 &werror);
178 if (!NT_STATUS_IS_OK(status)) {
179 return ntstatus_to_werror(status);
180 }
181
182 if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
183 offered = needed;
184 buffer = data_blob_talloc_zero(mem_ctx, needed);
185 W_ERROR_HAVE_NO_MEMORY(buffer.data);
186
187 status = dcerpc_spoolss_GetPrinterDriver2(b, mem_ctx,
188 handle,
189 architecture,
190 level,
191 &buffer,
192 offered,
193 client_major_version,
194 client_minor_version,
195 info,
196 &needed,
197 server_major_version,
198 server_minor_version,
199 &werror);
200 }
201 if (!NT_STATUS_IS_OK(status)) {
202 return ntstatus_to_werror(status);
203 }
204
205 return werror;
206}
207
208/**********************************************************************
209 convencience wrapper around rpccli_spoolss_AddPrinterEx
210**********************************************************************/
211
212WERROR rpccli_spoolss_addprinterex(struct rpc_pipe_client *cli,
213 TALLOC_CTX *mem_ctx,
214 struct spoolss_SetPrinterInfoCtr *info_ctr)
215{
216 WERROR result;
217 NTSTATUS status;
218 struct spoolss_DevmodeContainer devmode_ctr;
219 struct sec_desc_buf secdesc_ctr;
220 struct spoolss_UserLevelCtr userlevel_ctr;
221 struct spoolss_UserLevel1 level1;
222 struct policy_handle handle;
223 struct dcerpc_binding_handle *b = cli->binding_handle;
224
225 ZERO_STRUCT(devmode_ctr);
226 ZERO_STRUCT(secdesc_ctr);
227
228 level1.size = 28;
229 level1.build = 1381;
230 level1.major = 2;
231 level1.minor = 0;
232 level1.processor = 0;
233 level1.client = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
234 W_ERROR_HAVE_NO_MEMORY(level1.client);
235 level1.user = cli->auth->user_name;
236
237 userlevel_ctr.level = 1;
238 userlevel_ctr.user_info.level1 = &level1;
239
240 status = dcerpc_spoolss_AddPrinterEx(b, mem_ctx,
241 cli->srv_name_slash,
242 info_ctr,
243 &devmode_ctr,
244 &secdesc_ctr,
245 &userlevel_ctr,
246 &handle,
247 &result);
248 if (!NT_STATUS_IS_OK(status)) {
249 return ntstatus_to_werror(status);
250 }
251
252 return result;
253}
254
255/**********************************************************************
256 convencience wrapper around rpccli_spoolss_GetPrinter
257**********************************************************************/
258
259WERROR rpccli_spoolss_getprinter(struct rpc_pipe_client *cli,
260 TALLOC_CTX *mem_ctx,
261 struct policy_handle *handle,
262 uint32_t level,
263 uint32_t offered,
264 union spoolss_PrinterInfo *info)
265{
266 NTSTATUS status;
267 WERROR werror;
268 DATA_BLOB buffer;
269 uint32_t needed;
270 struct dcerpc_binding_handle *b = cli->binding_handle;
271
272 if (offered > 0) {
273 buffer = data_blob_talloc_zero(mem_ctx, offered);
274 W_ERROR_HAVE_NO_MEMORY(buffer.data);
275 }
276
277 status = dcerpc_spoolss_GetPrinter(b, mem_ctx,
278 handle,
279 level,
280 (offered > 0) ? &buffer : NULL,
281 offered,
282 info,
283 &needed,
284 &werror);
285 if (!NT_STATUS_IS_OK(status)) {
286 return ntstatus_to_werror(status);
287 }
288
289 if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
290
291 offered = needed;
292 buffer = data_blob_talloc_zero(mem_ctx, offered);
293 W_ERROR_HAVE_NO_MEMORY(buffer.data);
294
295 status = dcerpc_spoolss_GetPrinter(b, mem_ctx,
296 handle,
297 level,
298 &buffer,
299 offered,
300 info,
301 &needed,
302 &werror);
303 }
304 if (!NT_STATUS_IS_OK(status)) {
305 return ntstatus_to_werror(status);
306 }
307
308 return werror;
309}
310
311/**********************************************************************
312 convencience wrapper around rpccli_spoolss_GetJob
313**********************************************************************/
314
315WERROR rpccli_spoolss_getjob(struct rpc_pipe_client *cli,
316 TALLOC_CTX *mem_ctx,
317 struct policy_handle *handle,
318 uint32_t job_id,
319 uint32_t level,
320 uint32_t offered,
321 union spoolss_JobInfo *info)
322{
323 NTSTATUS status;
324 WERROR werror;
325 uint32_t needed;
326 DATA_BLOB buffer;
327 struct dcerpc_binding_handle *b = cli->binding_handle;
328
329 if (offered > 0) {
330 buffer = data_blob_talloc_zero(mem_ctx, offered);
331 W_ERROR_HAVE_NO_MEMORY(buffer.data);
332 }
333
334 status = dcerpc_spoolss_GetJob(b, mem_ctx,
335 handle,
336 job_id,
337 level,
338 (offered > 0) ? &buffer : NULL,
339 offered,
340 info,
341 &needed,
342 &werror);
343 if (!NT_STATUS_IS_OK(status)) {
344 return ntstatus_to_werror(status);
345 }
346
347 if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
348 offered = needed;
349 buffer = data_blob_talloc_zero(mem_ctx, needed);
350 W_ERROR_HAVE_NO_MEMORY(buffer.data);
351
352 status = dcerpc_spoolss_GetJob(b, mem_ctx,
353 handle,
354 job_id,
355 level,
356 &buffer,
357 offered,
358 info,
359 &needed,
360 &werror);
361 }
362 if (!NT_STATUS_IS_OK(status)) {
363 return ntstatus_to_werror(status);
364 }
365
366 return werror;
367}
368
369/**********************************************************************
370 convencience wrapper around rpccli_spoolss_EnumForms
371**********************************************************************/
372
373WERROR rpccli_spoolss_enumforms(struct rpc_pipe_client *cli,
374 TALLOC_CTX *mem_ctx,
375 struct policy_handle *handle,
376 uint32_t level,
377 uint32_t offered,
378 uint32_t *count,
379 union spoolss_FormInfo **info)
380{
381 NTSTATUS status;
382 WERROR werror;
383 uint32_t needed;
384 DATA_BLOB buffer;
385 struct dcerpc_binding_handle *b = cli->binding_handle;
386
387 if (offered > 0) {
388 buffer = data_blob_talloc_zero(mem_ctx, offered);
389 W_ERROR_HAVE_NO_MEMORY(buffer.data);
390 }
391
392 status = dcerpc_spoolss_EnumForms(b, mem_ctx,
393 handle,
394 level,
395 (offered > 0) ? &buffer : NULL,
396 offered,
397 count,
398 info,
399 &needed,
400 &werror);
401 if (!NT_STATUS_IS_OK(status)) {
402 return ntstatus_to_werror(status);
403 }
404
405 if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
406 offered = needed;
407 buffer = data_blob_talloc_zero(mem_ctx, needed);
408 W_ERROR_HAVE_NO_MEMORY(buffer.data);
409
410 status = dcerpc_spoolss_EnumForms(b, mem_ctx,
411 handle,
412 level,
413 (offered > 0) ? &buffer : NULL,
414 offered,
415 count,
416 info,
417 &needed,
418 &werror);
419 }
420 if (!NT_STATUS_IS_OK(status)) {
421 return ntstatus_to_werror(status);
422 }
423
424 return werror;
425}
426
427/**********************************************************************
428 convencience wrapper around rpccli_spoolss_EnumPrintProcessors
429**********************************************************************/
430
431WERROR rpccli_spoolss_enumprintprocessors(struct rpc_pipe_client *cli,
432 TALLOC_CTX *mem_ctx,
433 const char *servername,
434 const char *environment,
435 uint32_t level,
436 uint32_t offered,
437 uint32_t *count,
438 union spoolss_PrintProcessorInfo **info)
439{
440 NTSTATUS status;
441 WERROR werror;
442 uint32_t needed;
443 DATA_BLOB buffer;
444 struct dcerpc_binding_handle *b = cli->binding_handle;
445
446 if (offered > 0) {
447 buffer = data_blob_talloc_zero(mem_ctx, offered);
448 W_ERROR_HAVE_NO_MEMORY(buffer.data);
449 }
450
451 status = dcerpc_spoolss_EnumPrintProcessors(b, mem_ctx,
452 servername,
453 environment,
454 level,
455 (offered > 0) ? &buffer : NULL,
456 offered,
457 count,
458 info,
459 &needed,
460 &werror);
461 if (!NT_STATUS_IS_OK(status)) {
462 return ntstatus_to_werror(status);
463 }
464
465 if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
466 offered = needed;
467 buffer = data_blob_talloc_zero(mem_ctx, needed);
468 W_ERROR_HAVE_NO_MEMORY(buffer.data);
469
470 status = dcerpc_spoolss_EnumPrintProcessors(b, mem_ctx,
471 servername,
472 environment,
473 level,
474 (offered > 0) ? &buffer : NULL,
475 offered,
476 count,
477 info,
478 &needed,
479 &werror);
480 }
481 if (!NT_STATUS_IS_OK(status)) {
482 return ntstatus_to_werror(status);
483 }
484
485 return werror;
486}
487
488/**********************************************************************
489 convencience wrapper around rpccli_spoolss_EnumPrintProcDataTypes
490**********************************************************************/
491
492WERROR rpccli_spoolss_enumprintprocessordatatypes(struct rpc_pipe_client *cli,
493 TALLOC_CTX *mem_ctx,
494 const char *servername,
495 const char *print_processor_name,
496 uint32_t level,
497 uint32_t offered,
498 uint32_t *count,
499 union spoolss_PrintProcDataTypesInfo **info)
500{
501 NTSTATUS status;
502 WERROR werror;
503 uint32_t needed;
504 DATA_BLOB buffer;
505 struct dcerpc_binding_handle *b = cli->binding_handle;
506
507 if (offered > 0) {
508 buffer = data_blob_talloc_zero(mem_ctx, offered);
509 W_ERROR_HAVE_NO_MEMORY(buffer.data);
510 }
511
512 status = dcerpc_spoolss_EnumPrintProcDataTypes(b, mem_ctx,
513 servername,
514 print_processor_name,
515 level,
516 (offered > 0) ? &buffer : NULL,
517 offered,
518 count,
519 info,
520 &needed,
521 &werror);
522 if (!NT_STATUS_IS_OK(status)) {
523 return ntstatus_to_werror(status);
524 }
525
526 if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
527 offered = needed;
528 buffer = data_blob_talloc_zero(mem_ctx, needed);
529 W_ERROR_HAVE_NO_MEMORY(buffer.data);
530
531 status = dcerpc_spoolss_EnumPrintProcDataTypes(b, mem_ctx,
532 servername,
533 print_processor_name,
534 level,
535 (offered > 0) ? &buffer : NULL,
536 offered,
537 count,
538 info,
539 &needed,
540 &werror);
541 }
542 if (!NT_STATUS_IS_OK(status)) {
543 return ntstatus_to_werror(status);
544 }
545
546 return werror;
547}
548
549/**********************************************************************
550 convencience wrapper around rpccli_spoolss_EnumPorts
551**********************************************************************/
552
553WERROR rpccli_spoolss_enumports(struct rpc_pipe_client *cli,
554 TALLOC_CTX *mem_ctx,
555 const char *servername,
556 uint32_t level,
557 uint32_t offered,
558 uint32_t *count,
559 union spoolss_PortInfo **info)
560{
561 NTSTATUS status;
562 WERROR werror;
563 uint32_t needed;
564 DATA_BLOB buffer;
565 struct dcerpc_binding_handle *b = cli->binding_handle;
566
567 if (offered > 0) {
568 buffer = data_blob_talloc_zero(mem_ctx, offered);
569 W_ERROR_HAVE_NO_MEMORY(buffer.data);
570 }
571
572 status = dcerpc_spoolss_EnumPorts(b, mem_ctx,
573 servername,
574 level,
575 (offered > 0) ? &buffer : NULL,
576 offered,
577 count,
578 info,
579 &needed,
580 &werror);
581 if (!NT_STATUS_IS_OK(status)) {
582 return ntstatus_to_werror(status);
583 }
584
585 if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
586 offered = needed;
587 buffer = data_blob_talloc_zero(mem_ctx, needed);
588 W_ERROR_HAVE_NO_MEMORY(buffer.data);
589
590 status = dcerpc_spoolss_EnumPorts(b, mem_ctx,
591 servername,
592 level,
593 (offered > 0) ? &buffer : NULL,
594 offered,
595 count,
596 info,
597 &needed,
598 &werror);
599 }
600 if (!NT_STATUS_IS_OK(status)) {
601 return ntstatus_to_werror(status);
602 }
603
604 return werror;
605}
606
607/**********************************************************************
608 convencience wrapper around rpccli_spoolss_EnumMonitors
609**********************************************************************/
610
611WERROR rpccli_spoolss_enummonitors(struct rpc_pipe_client *cli,
612 TALLOC_CTX *mem_ctx,
613 const char *servername,
614 uint32_t level,
615 uint32_t offered,
616 uint32_t *count,
617 union spoolss_MonitorInfo **info)
618{
619 NTSTATUS status;
620 WERROR werror;
621 uint32_t needed;
622 DATA_BLOB buffer;
623 struct dcerpc_binding_handle *b = cli->binding_handle;
624
625 if (offered > 0) {
626 buffer = data_blob_talloc_zero(mem_ctx, offered);
627 W_ERROR_HAVE_NO_MEMORY(buffer.data);
628 }
629
630 status = dcerpc_spoolss_EnumMonitors(b, mem_ctx,
631 servername,
632 level,
633 (offered > 0) ? &buffer : NULL,
634 offered,
635 count,
636 info,
637 &needed,
638 &werror);
639 if (!NT_STATUS_IS_OK(status)) {
640 return ntstatus_to_werror(status);
641 }
642
643 if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
644 offered = needed;
645 buffer = data_blob_talloc_zero(mem_ctx, needed);
646 W_ERROR_HAVE_NO_MEMORY(buffer.data);
647
648 status = dcerpc_spoolss_EnumMonitors(b, mem_ctx,
649 servername,
650 level,
651 (offered > 0) ? &buffer : NULL,
652 offered,
653 count,
654 info,
655 &needed,
656 &werror);
657 }
658 if (!NT_STATUS_IS_OK(status)) {
659 return ntstatus_to_werror(status);
660 }
661
662 return werror;
663}
664
665/**********************************************************************
666 convencience wrapper around rpccli_spoolss_EnumJobs
667**********************************************************************/
668
669WERROR rpccli_spoolss_enumjobs(struct rpc_pipe_client *cli,
670 TALLOC_CTX *mem_ctx,
671 struct policy_handle *handle,
672 uint32_t firstjob,
673 uint32_t numjobs,
674 uint32_t level,
675 uint32_t offered,
676 uint32_t *count,
677 union spoolss_JobInfo **info)
678{
679 NTSTATUS status;
680 WERROR werror;
681 uint32_t needed;
682 DATA_BLOB buffer;
683 struct dcerpc_binding_handle *b = cli->binding_handle;
684
685 if (offered > 0) {
686 buffer = data_blob_talloc_zero(mem_ctx, offered);
687 W_ERROR_HAVE_NO_MEMORY(buffer.data);
688 }
689
690 status = dcerpc_spoolss_EnumJobs(b, mem_ctx,
691 handle,
692 firstjob,
693 numjobs,
694 level,
695 (offered > 0) ? &buffer : NULL,
696 offered,
697 count,
698 info,
699 &needed,
700 &werror);
701 if (!NT_STATUS_IS_OK(status)) {
702 return ntstatus_to_werror(status);
703 }
704
705 if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
706 offered = needed;
707 buffer = data_blob_talloc_zero(mem_ctx, needed);
708 W_ERROR_HAVE_NO_MEMORY(buffer.data);
709
710 status = dcerpc_spoolss_EnumJobs(b, mem_ctx,
711 handle,
712 firstjob,
713 numjobs,
714 level,
715 (offered > 0) ? &buffer : NULL,
716 offered,
717 count,
718 info,
719 &needed,
720 &werror);
721 }
722 if (!NT_STATUS_IS_OK(status)) {
723 return ntstatus_to_werror(status);
724 }
725
726 return werror;
727}
728
729/**********************************************************************
730 convencience wrapper around rpccli_spoolss_EnumPrinterDrivers
731**********************************************************************/
732
733WERROR rpccli_spoolss_enumprinterdrivers(struct rpc_pipe_client *cli,
734 TALLOC_CTX *mem_ctx,
735 const char *server,
736 const char *environment,
737 uint32_t level,
738 uint32_t offered,
739 uint32_t *count,
740 union spoolss_DriverInfo **info)
741{
742 NTSTATUS status;
743 WERROR werror;
744 uint32_t needed;
745 DATA_BLOB buffer;
746 struct dcerpc_binding_handle *b = cli->binding_handle;
747
748 if (offered > 0) {
749 buffer = data_blob_talloc_zero(mem_ctx, offered);
750 W_ERROR_HAVE_NO_MEMORY(buffer.data);
751 }
752
753 status = dcerpc_spoolss_EnumPrinterDrivers(b, mem_ctx,
754 server,
755 environment,
756 level,
757 (offered > 0) ? &buffer : NULL,
758 offered,
759 count,
760 info,
761 &needed,
762 &werror);
763 if (!NT_STATUS_IS_OK(status)) {
764 return ntstatus_to_werror(status);
765 }
766
767 if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
768 offered = needed;
769 buffer = data_blob_talloc_zero(mem_ctx, needed);
770 W_ERROR_HAVE_NO_MEMORY(buffer.data);
771
772 status = dcerpc_spoolss_EnumPrinterDrivers(b, mem_ctx,
773 server,
774 environment,
775 level,
776 (offered > 0) ? &buffer : NULL,
777 offered,
778 count,
779 info,
780 &needed,
781 &werror);
782 }
783 if (!NT_STATUS_IS_OK(status)) {
784 return ntstatus_to_werror(status);
785 }
786
787 return werror;
788}
789
790/**********************************************************************
791 convencience wrapper around rpccli_spoolss_EnumPrinters
792**********************************************************************/
793
794WERROR rpccli_spoolss_enumprinters(struct rpc_pipe_client *cli,
795 TALLOC_CTX *mem_ctx,
796 uint32_t flags,
797 const char *server,
798 uint32_t level,
799 uint32_t offered,
800 uint32_t *count,
801 union spoolss_PrinterInfo **info)
802{
803 NTSTATUS status;
804 WERROR werror;
805 uint32_t needed;
806 DATA_BLOB buffer;
807 struct dcerpc_binding_handle *b = cli->binding_handle;
808
809 if (offered > 0) {
810 buffer = data_blob_talloc_zero(mem_ctx, offered);
811 W_ERROR_HAVE_NO_MEMORY(buffer.data);
812 }
813
814 status = dcerpc_spoolss_EnumPrinters(b, mem_ctx,
815 flags,
816 server,
817 level,
818 (offered > 0) ? &buffer : NULL,
819 offered,
820 count,
821 info,
822 &needed,
823 &werror);
824 if (!NT_STATUS_IS_OK(status)) {
825 return ntstatus_to_werror(status);
826 }
827
828 if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
829 offered = needed;
830 buffer = data_blob_talloc_zero(mem_ctx, needed);
831 W_ERROR_HAVE_NO_MEMORY(buffer.data);
832
833 status = dcerpc_spoolss_EnumPrinters(b, mem_ctx,
834 flags,
835 server,
836 level,
837 (offered > 0) ? &buffer : NULL,
838 offered,
839 count,
840 info,
841 &needed,
842 &werror);
843 }
844 if (!NT_STATUS_IS_OK(status)) {
845 return ntstatus_to_werror(status);
846 }
847
848 return werror;
849}
850
851/**********************************************************************
852 convencience wrapper around rpccli_spoolss_GetPrinterData
853**********************************************************************/
854
855WERROR rpccli_spoolss_getprinterdata(struct rpc_pipe_client *cli,
856 TALLOC_CTX *mem_ctx,
857 struct policy_handle *handle,
858 const char *value_name,
859 uint32_t offered,
860 enum winreg_Type *type,
861 uint32_t *needed_p,
862 uint8_t **data_p)
863{
864 NTSTATUS status;
865 WERROR werror;
866 uint32_t needed;
867 uint8_t *data;
868 struct dcerpc_binding_handle *b = cli->binding_handle;
869
870 data = talloc_zero_array(mem_ctx, uint8_t, offered);
871 W_ERROR_HAVE_NO_MEMORY(data);
872
873 status = dcerpc_spoolss_GetPrinterData(b, mem_ctx,
874 handle,
875 value_name,
876 type,
877 data,
878 offered,
879 &needed,
880 &werror);
881 if (!NT_STATUS_IS_OK(status)) {
882 return ntstatus_to_werror(status);
883 }
884
885 if (W_ERROR_EQUAL(werror, WERR_MORE_DATA)) {
886 offered = needed;
887 data = talloc_zero_array(mem_ctx, uint8_t, offered);
888 W_ERROR_HAVE_NO_MEMORY(data);
889
890 status = dcerpc_spoolss_GetPrinterData(b, mem_ctx,
891 handle,
892 value_name,
893 type,
894 data,
895 offered,
896 &needed,
897 &werror);
898 }
899 if (!NT_STATUS_IS_OK(status)) {
900 return ntstatus_to_werror(status);
901 }
902
903 *data_p = data;
904 *needed_p = needed;
905
906 return werror;
907}
908
909/**********************************************************************
910 convencience wrapper around rpccli_spoolss_EnumPrinterKey
911**********************************************************************/
912
913WERROR rpccli_spoolss_enumprinterkey(struct rpc_pipe_client *cli,
914 TALLOC_CTX *mem_ctx,
915 struct policy_handle *handle,
916 const char *key_name,
917 const char ***key_buffer,
918 uint32_t offered)
919{
920 NTSTATUS status;
921 WERROR werror;
922 uint32_t needed;
923 union spoolss_KeyNames _key_buffer;
924 uint32_t _ndr_size;
925 struct dcerpc_binding_handle *b = cli->binding_handle;
926
927 status = dcerpc_spoolss_EnumPrinterKey(b, mem_ctx,
928 handle,
929 key_name,
930 &_ndr_size,
931 &_key_buffer,
932 offered,
933 &needed,
934 &werror);
935 if (!NT_STATUS_IS_OK(status)) {
936 return ntstatus_to_werror(status);
937 }
938
939 if (W_ERROR_EQUAL(werror, WERR_MORE_DATA)) {
940 offered = needed;
941 status = dcerpc_spoolss_EnumPrinterKey(b, mem_ctx,
942 handle,
943 key_name,
944 &_ndr_size,
945 &_key_buffer,
946 offered,
947 &needed,
948 &werror);
949 }
950 if (!NT_STATUS_IS_OK(status)) {
951 return ntstatus_to_werror(status);
952 }
953
954 *key_buffer = _key_buffer.string_array;
955
956 return werror;
957}
958
959/**********************************************************************
960 convencience wrapper around rpccli_spoolss_EnumPrinterDataEx
961**********************************************************************/
962
963WERROR rpccli_spoolss_enumprinterdataex(struct rpc_pipe_client *cli,
964 TALLOC_CTX *mem_ctx,
965 struct policy_handle *handle,
966 const char *key_name,
967 uint32_t offered,
968 uint32_t *count,
969 struct spoolss_PrinterEnumValues **info)
970{
971 NTSTATUS status;
972 WERROR werror;
973 uint32_t needed;
974 struct dcerpc_binding_handle *b = cli->binding_handle;
975
976 status = dcerpc_spoolss_EnumPrinterDataEx(b, mem_ctx,
977 handle,
978 key_name,
979 offered,
980 count,
981 info,
982 &needed,
983 &werror);
984 if (!NT_STATUS_IS_OK(status)) {
985 return ntstatus_to_werror(status);
986 }
987
988 if (W_ERROR_EQUAL(werror, WERR_MORE_DATA)) {
989 offered = needed;
990
991 status = dcerpc_spoolss_EnumPrinterDataEx(b, mem_ctx,
992 handle,
993 key_name,
994 offered,
995 count,
996 info,
997 &needed,
998 &werror);
999 }
1000 if (!NT_STATUS_IS_OK(status)) {
1001 return ntstatus_to_werror(status);
1002 }
1003
1004 return werror;
1005}
Note: See TracBrowser for help on using the repository browser.