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