From 935a551d25562c6459e6f6d7788539fc7849edfe Mon Sep 17 00:00:00 2001 From: Günther Deschner Date: Sat, 14 Feb 2009 01:19:07 +0100 Subject: s3: re-run make samba3-idl. Guenther --- librpc/gen_ndr/cli_spoolss.c | 28 +- librpc/gen_ndr/cli_spoolss.h | 17 +- librpc/gen_ndr/ndr_spoolss.c | 2093 ++++++++++++++++++++++++++++++++++++------ librpc/gen_ndr/ndr_spoolss.h | 16 + librpc/gen_ndr/spoolss.h | 258 +++++- 5 files changed, 2085 insertions(+), 327 deletions(-) (limited to 'librpc') diff --git a/librpc/gen_ndr/cli_spoolss.c b/librpc/gen_ndr/cli_spoolss.c index b8836f47ae..318e4e35ea 100644 --- a/librpc/gen_ndr/cli_spoolss.c +++ b/librpc/gen_ndr/cli_spoolss.c @@ -370,10 +370,9 @@ NTSTATUS rpccli_spoolss_DeletePrinter(struct rpc_pipe_client *cli, NTSTATUS rpccli_spoolss_SetPrinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, - uint32_t level /* [in] */, - union spoolss_SetPrinterInfo info /* [in] [switch_is(level)] */, - struct spoolss_DevmodeContainer devmode_ctr /* [in] */, - struct sec_desc_buf secdesc_ctr /* [in] */, + struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */, + struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */, + struct sec_desc_buf *secdesc_ctr /* [in] [ref] */, enum spoolss_PrinterControl command /* [in] */, WERROR *werror) { @@ -382,8 +381,7 @@ NTSTATUS rpccli_spoolss_SetPrinter(struct rpc_pipe_client *cli, /* In parameters */ r.in.handle = handle; - r.in.level = level; - r.in.info = info; + r.in.info_ctr = info_ctr; r.in.devmode_ctr = devmode_ctr; r.in.secdesc_ctr = secdesc_ctr; r.in.command = command; @@ -3308,12 +3306,10 @@ NTSTATUS rpccli_spoolss_OpenPrinterEx(struct rpc_pipe_client *cli, NTSTATUS rpccli_spoolss_AddPrinterEx(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server /* [in] [unique,charset(UTF16)] */, - uint32_t level /* [in] */, - union spoolss_PrinterInfo *info /* [in] [unique,switch_is(level)] */, - struct spoolss_DevmodeContainer devmode_ctr /* [in] */, - struct security_descriptor *secdesc /* [in] [unique] */, - uint32_t ulevel /* [in] */, - union spoolss_UserLevel userlevel /* [in] [switch_is(ulevel)] */, + struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */, + struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */, + struct sec_desc_buf *secdesc_ctr /* [in] [ref] */, + struct spoolss_UserLevelCtr *userlevel_ctr /* [in] [ref] */, struct policy_handle *handle /* [out] [ref] */, WERROR *werror) { @@ -3322,12 +3318,10 @@ NTSTATUS rpccli_spoolss_AddPrinterEx(struct rpc_pipe_client *cli, /* In parameters */ r.in.server = server; - r.in.level = level; - r.in.info = info; + r.in.info_ctr = info_ctr; r.in.devmode_ctr = devmode_ctr; - r.in.secdesc = secdesc; - r.in.ulevel = ulevel; - r.in.userlevel = userlevel; + r.in.secdesc_ctr = secdesc_ctr; + r.in.userlevel_ctr = userlevel_ctr; if (DEBUGLEVEL >= 10) { NDR_PRINT_IN_DEBUG(spoolss_AddPrinterEx, &r); diff --git a/librpc/gen_ndr/cli_spoolss.h b/librpc/gen_ndr/cli_spoolss.h index 243de024d1..0859d8d017 100644 --- a/librpc/gen_ndr/cli_spoolss.h +++ b/librpc/gen_ndr/cli_spoolss.h @@ -59,10 +59,9 @@ NTSTATUS rpccli_spoolss_DeletePrinter(struct rpc_pipe_client *cli, NTSTATUS rpccli_spoolss_SetPrinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, - uint32_t level /* [in] */, - union spoolss_SetPrinterInfo info /* [in] [switch_is(level)] */, - struct spoolss_DevmodeContainer devmode_ctr /* [in] */, - struct sec_desc_buf secdesc_ctr /* [in] */, + struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */, + struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */, + struct sec_desc_buf *secdesc_ctr /* [in] [ref] */, enum spoolss_PrinterControl command /* [in] */, WERROR *werror); NTSTATUS rpccli_spoolss_GetPrinter(struct rpc_pipe_client *cli, @@ -414,12 +413,10 @@ NTSTATUS rpccli_spoolss_OpenPrinterEx(struct rpc_pipe_client *cli, NTSTATUS rpccli_spoolss_AddPrinterEx(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server /* [in] [unique,charset(UTF16)] */, - uint32_t level /* [in] */, - union spoolss_PrinterInfo *info /* [in] [unique,switch_is(level)] */, - struct spoolss_DevmodeContainer devmode_ctr /* [in] */, - struct security_descriptor *secdesc /* [in] [unique] */, - uint32_t ulevel /* [in] */, - union spoolss_UserLevel userlevel /* [in] [switch_is(ulevel)] */, + struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */, + struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */, + struct sec_desc_buf *secdesc_ctr /* [in] [ref] */, + struct spoolss_UserLevelCtr *userlevel_ctr /* [in] [ref] */, struct policy_handle *handle /* [out] [ref] */, WERROR *werror); NTSTATUS rpccli_spoolss_47(struct rpc_pipe_client *cli, diff --git a/librpc/gen_ndr/ndr_spoolss.c b/librpc/gen_ndr/ndr_spoolss.c index f99fd54c83..1e4b5aa457 100644 --- a/librpc/gen_ndr/ndr_spoolss.c +++ b/librpc/gen_ndr/ndr_spoolss.c @@ -116,6 +116,114 @@ _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, ndr->depth--; } +static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r) +{ + NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r)); + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r) +{ + uint16_t v; + NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v)); + *r = v; + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r) +{ + const char *val = NULL; + + switch (r) { + case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break; + case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break; + case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break; + } + ndr_print_enum(ndr, name, "ENUM", val, r); +} + +static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r) +{ + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r)); + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r) +{ + uint32_t v; + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v)); + *r = v; + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r) +{ + const char *val = NULL; + + switch (r) { + case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break; + case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break; + case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break; + case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break; + case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break; + } + ndr_print_enum(ndr, name, "ENUM", val, r); +} + +static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r) +{ + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r)); + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r) +{ + uint32_t v; + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v)); + *r = v; + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r) +{ + const char *val = NULL; + + switch (r) { + case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break; + case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break; + case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break; + } + ndr_print_enum(ndr, name, "ENUM", val, r); +} + +static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r) +{ + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r)); + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r) +{ + uint32_t v; + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v)); + *r = v; + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r) +{ + const char *val = NULL; + + switch (r) { + case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break; + case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break; + case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break; + case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break; + case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break; + } + ndr_print_enum(ndr, name, "ENUM", val, r); +} + static enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r) { if (ndr_flags & NDR_SCALARS) { @@ -139,26 +247,26 @@ static enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter)); NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages)); NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown10)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown11)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown12)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling)); NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown14)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_errors)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown16)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown17)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown18)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown19)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors)); + NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes)); NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown21)); + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error)); NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown23)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers)); NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter)); - NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown25)); - NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown26)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown27)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown28)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown29)); + NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture)); + NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3)); } if (ndr_flags & NDR_BUFFERS) { { @@ -222,26 +330,26 @@ static enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter)); NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages)); NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown10)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown11)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown12)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling)); NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown14)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_errors)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown16)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown17)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown18)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown19)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors)); + NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes)); NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown21)); + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error)); NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown23)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers)); NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter)); - NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown25)); - NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown26)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown27)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown28)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown29)); + NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture)); + NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3)); } if (ndr_flags & NDR_BUFFERS) { { @@ -301,26 +409,26 @@ _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char * ndr_print_uint32(ndr, "global_counter", r->global_counter); ndr_print_uint32(ndr, "total_pages", r->total_pages); ndr_print_uint32(ndr, "version", r->version); - ndr_print_uint32(ndr, "unknown10", r->unknown10); - ndr_print_uint32(ndr, "unknown11", r->unknown11); - ndr_print_uint32(ndr, "unknown12", r->unknown12); + ndr_print_uint32(ndr, "free_build", r->free_build); + ndr_print_uint32(ndr, "spooling", r->spooling); + ndr_print_uint32(ndr, "max_spooling", r->max_spooling); ndr_print_uint32(ndr, "session_counter", r->session_counter); - ndr_print_uint32(ndr, "unknown14", r->unknown14); - ndr_print_uint32(ndr, "printer_errors", r->printer_errors); - ndr_print_uint32(ndr, "unknown16", r->unknown16); - ndr_print_uint32(ndr, "unknown17", r->unknown17); - ndr_print_uint32(ndr, "unknown18", r->unknown18); - ndr_print_uint32(ndr, "unknown19", r->unknown19); + ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper); + ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready); + ndr_print_uint32(ndr, "job_error", r->job_error); + ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors); + ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type); + ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes); ndr_print_uint32(ndr, "change_id", r->change_id); - ndr_print_uint32(ndr, "unknown21", r->unknown21); + ndr_print_WERROR(ndr, "last_error", r->last_error); ndr_print_uint32(ndr, "status", r->status); - ndr_print_uint32(ndr, "unknown23", r->unknown23); + ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers); ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter); - ndr_print_uint16(ndr, "unknown25", r->unknown25); - ndr_print_uint16(ndr, "unknown26", r->unknown26); - ndr_print_uint32(ndr, "unknown27", r->unknown27); - ndr_print_uint32(ndr, "unknown28", r->unknown28); - ndr_print_uint32(ndr, "unknown29", r->unknown29); + ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture); + ndr_print_uint16(ndr, "processor_level", r->processor_level); + ndr_print_uint32(ndr, "ref_ic", r->ref_ic); + ndr_print_uint32(ndr, "reserved2", r->reserved2); + ndr_print_uint32(ndr, "reserved3", r->reserved3); ndr->depth--; } @@ -2956,18 +3064,1145 @@ static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, i return NDR_ERR_SUCCESS; } -_PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r) +_PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r) +{ + const char *val = NULL; + + switch (r) { + case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break; + case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break; + case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break; + case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break; + case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break; + } + ndr_print_enum(ndr, name, "ENUM", val, r); +} + +static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes)); + NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors)); + NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id)); + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter)); + NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture)); + NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3)); + } + if (ndr_flags & NDR_BUFFERS) { + if (r->servername) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->printername) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r) +{ + uint32_t _ptr_servername; + TALLOC_CTX *_mem_save_servername_0; + uint32_t _ptr_printername; + TALLOC_CTX *_mem_save_printername_0; + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername)); + if (_ptr_servername) { + NDR_PULL_ALLOC(ndr, r->servername); + } else { + r->servername = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername)); + if (_ptr_printername) { + NDR_PULL_ALLOC(ndr, r->printername); + } else { + r->printername = NULL; + } + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes)); + NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors)); + NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id)); + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter)); + NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture)); + NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3)); + } + if (ndr_flags & NDR_BUFFERS) { + if (r->servername) { + _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->servername)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->servername)); + if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0); + } + if (r->printername) { + _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->printername)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->printername)); + if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r) +{ + ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0"); + ndr->depth++; + ndr_print_ptr(ndr, "servername", r->servername); + ndr->depth++; + if (r->servername) { + ndr_print_string(ndr, "servername", r->servername); + } + ndr->depth--; + ndr_print_ptr(ndr, "printername", r->printername); + ndr->depth++; + if (r->printername) { + ndr_print_string(ndr, "printername", r->printername); + } + ndr->depth--; + ndr_print_uint32(ndr, "cjobs", r->cjobs); + ndr_print_uint32(ndr, "total_jobs", r->total_jobs); + ndr_print_uint32(ndr, "total_bytes", r->total_bytes); + ndr_print_spoolss_Time(ndr, "time", &r->time); + ndr_print_uint32(ndr, "global_counter", r->global_counter); + ndr_print_uint32(ndr, "total_pages", r->total_pages); + ndr_print_uint32(ndr, "version", r->version); + ndr_print_uint32(ndr, "free_build", r->free_build); + ndr_print_uint32(ndr, "spooling", r->spooling); + ndr_print_uint32(ndr, "max_spooling", r->max_spooling); + ndr_print_uint32(ndr, "session_counter", r->session_counter); + ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper); + ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready); + ndr_print_uint32(ndr, "job_error", r->job_error); + ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors); + ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type); + ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes); + ndr_print_uint32(ndr, "change_id", r->change_id); + ndr_print_WERROR(ndr, "last_error", r->last_error); + ndr_print_uint32(ndr, "status", r->status); + ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers); + ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter); + ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture); + ndr_print_uint16(ndr, "processor_level", r->processor_level); + ndr_print_uint32(ndr, "ref_ic", r->ref_ic); + ndr_print_uint32(ndr, "reserved2", r->reserved2); + ndr_print_uint32(ndr, "reserved3", r->reserved3); + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->name)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->description)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment)); + } + if (ndr_flags & NDR_BUFFERS) { + if (r->name) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->description) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->comment) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r) +{ + uint32_t _ptr_name; + TALLOC_CTX *_mem_save_name_0; + uint32_t _ptr_description; + TALLOC_CTX *_mem_save_description_0; + uint32_t _ptr_comment; + TALLOC_CTX *_mem_save_comment_0; + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags)); + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name)); + if (_ptr_name) { + NDR_PULL_ALLOC(ndr, r->name); + } else { + r->name = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description)); + if (_ptr_description) { + NDR_PULL_ALLOC(ndr, r->description); + } else { + r->description = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment)); + if (_ptr_comment) { + NDR_PULL_ALLOC(ndr, r->comment); + } else { + r->comment = NULL; + } + } + if (ndr_flags & NDR_BUFFERS) { + if (r->name) { + _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->name, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->name)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->name)); + if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0); + } + if (r->description) { + _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->description, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->description)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->description)); + if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->description), ndr_get_array_length(ndr, &r->description)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0); + } + if (r->comment) { + _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->comment)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->comment)); + if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r) +{ + ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1"); + ndr->depth++; + ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags); + ndr_print_ptr(ndr, "name", r->name); + ndr->depth++; + if (r->name) { + ndr_print_string(ndr, "name", r->name); + } + ndr->depth--; + ndr_print_ptr(ndr, "description", r->description); + ndr->depth++; + if (r->description) { + ndr_print_string(ndr, "description", r->description); + } + ndr->depth--; + ndr_print_ptr(ndr, "comment", r->comment); + ndr->depth++; + if (r->comment) { + ndr_print_string(ndr, "comment", r->comment); + } + ndr->depth--; + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->location)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc)); + NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime)); + NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm)); + } + if (ndr_flags & NDR_BUFFERS) { + if (r->servername) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->printername) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->sharename) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->portname) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->drivername) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->comment) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->location) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->devmode) { + { + struct ndr_push *_ndr_devmode; + NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1)); + NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode)); + NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1)); + } + } + if (r->sepfile) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->printprocessor) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->datatype) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->parameters) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->secdesc) { + { + struct ndr_push *_ndr_secdesc; + NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1)); + NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc)); + NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1)); + } + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r) +{ + uint32_t _ptr_servername; + TALLOC_CTX *_mem_save_servername_0; + uint32_t _ptr_printername; + TALLOC_CTX *_mem_save_printername_0; + uint32_t _ptr_sharename; + TALLOC_CTX *_mem_save_sharename_0; + uint32_t _ptr_portname; + TALLOC_CTX *_mem_save_portname_0; + uint32_t _ptr_drivername; + TALLOC_CTX *_mem_save_drivername_0; + uint32_t _ptr_comment; + TALLOC_CTX *_mem_save_comment_0; + uint32_t _ptr_location; + TALLOC_CTX *_mem_save_location_0; + uint32_t _ptr_devmode; + TALLOC_CTX *_mem_save_devmode_0; + uint32_t _ptr_sepfile; + TALLOC_CTX *_mem_save_sepfile_0; + uint32_t _ptr_printprocessor; + TALLOC_CTX *_mem_save_printprocessor_0; + uint32_t _ptr_datatype; + TALLOC_CTX *_mem_save_datatype_0; + uint32_t _ptr_parameters; + TALLOC_CTX *_mem_save_parameters_0; + uint32_t _ptr_secdesc; + TALLOC_CTX *_mem_save_secdesc_0; + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername)); + if (_ptr_servername) { + NDR_PULL_ALLOC(ndr, r->servername); + } else { + r->servername = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername)); + if (_ptr_printername) { + NDR_PULL_ALLOC(ndr, r->printername); + } else { + r->printername = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename)); + if (_ptr_sharename) { + NDR_PULL_ALLOC(ndr, r->sharename); + } else { + r->sharename = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname)); + if (_ptr_portname) { + NDR_PULL_ALLOC(ndr, r->portname); + } else { + r->portname = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername)); + if (_ptr_drivername) { + NDR_PULL_ALLOC(ndr, r->drivername); + } else { + r->drivername = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment)); + if (_ptr_comment) { + NDR_PULL_ALLOC(ndr, r->comment); + } else { + r->comment = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location)); + if (_ptr_location) { + NDR_PULL_ALLOC(ndr, r->location); + } else { + r->location = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode)); + if (_ptr_devmode) { + NDR_PULL_ALLOC(ndr, r->devmode); + } else { + r->devmode = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile)); + if (_ptr_sepfile) { + NDR_PULL_ALLOC(ndr, r->sepfile); + } else { + r->sepfile = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor)); + if (_ptr_printprocessor) { + NDR_PULL_ALLOC(ndr, r->printprocessor); + } else { + r->printprocessor = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype)); + if (_ptr_datatype) { + NDR_PULL_ALLOC(ndr, r->datatype); + } else { + r->datatype = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters)); + if (_ptr_parameters) { + NDR_PULL_ALLOC(ndr, r->parameters); + } else { + r->parameters = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc)); + if (_ptr_secdesc) { + NDR_PULL_ALLOC(ndr, r->secdesc); + } else { + r->secdesc = NULL; + } + NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime)); + NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm)); + } + if (ndr_flags & NDR_BUFFERS) { + if (r->servername) { + _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->servername)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->servername)); + if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0); + } + if (r->printername) { + _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->printername)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->printername)); + if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0); + } + if (r->sharename) { + _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename)); + if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0); + } + if (r->portname) { + _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->portname)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->portname)); + if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0); + } + if (r->drivername) { + _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername)); + if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0); + } + if (r->comment) { + _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->comment)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->comment)); + if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0); + } + if (r->location) { + _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->location, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->location)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->location)); + if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->location), ndr_get_array_length(ndr, &r->location)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0); + } + if (r->devmode) { + _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0); + { + struct ndr_pull *_ndr_devmode; + NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1)); + NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode)); + NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1)); + } + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0); + } + if (r->sepfile) { + _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile)); + if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0); + } + if (r->printprocessor) { + _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor)); + if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0); + } + if (r->datatype) { + _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype)); + if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0); + } + if (r->parameters) { + _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters)); + if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0); + } + if (r->secdesc) { + _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0); + { + struct ndr_pull *_ndr_secdesc; + NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1)); + NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc)); + NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1)); + } + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r) +{ + ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2"); + ndr->depth++; + ndr_print_ptr(ndr, "servername", r->servername); + ndr->depth++; + if (r->servername) { + ndr_print_string(ndr, "servername", r->servername); + } + ndr->depth--; + ndr_print_ptr(ndr, "printername", r->printername); + ndr->depth++; + if (r->printername) { + ndr_print_string(ndr, "printername", r->printername); + } + ndr->depth--; + ndr_print_ptr(ndr, "sharename", r->sharename); + ndr->depth++; + if (r->sharename) { + ndr_print_string(ndr, "sharename", r->sharename); + } + ndr->depth--; + ndr_print_ptr(ndr, "portname", r->portname); + ndr->depth++; + if (r->portname) { + ndr_print_string(ndr, "portname", r->portname); + } + ndr->depth--; + ndr_print_ptr(ndr, "drivername", r->drivername); + ndr->depth++; + if (r->drivername) { + ndr_print_string(ndr, "drivername", r->drivername); + } + ndr->depth--; + ndr_print_ptr(ndr, "comment", r->comment); + ndr->depth++; + if (r->comment) { + ndr_print_string(ndr, "comment", r->comment); + } + ndr->depth--; + ndr_print_ptr(ndr, "location", r->location); + ndr->depth++; + if (r->location) { + ndr_print_string(ndr, "location", r->location); + } + ndr->depth--; + ndr_print_ptr(ndr, "devmode", r->devmode); + ndr->depth++; + if (r->devmode) { + ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode); + } + ndr->depth--; + ndr_print_ptr(ndr, "sepfile", r->sepfile); + ndr->depth++; + if (r->sepfile) { + ndr_print_string(ndr, "sepfile", r->sepfile); + } + ndr->depth--; + ndr_print_ptr(ndr, "printprocessor", r->printprocessor); + ndr->depth++; + if (r->printprocessor) { + ndr_print_string(ndr, "printprocessor", r->printprocessor); + } + ndr->depth--; + ndr_print_ptr(ndr, "datatype", r->datatype); + ndr->depth++; + if (r->datatype) { + ndr_print_string(ndr, "datatype", r->datatype); + } + ndr->depth--; + ndr_print_ptr(ndr, "parameters", r->parameters); + ndr->depth++; + if (r->parameters) { + ndr_print_string(ndr, "parameters", r->parameters); + } + ndr->depth--; + ndr_print_ptr(ndr, "secdesc", r->secdesc); + ndr->depth++; + if (r->secdesc) { + ndr_print_security_descriptor(ndr, "secdesc", r->secdesc); + } + ndr->depth--; + ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes); + ndr_print_uint32(ndr, "priority", r->priority); + ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority); + ndr_print_uint32(ndr, "starttime", r->starttime); + ndr_print_uint32(ndr, "untiltime", r->untiltime); + ndr_print_spoolss_PrinterStatus(ndr, "status", r->status); + ndr_print_uint32(ndr, "cjobs", r->cjobs); + ndr_print_uint32(ndr, "averageppm", r->averageppm); + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc)); + } + if (ndr_flags & NDR_BUFFERS) { + if (r->secdesc) { + NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc)); + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r) +{ + uint32_t _ptr_secdesc; + TALLOC_CTX *_mem_save_secdesc_0; + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc)); + if (_ptr_secdesc) { + NDR_PULL_ALLOC(ndr, r->secdesc); + } else { + r->secdesc = NULL; + } + } + if (ndr_flags & NDR_BUFFERS) { + if (r->secdesc) { + _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0); + NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r) +{ + ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3"); + ndr->depth++; + ndr_print_ptr(ndr, "secdesc", r->secdesc); + ndr->depth++; + if (r->secdesc) { + ndr_print_security_descriptor(ndr, "secdesc", r->secdesc); + } + ndr->depth--; + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername)); + NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes)); + } + if (ndr_flags & NDR_BUFFERS) { + if (r->printername) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->servername) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r) +{ + uint32_t _ptr_printername; + TALLOC_CTX *_mem_save_printername_0; + uint32_t _ptr_servername; + TALLOC_CTX *_mem_save_servername_0; + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername)); + if (_ptr_printername) { + NDR_PULL_ALLOC(ndr, r->printername); + } else { + r->printername = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername)); + if (_ptr_servername) { + NDR_PULL_ALLOC(ndr, r->servername); + } else { + r->servername = NULL; + } + NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes)); + } + if (ndr_flags & NDR_BUFFERS) { + if (r->printername) { + _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->printername)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->printername)); + if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0); + } + if (r->servername) { + _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->servername)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->servername)); + if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r) +{ + ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4"); + ndr->depth++; + ndr_print_ptr(ndr, "printername", r->printername); + ndr->depth++; + if (r->printername) { + ndr_print_string(ndr, "printername", r->printername); + } + ndr->depth--; + ndr_print_ptr(ndr, "servername", r->servername); + ndr->depth++; + if (r->servername) { + ndr_print_string(ndr, "servername", r->servername); + } + ndr->depth--; + ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes); + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname)); + NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout)); + } + if (ndr_flags & NDR_BUFFERS) { + if (r->printername) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->portname) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r) +{ + uint32_t _ptr_printername; + TALLOC_CTX *_mem_save_printername_0; + uint32_t _ptr_portname; + TALLOC_CTX *_mem_save_portname_0; + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername)); + if (_ptr_printername) { + NDR_PULL_ALLOC(ndr, r->printername); + } else { + r->printername = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname)); + if (_ptr_portname) { + NDR_PULL_ALLOC(ndr, r->portname); + } else { + r->portname = NULL; + } + NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout)); + } + if (ndr_flags & NDR_BUFFERS) { + if (r->printername) { + _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->printername)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->printername)); + if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0); + } + if (r->portname) { + _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->portname)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->portname)); + if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r) +{ + ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5"); + ndr->depth++; + ndr_print_ptr(ndr, "printername", r->printername); + ndr->depth++; + if (r->printername) { + ndr_print_string(ndr, "printername", r->printername); + } + ndr->depth--; + ndr_print_ptr(ndr, "portname", r->portname); + ndr->depth++; + if (r->portname) { + ndr_print_string(ndr, "portname", r->portname); + } + ndr->depth--; + ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes); + ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout); + ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout); + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status)); + } + if (ndr_flags & NDR_BUFFERS) { + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status)); + } + if (ndr_flags & NDR_BUFFERS) { + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r) +{ + ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6"); + ndr->depth++; + ndr_print_spoolss_PrinterStatus(ndr, "status", r->status); + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid)); + NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action)); + } + if (ndr_flags & NDR_BUFFERS) { + if (r->guid) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r) +{ + uint32_t _ptr_guid; + TALLOC_CTX *_mem_save_guid_0; + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid)); + if (_ptr_guid) { + NDR_PULL_ALLOC(ndr, r->guid); + } else { + r->guid = NULL; + } + NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action)); + } + if (ndr_flags & NDR_BUFFERS) { + if (r->guid) { + _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->guid)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->guid)); + if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guid), ndr_get_array_length(ndr, &r->guid)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r) { - const char *val = NULL; - - switch (r) { - case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break; - case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break; - case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break; - case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break; - case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break; + ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7"); + ndr->depth++; + ndr_print_ptr(ndr, "guid", r->guid); + ndr->depth++; + if (r->guid) { + ndr_print_string(ndr, "guid", r->guid); } - ndr_print_enum(ndr, name, "ENUM", val, r); + ndr->depth--; + ndr_print_spoolss_DsPrintAction(ndr, "action", r->action); + ndr->depth--; } static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r) @@ -3026,49 +4261,49 @@ static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, i switch (level) { case 0: if (r->info0) { - NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0)); + NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0)); } break; case 1: if (r->info1) { - NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1)); + NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1)); } break; case 2: if (r->info2) { - NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2)); + NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2)); } break; case 3: if (r->info3) { - NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3)); + NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3)); } break; case 4: if (r->info4) { - NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4)); + NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4)); } break; case 5: if (r->info5) { - NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5)); + NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5)); } break; case 6: if (r->info6) { - NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, r->info6)); + NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6)); } break; case 7: if (r->info7) { - NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7)); + NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7)); } break; @@ -3224,7 +4459,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, i if (r->info0) { _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr); NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0); - NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0)); + NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0)); NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0); } break; @@ -3233,7 +4468,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, i if (r->info1) { _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr); NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0); - NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1)); + NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1)); NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0); } break; @@ -3242,7 +4477,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, i if (r->info2) { _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr); NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0); - NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2)); + NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2)); NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0); } break; @@ -3251,7 +4486,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, i if (r->info3) { _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr); NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0); - NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3)); + NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3)); NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0); } break; @@ -3260,7 +4495,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, i if (r->info4) { _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr); NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0); - NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4)); + NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4)); NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0); } break; @@ -3269,7 +4504,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, i if (r->info5) { _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr); NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0); - NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5)); + NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5)); NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0); } break; @@ -3278,7 +4513,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, i if (r->info6) { _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr); NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0); - NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, r->info6)); + NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6)); NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0); } break; @@ -3287,7 +4522,7 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, i if (r->info7) { _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr); NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0); - NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7)); + NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7)); NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0); } break; @@ -3328,7 +4563,7 @@ _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char ndr_print_ptr(ndr, "info0", r->info0); ndr->depth++; if (r->info0) { - ndr_print_spoolss_PrinterInfo0(ndr, "info0", r->info0); + ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0); } ndr->depth--; break; @@ -3337,7 +4572,7 @@ _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char ndr_print_ptr(ndr, "info1", r->info1); ndr->depth++; if (r->info1) { - ndr_print_spoolss_PrinterInfo1(ndr, "info1", r->info1); + ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1); } ndr->depth--; break; @@ -3346,7 +4581,7 @@ _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char ndr_print_ptr(ndr, "info2", r->info2); ndr->depth++; if (r->info2) { - ndr_print_spoolss_PrinterInfo2(ndr, "info2", r->info2); + ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2); } ndr->depth--; break; @@ -3355,7 +4590,7 @@ _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char ndr_print_ptr(ndr, "info3", r->info3); ndr->depth++; if (r->info3) { - ndr_print_spoolss_PrinterInfo3(ndr, "info3", r->info3); + ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3); } ndr->depth--; break; @@ -3364,7 +4599,7 @@ _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char ndr_print_ptr(ndr, "info4", r->info4); ndr->depth++; if (r->info4) { - ndr_print_spoolss_PrinterInfo4(ndr, "info4", r->info4); + ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4); } ndr->depth--; break; @@ -3373,7 +4608,7 @@ _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char ndr_print_ptr(ndr, "info5", r->info5); ndr->depth++; if (r->info5) { - ndr_print_spoolss_PrinterInfo5(ndr, "info5", r->info5); + ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5); } ndr->depth--; break; @@ -3382,7 +4617,7 @@ _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char ndr_print_ptr(ndr, "info6", r->info6); ndr->depth++; if (r->info6) { - ndr_print_spoolss_PrinterInfo6(ndr, "info6", r->info6); + ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6); } ndr->depth--; break; @@ -3391,7 +4626,7 @@ _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char ndr_print_ptr(ndr, "info7", r->info7); ndr->depth++; if (r->info7) { - ndr_print_spoolss_PrinterInfo7(ndr, "info7", r->info7); + ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7); } ndr->depth--; break; @@ -3420,6 +4655,44 @@ _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char } } +static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level)); + NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level)); + NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info)); + } + if (ndr_flags & NDR_BUFFERS) { + NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level)); + NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level)); + NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info)); + } + if (ndr_flags & NDR_BUFFERS) { + NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info)); + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r) +{ + ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr"); + ndr->depth++; + ndr_print_uint32(ndr, "level", r->level); + ndr_print_set_switch_value(ndr, &r->info, r->level); + ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info); + ndr->depth--; +} + _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r) { if (ndr_flags & NDR_SCALARS) { @@ -10565,135 +11838,276 @@ _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *na ndr->depth--; } -static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r) +static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r) +{ + if (ndr_flags & NDR_SCALARS) { + int level = ndr_push_get_switch_value(ndr, r); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level)); + switch (level) { + case 0: { + NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0)); + break; } + + default: + return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level); + } + } + if (ndr_flags & NDR_BUFFERS) { + int level = ndr_push_get_switch_value(ndr, r); + switch (level) { + case 0: + if (r->info0) { + NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0)); + } + break; + + default: + return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level); + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r) +{ + int level; + uint32_t _level; + TALLOC_CTX *_mem_save_info0_0; + level = ndr_pull_get_switch_value(ndr, r); + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level)); + if (_level != level) { + return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level); + } + switch (level) { + case 0: { + uint32_t _ptr_info0; + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0)); + if (_ptr_info0) { + NDR_PULL_ALLOC(ndr, r->info0); + } else { + r->info0 = NULL; + } + break; } + + default: + return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level); + } + } + if (ndr_flags & NDR_BUFFERS) { + switch (level) { + case 0: + if (r->info0) { + _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0); + NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0); + } + break; + + default: + return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r) +{ + int level; + level = ndr_print_get_switch_value(ndr, r); + ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo"); + switch (level) { + case 0: + ndr_print_ptr(ndr, "info0", r->info0); + ndr->depth++; + if (r->info0) { + ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0); + } + ndr->depth--; + break; + + default: + ndr_print_bad_level(ndr, name, level); + } +} + +static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r) +{ + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r)); + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r) +{ + uint32_t v; + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v)); + *r = v; + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r) +{ + ndr_print_uint32(ndr, name, r); + ndr->depth++; + ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r); + ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r); + ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r); + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->client)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->user)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build)); + NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major)); + NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor)); + NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor)); + } + if (ndr_flags & NDR_BUFFERS) { + if (r->client) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->user) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r) +{ + uint32_t _ptr_client; + TALLOC_CTX *_mem_save_client_0; + uint32_t _ptr_user; + TALLOC_CTX *_mem_save_user_0; + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size)); + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client)); + if (_ptr_client) { + NDR_PULL_ALLOC(ndr, r->client); + } else { + r->client = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user)); + if (_ptr_user) { + NDR_PULL_ALLOC(ndr, r->user); + } else { + r->user = NULL; + } + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build)); + NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major)); + NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor)); + NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor)); + } + if (ndr_flags & NDR_BUFFERS) { + if (r->client) { + _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->client, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->client)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->client)); + if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client), ndr_get_array_length(ndr, &r->client)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0); + } + if (r->user) { + _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->user, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->user)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->user)); + if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user), ndr_get_array_length(ndr, &r->user)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r) +{ + ndr_print_struct(ndr, name, "spoolss_UserLevel1"); + ndr->depth++; + ndr_print_uint32(ndr, "size", r->size); + ndr_print_ptr(ndr, "client", r->client); + ndr->depth++; + if (r->client) { + ndr_print_string(ndr, "client", r->client); + } + ndr->depth--; + ndr_print_ptr(ndr, "user", r->user); + ndr->depth++; + if (r->user) { + ndr_print_string(ndr, "user", r->user); + } + ndr->depth--; + ndr_print_uint32(ndr, "build", r->build); + ndr_print_spoolss_MajorVersion(ndr, "major", r->major); + ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor); + ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor); + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r) { if (ndr_flags & NDR_SCALARS) { - int level = ndr_push_get_switch_value(ndr, r); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level)); - switch (level) { - case 0: { - NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0)); - break; } - - default: - return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level); - } + NDR_CHECK(ndr_push_align(ndr, 4)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used)); } if (ndr_flags & NDR_BUFFERS) { - int level = ndr_push_get_switch_value(ndr, r); - switch (level) { - case 0: - if (r->info0) { - NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0)); - } - break; - - default: - return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level); - } } return NDR_ERR_SUCCESS; } -static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r) +static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r) { - int level; - uint32_t _level; - TALLOC_CTX *_mem_save_info0_0; - level = ndr_pull_get_switch_value(ndr, r); if (ndr_flags & NDR_SCALARS) { - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level)); - if (_level != level) { - return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level); - } - switch (level) { - case 0: { - uint32_t _ptr_info0; - NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0)); - if (_ptr_info0) { - NDR_PULL_ALLOC(ndr, r->info0); - } else { - r->info0 = NULL; - } - break; } - - default: - return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level); - } + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used)); } if (ndr_flags & NDR_BUFFERS) { - switch (level) { - case 0: - if (r->info0) { - _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr); - NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0); - NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0)); - NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0); - } - break; - - default: - return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level); - } - } - return NDR_ERR_SUCCESS; -} - -_PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r) -{ - int level; - level = ndr_print_get_switch_value(ndr, r); - ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo"); - switch (level) { - case 0: - ndr_print_ptr(ndr, "info0", r->info0); - ndr->depth++; - if (r->info0) { - ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0); - } - ndr->depth--; - break; - - default: - ndr_print_bad_level(ndr, name, level); } -} - -static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r) -{ - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r)); - return NDR_ERR_SUCCESS; -} - -static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r) -{ - uint32_t v; - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v)); - *r = v; return NDR_ERR_SUCCESS; } -_PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r) +_PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r) { - ndr_print_uint32(ndr, name, r); + ndr_print_struct(ndr, name, "spoolss_UserLevel2"); ndr->depth++; - ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r); - ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r); - ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r); + ndr_print_uint32(ndr, "not_used", r->not_used); ndr->depth--; } -static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r) +static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r) { if (ndr_flags & NDR_SCALARS) { NDR_CHECK(ndr_push_align(ndr, 4)); NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2)); NDR_CHECK(ndr_push_unique_ptr(ndr, r->client)); NDR_CHECK(ndr_push_unique_ptr(ndr, r->user)); NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->processor)); + NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major)); + NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor)); + NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor)); + NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved)); } if (ndr_flags & NDR_BUFFERS) { if (r->client) { @@ -10712,7 +12126,7 @@ static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int n return NDR_ERR_SUCCESS; } -static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r) +static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r) { uint32_t _ptr_client; TALLOC_CTX *_mem_save_client_0; @@ -10721,6 +12135,8 @@ static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int n if (ndr_flags & NDR_SCALARS) { NDR_CHECK(ndr_pull_align(ndr, 4)); NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2)); NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client)); if (_ptr_client) { NDR_PULL_ALLOC(ndr, r->client); @@ -10734,9 +12150,10 @@ static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int n r->user = NULL; } NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor)); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->processor)); + NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major)); + NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor)); + NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor)); + NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved)); } if (ndr_flags & NDR_BUFFERS) { if (r->client) { @@ -10767,11 +12184,13 @@ static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int n return NDR_ERR_SUCCESS; } -_PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r) +_PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r) { - ndr_print_struct(ndr, name, "spoolss_UserLevel1"); + ndr_print_struct(ndr, name, "spoolss_UserLevel3"); ndr->depth++; ndr_print_uint32(ndr, "size", r->size); + ndr_print_uint32(ndr, "flags", r->flags); + ndr_print_uint32(ndr, "size2", r->size2); ndr_print_ptr(ndr, "client", r->client); ndr->depth++; if (r->client) { @@ -10785,9 +12204,10 @@ _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *na } ndr->depth--; ndr_print_uint32(ndr, "build", r->build); - ndr_print_uint32(ndr, "major", r->major); - ndr_print_uint32(ndr, "minor", r->minor); - ndr_print_uint32(ndr, "processor", r->processor); + ndr_print_spoolss_MajorVersion(ndr, "major", r->major); + ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor); + ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor); + ndr_print_udlong(ndr, "reserved", r->reserved); ndr->depth--; } @@ -10801,6 +12221,14 @@ static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int nd NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1)); break; } + case 2: { + NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2)); + break; } + + case 3: { + NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3)); + break; } + default: return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level); } @@ -10814,6 +12242,18 @@ static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int nd } break; + case 2: + if (r->level2) { + NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2)); + } + break; + + case 3: + if (r->level3) { + NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3)); + } + break; + default: return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level); } @@ -10826,6 +12266,8 @@ static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int nd int level; uint32_t _level; TALLOC_CTX *_mem_save_level1_0; + TALLOC_CTX *_mem_save_level2_0; + TALLOC_CTX *_mem_save_level3_0; level = ndr_pull_get_switch_value(ndr, r); if (ndr_flags & NDR_SCALARS) { NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level)); @@ -10843,6 +12285,26 @@ static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int nd } break; } + case 2: { + uint32_t _ptr_level2; + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2)); + if (_ptr_level2) { + NDR_PULL_ALLOC(ndr, r->level2); + } else { + r->level2 = NULL; + } + break; } + + case 3: { + uint32_t _ptr_level3; + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3)); + if (_ptr_level3) { + NDR_PULL_ALLOC(ndr, r->level3); + } else { + r->level3 = NULL; + } + break; } + default: return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level); } @@ -10858,6 +12320,24 @@ static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int nd } break; + case 2: + if (r->level2) { + _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0); + NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0); + } + break; + + case 3: + if (r->level3) { + _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0); + NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0); + } + break; + default: return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level); } @@ -10880,11 +12360,67 @@ _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *nam ndr->depth--; break; + case 2: + ndr_print_ptr(ndr, "level2", r->level2); + ndr->depth++; + if (r->level2) { + ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2); + } + ndr->depth--; + break; + + case 3: + ndr_print_ptr(ndr, "level3", r->level3); + ndr->depth++; + if (r->level3) { + ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3); + } + ndr->depth--; + break; + default: ndr_print_bad_level(ndr, name, level); } } +static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level)); + NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level)); + NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info)); + } + if (ndr_flags & NDR_BUFFERS) { + NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level)); + NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level)); + NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info)); + } + if (ndr_flags & NDR_BUFFERS) { + NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info)); + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r) +{ + ndr_print_struct(ndr, name, "spoolss_UserLevelCtr"); + ndr->depth++; + ndr_print_uint32(ndr, "level", r->level); + ndr_print_set_switch_value(ndr, &r->user_info, r->level); + ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info); + ndr->depth--; +} + _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r) { NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r)); @@ -11816,11 +13352,18 @@ static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int f return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); } NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle)); - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level)); - NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level)); - NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info)); - NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr)); - NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.secdesc_ctr)); + if (r->in.info_ctr == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr)); + if (r->in.devmode_ctr == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr)); + if (r->in.secdesc_ctr == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr)); NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command)); } if (flags & NDR_OUT) { @@ -11832,6 +13375,9 @@ static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int f static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r) { TALLOC_CTX *_mem_save_handle_0; + TALLOC_CTX *_mem_save_info_ctr_0; + TALLOC_CTX *_mem_save_devmode_ctr_0; + TALLOC_CTX *_mem_save_secdesc_ctr_0; if (flags & NDR_IN) { if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { NDR_PULL_ALLOC(ndr, r->in.handle); @@ -11840,11 +13386,27 @@ static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int f NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC); NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle)); NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC); - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level)); - NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level)); - NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info)); - NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr)); - NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.secdesc_ctr)); + if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { + NDR_PULL_ALLOC(ndr, r->in.info_ctr); + } + _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC); + if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { + NDR_PULL_ALLOC(ndr, r->in.devmode_ctr); + } + _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC); + if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { + NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr); + } + _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC); NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command)); } if (flags & NDR_OUT) { @@ -11867,11 +13429,18 @@ _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *na ndr->depth++; ndr_print_policy_handle(ndr, "handle", r->in.handle); ndr->depth--; - ndr_print_uint32(ndr, "level", r->in.level); - ndr_print_set_switch_value(ndr, &r->in.info, r->in.level); - ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->in.info); - ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr); - ndr_print_sec_desc_buf(ndr, "secdesc_ctr", &r->in.secdesc_ctr); + ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr); + ndr->depth++; + ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr); + ndr->depth--; + ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr); + ndr->depth++; + ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr); + ndr->depth--; + ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr); + ndr->depth++; + ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr); + ndr->depth--; ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command); ndr->depth--; } @@ -17158,20 +18727,22 @@ static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16))); NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16)); } - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level)); - NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info)); - if (r->in.info) { - NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level)); - NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info)); + if (r->in.info_ctr == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); } - NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr)); - NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.secdesc)); - if (r->in.secdesc) { - NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc)); + NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr)); + if (r->in.devmode_ctr == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); } - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.ulevel)); - NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.ulevel)); - NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel)); + NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr)); + if (r->in.secdesc_ctr == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr)); + if (r->in.userlevel_ctr == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr)); } if (flags & NDR_OUT) { if (r->out.handle == NULL) { @@ -17186,11 +18757,11 @@ static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r) { uint32_t _ptr_server; - uint32_t _ptr_info; - uint32_t _ptr_secdesc; TALLOC_CTX *_mem_save_server_0; - TALLOC_CTX *_mem_save_info_0; - TALLOC_CTX *_mem_save_secdesc_0; + TALLOC_CTX *_mem_save_info_ctr_0; + TALLOC_CTX *_mem_save_devmode_ctr_0; + TALLOC_CTX *_mem_save_secdesc_ctr_0; + TALLOC_CTX *_mem_save_userlevel_ctr_0; TALLOC_CTX *_mem_save_handle_0; if (flags & NDR_IN) { ZERO_STRUCT(r->out); @@ -17213,36 +18784,34 @@ static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16)); NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0); } - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level)); - NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info)); - if (_ptr_info) { - NDR_PULL_ALLOC(ndr, r->in.info); - } else { - r->in.info = NULL; + if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { + NDR_PULL_ALLOC(ndr, r->in.info_ctr); } - if (r->in.info) { - _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr); - NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0); - NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level)); - NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info)); - NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0); + _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC); + if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { + NDR_PULL_ALLOC(ndr, r->in.devmode_ctr); } - NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr)); - NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc)); - if (_ptr_secdesc) { - NDR_PULL_ALLOC(ndr, r->in.secdesc); - } else { - r->in.secdesc = NULL; + _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC); + if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { + NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr); } - if (r->in.secdesc) { - _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr); - NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc, 0); - NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc)); - NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0); + _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC); + if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { + NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr); } - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.ulevel)); - NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.ulevel)); - NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel)); + _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC); NDR_PULL_ALLOC(ndr, r->out.handle); ZERO_STRUCTP(r->out.handle); } @@ -17275,24 +18844,22 @@ _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char * ndr_print_string(ndr, "server", r->in.server); } ndr->depth--; - ndr_print_uint32(ndr, "level", r->in.level); - ndr_print_ptr(ndr, "info", r->in.info); + ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr); ndr->depth++; - if (r->in.info) { - ndr_print_set_switch_value(ndr, r->in.info, r->in.level); - ndr_print_spoolss_PrinterInfo(ndr, "info", r->in.info); - } + ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr); ndr->depth--; - ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr); - ndr_print_ptr(ndr, "secdesc", r->in.secdesc); + ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr); ndr->depth++; - if (r->in.secdesc) { - ndr_print_security_descriptor(ndr, "secdesc", r->in.secdesc); - } + ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr); + ndr->depth--; + ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr); + ndr->depth++; + ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr); + ndr->depth--; + ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr); + ndr->depth++; + ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr); ndr->depth--; - ndr_print_uint32(ndr, "ulevel", r->in.ulevel); - ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.ulevel); - ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel); ndr->depth--; } if (flags & NDR_OUT) { diff --git a/librpc/gen_ndr/ndr_spoolss.h b/librpc/gen_ndr/ndr_spoolss.h index 3bf74e5ff9..12015e013c 100644 --- a/librpc/gen_ndr/ndr_spoolss.h +++ b/librpc/gen_ndr/ndr_spoolss.h @@ -207,6 +207,10 @@ extern const struct ndr_interface_table ndr_table_spoolss; #define NDR_SPOOLSS_CALL_COUNT (96) void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r); void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r); +void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r); +void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r); +void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r); +void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r); void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r); void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r); enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r); @@ -238,7 +242,16 @@ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const un void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r); void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r); void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r); +void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r); +void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r); +void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r); +void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r); +void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r); +void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r); +void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r); +void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r); void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r); +void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r); enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r); enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r); void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r); @@ -317,7 +330,10 @@ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r); void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r); void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r); +void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r); +void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r); void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r); +void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r); enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r); enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r); void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r); diff --git a/librpc/gen_ndr/spoolss.h b/librpc/gen_ndr/spoolss.h index 22d845ef97..7ac38a7eb8 100644 --- a/librpc/gen_ndr/spoolss.h +++ b/librpc/gen_ndr/spoolss.h @@ -48,6 +48,74 @@ struct spoolss_TimeCtr { struct spoolss_Time *time;/* [unique] */ }; +enum spoolss_ProcessorArchitecture +#ifndef USE_UINT_ENUMS + { + PROCESSOR_ARCHITECTURE_INTEL=0x0000, + PROCESSOR_ARCHITECTURE_IA64=0x0006, + PROCESSOR_ARCHITECTURE_AMD64=0x0009 +} +#else + { __donnot_use_enum_spoolss_ProcessorArchitecture=0x7FFFFFFF} +#define PROCESSOR_ARCHITECTURE_INTEL ( 0x0000 ) +#define PROCESSOR_ARCHITECTURE_IA64 ( 0x0006 ) +#define PROCESSOR_ARCHITECTURE_AMD64 ( 0x0009 ) +#endif +; + +enum spoolss_ProcessorType +#ifndef USE_UINT_ENUMS + { + PROCESSOR_INTEL_386=0x00000182, + PROCESSOR_INTEL_486=0x000001E6, + PROCESSOR_INTEL_PENTIUM=0x0000024A, + PROCESSOR_INTEL_IA64=0x00000898, + PROCESSOR_AMD_X8664=0x000022A0 +} +#else + { __donnot_use_enum_spoolss_ProcessorType=0x7FFFFFFF} +#define PROCESSOR_INTEL_386 ( 0x00000182 ) +#define PROCESSOR_INTEL_486 ( 0x000001E6 ) +#define PROCESSOR_INTEL_PENTIUM ( 0x0000024A ) +#define PROCESSOR_INTEL_IA64 ( 0x00000898 ) +#define PROCESSOR_AMD_X8664 ( 0x000022A0 ) +#endif +; + +enum spoolss_MajorVersion +#ifndef USE_UINT_ENUMS + { + SPOOLSS_MAJOR_VERSION_NT4_95_98_ME=0x00000004, + SPOOLSS_MAJOR_VERSION_2000_2003_XP=0x00000005, + SPOOLSS_MAJOR_VERSION_2008_VISTA=0x00000006 +} +#else + { __donnot_use_enum_spoolss_MajorVersion=0x7FFFFFFF} +#define SPOOLSS_MAJOR_VERSION_NT4_95_98_ME ( 0x00000004 ) +#define SPOOLSS_MAJOR_VERSION_2000_2003_XP ( 0x00000005 ) +#define SPOOLSS_MAJOR_VERSION_2008_VISTA ( 0x00000006 ) +#endif +; + +enum spoolss_MinorVersion +#ifndef USE_UINT_ENUMS + { + SPOOLSS_MINOR_VERSION_0=0x00000000, + SPOOLSS_MINOR_VERSION_XP=0x00000001, + SPOOLSS_MINOR_VERSION_2003_XP64=0x00000002, + SPOOLSS_MINOR_VERSION_98=0x0000000a, + SPOOLSS_MINOR_VERSION_ME=0x0000005a +} +#else + { __donnot_use_enum_spoolss_MinorVersion=0x7FFFFFFF} +#define SPOOLSS_MINOR_VERSION_0 ( 0x00000000 ) +#define SPOOLSS_MINOR_VERSION_XP ( 0x00000001 ) +#define SPOOLSS_MINOR_VERSION_2003_XP64 ( 0x00000002 ) +#define SPOOLSS_MINOR_VERSION_98 ( 0x0000000a ) +#define SPOOLSS_MINOR_VERSION_ME ( 0x0000005a ) +#endif +; + struct spoolss_PrinterInfo0 { const char * printername;/* [relative,flag(LIBNDR_FLAG_STR_NULLTERM)] */ const char * servername;/* [relative,flag(LIBNDR_FLAG_STR_NULLTERM)] */ @@ -58,26 +126,26 @@ struct spoolss_PrinterInfo0 { uint32_t global_counter; uint32_t total_pages; uint32_t version; - uint32_t unknown10; - uint32_t unknown11; - uint32_t unknown12; + uint32_t free_build; + uint32_t spooling; + uint32_t max_spooling; uint32_t session_counter; - uint32_t unknown14; - uint32_t printer_errors; - uint32_t unknown16; - uint32_t unknown17; - uint32_t unknown18; - uint32_t unknown19; + uint32_t num_error_out_of_paper; + uint32_t num_error_not_ready; + uint32_t job_error; + uint32_t number_of_processors; + enum spoolss_ProcessorType processor_type; + uint32_t high_part_total_bytes; uint32_t change_id; - uint32_t unknown21; + WERROR last_error; uint32_t status; - uint32_t unknown23; + uint32_t enumerate_network_printers; uint32_t c_setprinter; - uint16_t unknown25; - uint16_t unknown26; - uint32_t unknown27; - uint32_t unknown28; - uint32_t unknown29; + enum spoolss_ProcessorArchitecture processor_architecture; + uint16_t processor_level; + uint32_t ref_ic; + uint32_t reserved2; + uint32_t reserved3; }; /* bitmap spoolss_DeviceModeFields */ @@ -368,19 +436,114 @@ enum spoolss_PrinterControl #endif ; +struct spoolss_SetPrinterInfo0 { + const char *servername;/* [unique,charset(UTF16)] */ + const char *printername;/* [unique,charset(UTF16)] */ + uint32_t cjobs; + uint32_t total_jobs; + uint32_t total_bytes; + struct spoolss_Time time; + uint32_t global_counter; + uint32_t total_pages; + uint32_t version; + uint32_t free_build; + uint32_t spooling; + uint32_t max_spooling; + uint32_t session_counter; + uint32_t num_error_out_of_paper; + uint32_t num_error_not_ready; + uint32_t job_error; + uint32_t number_of_processors; + enum spoolss_ProcessorType processor_type; + uint32_t high_part_total_bytes; + uint32_t change_id; + WERROR last_error; + uint32_t status; + uint32_t enumerate_network_printers; + uint32_t c_setprinter; + enum spoolss_ProcessorArchitecture processor_architecture; + uint16_t processor_level; + uint32_t ref_ic; + uint32_t reserved2; + uint32_t reserved3; +}; + +struct spoolss_SetPrinterInfo1 { + uint32_t flags; + const char *name;/* [unique,charset(UTF16)] */ + const char *description;/* [unique,charset(UTF16)] */ + const char *comment;/* [unique,charset(UTF16)] */ +}; + +struct spoolss_SetPrinterInfo2 { + const char *servername;/* [unique,charset(UTF16)] */ + const char *printername;/* [unique,charset(UTF16)] */ + const char *sharename;/* [unique,charset(UTF16)] */ + const char *portname;/* [unique,charset(UTF16)] */ + const char *drivername;/* [unique,charset(UTF16)] */ + const char *comment;/* [unique,charset(UTF16)] */ + const char *location;/* [unique,charset(UTF16)] */ + struct spoolss_DeviceMode *devmode;/* [unique,subcontext(0)] */ + const char *sepfile;/* [unique,charset(UTF16)] */ + const char *printprocessor;/* [unique,charset(UTF16)] */ + const char *datatype;/* [unique,charset(UTF16)] */ + const char *parameters;/* [unique,charset(UTF16)] */ + struct security_descriptor *secdesc;/* [unique,subcontext(0)] */ + uint32_t attributes; + uint32_t priority; + uint32_t defaultpriority; + uint32_t starttime; + uint32_t untiltime; + uint32_t status; + uint32_t cjobs; + uint32_t averageppm; +}; + +struct spoolss_SetPrinterInfo3 { + struct security_descriptor *secdesc;/* [unique] */ +}; + +struct spoolss_SetPrinterInfo4 { + const char *printername;/* [unique,charset(UTF16)] */ + const char *servername;/* [unique,charset(UTF16)] */ + uint32_t attributes; +}; + +struct spoolss_SetPrinterInfo5 { + const char *printername;/* [unique,charset(UTF16)] */ + const char *portname;/* [unique,charset(UTF16)] */ + uint32_t attributes; + uint32_t device_not_selected_timeout; + uint32_t transmission_retry_timeout; +}; + +struct spoolss_SetPrinterInfo6 { + uint32_t status; +}; + +struct spoolss_SetPrinterInfo7 { + const char *guid;/* [unique,charset(UTF16)] */ + uint32_t action; +}; + union spoolss_SetPrinterInfo { - struct spoolss_PrinterInfo0 *info0;/* [unique,case(0)] */ - struct spoolss_PrinterInfo1 *info1;/* [unique,case] */ - struct spoolss_PrinterInfo2 *info2;/* [unique,case(2)] */ - struct spoolss_PrinterInfo3 *info3;/* [unique,case(3)] */ - struct spoolss_PrinterInfo4 *info4;/* [unique,case(4)] */ - struct spoolss_PrinterInfo5 *info5;/* [unique,case(5)] */ - struct spoolss_PrinterInfo6 *info6;/* [unique,case(6)] */ - struct spoolss_PrinterInfo7 *info7;/* [unique,case(7)] */ + struct spoolss_SetPrinterInfo0 *info0;/* [unique,case(0)] */ + struct spoolss_SetPrinterInfo1 *info1;/* [unique,case] */ + struct spoolss_SetPrinterInfo2 *info2;/* [unique,case(2)] */ + struct spoolss_SetPrinterInfo3 *info3;/* [unique,case(3)] */ + struct spoolss_SetPrinterInfo4 *info4;/* [unique,case(4)] */ + struct spoolss_SetPrinterInfo5 *info5;/* [unique,case(5)] */ + struct spoolss_SetPrinterInfo6 *info6;/* [unique,case(6)] */ + struct spoolss_SetPrinterInfo7 *info7;/* [unique,case(7)] */ struct spoolss_DeviceModeInfo *info8;/* [unique,case(8)] */ struct spoolss_DeviceModeInfo *info9;/* [unique,case(9)] */ }/* [switch_type(uint32)] */; +struct spoolss_SetPrinterInfoCtr { + uint32_t level; + union spoolss_SetPrinterInfo info;/* [switch_is(level)] */ +}; + struct spoolss_StringArray { uint32_t _ndr_size;/* [value((ndr_size_spoolss_StringArray(r,ndr->iconv_convenience,ndr->flags)-4)/2)] */ const char ** string;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */ @@ -930,13 +1093,37 @@ struct spoolss_UserLevel1 { const char *client;/* [unique,charset(UTF16)] */ const char *user;/* [unique,charset(UTF16)] */ uint32_t build; - uint32_t major; - uint32_t minor; - uint32_t processor; + enum spoolss_MajorVersion major; + enum spoolss_MinorVersion minor; + enum spoolss_ProcessorArchitecture processor; +}; + +struct spoolss_UserLevel2 { + uint32_t not_used; +}; + +struct spoolss_UserLevel3 { + uint32_t size; + uint32_t flags; + uint32_t size2; + const char *client;/* [unique,charset(UTF16)] */ + const char *user;/* [unique,charset(UTF16)] */ + uint32_t build; + enum spoolss_MajorVersion major; + enum spoolss_MinorVersion minor; + enum spoolss_ProcessorArchitecture processor; + uint64_t reserved; }; union spoolss_UserLevel { struct spoolss_UserLevel1 *level1;/* [unique,case] */ + struct spoolss_UserLevel2 *level2;/* [unique,case(2)] */ + struct spoolss_UserLevel3 *level3;/* [unique,case(3)] */ +}/* [switch_type(uint32)] */; + +struct spoolss_UserLevelCtr { + uint32_t level; + union spoolss_UserLevel user_info;/* [switch_is(level)] */ }; /* bitmap spoolss_AccessRights */ @@ -1138,10 +1325,9 @@ struct spoolss_DeletePrinter { struct spoolss_SetPrinter { struct { struct policy_handle *handle;/* [ref] */ - uint32_t level; - union spoolss_SetPrinterInfo info;/* [switch_is(level)] */ - struct spoolss_DevmodeContainer devmode_ctr; - struct sec_desc_buf secdesc_ctr; + struct spoolss_SetPrinterInfoCtr *info_ctr;/* [ref] */ + struct spoolss_DevmodeContainer *devmode_ctr;/* [ref] */ + struct sec_desc_buf *secdesc_ctr;/* [ref] */ enum spoolss_PrinterControl command; } in; @@ -2136,12 +2322,10 @@ struct spoolss_OpenPrinterEx { struct spoolss_AddPrinterEx { struct { const char *server;/* [unique,charset(UTF16)] */ - uint32_t level; - union spoolss_PrinterInfo *info;/* [unique,switch_is(level)] */ - struct spoolss_DevmodeContainer devmode_ctr; - struct security_descriptor *secdesc;/* [unique] */ - uint32_t ulevel; - union spoolss_UserLevel userlevel;/* [switch_is(ulevel)] */ + struct spoolss_SetPrinterInfoCtr *info_ctr;/* [ref] */ + struct spoolss_DevmodeContainer *devmode_ctr;/* [ref] */ + struct sec_desc_buf *secdesc_ctr;/* [ref] */ + struct spoolss_UserLevelCtr *userlevel_ctr;/* [ref] */ } in; struct { -- cgit