3f369bdab3c2de92f97d5599076d627427474a51
[ira/wip.git] / source3 / rpc_client / cli_spoolss.c
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.h"
27
28 /**********************************************************************
29  convencience wrapper around rpccli_spoolss_OpenPrinterEx
30 **********************************************************************/
31
32 WERROR rpccli_spoolss_openprinter_ex(struct rpc_pipe_client *cli,
33                                      TALLOC_CTX *mem_ctx,
34                                      const char *printername,
35                                      uint32_t access_desired,
36                                      struct policy_handle *handle)
37 {
38         NTSTATUS status;
39         WERROR werror;
40         struct spoolss_DevmodeContainer devmode_ctr;
41         union spoolss_UserLevel userlevel;
42         struct spoolss_UserLevel1 level1;
43
44         ZERO_STRUCT(devmode_ctr);
45
46         level1.size     = 28;
47         level1.client   = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
48         W_ERROR_HAVE_NO_MEMORY(level1.client);
49         level1.user     = cli->auth->user_name;
50         level1.build    = 1381;
51         level1.major    = 2;
52         level1.minor    = 0;
53         level1.processor = 0;
54
55         userlevel.level1 = &level1;
56
57         status = rpccli_spoolss_OpenPrinterEx(cli, mem_ctx,
58                                               printername,
59                                               NULL,
60                                               devmode_ctr,
61                                               access_desired,
62                                               1, /* level */
63                                               userlevel,
64                                               handle,
65                                               &werror);
66
67         if (!W_ERROR_IS_OK(werror)) {
68                 return werror;
69         }
70
71         if (!NT_STATUS_IS_OK(status)) {
72                 return ntstatus_to_werror(status);
73         }
74
75         return WERR_OK;
76 }
77
78 /**********************************************************************
79  convencience wrapper around rpccli_spoolss_GetPrinterDriver2
80 **********************************************************************/
81
82 WERROR rpccli_spoolss_getprinterdriver2(struct rpc_pipe_client *cli,
83                                         TALLOC_CTX *mem_ctx,
84                                         struct policy_handle *handle,
85                                         const char *architecture,
86                                         uint32_t level,
87                                         uint32_t offered,
88                                         uint32_t client_major_version,
89                                         uint32_t client_minor_version,
90                                         union spoolss_DriverInfo *info,
91                                         uint32_t *server_major_version,
92                                         uint32_t *server_minor_version)
93 {
94         NTSTATUS status;
95         WERROR werror;
96         uint32_t needed;
97         DATA_BLOB buffer;
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 = rpccli_spoolss_GetPrinterDriver2(cli, mem_ctx,
105                                                   handle,
106                                                   architecture,
107                                                   level,
108                                                   (offered > 0) ? &buffer : NULL,
109                                                   offered,
110                                                   client_major_version,
111                                                   client_minor_version,
112                                                   info,
113                                                   &needed,
114                                                   server_major_version,
115                                                   server_minor_version,
116                                                   &werror);
117         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
118                 offered = needed;
119                 buffer = data_blob_talloc_zero(mem_ctx, needed);
120                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
121
122                 status = rpccli_spoolss_GetPrinterDriver2(cli, mem_ctx,
123                                                           handle,
124                                                           architecture,
125                                                           level,
126                                                           &buffer,
127                                                           offered,
128                                                           client_major_version,
129                                                           client_minor_version,
130                                                           info,
131                                                           &needed,
132                                                           server_major_version,
133                                                           server_minor_version,
134                                                           &werror);
135         }
136
137         return werror;
138 }
139
140 /**********************************************************************
141  convencience wrapper around rpccli_spoolss_AddPrinterEx
142 **********************************************************************/
143
144 WERROR rpccli_spoolss_addprinterex(struct rpc_pipe_client *cli,
145                                    TALLOC_CTX *mem_ctx,
146                                    struct spoolss_SetPrinterInfoCtr *info_ctr)
147 {
148         WERROR result;
149         NTSTATUS status;
150         struct spoolss_DevmodeContainer devmode_ctr;
151         struct sec_desc_buf secdesc_ctr;
152         struct spoolss_UserLevelCtr userlevel_ctr;
153         struct spoolss_UserLevel1 level1;
154         struct policy_handle handle;
155
156         ZERO_STRUCT(devmode_ctr);
157         ZERO_STRUCT(secdesc_ctr);
158
159         level1.size             = 28;
160         level1.build            = 1381;
161         level1.major            = 2;
162         level1.minor            = 0;
163         level1.processor        = 0;
164         level1.client           = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
165         W_ERROR_HAVE_NO_MEMORY(level1.client);
166         level1.user             = cli->auth->user_name;
167
168         userlevel_ctr.level = 1;
169         userlevel_ctr.user_info.level1 = &level1;
170
171         status = rpccli_spoolss_AddPrinterEx(cli, mem_ctx,
172                                              cli->srv_name_slash,
173                                              info_ctr,
174                                              &devmode_ctr,
175                                              &secdesc_ctr,
176                                              &userlevel_ctr,
177                                              &handle,
178                                              &result);
179         return result;
180 }
181
182 /**********************************************************************
183  convencience wrapper around rpccli_spoolss_GetPrinter
184 **********************************************************************/
185
186 WERROR rpccli_spoolss_getprinter(struct rpc_pipe_client *cli,
187                                  TALLOC_CTX *mem_ctx,
188                                  struct policy_handle *handle,
189                                  uint32_t level,
190                                  uint32_t offered,
191                                  union spoolss_PrinterInfo *info)
192 {
193         NTSTATUS status;
194         WERROR werror;
195         DATA_BLOB buffer;
196         uint32_t needed;
197
198         if (offered > 0) {
199                 buffer = data_blob_talloc_zero(mem_ctx, offered);
200                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
201         }
202
203         status = rpccli_spoolss_GetPrinter(cli, mem_ctx,
204                                            handle,
205                                            level,
206                                            (offered > 0) ? &buffer : NULL,
207                                            offered,
208                                            info,
209                                            &needed,
210                                            &werror);
211
212         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
213
214                 offered = needed;
215                 buffer = data_blob_talloc_zero(mem_ctx, offered);
216                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
217
218                 status = rpccli_spoolss_GetPrinter(cli, mem_ctx,
219                                                    handle,
220                                                    level,
221                                                    &buffer,
222                                                    offered,
223                                                    info,
224                                                    &needed,
225                                                    &werror);
226         }
227
228         return werror;
229 }
230
231 /**********************************************************************
232  convencience wrapper around rpccli_spoolss_GetJob
233 **********************************************************************/
234
235 WERROR rpccli_spoolss_getjob(struct rpc_pipe_client *cli,
236                              TALLOC_CTX *mem_ctx,
237                              struct policy_handle *handle,
238                              uint32_t job_id,
239                              uint32_t level,
240                              uint32_t offered,
241                              union spoolss_JobInfo *info)
242 {
243         NTSTATUS status;
244         WERROR werror;
245         uint32_t needed;
246         DATA_BLOB buffer;
247
248         if (offered > 0) {
249                 buffer = data_blob_talloc_zero(mem_ctx, offered);
250                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
251         }
252
253         status = rpccli_spoolss_GetJob(cli, mem_ctx,
254                                        handle,
255                                        job_id,
256                                        level,
257                                        (offered > 0) ? &buffer : NULL,
258                                        offered,
259                                        info,
260                                        &needed,
261                                        &werror);
262
263         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
264                 offered = needed;
265                 buffer = data_blob_talloc_zero(mem_ctx, needed);
266                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
267
268                 status = rpccli_spoolss_GetJob(cli, mem_ctx,
269                                                handle,
270                                                job_id,
271                                                level,
272                                                &buffer,
273                                                offered,
274                                                info,
275                                                &needed,
276                                                &werror);
277         }
278
279         return werror;
280 }
281
282 /**********************************************************************
283  convencience wrapper around rpccli_spoolss_EnumForms
284 **********************************************************************/
285
286 WERROR rpccli_spoolss_enumforms(struct rpc_pipe_client *cli,
287                                 TALLOC_CTX *mem_ctx,
288                                 struct policy_handle *handle,
289                                 uint32_t level,
290                                 uint32_t offered,
291                                 uint32_t *count,
292                                 union spoolss_FormInfo **info)
293 {
294         NTSTATUS status;
295         WERROR werror;
296         uint32_t needed;
297         DATA_BLOB buffer;
298
299         if (offered > 0) {
300                 buffer = data_blob_talloc_zero(mem_ctx, offered);
301                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
302         }
303
304         status = rpccli_spoolss_EnumForms(cli, mem_ctx,
305                                           handle,
306                                           level,
307                                           (offered > 0) ? &buffer : NULL,
308                                           offered,
309                                           count,
310                                           info,
311                                           &needed,
312                                           &werror);
313
314         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
315                 offered = needed;
316                 buffer = data_blob_talloc_zero(mem_ctx, needed);
317                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
318
319                 status = rpccli_spoolss_EnumForms(cli, mem_ctx,
320                                                   handle,
321                                                   level,
322                                                   (offered > 0) ? &buffer : NULL,
323                                                   offered,
324                                                   count,
325                                                   info,
326                                                   &needed,
327                                                   &werror);
328         }
329
330         return werror;
331 }
332
333 /**********************************************************************
334  convencience wrapper around rpccli_spoolss_EnumPrintProcessors
335 **********************************************************************/
336
337 WERROR rpccli_spoolss_enumprintprocessors(struct rpc_pipe_client *cli,
338                                           TALLOC_CTX *mem_ctx,
339                                           const char *servername,
340                                           const char *environment,
341                                           uint32_t level,
342                                           uint32_t offered,
343                                           uint32_t *count,
344                                           union spoolss_PrintProcessorInfo **info)
345 {
346         NTSTATUS status;
347         WERROR werror;
348         uint32_t needed;
349         DATA_BLOB buffer;
350
351         if (offered > 0) {
352                 buffer = data_blob_talloc_zero(mem_ctx, offered);
353                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
354         }
355
356         status = rpccli_spoolss_EnumPrintProcessors(cli, mem_ctx,
357                                                     servername,
358                                                     environment,
359                                                     level,
360                                                     (offered > 0) ? &buffer : NULL,
361                                                     offered,
362                                                     count,
363                                                     info,
364                                                     &needed,
365                                                     &werror);
366
367         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
368                 offered = needed;
369                 buffer = data_blob_talloc_zero(mem_ctx, needed);
370                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
371
372                 status = rpccli_spoolss_EnumPrintProcessors(cli, mem_ctx,
373                                                             servername,
374                                                             environment,
375                                                             level,
376                                                             (offered > 0) ? &buffer : NULL,
377                                                             offered,
378                                                             count,
379                                                             info,
380                                                             &needed,
381                                                             &werror);
382         }
383
384         return werror;
385 }
386
387 /**********************************************************************
388  convencience wrapper around rpccli_spoolss_EnumPrintProcDataTypes
389 **********************************************************************/
390
391 WERROR rpccli_spoolss_enumprintprocessordatatypes(struct rpc_pipe_client *cli,
392                                                   TALLOC_CTX *mem_ctx,
393                                                   const char *servername,
394                                                   const char *print_processor_name,
395                                                   uint32_t level,
396                                                   uint32_t offered,
397                                                   uint32_t *count,
398                                                   union spoolss_PrintProcDataTypesInfo **info)
399 {
400         NTSTATUS status;
401         WERROR werror;
402         uint32_t needed;
403         DATA_BLOB buffer;
404
405         if (offered > 0) {
406                 buffer = data_blob_talloc_zero(mem_ctx, offered);
407                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
408         }
409
410         status = rpccli_spoolss_EnumPrintProcDataTypes(cli, mem_ctx,
411                                                        servername,
412                                                        print_processor_name,
413                                                        level,
414                                                        (offered > 0) ? &buffer : NULL,
415                                                        offered,
416                                                        count,
417                                                        info,
418                                                        &needed,
419                                                        &werror);
420
421         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
422                 offered = needed;
423                 buffer = data_blob_talloc_zero(mem_ctx, needed);
424                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
425
426                 status = rpccli_spoolss_EnumPrintProcDataTypes(cli, mem_ctx,
427                                                                servername,
428                                                                print_processor_name,
429                                                                level,
430                                                                (offered > 0) ? &buffer : NULL,
431                                                                offered,
432                                                                count,
433                                                                info,
434                                                                &needed,
435                                                                &werror);
436         }
437
438         return werror;
439 }
440
441 /**********************************************************************
442  convencience wrapper around rpccli_spoolss_EnumPorts
443 **********************************************************************/
444
445 WERROR rpccli_spoolss_enumports(struct rpc_pipe_client *cli,
446                                 TALLOC_CTX *mem_ctx,
447                                 const char *servername,
448                                 uint32_t level,
449                                 uint32_t offered,
450                                 uint32_t *count,
451                                 union spoolss_PortInfo **info)
452 {
453         NTSTATUS status;
454         WERROR werror;
455         uint32_t needed;
456         DATA_BLOB buffer;
457
458         if (offered > 0) {
459                 buffer = data_blob_talloc_zero(mem_ctx, offered);
460                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
461         }
462
463         status = rpccli_spoolss_EnumPorts(cli, mem_ctx,
464                                           servername,
465                                           level,
466                                           (offered > 0) ? &buffer : NULL,
467                                           offered,
468                                           count,
469                                           info,
470                                           &needed,
471                                           &werror);
472
473         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
474                 offered = needed;
475                 buffer = data_blob_talloc_zero(mem_ctx, needed);
476                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
477
478                 status = rpccli_spoolss_EnumPorts(cli, mem_ctx,
479                                                   servername,
480                                                   level,
481                                                   (offered > 0) ? &buffer : NULL,
482                                                   offered,
483                                                   count,
484                                                   info,
485                                                   &needed,
486                                                   &werror);
487         }
488
489         return werror;
490 }
491
492 /**********************************************************************
493  convencience wrapper around rpccli_spoolss_EnumMonitors
494 **********************************************************************/
495
496 WERROR rpccli_spoolss_enummonitors(struct rpc_pipe_client *cli,
497                                    TALLOC_CTX *mem_ctx,
498                                    const char *servername,
499                                    uint32_t level,
500                                    uint32_t offered,
501                                    uint32_t *count,
502                                    union spoolss_MonitorInfo **info)
503 {
504         NTSTATUS status;
505         WERROR werror;
506         uint32_t needed;
507         DATA_BLOB buffer;
508
509         if (offered > 0) {
510                 buffer = data_blob_talloc_zero(mem_ctx, offered);
511                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
512         }
513
514         status = rpccli_spoolss_EnumMonitors(cli, mem_ctx,
515                                              servername,
516                                              level,
517                                              (offered > 0) ? &buffer : NULL,
518                                              offered,
519                                              count,
520                                              info,
521                                              &needed,
522                                              &werror);
523
524         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
525                 offered = needed;
526                 buffer = data_blob_talloc_zero(mem_ctx, needed);
527                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
528
529                 status = rpccli_spoolss_EnumMonitors(cli, mem_ctx,
530                                                      servername,
531                                                      level,
532                                                      (offered > 0) ? &buffer : NULL,
533                                                      offered,
534                                                      count,
535                                                      info,
536                                                      &needed,
537                                                      &werror);
538         }
539
540         return werror;
541 }
542
543 /**********************************************************************
544  convencience wrapper around rpccli_spoolss_EnumJobs
545 **********************************************************************/
546
547 WERROR rpccli_spoolss_enumjobs(struct rpc_pipe_client *cli,
548                                TALLOC_CTX *mem_ctx,
549                                struct policy_handle *handle,
550                                uint32_t firstjob,
551                                uint32_t numjobs,
552                                uint32_t level,
553                                uint32_t offered,
554                                uint32_t *count,
555                                union spoolss_JobInfo **info)
556 {
557         NTSTATUS status;
558         WERROR werror;
559         uint32_t needed;
560         DATA_BLOB buffer;
561
562         if (offered > 0) {
563                 buffer = data_blob_talloc_zero(mem_ctx, offered);
564                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
565         }
566
567         status = rpccli_spoolss_EnumJobs(cli, mem_ctx,
568                                          handle,
569                                          firstjob,
570                                          numjobs,
571                                          level,
572                                          (offered > 0) ? &buffer : NULL,
573                                          offered,
574                                          count,
575                                          info,
576                                          &needed,
577                                          &werror);
578
579         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
580                 offered = needed;
581                 buffer = data_blob_talloc_zero(mem_ctx, needed);
582                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
583
584                 status = rpccli_spoolss_EnumJobs(cli, mem_ctx,
585                                                  handle,
586                                                  firstjob,
587                                                  numjobs,
588                                                  level,
589                                                  (offered > 0) ? &buffer : NULL,
590                                                  offered,
591                                                  count,
592                                                  info,
593                                                  &needed,
594                                                  &werror);
595         }
596
597         return werror;
598 }
599
600 /**********************************************************************
601  convencience wrapper around rpccli_spoolss_EnumPrinterDrivers
602 **********************************************************************/
603
604 WERROR rpccli_spoolss_enumprinterdrivers(struct rpc_pipe_client *cli,
605                                          TALLOC_CTX *mem_ctx,
606                                          const char *server,
607                                          const char *environment,
608                                          uint32_t level,
609                                          uint32_t offered,
610                                          uint32_t *count,
611                                          union spoolss_DriverInfo **info)
612 {
613         NTSTATUS status;
614         WERROR werror;
615         uint32_t needed;
616         DATA_BLOB buffer;
617
618         if (offered > 0) {
619                 buffer = data_blob_talloc_zero(mem_ctx, offered);
620                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
621         }
622
623         status = rpccli_spoolss_EnumPrinterDrivers(cli, mem_ctx,
624                                                    server,
625                                                    environment,
626                                                    level,
627                                                    (offered > 0) ? &buffer : NULL,
628                                                    offered,
629                                                    count,
630                                                    info,
631                                                    &needed,
632                                                    &werror);
633
634         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
635                 offered = needed;
636                 buffer = data_blob_talloc_zero(mem_ctx, needed);
637                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
638
639                 status = rpccli_spoolss_EnumPrinterDrivers(cli, mem_ctx,
640                                                    server,
641                                                    environment,
642                                                    level,
643                                                    (offered > 0) ? &buffer : NULL,
644                                                    offered,
645                                                    count,
646                                                    info,
647                                                    &needed,
648                                                    &werror);
649         }
650
651         return werror;
652 }
653
654 /**********************************************************************
655  convencience wrapper around rpccli_spoolss_EnumPrinters
656 **********************************************************************/
657
658 WERROR rpccli_spoolss_enumprinters(struct rpc_pipe_client *cli,
659                                    TALLOC_CTX *mem_ctx,
660                                    uint32_t flags,
661                                    const char *server,
662                                    uint32_t level,
663                                    uint32_t offered,
664                                    uint32_t *count,
665                                    union spoolss_PrinterInfo **info)
666 {
667         NTSTATUS status;
668         WERROR werror;
669         uint32_t needed;
670         DATA_BLOB buffer;
671
672         if (offered > 0) {
673                 buffer = data_blob_talloc_zero(mem_ctx, offered);
674                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
675         }
676
677         status = rpccli_spoolss_EnumPrinters(cli, mem_ctx,
678                                              flags,
679                                              server,
680                                              level,
681                                              (offered > 0) ? &buffer : NULL,
682                                              offered,
683                                              count,
684                                              info,
685                                              &needed,
686                                              &werror);
687
688         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
689                 offered = needed;
690                 buffer = data_blob_talloc_zero(mem_ctx, needed);
691                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
692
693                 status = rpccli_spoolss_EnumPrinters(cli, mem_ctx,
694                                                      flags,
695                                                      server,
696                                                      level,
697                                                      (offered > 0) ? &buffer : NULL,
698                                                      offered,
699                                                      count,
700                                                      info,
701                                                      &needed,
702                                                      &werror);
703         }
704
705         return werror;
706 }
707
708 /**********************************************************************
709  convencience wrapper around rpccli_spoolss_GetPrinterData
710 **********************************************************************/
711
712 WERROR rpccli_spoolss_getprinterdata(struct rpc_pipe_client *cli,
713                                      TALLOC_CTX *mem_ctx,
714                                      struct policy_handle *handle,
715                                      const char *value_name,
716                                      uint32_t offered,
717                                      enum winreg_Type *type,
718                                      union spoolss_PrinterData *data)
719 {
720         NTSTATUS status;
721         WERROR werror;
722         uint32_t needed;
723
724         status = rpccli_spoolss_GetPrinterData(cli, mem_ctx,
725                                                handle,
726                                                value_name,
727                                                offered,
728                                                type,
729                                                data,
730                                                &needed,
731                                                &werror);
732
733         if (W_ERROR_EQUAL(werror, WERR_MORE_DATA)) {
734                 offered = needed;
735
736                 status = rpccli_spoolss_GetPrinterData(cli, mem_ctx,
737                                                        handle,
738                                                        value_name,
739                                                        offered,
740                                                        type,
741                                                        data,
742                                                        &needed,
743                                                        &werror);
744         }
745
746         return werror;
747 }
748
749 /**********************************************************************
750  convencience wrapper around rpccli_spoolss_EnumPrinterKey
751 **********************************************************************/
752
753 WERROR rpccli_spoolss_enumprinterkey(struct rpc_pipe_client *cli,
754                                      TALLOC_CTX *mem_ctx,
755                                      struct policy_handle *handle,
756                                      const char *key_name,
757                                      const char ***key_buffer,
758                                      uint32_t offered)
759 {
760         NTSTATUS status;
761         WERROR werror;
762         uint32_t needed;
763
764         status = rpccli_spoolss_EnumPrinterKey(cli, mem_ctx,
765                                                handle,
766                                                key_name,
767                                                key_buffer,
768                                                offered,
769                                                &needed,
770                                                &werror);
771
772         if (W_ERROR_EQUAL(werror, WERR_MORE_DATA)) {
773                 offered = needed;
774
775                 status = rpccli_spoolss_EnumPrinterKey(cli, mem_ctx,
776                                                        handle,
777                                                        key_name,
778                                                        key_buffer,
779                                                        offered,
780                                                        &needed,
781                                                        &werror);
782         }
783
784         return werror;
785 }
786
787 /**********************************************************************
788  convencience wrapper around rpccli_spoolss_EnumPrinterDataEx
789 **********************************************************************/
790
791 WERROR rpccli_spoolss_enumprinterdataex(struct rpc_pipe_client *cli,
792                                         TALLOC_CTX *mem_ctx,
793                                         struct policy_handle *handle,
794                                         const char *key_name,
795                                         uint32_t offered,
796                                         uint32_t *count,
797                                         struct spoolss_PrinterEnumValues **info)
798 {
799         NTSTATUS status;
800         WERROR werror;
801         uint32_t needed;
802
803         status = rpccli_spoolss_EnumPrinterDataEx(cli, mem_ctx,
804                                                   handle,
805                                                   key_name,
806                                                   offered,
807                                                   count,
808                                                   info,
809                                                   &needed,
810                                                   &werror);
811
812         if (W_ERROR_EQUAL(werror, WERR_MORE_DATA)) {
813                 offered = needed;
814
815                 status = rpccli_spoolss_EnumPrinterDataEx(cli, mem_ctx,
816                                                           handle,
817                                                           key_name,
818                                                           offered,
819                                                           count,
820                                                           info,
821                                                           &needed,
822                                                           &werror);
823         }
824
825         return werror;
826 }