LCOV - code coverage report
Current view: top level - source3/rpc_client - cli_spoolss.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 0 262 0.0 %
Date: 2021-09-23 10:06:22 Functions: 0 17 0.0 %

          Line data    Source code
       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           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
      49           0 :         struct cli_credentials *creds = gensec_get_credentials(cli->auth->auth_ctx);
      50             : 
      51           0 :         ZERO_STRUCT(devmode_ctr);
      52             : 
      53           0 :         werror = spoolss_init_spoolss_UserLevel1(mem_ctx,
      54             :                                                  cli_credentials_get_username(creds),
      55             :                                                  &level1);
      56           0 :         if (!W_ERROR_IS_OK(werror)) {
      57           0 :                 return werror;
      58             :         }
      59             : 
      60           0 :         userlevel_ctr.level = 1;
      61           0 :         userlevel_ctr.user_info.level1 = &level1;
      62             : 
      63           0 :         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           0 :         if (!NT_STATUS_IS_OK(status)) {
      73           0 :                 return ntstatus_to_werror(status);
      74             :         }
      75             : 
      76           0 :         if (!W_ERROR_IS_OK(werror)) {
      77           0 :                 return werror;
      78             :         }
      79             : 
      80           0 :         return WERR_OK;
      81             : }
      82             : 
      83             : /**********************************************************************
      84             :  convencience wrapper around rpccli_spoolss_GetPrinterDriver
      85             : **********************************************************************/
      86             : 
      87           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     100             : 
     101           0 :         if (offered > 0) {
     102           0 :                 buffer = data_blob_talloc_zero(mem_ctx, offered);
     103           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     104             :         }
     105             : 
     106           0 :         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           0 :         if (!NT_STATUS_IS_OK(status)) {
     116           0 :                 return ntstatus_to_werror(status);
     117             :         }
     118           0 :         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
     119           0 :                 offered = needed;
     120           0 :                 buffer = data_blob_talloc_zero(mem_ctx, needed);
     121           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     122             : 
     123           0 :                 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           0 :         if (!NT_STATUS_IS_OK(status)) {
     134           0 :                 return ntstatus_to_werror(status);
     135             :         }
     136             : 
     137           0 :         return werror;
     138             : }
     139             : 
     140             : /**********************************************************************
     141             :  convencience wrapper around rpccli_spoolss_GetPrinterDriver2
     142             : **********************************************************************/
     143             : 
     144           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     161             : 
     162           0 :         if (offered > 0) {
     163           0 :                 buffer = data_blob_talloc_zero(mem_ctx, offered);
     164           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     165             :         }
     166             : 
     167           0 :         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           0 :         if (!NT_STATUS_IS_OK(status)) {
     181           0 :                 return ntstatus_to_werror(status);
     182             :         }
     183             : 
     184           0 :         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
     185           0 :                 offered = needed;
     186           0 :                 buffer = data_blob_talloc_zero(mem_ctx, needed);
     187           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     188             : 
     189           0 :                 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           0 :         if (!NT_STATUS_IS_OK(status)) {
     204           0 :                 return ntstatus_to_werror(status);
     205             :         }
     206             : 
     207           0 :         return werror;
     208             : }
     209             : 
     210             : /**********************************************************************
     211             :  convencience wrapper around rpccli_spoolss_AddPrinterEx
     212             : **********************************************************************/
     213             : 
     214           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     226           0 :         struct cli_credentials *creds = gensec_get_credentials(cli->auth->auth_ctx);
     227             : 
     228           0 :         ZERO_STRUCT(devmode_ctr);
     229           0 :         ZERO_STRUCT(secdesc_ctr);
     230             : 
     231           0 :         result = spoolss_init_spoolss_UserLevel1(mem_ctx,
     232             :                                                  cli_credentials_get_username(creds),
     233             :                                                  &level1);
     234           0 :         if (!W_ERROR_IS_OK(result)) {
     235           0 :                 return result;
     236             :         }
     237             : 
     238           0 :         userlevel_ctr.level = 1;
     239           0 :         userlevel_ctr.user_info.level1 = &level1;
     240             : 
     241           0 :         status = dcerpc_spoolss_AddPrinterEx(b, mem_ctx,
     242           0 :                                              cli->srv_name_slash,
     243             :                                              info_ctr,
     244             :                                              &devmode_ctr,
     245             :                                              &secdesc_ctr,
     246             :                                              &userlevel_ctr,
     247             :                                              &handle,
     248             :                                              &result);
     249           0 :         if (!NT_STATUS_IS_OK(status)) {
     250           0 :                 return ntstatus_to_werror(status);
     251             :         }
     252             : 
     253           0 :         return result;
     254             : }
     255             : 
     256             : /**********************************************************************
     257             :  convencience wrapper around rpccli_spoolss_GetPrinter
     258             : **********************************************************************/
     259             : 
     260           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     272             : 
     273           0 :         if (offered > 0) {
     274           0 :                 buffer = data_blob_talloc_zero(mem_ctx, offered);
     275           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     276             :         }
     277             : 
     278           0 :         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           0 :         if (!NT_STATUS_IS_OK(status)) {
     287           0 :                 return ntstatus_to_werror(status);
     288             :         }
     289             : 
     290           0 :         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
     291             : 
     292           0 :                 offered = needed;
     293           0 :                 buffer = data_blob_talloc_zero(mem_ctx, offered);
     294           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     295             : 
     296           0 :                 status = dcerpc_spoolss_GetPrinter(b, mem_ctx,
     297             :                                                    handle,
     298             :                                                    level,
     299             :                                                    &buffer,
     300             :                                                    offered,
     301             :                                                    info,
     302             :                                                    &needed,
     303             :                                                    &werror);
     304             :         }
     305           0 :         if (!NT_STATUS_IS_OK(status)) {
     306           0 :                 return ntstatus_to_werror(status);
     307             :         }
     308             : 
     309           0 :         return werror;
     310             : }
     311             : 
     312             : /**********************************************************************
     313             :  convencience wrapper around rpccli_spoolss_GetJob
     314             : **********************************************************************/
     315             : 
     316           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     329             : 
     330           0 :         if (offered > 0) {
     331           0 :                 buffer = data_blob_talloc_zero(mem_ctx, offered);
     332           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     333             :         }
     334             : 
     335           0 :         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           0 :         if (!NT_STATUS_IS_OK(status)) {
     345           0 :                 return ntstatus_to_werror(status);
     346             :         }
     347             : 
     348           0 :         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
     349           0 :                 offered = needed;
     350           0 :                 buffer = data_blob_talloc_zero(mem_ctx, needed);
     351           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     352             : 
     353           0 :                 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           0 :         if (!NT_STATUS_IS_OK(status)) {
     364           0 :                 return ntstatus_to_werror(status);
     365             :         }
     366             : 
     367           0 :         return werror;
     368             : }
     369             : 
     370             : /**********************************************************************
     371             :  convencience wrapper around rpccli_spoolss_EnumForms
     372             : **********************************************************************/
     373             : 
     374           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     387             : 
     388           0 :         if (offered > 0) {
     389           0 :                 buffer = data_blob_talloc_zero(mem_ctx, offered);
     390           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     391             :         }
     392             : 
     393           0 :         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           0 :         if (!NT_STATUS_IS_OK(status)) {
     403           0 :                 return ntstatus_to_werror(status);
     404             :         }
     405             : 
     406           0 :         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
     407           0 :                 offered = needed;
     408           0 :                 buffer = data_blob_talloc_zero(mem_ctx, needed);
     409           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     410             : 
     411           0 :                 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           0 :         if (!NT_STATUS_IS_OK(status)) {
     422           0 :                 return ntstatus_to_werror(status);
     423             :         }
     424             : 
     425           0 :         return werror;
     426             : }
     427             : 
     428             : /**********************************************************************
     429             :  convencience wrapper around rpccli_spoolss_EnumPrintProcessors
     430             : **********************************************************************/
     431             : 
     432           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     446             : 
     447           0 :         if (offered > 0) {
     448           0 :                 buffer = data_blob_talloc_zero(mem_ctx, offered);
     449           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     450             :         }
     451             : 
     452           0 :         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           0 :         if (!NT_STATUS_IS_OK(status)) {
     463           0 :                 return ntstatus_to_werror(status);
     464             :         }
     465             : 
     466           0 :         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
     467           0 :                 offered = needed;
     468           0 :                 buffer = data_blob_talloc_zero(mem_ctx, needed);
     469           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     470             : 
     471           0 :                 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           0 :         if (!NT_STATUS_IS_OK(status)) {
     483           0 :                 return ntstatus_to_werror(status);
     484             :         }
     485             : 
     486           0 :         return werror;
     487             : }
     488             : 
     489             : /**********************************************************************
     490             :  convencience wrapper around rpccli_spoolss_EnumPrintProcessorDataTypes
     491             : **********************************************************************/
     492             : 
     493           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     507             : 
     508           0 :         if (offered > 0) {
     509           0 :                 buffer = data_blob_talloc_zero(mem_ctx, offered);
     510           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     511             :         }
     512             : 
     513           0 :         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           0 :         if (!NT_STATUS_IS_OK(status)) {
     524           0 :                 return ntstatus_to_werror(status);
     525             :         }
     526             : 
     527           0 :         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
     528           0 :                 offered = needed;
     529           0 :                 buffer = data_blob_talloc_zero(mem_ctx, needed);
     530           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     531             : 
     532           0 :                 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           0 :         if (!NT_STATUS_IS_OK(status)) {
     544           0 :                 return ntstatus_to_werror(status);
     545             :         }
     546             : 
     547           0 :         return werror;
     548             : }
     549             : 
     550             : /**********************************************************************
     551             :  convencience wrapper around rpccli_spoolss_EnumPorts
     552             : **********************************************************************/
     553             : 
     554           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     567             : 
     568           0 :         if (offered > 0) {
     569           0 :                 buffer = data_blob_talloc_zero(mem_ctx, offered);
     570           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     571             :         }
     572             : 
     573           0 :         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           0 :         if (!NT_STATUS_IS_OK(status)) {
     583           0 :                 return ntstatus_to_werror(status);
     584             :         }
     585             : 
     586           0 :         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
     587           0 :                 offered = needed;
     588           0 :                 buffer = data_blob_talloc_zero(mem_ctx, needed);
     589           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     590             : 
     591           0 :                 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           0 :         if (!NT_STATUS_IS_OK(status)) {
     602           0 :                 return ntstatus_to_werror(status);
     603             :         }
     604             : 
     605           0 :         return werror;
     606             : }
     607             : 
     608             : /**********************************************************************
     609             :  convencience wrapper around rpccli_spoolss_EnumMonitors
     610             : **********************************************************************/
     611             : 
     612           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     625             : 
     626           0 :         if (offered > 0) {
     627           0 :                 buffer = data_blob_talloc_zero(mem_ctx, offered);
     628           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     629             :         }
     630             : 
     631           0 :         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           0 :         if (!NT_STATUS_IS_OK(status)) {
     641           0 :                 return ntstatus_to_werror(status);
     642             :         }
     643             : 
     644           0 :         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
     645           0 :                 offered = needed;
     646           0 :                 buffer = data_blob_talloc_zero(mem_ctx, needed);
     647           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     648             : 
     649           0 :                 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           0 :         if (!NT_STATUS_IS_OK(status)) {
     660           0 :                 return ntstatus_to_werror(status);
     661             :         }
     662             : 
     663           0 :         return werror;
     664             : }
     665             : 
     666             : /**********************************************************************
     667             :  convencience wrapper around rpccli_spoolss_EnumJobs
     668             : **********************************************************************/
     669             : 
     670           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     685             : 
     686           0 :         if (offered > 0) {
     687           0 :                 buffer = data_blob_talloc_zero(mem_ctx, offered);
     688           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     689             :         }
     690             : 
     691           0 :         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           0 :         if (!NT_STATUS_IS_OK(status)) {
     703           0 :                 return ntstatus_to_werror(status);
     704             :         }
     705             : 
     706           0 :         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
     707           0 :                 offered = needed;
     708           0 :                 buffer = data_blob_talloc_zero(mem_ctx, needed);
     709           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     710             : 
     711           0 :                 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           0 :         if (!NT_STATUS_IS_OK(status)) {
     724           0 :                 return ntstatus_to_werror(status);
     725             :         }
     726             : 
     727           0 :         return werror;
     728             : }
     729             : 
     730             : /**********************************************************************
     731             :  convencience wrapper around rpccli_spoolss_EnumPrinterDrivers
     732             : **********************************************************************/
     733             : 
     734           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     748             : 
     749           0 :         if (offered > 0) {
     750           0 :                 buffer = data_blob_talloc_zero(mem_ctx, offered);
     751           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     752             :         }
     753             : 
     754           0 :         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           0 :         if (!NT_STATUS_IS_OK(status)) {
     765           0 :                 return ntstatus_to_werror(status);
     766             :         }
     767             : 
     768           0 :         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
     769           0 :                 offered = needed;
     770           0 :                 buffer = data_blob_talloc_zero(mem_ctx, needed);
     771           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     772             : 
     773           0 :                 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           0 :         if (!NT_STATUS_IS_OK(status)) {
     785           0 :                 return ntstatus_to_werror(status);
     786             :         }
     787             : 
     788           0 :         return werror;
     789             : }
     790             : 
     791             : /**********************************************************************
     792             :  convencience wrapper around rpccli_spoolss_EnumPrinters
     793             : **********************************************************************/
     794             : 
     795           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     809             : 
     810           0 :         if (offered > 0) {
     811           0 :                 buffer = data_blob_talloc_zero(mem_ctx, offered);
     812           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     813             :         }
     814             : 
     815           0 :         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           0 :         if (!NT_STATUS_IS_OK(status)) {
     826           0 :                 return ntstatus_to_werror(status);
     827             :         }
     828             : 
     829           0 :         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
     830           0 :                 offered = needed;
     831           0 :                 buffer = data_blob_talloc_zero(mem_ctx, needed);
     832           0 :                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
     833             : 
     834           0 :                 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           0 :         if (!NT_STATUS_IS_OK(status)) {
     846           0 :                 return ntstatus_to_werror(status);
     847             :         }
     848             : 
     849           0 :         return werror;
     850             : }
     851             : 
     852             : /**********************************************************************
     853             :  convencience wrapper around rpccli_spoolss_GetPrinterData
     854             : **********************************************************************/
     855             : 
     856           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     870             : 
     871           0 :         data = talloc_zero_array(mem_ctx, uint8_t, offered);
     872           0 :         W_ERROR_HAVE_NO_MEMORY(data);
     873             : 
     874           0 :         status = dcerpc_spoolss_GetPrinterData(b, mem_ctx,
     875             :                                                handle,
     876             :                                                value_name,
     877             :                                                type,
     878             :                                                data,
     879             :                                                offered,
     880             :                                                &needed,
     881             :                                                &werror);
     882           0 :         if (!NT_STATUS_IS_OK(status)) {
     883           0 :                 return ntstatus_to_werror(status);
     884             :         }
     885             : 
     886           0 :         if (W_ERROR_EQUAL(werror, WERR_MORE_DATA)) {
     887           0 :                 offered = needed;
     888           0 :                 data = talloc_zero_array(mem_ctx, uint8_t, offered);
     889           0 :                 W_ERROR_HAVE_NO_MEMORY(data);
     890             : 
     891           0 :                 status = dcerpc_spoolss_GetPrinterData(b, mem_ctx,
     892             :                                                        handle,
     893             :                                                        value_name,
     894             :                                                        type,
     895             :                                                        data,
     896             :                                                        offered,
     897             :                                                        &needed,
     898             :                                                        &werror);
     899             :         }
     900           0 :         if (!NT_STATUS_IS_OK(status)) {
     901           0 :                 return ntstatus_to_werror(status);
     902             :         }
     903             : 
     904           0 :         *data_p = data;
     905           0 :         *needed_p = needed;
     906             : 
     907           0 :         return werror;
     908             : }
     909             : 
     910             : /**********************************************************************
     911             :  convencience wrapper around rpccli_spoolss_EnumPrinterKey
     912             : **********************************************************************/
     913             : 
     914           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     927             : 
     928           0 :         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           0 :         if (!NT_STATUS_IS_OK(status)) {
     937           0 :                 return ntstatus_to_werror(status);
     938             :         }
     939             : 
     940           0 :         if (W_ERROR_EQUAL(werror, WERR_MORE_DATA)) {
     941           0 :                 offered = needed;
     942           0 :                 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           0 :         if (!NT_STATUS_IS_OK(status)) {
     952           0 :                 return ntstatus_to_werror(status);
     953             :         }
     954             : 
     955           0 :         *key_buffer = _key_buffer.string_array;
     956             : 
     957           0 :         return werror;
     958             : }
     959             : 
     960             : /**********************************************************************
     961             :  convencience wrapper around rpccli_spoolss_EnumPrinterDataEx
     962             : **********************************************************************/
     963             : 
     964           0 : 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           0 :         struct dcerpc_binding_handle *b = cli->binding_handle;
     976             : 
     977           0 :         status = dcerpc_spoolss_EnumPrinterDataEx(b, mem_ctx,
     978             :                                                   handle,
     979             :                                                   key_name,
     980             :                                                   offered,
     981             :                                                   count,
     982             :                                                   info,
     983             :                                                   &needed,
     984             :                                                   &werror);
     985           0 :         if (!NT_STATUS_IS_OK(status)) {
     986           0 :                 return ntstatus_to_werror(status);
     987             :         }
     988             : 
     989           0 :         if (W_ERROR_EQUAL(werror, WERR_MORE_DATA)) {
     990           0 :                 offered = needed;
     991             : 
     992           0 :                 status = dcerpc_spoolss_EnumPrinterDataEx(b, mem_ctx,
     993             :                                                           handle,
     994             :                                                           key_name,
     995             :                                                           offered,
     996             :                                                           count,
     997             :                                                           info,
     998             :                                                           &needed,
     999             :                                                           &werror);
    1000             :         }
    1001           0 :         if (!NT_STATUS_IS_OK(status)) {
    1002           0 :                 return ntstatus_to_werror(status);
    1003             :         }
    1004             : 
    1005           0 :         return werror;
    1006             : }

Generated by: LCOV version 1.13