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);
+}
+
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__ */
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) {
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_1<r->in.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,
(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 }
};
NDR_SPOOLSS_VERSION
},
.helpstring = NDR_SPOOLSS_HELPSTRING,
- .num_calls = 96,
+ .num_calls = 110,
.calls = spoolss_calls,
.endpoints = &spoolss_endpoints,
.authservices = &spoolss_authservices
#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);
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);
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 */
#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 {
};
+
+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 */
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[] =
{"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)
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;
}
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);
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__ */
git.samba.org / metze / samba / wip.git / commitdiff