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