From 80e2500f02d2e14e2acb7b352a82525827b5d357 Mon Sep 17 00:00:00 2001 From: Günther Deschner Date: Mon, 10 Aug 2009 16:45:13 +0200 Subject: s3: re-run make samba3-idl. Guenther --- librpc/gen_ndr/cli_spoolss.c | 2187 ++++++++++++++++++++++++++++++++++++++++++ librpc/gen_ndr/cli_spoolss.h | 152 +++ librpc/gen_ndr/ndr_spoolss.c | 1472 +++++++++++++++++++++++----- librpc/gen_ndr/ndr_spoolss.h | 45 +- librpc/gen_ndr/spoolss.h | 139 +++ librpc/gen_ndr/srv_spoolss.c | 1148 ++++++++++++++++++++++ librpc/gen_ndr/srv_spoolss.h | 28 + 7 files changed, 4943 insertions(+), 228 deletions(-) (limited to 'librpc/gen_ndr') diff --git a/librpc/gen_ndr/cli_spoolss.c b/librpc/gen_ndr/cli_spoolss.c index 21a7236c31..710af774a4 100644 --- a/librpc/gen_ndr/cli_spoolss.c +++ b/librpc/gen_ndr/cli_spoolss.c @@ -16012,3 +16012,2190 @@ NTSTATUS rpccli_spoolss_5f(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_spoolss_60_state { + struct spoolss_60 orig; + struct spoolss_60 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_spoolss_60_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_spoolss_60_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_spoolss_60_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_spoolss_60_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_60, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_spoolss, + NDR_SPOOLSS_60, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_spoolss_60_done, req); + return req; +} + +static void rpccli_spoolss_60_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_spoolss_60_state *state = tevent_req_data( + req, struct rpccli_spoolss_60_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_60, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_spoolss_60_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_spoolss_60_state *state = tevent_req_data( + req, struct rpccli_spoolss_60_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_spoolss_60(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror) +{ + struct spoolss_60 r; + NTSTATUS status; + + /* In parameters */ + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_60, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_spoolss, + NDR_SPOOLSS_60, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_60, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_spoolss_61_state { + struct spoolss_61 orig; + struct spoolss_61 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_spoolss_61_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_spoolss_61_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_spoolss_61_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_spoolss_61_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_61, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_spoolss, + NDR_SPOOLSS_61, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_spoolss_61_done, req); + return req; +} + +static void rpccli_spoolss_61_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_spoolss_61_state *state = tevent_req_data( + req, struct rpccli_spoolss_61_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_61, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_spoolss_61_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_spoolss_61_state *state = tevent_req_data( + req, struct rpccli_spoolss_61_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_spoolss_61(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror) +{ + struct spoolss_61 r; + NTSTATUS status; + + /* In parameters */ + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_61, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_spoolss, + NDR_SPOOLSS_61, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_61, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_spoolss_62_state { + struct spoolss_62 orig; + struct spoolss_62 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_spoolss_62_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_spoolss_62_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_spoolss_62_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_spoolss_62_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_62, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_spoolss, + NDR_SPOOLSS_62, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_spoolss_62_done, req); + return req; +} + +static void rpccli_spoolss_62_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_spoolss_62_state *state = tevent_req_data( + req, struct rpccli_spoolss_62_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_62, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_spoolss_62_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_spoolss_62_state *state = tevent_req_data( + req, struct rpccli_spoolss_62_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_spoolss_62(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror) +{ + struct spoolss_62 r; + NTSTATUS status; + + /* In parameters */ + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_62, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_spoolss, + NDR_SPOOLSS_62, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_62, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_spoolss_63_state { + struct spoolss_63 orig; + struct spoolss_63 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_spoolss_63_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_spoolss_63_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_spoolss_63_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_spoolss_63_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_63, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_spoolss, + NDR_SPOOLSS_63, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_spoolss_63_done, req); + return req; +} + +static void rpccli_spoolss_63_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_spoolss_63_state *state = tevent_req_data( + req, struct rpccli_spoolss_63_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_63, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_spoolss_63_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_spoolss_63_state *state = tevent_req_data( + req, struct rpccli_spoolss_63_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_spoolss_63(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror) +{ + struct spoolss_63 r; + NTSTATUS status; + + /* In parameters */ + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_63, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_spoolss, + NDR_SPOOLSS_63, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_63, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_spoolss_64_state { + struct spoolss_64 orig; + struct spoolss_64 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_spoolss_64_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_spoolss_64_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_spoolss_64_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_spoolss_64_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_64, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_spoolss, + NDR_SPOOLSS_64, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_spoolss_64_done, req); + return req; +} + +static void rpccli_spoolss_64_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_spoolss_64_state *state = tevent_req_data( + req, struct rpccli_spoolss_64_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_64, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_spoolss_64_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_spoolss_64_state *state = tevent_req_data( + req, struct rpccli_spoolss_64_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_spoolss_64(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror) +{ + struct spoolss_64 r; + NTSTATUS status; + + /* In parameters */ + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_64, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_spoolss, + NDR_SPOOLSS_64, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_64, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_spoolss_65_state { + struct spoolss_65 orig; + struct spoolss_65 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_spoolss_65_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_spoolss_65_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_spoolss_65_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_spoolss_65_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_65, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_spoolss, + NDR_SPOOLSS_65, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_spoolss_65_done, req); + return req; +} + +static void rpccli_spoolss_65_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_spoolss_65_state *state = tevent_req_data( + req, struct rpccli_spoolss_65_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_65, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_spoolss_65_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_spoolss_65_state *state = tevent_req_data( + req, struct rpccli_spoolss_65_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_spoolss_65(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror) +{ + struct spoolss_65 r; + NTSTATUS status; + + /* In parameters */ + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_65, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_spoolss, + NDR_SPOOLSS_65, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_65, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_spoolss_GetCorePrinterDrivers_state { + struct spoolss_GetCorePrinterDrivers orig; + struct spoolss_GetCorePrinterDrivers tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_spoolss_GetCorePrinterDrivers_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_spoolss_GetCorePrinterDrivers_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_servername /* [in] [unique,charset(UTF16)] */, + const char *_architecture /* [in] [ref,charset(UTF16)] */, + uint32_t _core_driver_size /* [in] */, + const char *_core_driver_dependencies /* [in] [ref,charset(UTF16),size_is(core_driver_size)] */, + uint32_t _core_printer_driver_count /* [in] */, + struct spoolss_CorePrinterDriver *_core_printer_drivers /* [out] [ref,size_is(core_printer_driver_count)] */) +{ + struct tevent_req *req; + struct rpccli_spoolss_GetCorePrinterDrivers_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_spoolss_GetCorePrinterDrivers_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.servername = _servername; + state->orig.in.architecture = _architecture; + state->orig.in.core_driver_size = _core_driver_size; + state->orig.in.core_driver_dependencies = _core_driver_dependencies; + state->orig.in.core_printer_driver_count = _core_printer_driver_count; + + /* Out parameters */ + state->orig.out.core_printer_drivers = _core_printer_drivers; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_GetCorePrinterDrivers, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_spoolss_GetCorePrinterDrivers_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_spoolss, + NDR_SPOOLSS_GETCOREPRINTERDRIVERS, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_spoolss_GetCorePrinterDrivers_done, req); + return req; +} + +static void rpccli_spoolss_GetCorePrinterDrivers_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_spoolss_GetCorePrinterDrivers_state *state = tevent_req_data( + req, struct rpccli_spoolss_GetCorePrinterDrivers_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + memcpy(state->orig.out.core_printer_drivers, state->tmp.out.core_printer_drivers, state->tmp.in.core_printer_driver_count * sizeof(*state->orig.out.core_printer_drivers)); + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_GetCorePrinterDrivers, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_spoolss_GetCorePrinterDrivers_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_spoolss_GetCorePrinterDrivers_state *state = tevent_req_data( + req, struct rpccli_spoolss_GetCorePrinterDrivers_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_spoolss_GetCorePrinterDrivers(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + const char *servername /* [in] [unique,charset(UTF16)] */, + const char *architecture /* [in] [ref,charset(UTF16)] */, + uint32_t core_driver_size /* [in] */, + const char *core_driver_dependencies /* [in] [ref,charset(UTF16),size_is(core_driver_size)] */, + uint32_t core_printer_driver_count /* [in] */, + struct spoolss_CorePrinterDriver *core_printer_drivers /* [out] [ref,size_is(core_printer_driver_count)] */, + WERROR *werror) +{ + struct spoolss_GetCorePrinterDrivers r; + NTSTATUS status; + + /* In parameters */ + r.in.servername = servername; + r.in.architecture = architecture; + r.in.core_driver_size = core_driver_size; + r.in.core_driver_dependencies = core_driver_dependencies; + r.in.core_printer_driver_count = core_printer_driver_count; + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_GetCorePrinterDrivers, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_spoolss, + NDR_SPOOLSS_GETCOREPRINTERDRIVERS, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_GetCorePrinterDrivers, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + memcpy(core_printer_drivers, r.out.core_printer_drivers, r.in.core_printer_driver_count * sizeof(*core_printer_drivers)); + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_spoolss_67_state { + struct spoolss_67 orig; + struct spoolss_67 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_spoolss_67_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_spoolss_67_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_spoolss_67_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_spoolss_67_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_67, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_spoolss, + NDR_SPOOLSS_67, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_spoolss_67_done, req); + return req; +} + +static void rpccli_spoolss_67_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_spoolss_67_state *state = tevent_req_data( + req, struct rpccli_spoolss_67_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_67, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_spoolss_67_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_spoolss_67_state *state = tevent_req_data( + req, struct rpccli_spoolss_67_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_spoolss_67(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror) +{ + struct spoolss_67 r; + NTSTATUS status; + + /* In parameters */ + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_67, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_spoolss, + NDR_SPOOLSS_67, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_67, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_spoolss_GetPrinterDriverPackagePath_state { + struct spoolss_GetPrinterDriverPackagePath orig; + struct spoolss_GetPrinterDriverPackagePath tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_spoolss_GetPrinterDriverPackagePath_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_spoolss_GetPrinterDriverPackagePath_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_servername /* [in] [unique,charset(UTF16)] */, + const char *_architecture /* [in] [ref,charset(UTF16)] */, + const char *_language /* [in] [unique,charset(UTF16)] */, + const char *_package_id /* [in] [ref,charset(UTF16)] */, + const char *_driver_package_cab /* [in,out] [unique,charset(UTF16),size_is(driver_package_cab_size)] */, + uint32_t _driver_package_cab_size /* [in] */, + uint32_t *_required /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_spoolss_GetPrinterDriverPackagePath_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.servername = _servername; + state->orig.in.architecture = _architecture; + state->orig.in.language = _language; + state->orig.in.package_id = _package_id; + state->orig.in.driver_package_cab = _driver_package_cab; + state->orig.in.driver_package_cab_size = _driver_package_cab_size; + + /* Out parameters */ + state->orig.out.driver_package_cab = _driver_package_cab; + state->orig.out.required = _required; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverPackagePath, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_spoolss_GetPrinterDriverPackagePath_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_spoolss, + NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriverPackagePath_done, req); + return req; +} + +static void rpccli_spoolss_GetPrinterDriverPackagePath_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state = tevent_req_data( + req, struct rpccli_spoolss_GetPrinterDriverPackagePath_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + if (state->orig.out.driver_package_cab && state->tmp.out.driver_package_cab) { + memcpy(CONST_DISCARD(char *, state->orig.out.driver_package_cab), state->tmp.out.driver_package_cab, state->tmp.in.driver_package_cab_size * sizeof(*state->orig.out.driver_package_cab)); + } + *state->orig.out.required = *state->tmp.out.required; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverPackagePath, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_spoolss_GetPrinterDriverPackagePath_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state = tevent_req_data( + req, struct rpccli_spoolss_GetPrinterDriverPackagePath_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_spoolss_GetPrinterDriverPackagePath(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + const char *servername /* [in] [unique,charset(UTF16)] */, + const char *architecture /* [in] [ref,charset(UTF16)] */, + const char *language /* [in] [unique,charset(UTF16)] */, + const char *package_id /* [in] [ref,charset(UTF16)] */, + const char *driver_package_cab /* [in,out] [unique,charset(UTF16),size_is(driver_package_cab_size)] */, + uint32_t driver_package_cab_size /* [in] */, + uint32_t *required /* [out] [ref] */, + WERROR *werror) +{ + struct spoolss_GetPrinterDriverPackagePath r; + NTSTATUS status; + + /* In parameters */ + r.in.servername = servername; + r.in.architecture = architecture; + r.in.language = language; + r.in.package_id = package_id; + r.in.driver_package_cab = driver_package_cab; + r.in.driver_package_cab_size = driver_package_cab_size; + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverPackagePath, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_spoolss, + NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverPackagePath, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + if (driver_package_cab && r.out.driver_package_cab) { + memcpy(CONST_DISCARD(char *, driver_package_cab), r.out.driver_package_cab, r.in.driver_package_cab_size * sizeof(*driver_package_cab)); + } + *required = *r.out.required; + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_spoolss_69_state { + struct spoolss_69 orig; + struct spoolss_69 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_spoolss_69_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_spoolss_69_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_spoolss_69_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_spoolss_69_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_69, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_spoolss, + NDR_SPOOLSS_69, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_spoolss_69_done, req); + return req; +} + +static void rpccli_spoolss_69_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_spoolss_69_state *state = tevent_req_data( + req, struct rpccli_spoolss_69_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_69, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_spoolss_69_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_spoolss_69_state *state = tevent_req_data( + req, struct rpccli_spoolss_69_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_spoolss_69(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror) +{ + struct spoolss_69 r; + NTSTATUS status; + + /* In parameters */ + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_69, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_spoolss, + NDR_SPOOLSS_69, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_69, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_spoolss_6a_state { + struct spoolss_6a orig; + struct spoolss_6a tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_spoolss_6a_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_spoolss_6a_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_spoolss_6a_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_spoolss_6a_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_6a, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_spoolss, + NDR_SPOOLSS_6A, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_spoolss_6a_done, req); + return req; +} + +static void rpccli_spoolss_6a_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_spoolss_6a_state *state = tevent_req_data( + req, struct rpccli_spoolss_6a_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_6a, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_spoolss_6a_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_spoolss_6a_state *state = tevent_req_data( + req, struct rpccli_spoolss_6a_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_spoolss_6a(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror) +{ + struct spoolss_6a r; + NTSTATUS status; + + /* In parameters */ + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_6a, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_spoolss, + NDR_SPOOLSS_6A, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_6a, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_spoolss_6b_state { + struct spoolss_6b orig; + struct spoolss_6b tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_spoolss_6b_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_spoolss_6b_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_spoolss_6b_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_spoolss_6b_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_6b, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_spoolss, + NDR_SPOOLSS_6B, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_spoolss_6b_done, req); + return req; +} + +static void rpccli_spoolss_6b_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_spoolss_6b_state *state = tevent_req_data( + req, struct rpccli_spoolss_6b_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_6b, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_spoolss_6b_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_spoolss_6b_state *state = tevent_req_data( + req, struct rpccli_spoolss_6b_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_spoolss_6b(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror) +{ + struct spoolss_6b r; + NTSTATUS status; + + /* In parameters */ + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_6b, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_spoolss, + NDR_SPOOLSS_6B, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_6b, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_spoolss_6c_state { + struct spoolss_6c orig; + struct spoolss_6c tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_spoolss_6c_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_spoolss_6c_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_spoolss_6c_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_spoolss_6c_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_6c, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_spoolss, + NDR_SPOOLSS_6C, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_spoolss_6c_done, req); + return req; +} + +static void rpccli_spoolss_6c_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_spoolss_6c_state *state = tevent_req_data( + req, struct rpccli_spoolss_6c_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_6c, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_spoolss_6c_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_spoolss_6c_state *state = tevent_req_data( + req, struct rpccli_spoolss_6c_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_spoolss_6c(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror) +{ + struct spoolss_6c r; + NTSTATUS status; + + /* In parameters */ + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_6c, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_spoolss, + NDR_SPOOLSS_6C, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_6c, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_spoolss_6d_state { + struct spoolss_6d orig; + struct spoolss_6d tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_spoolss_6d_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_spoolss_6d_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_spoolss_6d_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_spoolss_6d_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_6d, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_spoolss, + NDR_SPOOLSS_6D, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_spoolss_6d_done, req); + return req; +} + +static void rpccli_spoolss_6d_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_spoolss_6d_state *state = tevent_req_data( + req, struct rpccli_spoolss_6d_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_6d, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_spoolss_6d_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_spoolss_6d_state *state = tevent_req_data( + req, struct rpccli_spoolss_6d_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_spoolss_6d(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror) +{ + struct spoolss_6d r; + NTSTATUS status; + + /* In parameters */ + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_6d, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_spoolss, + NDR_SPOOLSS_6D, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_6d, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + diff --git a/librpc/gen_ndr/cli_spoolss.h b/librpc/gen_ndr/cli_spoolss.h index abecaef56b..985337deeb 100644 --- a/librpc/gen_ndr/cli_spoolss.h +++ b/librpc/gen_ndr/cli_spoolss.h @@ -1453,4 +1453,156 @@ NTSTATUS rpccli_spoolss_5f_recv(struct tevent_req *req, NTSTATUS rpccli_spoolss_5f(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, WERROR *werror); +struct tevent_req *rpccli_spoolss_60_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli); +NTSTATUS rpccli_spoolss_60_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_spoolss_60(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror); +struct tevent_req *rpccli_spoolss_61_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli); +NTSTATUS rpccli_spoolss_61_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_spoolss_61(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror); +struct tevent_req *rpccli_spoolss_62_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli); +NTSTATUS rpccli_spoolss_62_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_spoolss_62(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror); +struct tevent_req *rpccli_spoolss_63_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli); +NTSTATUS rpccli_spoolss_63_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_spoolss_63(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror); +struct tevent_req *rpccli_spoolss_64_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli); +NTSTATUS rpccli_spoolss_64_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_spoolss_64(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror); +struct tevent_req *rpccli_spoolss_65_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli); +NTSTATUS rpccli_spoolss_65_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_spoolss_65(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror); +struct tevent_req *rpccli_spoolss_GetCorePrinterDrivers_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_servername /* [in] [unique,charset(UTF16)] */, + const char *_architecture /* [in] [ref,charset(UTF16)] */, + uint32_t _core_driver_size /* [in] */, + const char *_core_driver_dependencies /* [in] [ref,charset(UTF16),size_is(core_driver_size)] */, + uint32_t _core_printer_driver_count /* [in] */, + struct spoolss_CorePrinterDriver *_core_printer_drivers /* [out] [ref,size_is(core_printer_driver_count)] */); +NTSTATUS rpccli_spoolss_GetCorePrinterDrivers_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_spoolss_GetCorePrinterDrivers(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + const char *servername /* [in] [unique,charset(UTF16)] */, + const char *architecture /* [in] [ref,charset(UTF16)] */, + uint32_t core_driver_size /* [in] */, + const char *core_driver_dependencies /* [in] [ref,charset(UTF16),size_is(core_driver_size)] */, + uint32_t core_printer_driver_count /* [in] */, + struct spoolss_CorePrinterDriver *core_printer_drivers /* [out] [ref,size_is(core_printer_driver_count)] */, + WERROR *werror); +struct tevent_req *rpccli_spoolss_67_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli); +NTSTATUS rpccli_spoolss_67_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_spoolss_67(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror); +struct tevent_req *rpccli_spoolss_GetPrinterDriverPackagePath_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_servername /* [in] [unique,charset(UTF16)] */, + const char *_architecture /* [in] [ref,charset(UTF16)] */, + const char *_language /* [in] [unique,charset(UTF16)] */, + const char *_package_id /* [in] [ref,charset(UTF16)] */, + const char *_driver_package_cab /* [in,out] [unique,charset(UTF16),size_is(driver_package_cab_size)] */, + uint32_t _driver_package_cab_size /* [in] */, + uint32_t *_required /* [out] [ref] */); +NTSTATUS rpccli_spoolss_GetPrinterDriverPackagePath_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_spoolss_GetPrinterDriverPackagePath(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + const char *servername /* [in] [unique,charset(UTF16)] */, + const char *architecture /* [in] [ref,charset(UTF16)] */, + const char *language /* [in] [unique,charset(UTF16)] */, + const char *package_id /* [in] [ref,charset(UTF16)] */, + const char *driver_package_cab /* [in,out] [unique,charset(UTF16),size_is(driver_package_cab_size)] */, + uint32_t driver_package_cab_size /* [in] */, + uint32_t *required /* [out] [ref] */, + WERROR *werror); +struct tevent_req *rpccli_spoolss_69_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli); +NTSTATUS rpccli_spoolss_69_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_spoolss_69(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror); +struct tevent_req *rpccli_spoolss_6a_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli); +NTSTATUS rpccli_spoolss_6a_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_spoolss_6a(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror); +struct tevent_req *rpccli_spoolss_6b_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli); +NTSTATUS rpccli_spoolss_6b_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_spoolss_6b(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror); +struct tevent_req *rpccli_spoolss_6c_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli); +NTSTATUS rpccli_spoolss_6c_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_spoolss_6c(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror); +struct tevent_req *rpccli_spoolss_6d_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli); +NTSTATUS rpccli_spoolss_6d_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_spoolss_6d(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + WERROR *werror); #endif /* __CLI_SPOOLSS__ */ diff --git a/librpc/gen_ndr/ndr_spoolss.c b/librpc/gen_ndr/ndr_spoolss.c index ebedcc5e42..ca86ec5690 100644 --- a/librpc/gen_ndr/ndr_spoolss.c +++ b/librpc/gen_ndr/ndr_spoolss.c @@ -19259,6 +19259,45 @@ _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, c ndr->depth--; } +static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr, int ndr_flags, const struct spoolss_CorePrinterDriver *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 8)); + NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->core_driver_guid)); + NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date)); + NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version)); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8)); + } + if (ndr_flags & NDR_BUFFERS) { + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr, int ndr_flags, struct spoolss_CorePrinterDriver *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 8)); + NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->core_driver_guid)); + NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date)); + NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version)); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 520, sizeof(uint8_t), CH_UTF8)); + } + if (ndr_flags & NDR_BUFFERS) { + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r) +{ + ndr_print_struct(ndr, name, "spoolss_CorePrinterDriver"); + ndr->depth++; + ndr_print_GUID(ndr, "core_driver_guid", &r->core_driver_guid); + ndr_print_NTTIME(ndr, "driver_date", r->driver_date); + ndr_print_hyper(ndr, "driver_version", r->driver_version); + ndr_print_string(ndr, "formname", r->formname); + ndr->depth--; +} + _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r) { if (flags & NDR_IN) { @@ -28477,232 +28516,1099 @@ _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int ndr->depth--; } -static const struct ndr_interface_call spoolss_calls[] = { - { - "spoolss_EnumPrinters", - sizeof(struct spoolss_EnumPrinters), - (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters, - (ndr_print_function_t) ndr_print_spoolss_EnumPrinters, - false, - }, - { - "spoolss_OpenPrinter", - sizeof(struct spoolss_OpenPrinter), - (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter, - (ndr_print_function_t) ndr_print_spoolss_OpenPrinter, - false, - }, - { - "spoolss_SetJob", - sizeof(struct spoolss_SetJob), - (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob, - (ndr_print_function_t) ndr_print_spoolss_SetJob, - false, - }, - { - "spoolss_GetJob", - sizeof(struct spoolss_GetJob), - (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob, - (ndr_print_function_t) ndr_print_spoolss_GetJob, - false, - }, - { - "spoolss_EnumJobs", - sizeof(struct spoolss_EnumJobs), - (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs, - (ndr_print_function_t) ndr_print_spoolss_EnumJobs, - false, - }, - { - "spoolss_AddPrinter", - sizeof(struct spoolss_AddPrinter), - (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter, - (ndr_print_function_t) ndr_print_spoolss_AddPrinter, - false, - }, - { - "spoolss_DeletePrinter", - sizeof(struct spoolss_DeletePrinter), - (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter, - (ndr_print_function_t) ndr_print_spoolss_DeletePrinter, - false, - }, - { - "spoolss_SetPrinter", - sizeof(struct spoolss_SetPrinter), - (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter, - (ndr_print_function_t) ndr_print_spoolss_SetPrinter, - false, - }, - { - "spoolss_GetPrinter", - sizeof(struct spoolss_GetPrinter), - (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter, - (ndr_print_function_t) ndr_print_spoolss_GetPrinter, - false, - }, - { - "spoolss_AddPrinterDriver", - sizeof(struct spoolss_AddPrinterDriver), - (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver, - (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver, - false, - }, - { - "spoolss_EnumPrinterDrivers", - sizeof(struct spoolss_EnumPrinterDrivers), - (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers, - (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers, - false, - }, - { - "spoolss_GetPrinterDriver", - sizeof(struct spoolss_GetPrinterDriver), - (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver, - (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver, - false, - }, - { - "spoolss_GetPrinterDriverDirectory", - sizeof(struct spoolss_GetPrinterDriverDirectory), - (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory, - (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory, - false, - }, - { - "spoolss_DeletePrinterDriver", - sizeof(struct spoolss_DeletePrinterDriver), - (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver, - (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver, - false, - }, - { - "spoolss_AddPrintProcessor", - sizeof(struct spoolss_AddPrintProcessor), - (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor, - (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor, - false, - }, - { - "spoolss_EnumPrintProcessors", - sizeof(struct spoolss_EnumPrintProcessors), - (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors, - (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors, - false, - }, - { - "spoolss_GetPrintProcessorDirectory", - sizeof(struct spoolss_GetPrintProcessorDirectory), - (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory, - (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory, - false, - }, - { - "spoolss_StartDocPrinter", - sizeof(struct spoolss_StartDocPrinter), - (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter, - (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter, - false, - }, - { - "spoolss_StartPagePrinter", - sizeof(struct spoolss_StartPagePrinter), - (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter, - (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter, - false, - }, - { - "spoolss_WritePrinter", - sizeof(struct spoolss_WritePrinter), - (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter, - (ndr_print_function_t) ndr_print_spoolss_WritePrinter, - false, - }, - { - "spoolss_EndPagePrinter", - sizeof(struct spoolss_EndPagePrinter), - (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter, - (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter, - false, - }, - { - "spoolss_AbortPrinter", - sizeof(struct spoolss_AbortPrinter), - (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter, - (ndr_print_function_t) ndr_print_spoolss_AbortPrinter, - false, - }, - { - "spoolss_ReadPrinter", - sizeof(struct spoolss_ReadPrinter), - (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter, - (ndr_print_function_t) ndr_print_spoolss_ReadPrinter, - false, - }, - { - "spoolss_EndDocPrinter", - sizeof(struct spoolss_EndDocPrinter), - (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter, - (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter, - false, - }, - { - "spoolss_AddJob", - sizeof(struct spoolss_AddJob), - (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob, - (ndr_print_function_t) ndr_print_spoolss_AddJob, - false, - }, - { - "spoolss_ScheduleJob", - sizeof(struct spoolss_ScheduleJob), - (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob, - (ndr_print_function_t) ndr_print_spoolss_ScheduleJob, - false, - }, - { - "spoolss_GetPrinterData", - sizeof(struct spoolss_GetPrinterData), - (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData, - (ndr_print_function_t) ndr_print_spoolss_GetPrinterData, - false, - }, - { - "spoolss_SetPrinterData", - sizeof(struct spoolss_SetPrinterData), - (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData, - (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData, - (ndr_print_function_t) ndr_print_spoolss_SetPrinterData, - false, - }, - { +static enum ndr_err_code ndr_push_spoolss_60(struct ndr_push *ndr, int flags, const struct spoolss_60 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_60(struct ndr_pull *ndr, int flags, struct spoolss_60 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r) +{ + ndr_print_struct(ndr, name, "spoolss_60"); + ndr->depth++; + if (flags & NDR_SET_VALUES) { + ndr->flags |= LIBNDR_PRINT_SET_VALUES; + } + if (flags & NDR_IN) { + ndr_print_struct(ndr, "in", "spoolss_60"); + ndr->depth++; + ndr->depth--; + } + if (flags & NDR_OUT) { + ndr_print_struct(ndr, "out", "spoolss_60"); + ndr->depth++; + ndr_print_WERROR(ndr, "result", r->out.result); + ndr->depth--; + } + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_61(struct ndr_push *ndr, int flags, const struct spoolss_61 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_61(struct ndr_pull *ndr, int flags, struct spoolss_61 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r) +{ + ndr_print_struct(ndr, name, "spoolss_61"); + ndr->depth++; + if (flags & NDR_SET_VALUES) { + ndr->flags |= LIBNDR_PRINT_SET_VALUES; + } + if (flags & NDR_IN) { + ndr_print_struct(ndr, "in", "spoolss_61"); + ndr->depth++; + ndr->depth--; + } + if (flags & NDR_OUT) { + ndr_print_struct(ndr, "out", "spoolss_61"); + ndr->depth++; + ndr_print_WERROR(ndr, "result", r->out.result); + ndr->depth--; + } + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_62(struct ndr_push *ndr, int flags, const struct spoolss_62 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_62(struct ndr_pull *ndr, int flags, struct spoolss_62 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r) +{ + ndr_print_struct(ndr, name, "spoolss_62"); + ndr->depth++; + if (flags & NDR_SET_VALUES) { + ndr->flags |= LIBNDR_PRINT_SET_VALUES; + } + if (flags & NDR_IN) { + ndr_print_struct(ndr, "in", "spoolss_62"); + ndr->depth++; + ndr->depth--; + } + if (flags & NDR_OUT) { + ndr_print_struct(ndr, "out", "spoolss_62"); + ndr->depth++; + ndr_print_WERROR(ndr, "result", r->out.result); + ndr->depth--; + } + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_63(struct ndr_push *ndr, int flags, const struct spoolss_63 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_63(struct ndr_pull *ndr, int flags, struct spoolss_63 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r) +{ + ndr_print_struct(ndr, name, "spoolss_63"); + ndr->depth++; + if (flags & NDR_SET_VALUES) { + ndr->flags |= LIBNDR_PRINT_SET_VALUES; + } + if (flags & NDR_IN) { + ndr_print_struct(ndr, "in", "spoolss_63"); + ndr->depth++; + ndr->depth--; + } + if (flags & NDR_OUT) { + ndr_print_struct(ndr, "out", "spoolss_63"); + ndr->depth++; + ndr_print_WERROR(ndr, "result", r->out.result); + ndr->depth--; + } + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_64(struct ndr_push *ndr, int flags, const struct spoolss_64 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_64(struct ndr_pull *ndr, int flags, struct spoolss_64 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r) +{ + ndr_print_struct(ndr, name, "spoolss_64"); + ndr->depth++; + if (flags & NDR_SET_VALUES) { + ndr->flags |= LIBNDR_PRINT_SET_VALUES; + } + if (flags & NDR_IN) { + ndr_print_struct(ndr, "in", "spoolss_64"); + ndr->depth++; + ndr->depth--; + } + if (flags & NDR_OUT) { + ndr_print_struct(ndr, "out", "spoolss_64"); + ndr->depth++; + ndr_print_WERROR(ndr, "result", r->out.result); + ndr->depth--; + } + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_65(struct ndr_push *ndr, int flags, const struct spoolss_65 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_65(struct ndr_pull *ndr, int flags, struct spoolss_65 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r) +{ + ndr_print_struct(ndr, name, "spoolss_65"); + ndr->depth++; + if (flags & NDR_SET_VALUES) { + ndr->flags |= LIBNDR_PRINT_SET_VALUES; + } + if (flags & NDR_IN) { + ndr_print_struct(ndr, "in", "spoolss_65"); + ndr->depth++; + ndr->depth--; + } + if (flags & NDR_OUT) { + ndr_print_struct(ndr, "out", "spoolss_65"); + ndr->depth++; + ndr_print_WERROR(ndr, "result", r->out.result); + ndr->depth--; + } + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_GetCorePrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_GetCorePrinterDrivers *r) +{ + uint32_t cntr_core_printer_drivers_1; + if (flags & NDR_IN) { + NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername)); + if (r->in.servername) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->in.architecture == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size)); + if (r->in.core_driver_dependencies == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size)); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.core_driver_dependencies, r->in.core_driver_size, sizeof(uint16_t), CH_UTF16)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count)); + } + if (flags & NDR_OUT) { + if (r->out.core_printer_drivers == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count)); + for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) { + NDR_CHECK(ndr_push_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1])); + } + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_GetCorePrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_GetCorePrinterDrivers *r) +{ + uint32_t _ptr_servername; + uint32_t cntr_core_printer_drivers_1; + TALLOC_CTX *_mem_save_servername_0; + TALLOC_CTX *_mem_save_core_printer_drivers_1; + if (flags & NDR_IN) { + ZERO_STRUCT(r->out); + + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername)); + if (_ptr_servername) { + NDR_PULL_ALLOC(ndr, r->in.servername); + } else { + r->in.servername = NULL; + } + if (r->in.servername) { + _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername)); + if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.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->in.servername), ndr_get_array_length(ndr, &r->in.servername)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0); + } + NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture)); + if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_driver_size)); + NDR_CHECK(ndr_pull_array_size(ndr, &r->in.core_driver_dependencies)); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.core_driver_dependencies, ndr_get_array_size(ndr, &r->in.core_driver_dependencies), sizeof(uint16_t), CH_UTF16)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_printer_driver_count)); + NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, r->in.core_printer_driver_count); + memset(r->out.core_printer_drivers, 0, (r->in.core_printer_driver_count) * sizeof(*r->out.core_printer_drivers)); + if (r->in.core_driver_dependencies) { + NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.core_driver_dependencies, r->in.core_driver_size)); + } + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_pull_array_size(ndr, &r->out.core_printer_drivers)); + if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { + NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, ndr_get_array_size(ndr, &r->out.core_printer_drivers)); + } + _mem_save_core_printer_drivers_1 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->out.core_printer_drivers, 0); + for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) { + NDR_CHECK(ndr_pull_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1])); + } + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_printer_drivers_1, 0); + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); + if (r->out.core_printer_drivers) { + NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.core_printer_drivers, r->in.core_printer_driver_count)); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r) +{ + uint32_t cntr_core_printer_drivers_1; + ndr_print_struct(ndr, name, "spoolss_GetCorePrinterDrivers"); + ndr->depth++; + if (flags & NDR_SET_VALUES) { + ndr->flags |= LIBNDR_PRINT_SET_VALUES; + } + if (flags & NDR_IN) { + ndr_print_struct(ndr, "in", "spoolss_GetCorePrinterDrivers"); + ndr->depth++; + ndr_print_ptr(ndr, "servername", r->in.servername); + ndr->depth++; + if (r->in.servername) { + ndr_print_string(ndr, "servername", r->in.servername); + } + ndr->depth--; + ndr_print_ptr(ndr, "architecture", r->in.architecture); + ndr->depth++; + ndr_print_string(ndr, "architecture", r->in.architecture); + ndr->depth--; + ndr_print_uint32(ndr, "core_driver_size", r->in.core_driver_size); + ndr_print_ptr(ndr, "core_driver_dependencies", r->in.core_driver_dependencies); + ndr->depth++; + ndr_print_string(ndr, "core_driver_dependencies", r->in.core_driver_dependencies); + ndr->depth--; + ndr_print_uint32(ndr, "core_printer_driver_count", r->in.core_printer_driver_count); + ndr->depth--; + } + if (flags & NDR_OUT) { + ndr_print_struct(ndr, "out", "spoolss_GetCorePrinterDrivers"); + ndr->depth++; + ndr_print_ptr(ndr, "core_printer_drivers", r->out.core_printer_drivers); + ndr->depth++; + ndr->print(ndr, "%s: ARRAY(%d)", "core_printer_drivers", (int)r->in.core_printer_driver_count); + ndr->depth++; + for (cntr_core_printer_drivers_1=0;cntr_core_printer_drivers_1in.core_printer_driver_count;cntr_core_printer_drivers_1++) { + char *idx_1=NULL; + if (asprintf(&idx_1, "[%d]", cntr_core_printer_drivers_1) != -1) { + ndr_print_spoolss_CorePrinterDriver(ndr, "core_printer_drivers", &r->out.core_printer_drivers[cntr_core_printer_drivers_1]); + free(idx_1); + } + } + ndr->depth--; + ndr->depth--; + ndr_print_WERROR(ndr, "result", r->out.result); + ndr->depth--; + } + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_67(struct ndr_push *ndr, int flags, const struct spoolss_67 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_67(struct ndr_pull *ndr, int flags, struct spoolss_67 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r) +{ + ndr_print_struct(ndr, name, "spoolss_67"); + ndr->depth++; + if (flags & NDR_SET_VALUES) { + ndr->flags |= LIBNDR_PRINT_SET_VALUES; + } + if (flags & NDR_IN) { + ndr_print_struct(ndr, "in", "spoolss_67"); + ndr->depth++; + ndr->depth--; + } + if (flags & NDR_OUT) { + ndr_print_struct(ndr, "out", "spoolss_67"); + ndr->depth++; + ndr_print_WERROR(ndr, "result", r->out.result); + ndr->depth--; + } + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_GetPrinterDriverPackagePath(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverPackagePath *r) +{ + if (flags & NDR_IN) { + NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername)); + if (r->in.servername) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->in.architecture == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.language)); + if (r->in.language) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.language, ndr_charset_length(r->in.language, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + if (r->in.package_id == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.package_id, ndr_charset_length(r->in.package_id, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.driver_package_cab)); + if (r->in.driver_package_cab) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size)); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16)); + } + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size)); + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.driver_package_cab)); + if (r->out.driver_package_cab) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size)); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16)); + } + if (r->out.required == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required)); + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverPackagePath(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverPackagePath *r) +{ + uint32_t _ptr_servername; + uint32_t _ptr_language; + uint32_t _ptr_driver_package_cab; + TALLOC_CTX *_mem_save_servername_0; + TALLOC_CTX *_mem_save_language_0; + TALLOC_CTX *_mem_save_driver_package_cab_0; + TALLOC_CTX *_mem_save_required_0; + if (flags & NDR_IN) { + ZERO_STRUCT(r->out); + + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername)); + if (_ptr_servername) { + NDR_PULL_ALLOC(ndr, r->in.servername); + } else { + r->in.servername = NULL; + } + if (r->in.servername) { + _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername)); + if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.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->in.servername), ndr_get_array_length(ndr, &r->in.servername)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0); + } + NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture)); + if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16)); + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_language)); + if (_ptr_language) { + NDR_PULL_ALLOC(ndr, r->in.language); + } else { + r->in.language = NULL; + } + if (r->in.language) { + _mem_save_language_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->in.language, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->in.language)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->in.language)); + if (ndr_get_array_length(ndr, &r->in.language) > ndr_get_array_size(ndr, &r->in.language)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.language), ndr_get_array_length(ndr, &r->in.language)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.language, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_0, 0); + } + NDR_CHECK(ndr_pull_array_size(ndr, &r->in.package_id)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->in.package_id)); + if (ndr_get_array_length(ndr, &r->in.package_id) > ndr_get_array_size(ndr, &r->in.package_id)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.package_id), ndr_get_array_length(ndr, &r->in.package_id)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.package_id, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t), CH_UTF16)); + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab)); + if (_ptr_driver_package_cab) { + NDR_PULL_ALLOC(ndr, r->in.driver_package_cab); + } else { + r->in.driver_package_cab = NULL; + } + if (r->in.driver_package_cab) { + _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->in.driver_package_cab, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver_package_cab)); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver_package_cab, ndr_get_array_size(ndr, &r->in.driver_package_cab), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0); + } + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.driver_package_cab_size)); + NDR_PULL_ALLOC(ndr, r->out.required); + ZERO_STRUCTP(r->out.required); + if (r->in.driver_package_cab) { + NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.driver_package_cab, r->in.driver_package_cab_size)); + } + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab)); + if (_ptr_driver_package_cab) { + NDR_PULL_ALLOC(ndr, r->out.driver_package_cab); + } else { + r->out.driver_package_cab = NULL; + } + if (r->out.driver_package_cab) { + _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->out.driver_package_cab, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->out.driver_package_cab)); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->out.driver_package_cab, ndr_get_array_size(ndr, &r->out.driver_package_cab), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0); + } + if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { + NDR_PULL_ALLOC(ndr, r->out.required); + } + _mem_save_required_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->out.required, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_0, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); + if (r->out.driver_package_cab) { + NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.driver_package_cab, r->in.driver_package_cab_size)); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r) +{ + ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverPackagePath"); + ndr->depth++; + if (flags & NDR_SET_VALUES) { + ndr->flags |= LIBNDR_PRINT_SET_VALUES; + } + if (flags & NDR_IN) { + ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverPackagePath"); + ndr->depth++; + ndr_print_ptr(ndr, "servername", r->in.servername); + ndr->depth++; + if (r->in.servername) { + ndr_print_string(ndr, "servername", r->in.servername); + } + ndr->depth--; + ndr_print_ptr(ndr, "architecture", r->in.architecture); + ndr->depth++; + ndr_print_string(ndr, "architecture", r->in.architecture); + ndr->depth--; + ndr_print_ptr(ndr, "language", r->in.language); + ndr->depth++; + if (r->in.language) { + ndr_print_string(ndr, "language", r->in.language); + } + ndr->depth--; + ndr_print_ptr(ndr, "package_id", r->in.package_id); + ndr->depth++; + ndr_print_string(ndr, "package_id", r->in.package_id); + ndr->depth--; + ndr_print_ptr(ndr, "driver_package_cab", r->in.driver_package_cab); + ndr->depth++; + if (r->in.driver_package_cab) { + ndr_print_string(ndr, "driver_package_cab", r->in.driver_package_cab); + } + ndr->depth--; + ndr_print_uint32(ndr, "driver_package_cab_size", r->in.driver_package_cab_size); + ndr->depth--; + } + if (flags & NDR_OUT) { + ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverPackagePath"); + ndr->depth++; + ndr_print_ptr(ndr, "driver_package_cab", r->out.driver_package_cab); + ndr->depth++; + if (r->out.driver_package_cab) { + ndr_print_string(ndr, "driver_package_cab", r->out.driver_package_cab); + } + ndr->depth--; + ndr_print_ptr(ndr, "required", r->out.required); + ndr->depth++; + ndr_print_uint32(ndr, "required", *r->out.required); + ndr->depth--; + ndr_print_WERROR(ndr, "result", r->out.result); + ndr->depth--; + } + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_69(struct ndr_push *ndr, int flags, const struct spoolss_69 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_69(struct ndr_pull *ndr, int flags, struct spoolss_69 *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r) +{ + ndr_print_struct(ndr, name, "spoolss_69"); + ndr->depth++; + if (flags & NDR_SET_VALUES) { + ndr->flags |= LIBNDR_PRINT_SET_VALUES; + } + if (flags & NDR_IN) { + ndr_print_struct(ndr, "in", "spoolss_69"); + ndr->depth++; + ndr->depth--; + } + if (flags & NDR_OUT) { + ndr_print_struct(ndr, "out", "spoolss_69"); + ndr->depth++; + ndr_print_WERROR(ndr, "result", r->out.result); + ndr->depth--; + } + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_6a(struct ndr_push *ndr, int flags, const struct spoolss_6a *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_6a(struct ndr_pull *ndr, int flags, struct spoolss_6a *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r) +{ + ndr_print_struct(ndr, name, "spoolss_6a"); + ndr->depth++; + if (flags & NDR_SET_VALUES) { + ndr->flags |= LIBNDR_PRINT_SET_VALUES; + } + if (flags & NDR_IN) { + ndr_print_struct(ndr, "in", "spoolss_6a"); + ndr->depth++; + ndr->depth--; + } + if (flags & NDR_OUT) { + ndr_print_struct(ndr, "out", "spoolss_6a"); + ndr->depth++; + ndr_print_WERROR(ndr, "result", r->out.result); + ndr->depth--; + } + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_6b(struct ndr_push *ndr, int flags, const struct spoolss_6b *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_6b(struct ndr_pull *ndr, int flags, struct spoolss_6b *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r) +{ + ndr_print_struct(ndr, name, "spoolss_6b"); + ndr->depth++; + if (flags & NDR_SET_VALUES) { + ndr->flags |= LIBNDR_PRINT_SET_VALUES; + } + if (flags & NDR_IN) { + ndr_print_struct(ndr, "in", "spoolss_6b"); + ndr->depth++; + ndr->depth--; + } + if (flags & NDR_OUT) { + ndr_print_struct(ndr, "out", "spoolss_6b"); + ndr->depth++; + ndr_print_WERROR(ndr, "result", r->out.result); + ndr->depth--; + } + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_6c(struct ndr_push *ndr, int flags, const struct spoolss_6c *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_6c(struct ndr_pull *ndr, int flags, struct spoolss_6c *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r) +{ + ndr_print_struct(ndr, name, "spoolss_6c"); + ndr->depth++; + if (flags & NDR_SET_VALUES) { + ndr->flags |= LIBNDR_PRINT_SET_VALUES; + } + if (flags & NDR_IN) { + ndr_print_struct(ndr, "in", "spoolss_6c"); + ndr->depth++; + ndr->depth--; + } + if (flags & NDR_OUT) { + ndr_print_struct(ndr, "out", "spoolss_6c"); + ndr->depth++; + ndr_print_WERROR(ndr, "result", r->out.result); + ndr->depth--; + } + ndr->depth--; +} + +static enum ndr_err_code ndr_push_spoolss_6d(struct ndr_push *ndr, int flags, const struct spoolss_6d *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_spoolss_6d(struct ndr_pull *ndr, int flags, struct spoolss_6d *r) +{ + if (flags & NDR_IN) { + } + if (flags & NDR_OUT) { + NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r) +{ + ndr_print_struct(ndr, name, "spoolss_6d"); + ndr->depth++; + if (flags & NDR_SET_VALUES) { + ndr->flags |= LIBNDR_PRINT_SET_VALUES; + } + if (flags & NDR_IN) { + ndr_print_struct(ndr, "in", "spoolss_6d"); + ndr->depth++; + ndr->depth--; + } + if (flags & NDR_OUT) { + ndr_print_struct(ndr, "out", "spoolss_6d"); + ndr->depth++; + ndr_print_WERROR(ndr, "result", r->out.result); + ndr->depth--; + } + ndr->depth--; +} + +static const struct ndr_interface_call spoolss_calls[] = { + { + "spoolss_EnumPrinters", + sizeof(struct spoolss_EnumPrinters), + (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters, + (ndr_print_function_t) ndr_print_spoolss_EnumPrinters, + false, + }, + { + "spoolss_OpenPrinter", + sizeof(struct spoolss_OpenPrinter), + (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter, + (ndr_print_function_t) ndr_print_spoolss_OpenPrinter, + false, + }, + { + "spoolss_SetJob", + sizeof(struct spoolss_SetJob), + (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob, + (ndr_print_function_t) ndr_print_spoolss_SetJob, + false, + }, + { + "spoolss_GetJob", + sizeof(struct spoolss_GetJob), + (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob, + (ndr_print_function_t) ndr_print_spoolss_GetJob, + false, + }, + { + "spoolss_EnumJobs", + sizeof(struct spoolss_EnumJobs), + (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs, + (ndr_print_function_t) ndr_print_spoolss_EnumJobs, + false, + }, + { + "spoolss_AddPrinter", + sizeof(struct spoolss_AddPrinter), + (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter, + (ndr_print_function_t) ndr_print_spoolss_AddPrinter, + false, + }, + { + "spoolss_DeletePrinter", + sizeof(struct spoolss_DeletePrinter), + (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter, + (ndr_print_function_t) ndr_print_spoolss_DeletePrinter, + false, + }, + { + "spoolss_SetPrinter", + sizeof(struct spoolss_SetPrinter), + (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter, + (ndr_print_function_t) ndr_print_spoolss_SetPrinter, + false, + }, + { + "spoolss_GetPrinter", + sizeof(struct spoolss_GetPrinter), + (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter, + (ndr_print_function_t) ndr_print_spoolss_GetPrinter, + false, + }, + { + "spoolss_AddPrinterDriver", + sizeof(struct spoolss_AddPrinterDriver), + (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver, + (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver, + false, + }, + { + "spoolss_EnumPrinterDrivers", + sizeof(struct spoolss_EnumPrinterDrivers), + (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers, + (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers, + false, + }, + { + "spoolss_GetPrinterDriver", + sizeof(struct spoolss_GetPrinterDriver), + (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver, + (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver, + false, + }, + { + "spoolss_GetPrinterDriverDirectory", + sizeof(struct spoolss_GetPrinterDriverDirectory), + (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory, + (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory, + false, + }, + { + "spoolss_DeletePrinterDriver", + sizeof(struct spoolss_DeletePrinterDriver), + (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver, + (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver, + false, + }, + { + "spoolss_AddPrintProcessor", + sizeof(struct spoolss_AddPrintProcessor), + (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor, + (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor, + false, + }, + { + "spoolss_EnumPrintProcessors", + sizeof(struct spoolss_EnumPrintProcessors), + (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors, + (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors, + false, + }, + { + "spoolss_GetPrintProcessorDirectory", + sizeof(struct spoolss_GetPrintProcessorDirectory), + (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory, + (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory, + false, + }, + { + "spoolss_StartDocPrinter", + sizeof(struct spoolss_StartDocPrinter), + (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter, + (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter, + false, + }, + { + "spoolss_StartPagePrinter", + sizeof(struct spoolss_StartPagePrinter), + (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter, + (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter, + false, + }, + { + "spoolss_WritePrinter", + sizeof(struct spoolss_WritePrinter), + (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter, + (ndr_print_function_t) ndr_print_spoolss_WritePrinter, + false, + }, + { + "spoolss_EndPagePrinter", + sizeof(struct spoolss_EndPagePrinter), + (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter, + (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter, + false, + }, + { + "spoolss_AbortPrinter", + sizeof(struct spoolss_AbortPrinter), + (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter, + (ndr_print_function_t) ndr_print_spoolss_AbortPrinter, + false, + }, + { + "spoolss_ReadPrinter", + sizeof(struct spoolss_ReadPrinter), + (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter, + (ndr_print_function_t) ndr_print_spoolss_ReadPrinter, + false, + }, + { + "spoolss_EndDocPrinter", + sizeof(struct spoolss_EndDocPrinter), + (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter, + (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter, + false, + }, + { + "spoolss_AddJob", + sizeof(struct spoolss_AddJob), + (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob, + (ndr_print_function_t) ndr_print_spoolss_AddJob, + false, + }, + { + "spoolss_ScheduleJob", + sizeof(struct spoolss_ScheduleJob), + (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob, + (ndr_print_function_t) ndr_print_spoolss_ScheduleJob, + false, + }, + { + "spoolss_GetPrinterData", + sizeof(struct spoolss_GetPrinterData), + (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData, + (ndr_print_function_t) ndr_print_spoolss_GetPrinterData, + false, + }, + { + "spoolss_SetPrinterData", + sizeof(struct spoolss_SetPrinterData), + (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData, + (ndr_print_function_t) ndr_print_spoolss_SetPrinterData, + false, + }, + { "spoolss_WaitForPrinterChange", sizeof(struct spoolss_WaitForPrinterChange), (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange, @@ -29246,6 +30152,118 @@ static const struct ndr_interface_call spoolss_calls[] = { (ndr_print_function_t) ndr_print_spoolss_5f, false, }, + { + "spoolss_60", + sizeof(struct spoolss_60), + (ndr_push_flags_fn_t) ndr_push_spoolss_60, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_60, + (ndr_print_function_t) ndr_print_spoolss_60, + false, + }, + { + "spoolss_61", + sizeof(struct spoolss_61), + (ndr_push_flags_fn_t) ndr_push_spoolss_61, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_61, + (ndr_print_function_t) ndr_print_spoolss_61, + false, + }, + { + "spoolss_62", + sizeof(struct spoolss_62), + (ndr_push_flags_fn_t) ndr_push_spoolss_62, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_62, + (ndr_print_function_t) ndr_print_spoolss_62, + false, + }, + { + "spoolss_63", + sizeof(struct spoolss_63), + (ndr_push_flags_fn_t) ndr_push_spoolss_63, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_63, + (ndr_print_function_t) ndr_print_spoolss_63, + false, + }, + { + "spoolss_64", + sizeof(struct spoolss_64), + (ndr_push_flags_fn_t) ndr_push_spoolss_64, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_64, + (ndr_print_function_t) ndr_print_spoolss_64, + false, + }, + { + "spoolss_65", + sizeof(struct spoolss_65), + (ndr_push_flags_fn_t) ndr_push_spoolss_65, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_65, + (ndr_print_function_t) ndr_print_spoolss_65, + false, + }, + { + "spoolss_GetCorePrinterDrivers", + sizeof(struct spoolss_GetCorePrinterDrivers), + (ndr_push_flags_fn_t) ndr_push_spoolss_GetCorePrinterDrivers, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetCorePrinterDrivers, + (ndr_print_function_t) ndr_print_spoolss_GetCorePrinterDrivers, + false, + }, + { + "spoolss_67", + sizeof(struct spoolss_67), + (ndr_push_flags_fn_t) ndr_push_spoolss_67, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_67, + (ndr_print_function_t) ndr_print_spoolss_67, + false, + }, + { + "spoolss_GetPrinterDriverPackagePath", + sizeof(struct spoolss_GetPrinterDriverPackagePath), + (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverPackagePath, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverPackagePath, + (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverPackagePath, + false, + }, + { + "spoolss_69", + sizeof(struct spoolss_69), + (ndr_push_flags_fn_t) ndr_push_spoolss_69, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_69, + (ndr_print_function_t) ndr_print_spoolss_69, + false, + }, + { + "spoolss_6a", + sizeof(struct spoolss_6a), + (ndr_push_flags_fn_t) ndr_push_spoolss_6a, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_6a, + (ndr_print_function_t) ndr_print_spoolss_6a, + false, + }, + { + "spoolss_6b", + sizeof(struct spoolss_6b), + (ndr_push_flags_fn_t) ndr_push_spoolss_6b, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_6b, + (ndr_print_function_t) ndr_print_spoolss_6b, + false, + }, + { + "spoolss_6c", + sizeof(struct spoolss_6c), + (ndr_push_flags_fn_t) ndr_push_spoolss_6c, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_6c, + (ndr_print_function_t) ndr_print_spoolss_6c, + false, + }, + { + "spoolss_6d", + sizeof(struct spoolss_6d), + (ndr_push_flags_fn_t) ndr_push_spoolss_6d, + (ndr_pull_flags_fn_t) ndr_pull_spoolss_6d, + (ndr_print_function_t) ndr_print_spoolss_6d, + false, + }, { NULL, 0, NULL, NULL, NULL, false } }; @@ -29275,7 +30293,7 @@ const struct ndr_interface_table ndr_table_spoolss = { NDR_SPOOLSS_VERSION }, .helpstring = NDR_SPOOLSS_HELPSTRING, - .num_calls = 96, + .num_calls = 110, .calls = spoolss_calls, .endpoints = &spoolss_endpoints, .authservices = &spoolss_authservices diff --git a/librpc/gen_ndr/ndr_spoolss.h b/librpc/gen_ndr/ndr_spoolss.h index 9a33852756..185f8254bd 100644 --- a/librpc/gen_ndr/ndr_spoolss.h +++ b/librpc/gen_ndr/ndr_spoolss.h @@ -204,7 +204,35 @@ extern const struct ndr_interface_table ndr_table_spoolss; #define NDR_SPOOLSS_5F (0x5f) -#define NDR_SPOOLSS_CALL_COUNT (96) +#define NDR_SPOOLSS_60 (0x60) + +#define NDR_SPOOLSS_61 (0x61) + +#define NDR_SPOOLSS_62 (0x62) + +#define NDR_SPOOLSS_63 (0x63) + +#define NDR_SPOOLSS_64 (0x64) + +#define NDR_SPOOLSS_65 (0x65) + +#define NDR_SPOOLSS_GETCOREPRINTERDRIVERS (0x66) + +#define NDR_SPOOLSS_67 (0x67) + +#define NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH (0x68) + +#define NDR_SPOOLSS_69 (0x69) + +#define NDR_SPOOLSS_6A (0x6a) + +#define NDR_SPOOLSS_6B (0x6b) + +#define NDR_SPOOLSS_6C (0x6c) + +#define NDR_SPOOLSS_6D (0x6d) + +#define NDR_SPOOLSS_CALL_COUNT (110) 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); @@ -508,6 +536,7 @@ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r); void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r); void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r); +void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r); enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r); enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r); void ndr_print__spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct _spoolss_EnumPrinters *r); @@ -715,4 +744,18 @@ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, co void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r); void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r); void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r); +void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r); +void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r); +void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r); +void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r); +void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r); +void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r); +void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r); +void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r); +void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r); +void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r); +void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r); +void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r); +void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r); +void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r); #endif /* _HEADER_NDR_spoolss */ diff --git a/librpc/gen_ndr/spoolss.h b/librpc/gen_ndr/spoolss.h index bd3318ef53..71e1e9414e 100644 --- a/librpc/gen_ndr/spoolss.h +++ b/librpc/gen_ndr/spoolss.h @@ -2053,6 +2053,13 @@ struct spoolss_MonitorUi { #define APD_COPY_TO_ALL_SPOOLERS ( 0x00002000 ) #define APD_RETURN_BLOCKING_STATUS_CODE ( 0x00010000 ) +struct spoolss_CorePrinterDriver { + struct GUID core_driver_guid; + NTTIME driver_date; + uint64_t driver_version; + const char *formname;/* [charset(UTF8)] */ +}; + struct _spoolss_EnumPrinters { struct { @@ -3646,4 +3653,136 @@ struct spoolss_5f { }; + +struct spoolss_60 { + struct { + WERROR result; + } out; + +}; + + +struct spoolss_61 { + struct { + WERROR result; + } out; + +}; + + +struct spoolss_62 { + struct { + WERROR result; + } out; + +}; + + +struct spoolss_63 { + struct { + WERROR result; + } out; + +}; + + +struct spoolss_64 { + struct { + WERROR result; + } out; + +}; + + +struct spoolss_65 { + struct { + WERROR result; + } out; + +}; + + +struct spoolss_GetCorePrinterDrivers { + struct { + const char *servername;/* [unique,charset(UTF16)] */ + const char *architecture;/* [ref,charset(UTF16)] */ + uint32_t core_driver_size; + const char *core_driver_dependencies;/* [ref,charset(UTF16),size_is(core_driver_size)] */ + uint32_t core_printer_driver_count; + } in; + + struct { + struct spoolss_CorePrinterDriver *core_printer_drivers;/* [ref,size_is(core_printer_driver_count)] */ + WERROR result; + } out; + +}; + + +struct spoolss_67 { + struct { + WERROR result; + } out; + +}; + + +struct spoolss_GetPrinterDriverPackagePath { + struct { + const char *servername;/* [unique,charset(UTF16)] */ + const char *architecture;/* [ref,charset(UTF16)] */ + const char *language;/* [unique,charset(UTF16)] */ + const char *package_id;/* [ref,charset(UTF16)] */ + uint32_t driver_package_cab_size; + const char *driver_package_cab;/* [unique,charset(UTF16),size_is(driver_package_cab_size)] */ + } in; + + struct { + uint32_t *required;/* [ref] */ + const char *driver_package_cab;/* [unique,charset(UTF16),size_is(driver_package_cab_size)] */ + WERROR result; + } out; + +}; + + +struct spoolss_69 { + struct { + WERROR result; + } out; + +}; + + +struct spoolss_6a { + struct { + WERROR result; + } out; + +}; + + +struct spoolss_6b { + struct { + WERROR result; + } out; + +}; + + +struct spoolss_6c { + struct { + WERROR result; + } out; + +}; + + +struct spoolss_6d { + struct { + WERROR result; + } out; + +}; + #endif /* _HEADER_spoolss */ diff --git a/librpc/gen_ndr/srv_spoolss.c b/librpc/gen_ndr/srv_spoolss.c index ae99f098a6..c3266dc5af 100644 --- a/librpc/gen_ndr/srv_spoolss.c +++ b/librpc/gen_ndr/srv_spoolss.c @@ -7481,6 +7481,1043 @@ static bool api_spoolss_5f(pipes_struct *p) return true; } +static bool api_spoolss_60(pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + DATA_BLOB blob; + struct spoolss_60 *r; + + call = &ndr_table_spoolss.calls[NDR_SPOOLSS_60]; + + r = talloc(talloc_tos(), struct spoolss_60); + if (r == NULL) { + return false; + } + + if (!prs_data_blob(&p->in_data.data, &blob, r)) { + talloc_free(r); + return false; + } + + pull = ndr_pull_init_blob(&blob, r, NULL); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_60, r); + } + + r->out.result = _spoolss_60(p, r); + + if (p->rng_fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_60, r); + } + + push = ndr_push_init_ctx(r, NULL); + if (push == NULL) { + talloc_free(r); + return false; + } + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + blob = ndr_push_blob(push); + if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { + talloc_free(r); + return false; + } + + talloc_free(r); + + return true; +} + +static bool api_spoolss_61(pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + DATA_BLOB blob; + struct spoolss_61 *r; + + call = &ndr_table_spoolss.calls[NDR_SPOOLSS_61]; + + r = talloc(talloc_tos(), struct spoolss_61); + if (r == NULL) { + return false; + } + + if (!prs_data_blob(&p->in_data.data, &blob, r)) { + talloc_free(r); + return false; + } + + pull = ndr_pull_init_blob(&blob, r, NULL); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_61, r); + } + + r->out.result = _spoolss_61(p, r); + + if (p->rng_fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_61, r); + } + + push = ndr_push_init_ctx(r, NULL); + if (push == NULL) { + talloc_free(r); + return false; + } + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + blob = ndr_push_blob(push); + if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { + talloc_free(r); + return false; + } + + talloc_free(r); + + return true; +} + +static bool api_spoolss_62(pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + DATA_BLOB blob; + struct spoolss_62 *r; + + call = &ndr_table_spoolss.calls[NDR_SPOOLSS_62]; + + r = talloc(talloc_tos(), struct spoolss_62); + if (r == NULL) { + return false; + } + + if (!prs_data_blob(&p->in_data.data, &blob, r)) { + talloc_free(r); + return false; + } + + pull = ndr_pull_init_blob(&blob, r, NULL); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_62, r); + } + + r->out.result = _spoolss_62(p, r); + + if (p->rng_fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_62, r); + } + + push = ndr_push_init_ctx(r, NULL); + if (push == NULL) { + talloc_free(r); + return false; + } + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + blob = ndr_push_blob(push); + if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { + talloc_free(r); + return false; + } + + talloc_free(r); + + return true; +} + +static bool api_spoolss_63(pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + DATA_BLOB blob; + struct spoolss_63 *r; + + call = &ndr_table_spoolss.calls[NDR_SPOOLSS_63]; + + r = talloc(talloc_tos(), struct spoolss_63); + if (r == NULL) { + return false; + } + + if (!prs_data_blob(&p->in_data.data, &blob, r)) { + talloc_free(r); + return false; + } + + pull = ndr_pull_init_blob(&blob, r, NULL); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_63, r); + } + + r->out.result = _spoolss_63(p, r); + + if (p->rng_fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_63, r); + } + + push = ndr_push_init_ctx(r, NULL); + if (push == NULL) { + talloc_free(r); + return false; + } + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + blob = ndr_push_blob(push); + if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { + talloc_free(r); + return false; + } + + talloc_free(r); + + return true; +} + +static bool api_spoolss_64(pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + DATA_BLOB blob; + struct spoolss_64 *r; + + call = &ndr_table_spoolss.calls[NDR_SPOOLSS_64]; + + r = talloc(talloc_tos(), struct spoolss_64); + if (r == NULL) { + return false; + } + + if (!prs_data_blob(&p->in_data.data, &blob, r)) { + talloc_free(r); + return false; + } + + pull = ndr_pull_init_blob(&blob, r, NULL); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_64, r); + } + + r->out.result = _spoolss_64(p, r); + + if (p->rng_fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_64, r); + } + + push = ndr_push_init_ctx(r, NULL); + if (push == NULL) { + talloc_free(r); + return false; + } + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + blob = ndr_push_blob(push); + if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { + talloc_free(r); + return false; + } + + talloc_free(r); + + return true; +} + +static bool api_spoolss_65(pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + DATA_BLOB blob; + struct spoolss_65 *r; + + call = &ndr_table_spoolss.calls[NDR_SPOOLSS_65]; + + r = talloc(talloc_tos(), struct spoolss_65); + if (r == NULL) { + return false; + } + + if (!prs_data_blob(&p->in_data.data, &blob, r)) { + talloc_free(r); + return false; + } + + pull = ndr_pull_init_blob(&blob, r, NULL); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_65, r); + } + + r->out.result = _spoolss_65(p, r); + + if (p->rng_fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_65, r); + } + + push = ndr_push_init_ctx(r, NULL); + if (push == NULL) { + talloc_free(r); + return false; + } + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + blob = ndr_push_blob(push); + if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { + talloc_free(r); + return false; + } + + talloc_free(r); + + return true; +} + +static bool api_spoolss_GetCorePrinterDrivers(pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + DATA_BLOB blob; + struct spoolss_GetCorePrinterDrivers *r; + + call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETCOREPRINTERDRIVERS]; + + r = talloc(talloc_tos(), struct spoolss_GetCorePrinterDrivers); + if (r == NULL) { + return false; + } + + if (!prs_data_blob(&p->in_data.data, &blob, r)) { + talloc_free(r); + return false; + } + + pull = ndr_pull_init_blob(&blob, r, NULL); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_GetCorePrinterDrivers, r); + } + + ZERO_STRUCT(r->out); + r->out.core_printer_drivers = talloc_zero_array(r, struct spoolss_CorePrinterDriver, r->in.core_printer_driver_count); + if (r->out.core_printer_drivers == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _spoolss_GetCorePrinterDrivers(p, r); + + if (p->rng_fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_GetCorePrinterDrivers, r); + } + + push = ndr_push_init_ctx(r, NULL); + if (push == NULL) { + talloc_free(r); + return false; + } + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + blob = ndr_push_blob(push); + if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { + talloc_free(r); + return false; + } + + talloc_free(r); + + return true; +} + +static bool api_spoolss_67(pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + DATA_BLOB blob; + struct spoolss_67 *r; + + call = &ndr_table_spoolss.calls[NDR_SPOOLSS_67]; + + r = talloc(talloc_tos(), struct spoolss_67); + if (r == NULL) { + return false; + } + + if (!prs_data_blob(&p->in_data.data, &blob, r)) { + talloc_free(r); + return false; + } + + pull = ndr_pull_init_blob(&blob, r, NULL); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_67, r); + } + + r->out.result = _spoolss_67(p, r); + + if (p->rng_fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_67, r); + } + + push = ndr_push_init_ctx(r, NULL); + if (push == NULL) { + talloc_free(r); + return false; + } + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + blob = ndr_push_blob(push); + if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { + talloc_free(r); + return false; + } + + talloc_free(r); + + return true; +} + +static bool api_spoolss_GetPrinterDriverPackagePath(pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + DATA_BLOB blob; + struct spoolss_GetPrinterDriverPackagePath *r; + + call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH]; + + r = talloc(talloc_tos(), struct spoolss_GetPrinterDriverPackagePath); + if (r == NULL) { + return false; + } + + if (!prs_data_blob(&p->in_data.data, &blob, r)) { + talloc_free(r); + return false; + } + + pull = ndr_pull_init_blob(&blob, r, NULL); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverPackagePath, r); + } + + ZERO_STRUCT(r->out); + r->out.driver_package_cab = r->in.driver_package_cab; + r->out.required = talloc_zero(r, uint32_t); + if (r->out.required == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _spoolss_GetPrinterDriverPackagePath(p, r); + + if (p->rng_fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverPackagePath, r); + } + + push = ndr_push_init_ctx(r, NULL); + if (push == NULL) { + talloc_free(r); + return false; + } + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + blob = ndr_push_blob(push); + if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { + talloc_free(r); + return false; + } + + talloc_free(r); + + return true; +} + +static bool api_spoolss_69(pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + DATA_BLOB blob; + struct spoolss_69 *r; + + call = &ndr_table_spoolss.calls[NDR_SPOOLSS_69]; + + r = talloc(talloc_tos(), struct spoolss_69); + if (r == NULL) { + return false; + } + + if (!prs_data_blob(&p->in_data.data, &blob, r)) { + talloc_free(r); + return false; + } + + pull = ndr_pull_init_blob(&blob, r, NULL); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_69, r); + } + + r->out.result = _spoolss_69(p, r); + + if (p->rng_fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_69, r); + } + + push = ndr_push_init_ctx(r, NULL); + if (push == NULL) { + talloc_free(r); + return false; + } + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + blob = ndr_push_blob(push); + if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { + talloc_free(r); + return false; + } + + talloc_free(r); + + return true; +} + +static bool api_spoolss_6a(pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + DATA_BLOB blob; + struct spoolss_6a *r; + + call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6A]; + + r = talloc(talloc_tos(), struct spoolss_6a); + if (r == NULL) { + return false; + } + + if (!prs_data_blob(&p->in_data.data, &blob, r)) { + talloc_free(r); + return false; + } + + pull = ndr_pull_init_blob(&blob, r, NULL); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_6a, r); + } + + r->out.result = _spoolss_6a(p, r); + + if (p->rng_fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_6a, r); + } + + push = ndr_push_init_ctx(r, NULL); + if (push == NULL) { + talloc_free(r); + return false; + } + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + blob = ndr_push_blob(push); + if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { + talloc_free(r); + return false; + } + + talloc_free(r); + + return true; +} + +static bool api_spoolss_6b(pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + DATA_BLOB blob; + struct spoolss_6b *r; + + call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6B]; + + r = talloc(talloc_tos(), struct spoolss_6b); + if (r == NULL) { + return false; + } + + if (!prs_data_blob(&p->in_data.data, &blob, r)) { + talloc_free(r); + return false; + } + + pull = ndr_pull_init_blob(&blob, r, NULL); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_6b, r); + } + + r->out.result = _spoolss_6b(p, r); + + if (p->rng_fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_6b, r); + } + + push = ndr_push_init_ctx(r, NULL); + if (push == NULL) { + talloc_free(r); + return false; + } + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + blob = ndr_push_blob(push); + if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { + talloc_free(r); + return false; + } + + talloc_free(r); + + return true; +} + +static bool api_spoolss_6c(pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + DATA_BLOB blob; + struct spoolss_6c *r; + + call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6C]; + + r = talloc(talloc_tos(), struct spoolss_6c); + if (r == NULL) { + return false; + } + + if (!prs_data_blob(&p->in_data.data, &blob, r)) { + talloc_free(r); + return false; + } + + pull = ndr_pull_init_blob(&blob, r, NULL); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_6c, r); + } + + r->out.result = _spoolss_6c(p, r); + + if (p->rng_fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_6c, r); + } + + push = ndr_push_init_ctx(r, NULL); + if (push == NULL) { + talloc_free(r); + return false; + } + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + blob = ndr_push_blob(push); + if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { + talloc_free(r); + return false; + } + + talloc_free(r); + + return true; +} + +static bool api_spoolss_6d(pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + DATA_BLOB blob; + struct spoolss_6d *r; + + call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6D]; + + r = talloc(talloc_tos(), struct spoolss_6d); + if (r == NULL) { + return false; + } + + if (!prs_data_blob(&p->in_data.data, &blob, r)) { + talloc_free(r); + return false; + } + + pull = ndr_pull_init_blob(&blob, r, NULL); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(spoolss_6d, r); + } + + r->out.result = _spoolss_6d(p, r); + + if (p->rng_fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(spoolss_6d, r); + } + + push = ndr_push_init_ctx(r, NULL); + if (push == NULL) { + talloc_free(r); + return false; + } + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + blob = ndr_push_blob(push); + if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { + talloc_free(r); + return false; + } + + talloc_free(r); + + return true; +} + /* Tables */ static struct api_struct api_spoolss_cmds[] = @@ -7581,6 +8618,20 @@ static struct api_struct api_spoolss_cmds[] = {"SPOOLSS_5D", NDR_SPOOLSS_5D, api_spoolss_5d}, {"SPOOLSS_5E", NDR_SPOOLSS_5E, api_spoolss_5e}, {"SPOOLSS_5F", NDR_SPOOLSS_5F, api_spoolss_5f}, + {"SPOOLSS_60", NDR_SPOOLSS_60, api_spoolss_60}, + {"SPOOLSS_61", NDR_SPOOLSS_61, api_spoolss_61}, + {"SPOOLSS_62", NDR_SPOOLSS_62, api_spoolss_62}, + {"SPOOLSS_63", NDR_SPOOLSS_63, api_spoolss_63}, + {"SPOOLSS_64", NDR_SPOOLSS_64, api_spoolss_64}, + {"SPOOLSS_65", NDR_SPOOLSS_65, api_spoolss_65}, + {"SPOOLSS_GETCOREPRINTERDRIVERS", NDR_SPOOLSS_GETCOREPRINTERDRIVERS, api_spoolss_GetCorePrinterDrivers}, + {"SPOOLSS_67", NDR_SPOOLSS_67, api_spoolss_67}, + {"SPOOLSS_GETPRINTERDRIVERPACKAGEPATH", NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH, api_spoolss_GetPrinterDriverPackagePath}, + {"SPOOLSS_69", NDR_SPOOLSS_69, api_spoolss_69}, + {"SPOOLSS_6A", NDR_SPOOLSS_6A, api_spoolss_6a}, + {"SPOOLSS_6B", NDR_SPOOLSS_6B, api_spoolss_6b}, + {"SPOOLSS_6C", NDR_SPOOLSS_6C, api_spoolss_6c}, + {"SPOOLSS_6D", NDR_SPOOLSS_6D, api_spoolss_6d}, }; void spoolss_get_pipe_fns(struct api_struct **fns, int *n_fns) @@ -8569,6 +9620,103 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, return NT_STATUS_OK; } + case NDR_SPOOLSS_60: { + struct spoolss_60 *r = (struct spoolss_60 *)_r; + r->out.result = _spoolss_60(cli->pipes_struct, r); + return NT_STATUS_OK; + } + + case NDR_SPOOLSS_61: { + struct spoolss_61 *r = (struct spoolss_61 *)_r; + r->out.result = _spoolss_61(cli->pipes_struct, r); + return NT_STATUS_OK; + } + + case NDR_SPOOLSS_62: { + struct spoolss_62 *r = (struct spoolss_62 *)_r; + r->out.result = _spoolss_62(cli->pipes_struct, r); + return NT_STATUS_OK; + } + + case NDR_SPOOLSS_63: { + struct spoolss_63 *r = (struct spoolss_63 *)_r; + r->out.result = _spoolss_63(cli->pipes_struct, r); + return NT_STATUS_OK; + } + + case NDR_SPOOLSS_64: { + struct spoolss_64 *r = (struct spoolss_64 *)_r; + r->out.result = _spoolss_64(cli->pipes_struct, r); + return NT_STATUS_OK; + } + + case NDR_SPOOLSS_65: { + struct spoolss_65 *r = (struct spoolss_65 *)_r; + r->out.result = _spoolss_65(cli->pipes_struct, r); + return NT_STATUS_OK; + } + + case NDR_SPOOLSS_GETCOREPRINTERDRIVERS: { + struct spoolss_GetCorePrinterDrivers *r = (struct spoolss_GetCorePrinterDrivers *)_r; + ZERO_STRUCT(r->out); + r->out.core_printer_drivers = talloc_zero_array(mem_ctx, struct spoolss_CorePrinterDriver, r->in.core_printer_driver_count); + if (r->out.core_printer_drivers == NULL) { + return NT_STATUS_NO_MEMORY; + } + + r->out.result = _spoolss_GetCorePrinterDrivers(cli->pipes_struct, r); + return NT_STATUS_OK; + } + + case NDR_SPOOLSS_67: { + struct spoolss_67 *r = (struct spoolss_67 *)_r; + r->out.result = _spoolss_67(cli->pipes_struct, r); + return NT_STATUS_OK; + } + + case NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH: { + struct spoolss_GetPrinterDriverPackagePath *r = (struct spoolss_GetPrinterDriverPackagePath *)_r; + ZERO_STRUCT(r->out); + r->out.driver_package_cab = r->in.driver_package_cab; + r->out.required = talloc_zero(mem_ctx, uint32_t); + if (r->out.required == NULL) { + return NT_STATUS_NO_MEMORY; + } + + r->out.result = _spoolss_GetPrinterDriverPackagePath(cli->pipes_struct, r); + return NT_STATUS_OK; + } + + case NDR_SPOOLSS_69: { + struct spoolss_69 *r = (struct spoolss_69 *)_r; + r->out.result = _spoolss_69(cli->pipes_struct, r); + return NT_STATUS_OK; + } + + case NDR_SPOOLSS_6A: { + struct spoolss_6a *r = (struct spoolss_6a *)_r; + r->out.result = _spoolss_6a(cli->pipes_struct, r); + return NT_STATUS_OK; + } + + case NDR_SPOOLSS_6B: { + struct spoolss_6b *r = (struct spoolss_6b *)_r; + r->out.result = _spoolss_6b(cli->pipes_struct, r); + return NT_STATUS_OK; + } + + case NDR_SPOOLSS_6C: { + struct spoolss_6c *r = (struct spoolss_6c *)_r; + r->out.result = _spoolss_6c(cli->pipes_struct, r); + return NT_STATUS_OK; + } + + case NDR_SPOOLSS_6D: { + struct spoolss_6d *r = (struct spoolss_6d *)_r; + r->out.result = _spoolss_6d(cli->pipes_struct, r); + return NT_STATUS_OK; + } + default: return NT_STATUS_NOT_IMPLEMENTED; } diff --git a/librpc/gen_ndr/srv_spoolss.h b/librpc/gen_ndr/srv_spoolss.h index da31eb78b6..8b5d8f8d48 100644 --- a/librpc/gen_ndr/srv_spoolss.h +++ b/librpc/gen_ndr/srv_spoolss.h @@ -97,6 +97,20 @@ WERROR _spoolss_5c(pipes_struct *p, struct spoolss_5c *r); WERROR _spoolss_5d(pipes_struct *p, struct spoolss_5d *r); WERROR _spoolss_5e(pipes_struct *p, struct spoolss_5e *r); WERROR _spoolss_5f(pipes_struct *p, struct spoolss_5f *r); +WERROR _spoolss_60(pipes_struct *p, struct spoolss_60 *r); +WERROR _spoolss_61(pipes_struct *p, struct spoolss_61 *r); +WERROR _spoolss_62(pipes_struct *p, struct spoolss_62 *r); +WERROR _spoolss_63(pipes_struct *p, struct spoolss_63 *r); +WERROR _spoolss_64(pipes_struct *p, struct spoolss_64 *r); +WERROR _spoolss_65(pipes_struct *p, struct spoolss_65 *r); +WERROR _spoolss_GetCorePrinterDrivers(pipes_struct *p, struct spoolss_GetCorePrinterDrivers *r); +WERROR _spoolss_67(pipes_struct *p, struct spoolss_67 *r); +WERROR _spoolss_GetPrinterDriverPackagePath(pipes_struct *p, struct spoolss_GetPrinterDriverPackagePath *r); +WERROR _spoolss_69(pipes_struct *p, struct spoolss_69 *r); +WERROR _spoolss_6a(pipes_struct *p, struct spoolss_6a *r); +WERROR _spoolss_6b(pipes_struct *p, struct spoolss_6b *r); +WERROR _spoolss_6c(pipes_struct *p, struct spoolss_6c *r); +WERROR _spoolss_6d(pipes_struct *p, struct spoolss_6d *r); void spoolss_get_pipe_fns(struct api_struct **fns, int *n_fns); NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *r); WERROR _spoolss_EnumPrinters(pipes_struct *p, struct spoolss_EnumPrinters *r); @@ -195,5 +209,19 @@ WERROR _spoolss_5c(pipes_struct *p, struct spoolss_5c *r); WERROR _spoolss_5d(pipes_struct *p, struct spoolss_5d *r); WERROR _spoolss_5e(pipes_struct *p, struct spoolss_5e *r); WERROR _spoolss_5f(pipes_struct *p, struct spoolss_5f *r); +WERROR _spoolss_60(pipes_struct *p, struct spoolss_60 *r); +WERROR _spoolss_61(pipes_struct *p, struct spoolss_61 *r); +WERROR _spoolss_62(pipes_struct *p, struct spoolss_62 *r); +WERROR _spoolss_63(pipes_struct *p, struct spoolss_63 *r); +WERROR _spoolss_64(pipes_struct *p, struct spoolss_64 *r); +WERROR _spoolss_65(pipes_struct *p, struct spoolss_65 *r); +WERROR _spoolss_GetCorePrinterDrivers(pipes_struct *p, struct spoolss_GetCorePrinterDrivers *r); +WERROR _spoolss_67(pipes_struct *p, struct spoolss_67 *r); +WERROR _spoolss_GetPrinterDriverPackagePath(pipes_struct *p, struct spoolss_GetPrinterDriverPackagePath *r); +WERROR _spoolss_69(pipes_struct *p, struct spoolss_69 *r); +WERROR _spoolss_6a(pipes_struct *p, struct spoolss_6a *r); +WERROR _spoolss_6b(pipes_struct *p, struct spoolss_6b *r); +WERROR _spoolss_6c(pipes_struct *p, struct spoolss_6c *r); +WERROR _spoolss_6d(pipes_struct *p, struct spoolss_6d *r); NTSTATUS rpc_spoolss_init(void); #endif /* __SRV_SPOOLSS__ */ -- cgit