?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
idl: recompile our IDL
[Samba/aatanasov.git] / librpc / gen_ndr / cli_spoolss.c
blob710af774a4ac2e8fb91a1f240a218908900619bc
1 /*
2 * Unix SMB/CIFS implementation.
3 * client auto-generated by pidl. DO NOT MODIFY!
4 */
5
6 #include "includes.h"
7 #include "../librpc/gen_ndr/cli_spoolss.h"
8
9 struct rpccli_spoolss_EnumPrinters_state {
10 struct spoolss_EnumPrinters orig;
11 struct spoolss_EnumPrinters tmp;
12 TALLOC_CTX *out_mem_ctx;
13 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14 };
15
16 static void rpccli_spoolss_EnumPrinters_done(struct tevent_req *subreq);
17
18 struct tevent_req *rpccli_spoolss_EnumPrinters_send(TALLOC_CTX *mem_ctx,
19 struct tevent_context *ev,
20 struct rpc_pipe_client *cli,
21 uint32_t _flags /* [in] */,
22 const char *_server /* [in] [unique,charset(UTF16)] */,
23 uint32_t _level /* [in] */,
24 DATA_BLOB *_buffer /* [in] [unique] */,
25 uint32_t _offered /* [in] */,
26 uint32_t *_count /* [out] [ref] */,
27 union spoolss_PrinterInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
28 uint32_t *_needed /* [out] [ref] */)
29 {
30 struct tevent_req *req;
31 struct rpccli_spoolss_EnumPrinters_state *state;
32 struct tevent_req *subreq;
33
34 req = tevent_req_create(mem_ctx, &state,
35 struct rpccli_spoolss_EnumPrinters_state);
36 if (req == NULL) {
37 return NULL;
38 }
39 state->out_mem_ctx = NULL;
40 state->dispatch_recv = cli->dispatch_recv;
41
42 /* In parameters */
43 state->orig.in.flags = _flags;
44 state->orig.in.server = _server;
45 state->orig.in.level = _level;
46 state->orig.in.buffer = _buffer;
47 state->orig.in.offered = _offered;
48
49 /* Out parameters */
50 state->orig.out.count = _count;
51 state->orig.out.info = _info;
52 state->orig.out.needed = _needed;
53
54 /* Result */
55 ZERO_STRUCT(state->orig.out.result);
56
57 if (DEBUGLEVEL >= 10) {
58 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinters, &state->orig);
59 }
60
61 state->out_mem_ctx = talloc_named_const(state, 0,
62 "rpccli_spoolss_EnumPrinters_out_memory");
63 if (tevent_req_nomem(state->out_mem_ctx, req)) {
64 return tevent_req_post(req, ev);
65 }
66
67 /* make a temporary copy, that we pass to the dispatch function */
68 state->tmp = state->orig;
69
70 subreq = cli->dispatch_send(state, ev, cli,
71 &ndr_table_spoolss,
72 NDR_SPOOLSS_ENUMPRINTERS,
73 &state->tmp);
74 if (tevent_req_nomem(subreq, req)) {
75 return tevent_req_post(req, ev);
76 }
77 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinters_done, req);
78 return req;
79 }
80
81 static void rpccli_spoolss_EnumPrinters_done(struct tevent_req *subreq)
82 {
83 struct tevent_req *req = tevent_req_callback_data(
84 subreq, struct tevent_req);
85 struct rpccli_spoolss_EnumPrinters_state *state = tevent_req_data(
86 req, struct rpccli_spoolss_EnumPrinters_state);
87 NTSTATUS status;
88 TALLOC_CTX *mem_ctx;
89
90 if (state->out_mem_ctx) {
91 mem_ctx = state->out_mem_ctx;
92 } else {
93 mem_ctx = state;
94 }
95
96 status = state->dispatch_recv(subreq, mem_ctx);
97 TALLOC_FREE(subreq);
98 if (!NT_STATUS_IS_OK(status)) {
99 tevent_req_nterror(req, status);
100 return;
101 }
102
103 /* Copy out parameters */
104 *state->orig.out.count = *state->tmp.out.count;
105 *state->orig.out.info = *state->tmp.out.info;
106 *state->orig.out.needed = *state->tmp.out.needed;
107
108 /* Copy result */
109 state->orig.out.result = state->tmp.out.result;
110
111 /* Reset temporary structure */
112 ZERO_STRUCT(state->tmp);
113
114 if (DEBUGLEVEL >= 10) {
115 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinters, &state->orig);
116 }
117
118 tevent_req_done(req);
119 }
120
121 NTSTATUS rpccli_spoolss_EnumPrinters_recv(struct tevent_req *req,
122 TALLOC_CTX *mem_ctx,
123 WERROR *result)
124 {
125 struct rpccli_spoolss_EnumPrinters_state *state = tevent_req_data(
126 req, struct rpccli_spoolss_EnumPrinters_state);
127 NTSTATUS status;
128
129 if (tevent_req_is_nterror(req, &status)) {
130 tevent_req_received(req);
131 return status;
132 }
133
134 /* Steal possbile out parameters to the callers context */
135 talloc_steal(mem_ctx, state->out_mem_ctx);
136
137 /* Return result */
138 *result = state->orig.out.result;
139
140 tevent_req_received(req);
141 return NT_STATUS_OK;
142 }
143
144 NTSTATUS rpccli_spoolss_EnumPrinters(struct rpc_pipe_client *cli,
145 TALLOC_CTX *mem_ctx,
146 uint32_t flags /* [in] */,
147 const char *server /* [in] [unique,charset(UTF16)] */,
148 uint32_t level /* [in] */,
149 DATA_BLOB *buffer /* [in] [unique] */,
150 uint32_t offered /* [in] */,
151 uint32_t *count /* [out] [ref] */,
152 union spoolss_PrinterInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
153 uint32_t *needed /* [out] [ref] */,
154 WERROR *werror)
155 {
156 struct spoolss_EnumPrinters r;
157 NTSTATUS status;
158
159 /* In parameters */
160 r.in.flags = flags;
161 r.in.server = server;
162 r.in.level = level;
163 r.in.buffer = buffer;
164 r.in.offered = offered;
165
166 if (DEBUGLEVEL >= 10) {
167 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinters, &r);
168 }
169
170 status = cli->dispatch(cli,
171 mem_ctx,
172 &ndr_table_spoolss,
173 NDR_SPOOLSS_ENUMPRINTERS,
174 &r);
175
176 if (!NT_STATUS_IS_OK(status)) {
177 return status;
178 }
179
180 if (DEBUGLEVEL >= 10) {
181 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinters, &r);
182 }
183
184 if (NT_STATUS_IS_ERR(status)) {
185 return status;
186 }
187
188 /* Return variables */
189 *count = *r.out.count;
190 *info = *r.out.info;
191 *needed = *r.out.needed;
192
193 /* Return result */
194 if (werror) {
195 *werror = r.out.result;
196 }
197
198 return werror_to_ntstatus(r.out.result);
199 }
200
201 struct rpccli_spoolss_OpenPrinter_state {
202 struct spoolss_OpenPrinter orig;
203 struct spoolss_OpenPrinter tmp;
204 TALLOC_CTX *out_mem_ctx;
205 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
206 };
207
208 static void rpccli_spoolss_OpenPrinter_done(struct tevent_req *subreq);
209
210 struct tevent_req *rpccli_spoolss_OpenPrinter_send(TALLOC_CTX *mem_ctx,
211 struct tevent_context *ev,
212 struct rpc_pipe_client *cli,
213 const char *_printername /* [in] [unique,charset(UTF16)] */,
214 const char *_datatype /* [in] [unique,charset(UTF16)] */,
215 struct spoolss_DevmodeContainer _devmode_ctr /* [in] */,
216 uint32_t _access_mask /* [in] */,
217 struct policy_handle *_handle /* [out] [ref] */)
218 {
219 struct tevent_req *req;
220 struct rpccli_spoolss_OpenPrinter_state *state;
221 struct tevent_req *subreq;
222
223 req = tevent_req_create(mem_ctx, &state,
224 struct rpccli_spoolss_OpenPrinter_state);
225 if (req == NULL) {
226 return NULL;
227 }
228 state->out_mem_ctx = NULL;
229 state->dispatch_recv = cli->dispatch_recv;
230
231 /* In parameters */
232 state->orig.in.printername = _printername;
233 state->orig.in.datatype = _datatype;
234 state->orig.in.devmode_ctr = _devmode_ctr;
235 state->orig.in.access_mask = _access_mask;
236
237 /* Out parameters */
238 state->orig.out.handle = _handle;
239
240 /* Result */
241 ZERO_STRUCT(state->orig.out.result);
242
243 if (DEBUGLEVEL >= 10) {
244 NDR_PRINT_IN_DEBUG(spoolss_OpenPrinter, &state->orig);
245 }
246
247 state->out_mem_ctx = talloc_named_const(state, 0,
248 "rpccli_spoolss_OpenPrinter_out_memory");
249 if (tevent_req_nomem(state->out_mem_ctx, req)) {
250 return tevent_req_post(req, ev);
251 }
252
253 /* make a temporary copy, that we pass to the dispatch function */
254 state->tmp = state->orig;
255
256 subreq = cli->dispatch_send(state, ev, cli,
257 &ndr_table_spoolss,
258 NDR_SPOOLSS_OPENPRINTER,
259 &state->tmp);
260 if (tevent_req_nomem(subreq, req)) {
261 return tevent_req_post(req, ev);
262 }
263 tevent_req_set_callback(subreq, rpccli_spoolss_OpenPrinter_done, req);
264 return req;
265 }
266
267 static void rpccli_spoolss_OpenPrinter_done(struct tevent_req *subreq)
268 {
269 struct tevent_req *req = tevent_req_callback_data(
270 subreq, struct tevent_req);
271 struct rpccli_spoolss_OpenPrinter_state *state = tevent_req_data(
272 req, struct rpccli_spoolss_OpenPrinter_state);
273 NTSTATUS status;
274 TALLOC_CTX *mem_ctx;
275
276 if (state->out_mem_ctx) {
277 mem_ctx = state->out_mem_ctx;
278 } else {
279 mem_ctx = state;
280 }
281
282 status = state->dispatch_recv(subreq, mem_ctx);
283 TALLOC_FREE(subreq);
284 if (!NT_STATUS_IS_OK(status)) {
285 tevent_req_nterror(req, status);
286 return;
287 }
288
289 /* Copy out parameters */
290 *state->orig.out.handle = *state->tmp.out.handle;
291
292 /* Copy result */
293 state->orig.out.result = state->tmp.out.result;
294
295 /* Reset temporary structure */
296 ZERO_STRUCT(state->tmp);
297
298 if (DEBUGLEVEL >= 10) {
299 NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinter, &state->orig);
300 }
301
302 tevent_req_done(req);
303 }
304
305 NTSTATUS rpccli_spoolss_OpenPrinter_recv(struct tevent_req *req,
306 TALLOC_CTX *mem_ctx,
307 WERROR *result)
308 {
309 struct rpccli_spoolss_OpenPrinter_state *state = tevent_req_data(
310 req, struct rpccli_spoolss_OpenPrinter_state);
311 NTSTATUS status;
312
313 if (tevent_req_is_nterror(req, &status)) {
314 tevent_req_received(req);
315 return status;
316 }
317
318 /* Steal possbile out parameters to the callers context */
319 talloc_steal(mem_ctx, state->out_mem_ctx);
320
321 /* Return result */
322 *result = state->orig.out.result;
323
324 tevent_req_received(req);
325 return NT_STATUS_OK;
326 }
327
328 NTSTATUS rpccli_spoolss_OpenPrinter(struct rpc_pipe_client *cli,
329 TALLOC_CTX *mem_ctx,
330 const char *printername /* [in] [unique,charset(UTF16)] */,
331 const char *datatype /* [in] [unique,charset(UTF16)] */,
332 struct spoolss_DevmodeContainer devmode_ctr /* [in] */,
333 uint32_t access_mask /* [in] */,
334 struct policy_handle *handle /* [out] [ref] */,
335 WERROR *werror)
336 {
337 struct spoolss_OpenPrinter r;
338 NTSTATUS status;
339
340 /* In parameters */
341 r.in.printername = printername;
342 r.in.datatype = datatype;
343 r.in.devmode_ctr = devmode_ctr;
344 r.in.access_mask = access_mask;
345
346 if (DEBUGLEVEL >= 10) {
347 NDR_PRINT_IN_DEBUG(spoolss_OpenPrinter, &r);
348 }
349
350 status = cli->dispatch(cli,
351 mem_ctx,
352 &ndr_table_spoolss,
353 NDR_SPOOLSS_OPENPRINTER,
354 &r);
355
356 if (!NT_STATUS_IS_OK(status)) {
357 return status;
358 }
359
360 if (DEBUGLEVEL >= 10) {
361 NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinter, &r);
362 }
363
364 if (NT_STATUS_IS_ERR(status)) {
365 return status;
366 }
367
368 /* Return variables */
369 *handle = *r.out.handle;
370
371 /* Return result */
372 if (werror) {
373 *werror = r.out.result;
374 }
375
376 return werror_to_ntstatus(r.out.result);
377 }
378
379 struct rpccli_spoolss_SetJob_state {
380 struct spoolss_SetJob orig;
381 struct spoolss_SetJob tmp;
382 TALLOC_CTX *out_mem_ctx;
383 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
384 };
385
386 static void rpccli_spoolss_SetJob_done(struct tevent_req *subreq);
387
388 struct tevent_req *rpccli_spoolss_SetJob_send(TALLOC_CTX *mem_ctx,
389 struct tevent_context *ev,
390 struct rpc_pipe_client *cli,
391 struct policy_handle *_handle /* [in] [ref] */,
392 uint32_t _job_id /* [in] */,
393 struct spoolss_JobInfoContainer *_ctr /* [in] [unique] */,
394 enum spoolss_JobControl _command /* [in] */)
395 {
396 struct tevent_req *req;
397 struct rpccli_spoolss_SetJob_state *state;
398 struct tevent_req *subreq;
399
400 req = tevent_req_create(mem_ctx, &state,
401 struct rpccli_spoolss_SetJob_state);
402 if (req == NULL) {
403 return NULL;
404 }
405 state->out_mem_ctx = NULL;
406 state->dispatch_recv = cli->dispatch_recv;
407
408 /* In parameters */
409 state->orig.in.handle = _handle;
410 state->orig.in.job_id = _job_id;
411 state->orig.in.ctr = _ctr;
412 state->orig.in.command = _command;
413
414 /* Out parameters */
415
416 /* Result */
417 ZERO_STRUCT(state->orig.out.result);
418
419 if (DEBUGLEVEL >= 10) {
420 NDR_PRINT_IN_DEBUG(spoolss_SetJob, &state->orig);
421 }
422
423 /* make a temporary copy, that we pass to the dispatch function */
424 state->tmp = state->orig;
425
426 subreq = cli->dispatch_send(state, ev, cli,
427 &ndr_table_spoolss,
428 NDR_SPOOLSS_SETJOB,
429 &state->tmp);
430 if (tevent_req_nomem(subreq, req)) {
431 return tevent_req_post(req, ev);
432 }
433 tevent_req_set_callback(subreq, rpccli_spoolss_SetJob_done, req);
434 return req;
435 }
436
437 static void rpccli_spoolss_SetJob_done(struct tevent_req *subreq)
438 {
439 struct tevent_req *req = tevent_req_callback_data(
440 subreq, struct tevent_req);
441 struct rpccli_spoolss_SetJob_state *state = tevent_req_data(
442 req, struct rpccli_spoolss_SetJob_state);
443 NTSTATUS status;
444 TALLOC_CTX *mem_ctx;
445
446 if (state->out_mem_ctx) {
447 mem_ctx = state->out_mem_ctx;
448 } else {
449 mem_ctx = state;
450 }
451
452 status = state->dispatch_recv(subreq, mem_ctx);
453 TALLOC_FREE(subreq);
454 if (!NT_STATUS_IS_OK(status)) {
455 tevent_req_nterror(req, status);
456 return;
457 }
458
459 /* Copy out parameters */
460
461 /* Copy result */
462 state->orig.out.result = state->tmp.out.result;
463
464 /* Reset temporary structure */
465 ZERO_STRUCT(state->tmp);
466
467 if (DEBUGLEVEL >= 10) {
468 NDR_PRINT_OUT_DEBUG(spoolss_SetJob, &state->orig);
469 }
470
471 tevent_req_done(req);
472 }
473
474 NTSTATUS rpccli_spoolss_SetJob_recv(struct tevent_req *req,
475 TALLOC_CTX *mem_ctx,
476 WERROR *result)
477 {
478 struct rpccli_spoolss_SetJob_state *state = tevent_req_data(
479 req, struct rpccli_spoolss_SetJob_state);
480 NTSTATUS status;
481
482 if (tevent_req_is_nterror(req, &status)) {
483 tevent_req_received(req);
484 return status;
485 }
486
487 /* Steal possbile out parameters to the callers context */
488 talloc_steal(mem_ctx, state->out_mem_ctx);
489
490 /* Return result */
491 *result = state->orig.out.result;
492
493 tevent_req_received(req);
494 return NT_STATUS_OK;
495 }
496
497 NTSTATUS rpccli_spoolss_SetJob(struct rpc_pipe_client *cli,
498 TALLOC_CTX *mem_ctx,
499 struct policy_handle *handle /* [in] [ref] */,
500 uint32_t job_id /* [in] */,
501 struct spoolss_JobInfoContainer *ctr /* [in] [unique] */,
502 enum spoolss_JobControl command /* [in] */,
503 WERROR *werror)
504 {
505 struct spoolss_SetJob r;
506 NTSTATUS status;
507
508 /* In parameters */
509 r.in.handle = handle;
510 r.in.job_id = job_id;
511 r.in.ctr = ctr;
512 r.in.command = command;
513
514 if (DEBUGLEVEL >= 10) {
515 NDR_PRINT_IN_DEBUG(spoolss_SetJob, &r);
516 }
517
518 status = cli->dispatch(cli,
519 mem_ctx,
520 &ndr_table_spoolss,
521 NDR_SPOOLSS_SETJOB,
522 &r);
523
524 if (!NT_STATUS_IS_OK(status)) {
525 return status;
526 }
527
528 if (DEBUGLEVEL >= 10) {
529 NDR_PRINT_OUT_DEBUG(spoolss_SetJob, &r);
530 }
531
532 if (NT_STATUS_IS_ERR(status)) {
533 return status;
534 }
535
536 /* Return variables */
537
538 /* Return result */
539 if (werror) {
540 *werror = r.out.result;
541 }
542
543 return werror_to_ntstatus(r.out.result);
544 }
545
546 struct rpccli_spoolss_GetJob_state {
547 struct spoolss_GetJob orig;
548 struct spoolss_GetJob tmp;
549 TALLOC_CTX *out_mem_ctx;
550 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
551 };
552
553 static void rpccli_spoolss_GetJob_done(struct tevent_req *subreq);
554
555 struct tevent_req *rpccli_spoolss_GetJob_send(TALLOC_CTX *mem_ctx,
556 struct tevent_context *ev,
557 struct rpc_pipe_client *cli,
558 struct policy_handle *_handle /* [in] [ref] */,
559 uint32_t _job_id /* [in] */,
560 uint32_t _level /* [in] */,
561 DATA_BLOB *_buffer /* [in] [unique] */,
562 uint32_t _offered /* [in] */,
563 union spoolss_JobInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
564 uint32_t *_needed /* [out] [ref] */)
565 {
566 struct tevent_req *req;
567 struct rpccli_spoolss_GetJob_state *state;
568 struct tevent_req *subreq;
569
570 req = tevent_req_create(mem_ctx, &state,
571 struct rpccli_spoolss_GetJob_state);
572 if (req == NULL) {
573 return NULL;
574 }
575 state->out_mem_ctx = NULL;
576 state->dispatch_recv = cli->dispatch_recv;
577
578 /* In parameters */
579 state->orig.in.handle = _handle;
580 state->orig.in.job_id = _job_id;
581 state->orig.in.level = _level;
582 state->orig.in.buffer = _buffer;
583 state->orig.in.offered = _offered;
584
585 /* Out parameters */
586 state->orig.out.info = _info;
587 state->orig.out.needed = _needed;
588
589 /* Result */
590 ZERO_STRUCT(state->orig.out.result);
591
592 if (DEBUGLEVEL >= 10) {
593 NDR_PRINT_IN_DEBUG(spoolss_GetJob, &state->orig);
594 }
595
596 state->out_mem_ctx = talloc_named_const(state, 0,
597 "rpccli_spoolss_GetJob_out_memory");
598 if (tevent_req_nomem(state->out_mem_ctx, req)) {
599 return tevent_req_post(req, ev);
600 }
601
602 /* make a temporary copy, that we pass to the dispatch function */
603 state->tmp = state->orig;
604
605 subreq = cli->dispatch_send(state, ev, cli,
606 &ndr_table_spoolss,
607 NDR_SPOOLSS_GETJOB,
608 &state->tmp);
609 if (tevent_req_nomem(subreq, req)) {
610 return tevent_req_post(req, ev);
611 }
612 tevent_req_set_callback(subreq, rpccli_spoolss_GetJob_done, req);
613 return req;
614 }
615
616 static void rpccli_spoolss_GetJob_done(struct tevent_req *subreq)
617 {
618 struct tevent_req *req = tevent_req_callback_data(
619 subreq, struct tevent_req);
620 struct rpccli_spoolss_GetJob_state *state = tevent_req_data(
621 req, struct rpccli_spoolss_GetJob_state);
622 NTSTATUS status;
623 TALLOC_CTX *mem_ctx;
624
625 if (state->out_mem_ctx) {
626 mem_ctx = state->out_mem_ctx;
627 } else {
628 mem_ctx = state;
629 }
630
631 status = state->dispatch_recv(subreq, mem_ctx);
632 TALLOC_FREE(subreq);
633 if (!NT_STATUS_IS_OK(status)) {
634 tevent_req_nterror(req, status);
635 return;
636 }
637
638 /* Copy out parameters */
639 if (state->orig.out.info && state->tmp.out.info) {
640 *state->orig.out.info = *state->tmp.out.info;
641 }
642 *state->orig.out.needed = *state->tmp.out.needed;
643
644 /* Copy result */
645 state->orig.out.result = state->tmp.out.result;
646
647 /* Reset temporary structure */
648 ZERO_STRUCT(state->tmp);
649
650 if (DEBUGLEVEL >= 10) {
651 NDR_PRINT_OUT_DEBUG(spoolss_GetJob, &state->orig);
652 }
653
654 tevent_req_done(req);
655 }
656
657 NTSTATUS rpccli_spoolss_GetJob_recv(struct tevent_req *req,
658 TALLOC_CTX *mem_ctx,
659 WERROR *result)
660 {
661 struct rpccli_spoolss_GetJob_state *state = tevent_req_data(
662 req, struct rpccli_spoolss_GetJob_state);
663 NTSTATUS status;
664
665 if (tevent_req_is_nterror(req, &status)) {
666 tevent_req_received(req);
667 return status;
668 }
669
670 /* Steal possbile out parameters to the callers context */
671 talloc_steal(mem_ctx, state->out_mem_ctx);
672
673 /* Return result */
674 *result = state->orig.out.result;
675
676 tevent_req_received(req);
677 return NT_STATUS_OK;
678 }
679
680 NTSTATUS rpccli_spoolss_GetJob(struct rpc_pipe_client *cli,
681 TALLOC_CTX *mem_ctx,
682 struct policy_handle *handle /* [in] [ref] */,
683 uint32_t job_id /* [in] */,
684 uint32_t level /* [in] */,
685 DATA_BLOB *buffer /* [in] [unique] */,
686 uint32_t offered /* [in] */,
687 union spoolss_JobInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
688 uint32_t *needed /* [out] [ref] */,
689 WERROR *werror)
690 {
691 struct spoolss_GetJob r;
692 NTSTATUS status;
693
694 /* In parameters */
695 r.in.handle = handle;
696 r.in.job_id = job_id;
697 r.in.level = level;
698 r.in.buffer = buffer;
699 r.in.offered = offered;
700
701 if (DEBUGLEVEL >= 10) {
702 NDR_PRINT_IN_DEBUG(spoolss_GetJob, &r);
703 }
704
705 status = cli->dispatch(cli,
706 mem_ctx,
707 &ndr_table_spoolss,
708 NDR_SPOOLSS_GETJOB,
709 &r);
710
711 if (!NT_STATUS_IS_OK(status)) {
712 return status;
713 }
714
715 if (DEBUGLEVEL >= 10) {
716 NDR_PRINT_OUT_DEBUG(spoolss_GetJob, &r);
717 }
718
719 if (NT_STATUS_IS_ERR(status)) {
720 return status;
721 }
722
723 /* Return variables */
724 if (info && r.out.info) {
725 *info = *r.out.info;
726 }
727 *needed = *r.out.needed;
728
729 /* Return result */
730 if (werror) {
731 *werror = r.out.result;
732 }
733
734 return werror_to_ntstatus(r.out.result);
735 }
736
737 struct rpccli_spoolss_EnumJobs_state {
738 struct spoolss_EnumJobs orig;
739 struct spoolss_EnumJobs tmp;
740 TALLOC_CTX *out_mem_ctx;
741 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
742 };
743
744 static void rpccli_spoolss_EnumJobs_done(struct tevent_req *subreq);
745
746 struct tevent_req *rpccli_spoolss_EnumJobs_send(TALLOC_CTX *mem_ctx,
747 struct tevent_context *ev,
748 struct rpc_pipe_client *cli,
749 struct policy_handle *_handle /* [in] [ref] */,
750 uint32_t _firstjob /* [in] */,
751 uint32_t _numjobs /* [in] */,
752 uint32_t _level /* [in] */,
753 DATA_BLOB *_buffer /* [in] [unique] */,
754 uint32_t _offered /* [in] */,
755 uint32_t *_count /* [out] [ref] */,
756 union spoolss_JobInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
757 uint32_t *_needed /* [out] [ref] */)
758 {
759 struct tevent_req *req;
760 struct rpccli_spoolss_EnumJobs_state *state;
761 struct tevent_req *subreq;
762
763 req = tevent_req_create(mem_ctx, &state,
764 struct rpccli_spoolss_EnumJobs_state);
765 if (req == NULL) {
766 return NULL;
767 }
768 state->out_mem_ctx = NULL;
769 state->dispatch_recv = cli->dispatch_recv;
770
771 /* In parameters */
772 state->orig.in.handle = _handle;
773 state->orig.in.firstjob = _firstjob;
774 state->orig.in.numjobs = _numjobs;
775 state->orig.in.level = _level;
776 state->orig.in.buffer = _buffer;
777 state->orig.in.offered = _offered;
778
779 /* Out parameters */
780 state->orig.out.count = _count;
781 state->orig.out.info = _info;
782 state->orig.out.needed = _needed;
783
784 /* Result */
785 ZERO_STRUCT(state->orig.out.result);
786
787 if (DEBUGLEVEL >= 10) {
788 NDR_PRINT_IN_DEBUG(spoolss_EnumJobs, &state->orig);
789 }
790
791 state->out_mem_ctx = talloc_named_const(state, 0,
792 "rpccli_spoolss_EnumJobs_out_memory");
793 if (tevent_req_nomem(state->out_mem_ctx, req)) {
794 return tevent_req_post(req, ev);
795 }
796
797 /* make a temporary copy, that we pass to the dispatch function */
798 state->tmp = state->orig;
799
800 subreq = cli->dispatch_send(state, ev, cli,
801 &ndr_table_spoolss,
802 NDR_SPOOLSS_ENUMJOBS,
803 &state->tmp);
804 if (tevent_req_nomem(subreq, req)) {
805 return tevent_req_post(req, ev);
806 }
807 tevent_req_set_callback(subreq, rpccli_spoolss_EnumJobs_done, req);
808 return req;
809 }
810
811 static void rpccli_spoolss_EnumJobs_done(struct tevent_req *subreq)
812 {
813 struct tevent_req *req = tevent_req_callback_data(
814 subreq, struct tevent_req);
815 struct rpccli_spoolss_EnumJobs_state *state = tevent_req_data(
816 req, struct rpccli_spoolss_EnumJobs_state);
817 NTSTATUS status;
818 TALLOC_CTX *mem_ctx;
819
820 if (state->out_mem_ctx) {
821 mem_ctx = state->out_mem_ctx;
822 } else {
823 mem_ctx = state;
824 }
825
826 status = state->dispatch_recv(subreq, mem_ctx);
827 TALLOC_FREE(subreq);
828 if (!NT_STATUS_IS_OK(status)) {
829 tevent_req_nterror(req, status);
830 return;
831 }
832
833 /* Copy out parameters */
834 *state->orig.out.count = *state->tmp.out.count;
835 *state->orig.out.info = *state->tmp.out.info;
836 *state->orig.out.needed = *state->tmp.out.needed;
837
838 /* Copy result */
839 state->orig.out.result = state->tmp.out.result;
840
841 /* Reset temporary structure */
842 ZERO_STRUCT(state->tmp);
843
844 if (DEBUGLEVEL >= 10) {
845 NDR_PRINT_OUT_DEBUG(spoolss_EnumJobs, &state->orig);
846 }
847
848 tevent_req_done(req);
849 }
850
851 NTSTATUS rpccli_spoolss_EnumJobs_recv(struct tevent_req *req,
852 TALLOC_CTX *mem_ctx,
853 WERROR *result)
854 {
855 struct rpccli_spoolss_EnumJobs_state *state = tevent_req_data(
856 req, struct rpccli_spoolss_EnumJobs_state);
857 NTSTATUS status;
858
859 if (tevent_req_is_nterror(req, &status)) {
860 tevent_req_received(req);
861 return status;
862 }
863
864 /* Steal possbile out parameters to the callers context */
865 talloc_steal(mem_ctx, state->out_mem_ctx);
866
867 /* Return result */
868 *result = state->orig.out.result;
869
870 tevent_req_received(req);
871 return NT_STATUS_OK;
872 }
873
874 NTSTATUS rpccli_spoolss_EnumJobs(struct rpc_pipe_client *cli,
875 TALLOC_CTX *mem_ctx,
876 struct policy_handle *handle /* [in] [ref] */,
877 uint32_t firstjob /* [in] */,
878 uint32_t numjobs /* [in] */,
879 uint32_t level /* [in] */,
880 DATA_BLOB *buffer /* [in] [unique] */,
881 uint32_t offered /* [in] */,
882 uint32_t *count /* [out] [ref] */,
883 union spoolss_JobInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
884 uint32_t *needed /* [out] [ref] */,
885 WERROR *werror)
886 {
887 struct spoolss_EnumJobs r;
888 NTSTATUS status;
889
890 /* In parameters */
891 r.in.handle = handle;
892 r.in.firstjob = firstjob;
893 r.in.numjobs = numjobs;
894 r.in.level = level;
895 r.in.buffer = buffer;
896 r.in.offered = offered;
897
898 if (DEBUGLEVEL >= 10) {
899 NDR_PRINT_IN_DEBUG(spoolss_EnumJobs, &r);
900 }
901
902 status = cli->dispatch(cli,
903 mem_ctx,
904 &ndr_table_spoolss,
905 NDR_SPOOLSS_ENUMJOBS,
906 &r);
907
908 if (!NT_STATUS_IS_OK(status)) {
909 return status;
910 }
911
912 if (DEBUGLEVEL >= 10) {
913 NDR_PRINT_OUT_DEBUG(spoolss_EnumJobs, &r);
914 }
915
916 if (NT_STATUS_IS_ERR(status)) {
917 return status;
918 }
919
920 /* Return variables */
921 *count = *r.out.count;
922 *info = *r.out.info;
923 *needed = *r.out.needed;
924
925 /* Return result */
926 if (werror) {
927 *werror = r.out.result;
928 }
929
930 return werror_to_ntstatus(r.out.result);
931 }
932
933 struct rpccli_spoolss_AddPrinter_state {
934 struct spoolss_AddPrinter orig;
935 struct spoolss_AddPrinter tmp;
936 TALLOC_CTX *out_mem_ctx;
937 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
938 };
939
940 static void rpccli_spoolss_AddPrinter_done(struct tevent_req *subreq);
941
942 struct tevent_req *rpccli_spoolss_AddPrinter_send(TALLOC_CTX *mem_ctx,
943 struct tevent_context *ev,
944 struct rpc_pipe_client *cli,
945 const char *_server /* [in] [unique,charset(UTF16)] */,
946 struct spoolss_SetPrinterInfoCtr *_info_ctr /* [in] [ref] */,
947 struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */,
948 struct sec_desc_buf *_secdesc_ctr /* [in] [ref] */,
949 struct policy_handle *_handle /* [out] [ref] */)
950 {
951 struct tevent_req *req;
952 struct rpccli_spoolss_AddPrinter_state *state;
953 struct tevent_req *subreq;
954
955 req = tevent_req_create(mem_ctx, &state,
956 struct rpccli_spoolss_AddPrinter_state);
957 if (req == NULL) {
958 return NULL;
959 }
960 state->out_mem_ctx = NULL;
961 state->dispatch_recv = cli->dispatch_recv;
962
963 /* In parameters */
964 state->orig.in.server = _server;
965 state->orig.in.info_ctr = _info_ctr;
966 state->orig.in.devmode_ctr = _devmode_ctr;
967 state->orig.in.secdesc_ctr = _secdesc_ctr;
968
969 /* Out parameters */
970 state->orig.out.handle = _handle;
971
972 /* Result */
973 ZERO_STRUCT(state->orig.out.result);
974
975 if (DEBUGLEVEL >= 10) {
976 NDR_PRINT_IN_DEBUG(spoolss_AddPrinter, &state->orig);
977 }
978
979 state->out_mem_ctx = talloc_named_const(state, 0,
980 "rpccli_spoolss_AddPrinter_out_memory");
981 if (tevent_req_nomem(state->out_mem_ctx, req)) {
982 return tevent_req_post(req, ev);
983 }
984
985 /* make a temporary copy, that we pass to the dispatch function */
986 state->tmp = state->orig;
987
988 subreq = cli->dispatch_send(state, ev, cli,
989 &ndr_table_spoolss,
990 NDR_SPOOLSS_ADDPRINTER,
991 &state->tmp);
992 if (tevent_req_nomem(subreq, req)) {
993 return tevent_req_post(req, ev);
994 }
995 tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinter_done, req);
996 return req;
997 }
998
999 static void rpccli_spoolss_AddPrinter_done(struct tevent_req *subreq)
1000 {
1001 struct tevent_req *req = tevent_req_callback_data(
1002 subreq, struct tevent_req);
1003 struct rpccli_spoolss_AddPrinter_state *state = tevent_req_data(
1004 req, struct rpccli_spoolss_AddPrinter_state);
1005 NTSTATUS status;
1006 TALLOC_CTX *mem_ctx;
1007
1008 if (state->out_mem_ctx) {
1009 mem_ctx = state->out_mem_ctx;
1010 } else {
1011 mem_ctx = state;
1012 }
1013
1014 status = state->dispatch_recv(subreq, mem_ctx);
1015 TALLOC_FREE(subreq);
1016 if (!NT_STATUS_IS_OK(status)) {
1017 tevent_req_nterror(req, status);
1018 return;
1019 }
1020
1021 /* Copy out parameters */
1022 *state->orig.out.handle = *state->tmp.out.handle;
1023
1024 /* Copy result */
1025 state->orig.out.result = state->tmp.out.result;
1026
1027 /* Reset temporary structure */
1028 ZERO_STRUCT(state->tmp);
1029
1030 if (DEBUGLEVEL >= 10) {
1031 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinter, &state->orig);
1032 }
1033
1034 tevent_req_done(req);
1035 }
1036
1037 NTSTATUS rpccli_spoolss_AddPrinter_recv(struct tevent_req *req,
1038 TALLOC_CTX *mem_ctx,
1039 WERROR *result)
1040 {
1041 struct rpccli_spoolss_AddPrinter_state *state = tevent_req_data(
1042 req, struct rpccli_spoolss_AddPrinter_state);
1043 NTSTATUS status;
1044
1045 if (tevent_req_is_nterror(req, &status)) {
1046 tevent_req_received(req);
1047 return status;
1048 }
1049
1050 /* Steal possbile out parameters to the callers context */
1051 talloc_steal(mem_ctx, state->out_mem_ctx);
1052
1053 /* Return result */
1054 *result = state->orig.out.result;
1055
1056 tevent_req_received(req);
1057 return NT_STATUS_OK;
1058 }
1059
1060 NTSTATUS rpccli_spoolss_AddPrinter(struct rpc_pipe_client *cli,
1061 TALLOC_CTX *mem_ctx,
1062 const char *server /* [in] [unique,charset(UTF16)] */,
1063 struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */,
1064 struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
1065 struct sec_desc_buf *secdesc_ctr /* [in] [ref] */,
1066 struct policy_handle *handle /* [out] [ref] */,
1067 WERROR *werror)
1068 {
1069 struct spoolss_AddPrinter r;
1070 NTSTATUS status;
1071
1072 /* In parameters */
1073 r.in.server = server;
1074 r.in.info_ctr = info_ctr;
1075 r.in.devmode_ctr = devmode_ctr;
1076 r.in.secdesc_ctr = secdesc_ctr;
1077
1078 if (DEBUGLEVEL >= 10) {
1079 NDR_PRINT_IN_DEBUG(spoolss_AddPrinter, &r);
1080 }
1081
1082 status = cli->dispatch(cli,
1083 mem_ctx,
1084 &ndr_table_spoolss,
1085 NDR_SPOOLSS_ADDPRINTER,
1086 &r);
1087
1088 if (!NT_STATUS_IS_OK(status)) {
1089 return status;
1090 }
1091
1092 if (DEBUGLEVEL >= 10) {
1093 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinter, &r);
1094 }
1095
1096 if (NT_STATUS_IS_ERR(status)) {
1097 return status;
1098 }
1099
1100 /* Return variables */
1101 *handle = *r.out.handle;
1102
1103 /* Return result */
1104 if (werror) {
1105 *werror = r.out.result;
1106 }
1107
1108 return werror_to_ntstatus(r.out.result);
1109 }
1110
1111 struct rpccli_spoolss_DeletePrinter_state {
1112 struct spoolss_DeletePrinter orig;
1113 struct spoolss_DeletePrinter tmp;
1114 TALLOC_CTX *out_mem_ctx;
1115 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1116 };
1117
1118 static void rpccli_spoolss_DeletePrinter_done(struct tevent_req *subreq);
1119
1120 struct tevent_req *rpccli_spoolss_DeletePrinter_send(TALLOC_CTX *mem_ctx,
1121 struct tevent_context *ev,
1122 struct rpc_pipe_client *cli,
1123 struct policy_handle *_handle /* [in] [ref] */)
1124 {
1125 struct tevent_req *req;
1126 struct rpccli_spoolss_DeletePrinter_state *state;
1127 struct tevent_req *subreq;
1128
1129 req = tevent_req_create(mem_ctx, &state,
1130 struct rpccli_spoolss_DeletePrinter_state);
1131 if (req == NULL) {
1132 return NULL;
1133 }
1134 state->out_mem_ctx = NULL;
1135 state->dispatch_recv = cli->dispatch_recv;
1136
1137 /* In parameters */
1138 state->orig.in.handle = _handle;
1139
1140 /* Out parameters */
1141
1142 /* Result */
1143 ZERO_STRUCT(state->orig.out.result);
1144
1145 if (DEBUGLEVEL >= 10) {
1146 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinter, &state->orig);
1147 }
1148
1149 /* make a temporary copy, that we pass to the dispatch function */
1150 state->tmp = state->orig;
1151
1152 subreq = cli->dispatch_send(state, ev, cli,
1153 &ndr_table_spoolss,
1154 NDR_SPOOLSS_DELETEPRINTER,
1155 &state->tmp);
1156 if (tevent_req_nomem(subreq, req)) {
1157 return tevent_req_post(req, ev);
1158 }
1159 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinter_done, req);
1160 return req;
1161 }
1162
1163 static void rpccli_spoolss_DeletePrinter_done(struct tevent_req *subreq)
1164 {
1165 struct tevent_req *req = tevent_req_callback_data(
1166 subreq, struct tevent_req);
1167 struct rpccli_spoolss_DeletePrinter_state *state = tevent_req_data(
1168 req, struct rpccli_spoolss_DeletePrinter_state);
1169 NTSTATUS status;
1170 TALLOC_CTX *mem_ctx;
1171
1172 if (state->out_mem_ctx) {
1173 mem_ctx = state->out_mem_ctx;
1174 } else {
1175 mem_ctx = state;
1176 }
1177
1178 status = state->dispatch_recv(subreq, mem_ctx);
1179 TALLOC_FREE(subreq);
1180 if (!NT_STATUS_IS_OK(status)) {
1181 tevent_req_nterror(req, status);
1182 return;
1183 }
1184
1185 /* Copy out parameters */
1186
1187 /* Copy result */
1188 state->orig.out.result = state->tmp.out.result;
1189
1190 /* Reset temporary structure */
1191 ZERO_STRUCT(state->tmp);
1192
1193 if (DEBUGLEVEL >= 10) {
1194 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinter, &state->orig);
1195 }
1196
1197 tevent_req_done(req);
1198 }
1199
1200 NTSTATUS rpccli_spoolss_DeletePrinter_recv(struct tevent_req *req,
1201 TALLOC_CTX *mem_ctx,
1202 WERROR *result)
1203 {
1204 struct rpccli_spoolss_DeletePrinter_state *state = tevent_req_data(
1205 req, struct rpccli_spoolss_DeletePrinter_state);
1206 NTSTATUS status;
1207
1208 if (tevent_req_is_nterror(req, &status)) {
1209 tevent_req_received(req);
1210 return status;
1211 }
1212
1213 /* Steal possbile out parameters to the callers context */
1214 talloc_steal(mem_ctx, state->out_mem_ctx);
1215
1216 /* Return result */
1217 *result = state->orig.out.result;
1218
1219 tevent_req_received(req);
1220 return NT_STATUS_OK;
1221 }
1222
1223 NTSTATUS rpccli_spoolss_DeletePrinter(struct rpc_pipe_client *cli,
1224 TALLOC_CTX *mem_ctx,
1225 struct policy_handle *handle /* [in] [ref] */,
1226 WERROR *werror)
1227 {
1228 struct spoolss_DeletePrinter r;
1229 NTSTATUS status;
1230
1231 /* In parameters */
1232 r.in.handle = handle;
1233
1234 if (DEBUGLEVEL >= 10) {
1235 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinter, &r);
1236 }
1237
1238 status = cli->dispatch(cli,
1239 mem_ctx,
1240 &ndr_table_spoolss,
1241 NDR_SPOOLSS_DELETEPRINTER,
1242 &r);
1243
1244 if (!NT_STATUS_IS_OK(status)) {
1245 return status;
1246 }
1247
1248 if (DEBUGLEVEL >= 10) {
1249 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinter, &r);
1250 }
1251
1252 if (NT_STATUS_IS_ERR(status)) {
1253 return status;
1254 }
1255
1256 /* Return variables */
1257
1258 /* Return result */
1259 if (werror) {
1260 *werror = r.out.result;
1261 }
1262
1263 return werror_to_ntstatus(r.out.result);
1264 }
1265
1266 struct rpccli_spoolss_SetPrinter_state {
1267 struct spoolss_SetPrinter orig;
1268 struct spoolss_SetPrinter tmp;
1269 TALLOC_CTX *out_mem_ctx;
1270 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1271 };
1272
1273 static void rpccli_spoolss_SetPrinter_done(struct tevent_req *subreq);
1274
1275 struct tevent_req *rpccli_spoolss_SetPrinter_send(TALLOC_CTX *mem_ctx,
1276 struct tevent_context *ev,
1277 struct rpc_pipe_client *cli,
1278 struct policy_handle *_handle /* [in] [ref] */,
1279 struct spoolss_SetPrinterInfoCtr *_info_ctr /* [in] [ref] */,
1280 struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */,
1281 struct sec_desc_buf *_secdesc_ctr /* [in] [ref] */,
1282 enum spoolss_PrinterControl _command /* [in] */)
1283 {
1284 struct tevent_req *req;
1285 struct rpccli_spoolss_SetPrinter_state *state;
1286 struct tevent_req *subreq;
1287
1288 req = tevent_req_create(mem_ctx, &state,
1289 struct rpccli_spoolss_SetPrinter_state);
1290 if (req == NULL) {
1291 return NULL;
1292 }
1293 state->out_mem_ctx = NULL;
1294 state->dispatch_recv = cli->dispatch_recv;
1295
1296 /* In parameters */
1297 state->orig.in.handle = _handle;
1298 state->orig.in.info_ctr = _info_ctr;
1299 state->orig.in.devmode_ctr = _devmode_ctr;
1300 state->orig.in.secdesc_ctr = _secdesc_ctr;
1301 state->orig.in.command = _command;
1302
1303 /* Out parameters */
1304
1305 /* Result */
1306 ZERO_STRUCT(state->orig.out.result);
1307
1308 if (DEBUGLEVEL >= 10) {
1309 NDR_PRINT_IN_DEBUG(spoolss_SetPrinter, &state->orig);
1310 }
1311
1312 /* make a temporary copy, that we pass to the dispatch function */
1313 state->tmp = state->orig;
1314
1315 subreq = cli->dispatch_send(state, ev, cli,
1316 &ndr_table_spoolss,
1317 NDR_SPOOLSS_SETPRINTER,
1318 &state->tmp);
1319 if (tevent_req_nomem(subreq, req)) {
1320 return tevent_req_post(req, ev);
1321 }
1322 tevent_req_set_callback(subreq, rpccli_spoolss_SetPrinter_done, req);
1323 return req;
1324 }
1325
1326 static void rpccli_spoolss_SetPrinter_done(struct tevent_req *subreq)
1327 {
1328 struct tevent_req *req = tevent_req_callback_data(
1329 subreq, struct tevent_req);
1330 struct rpccli_spoolss_SetPrinter_state *state = tevent_req_data(
1331 req, struct rpccli_spoolss_SetPrinter_state);
1332 NTSTATUS status;
1333 TALLOC_CTX *mem_ctx;
1334
1335 if (state->out_mem_ctx) {
1336 mem_ctx = state->out_mem_ctx;
1337 } else {
1338 mem_ctx = state;
1339 }
1340
1341 status = state->dispatch_recv(subreq, mem_ctx);
1342 TALLOC_FREE(subreq);
1343 if (!NT_STATUS_IS_OK(status)) {
1344 tevent_req_nterror(req, status);
1345 return;
1346 }
1347
1348 /* Copy out parameters */
1349
1350 /* Copy result */
1351 state->orig.out.result = state->tmp.out.result;
1352
1353 /* Reset temporary structure */
1354 ZERO_STRUCT(state->tmp);
1355
1356 if (DEBUGLEVEL >= 10) {
1357 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinter, &state->orig);
1358 }
1359
1360 tevent_req_done(req);
1361 }
1362
1363 NTSTATUS rpccli_spoolss_SetPrinter_recv(struct tevent_req *req,
1364 TALLOC_CTX *mem_ctx,
1365 WERROR *result)
1366 {
1367 struct rpccli_spoolss_SetPrinter_state *state = tevent_req_data(
1368 req, struct rpccli_spoolss_SetPrinter_state);
1369 NTSTATUS status;
1370
1371 if (tevent_req_is_nterror(req, &status)) {
1372 tevent_req_received(req);
1373 return status;
1374 }
1375
1376 /* Steal possbile out parameters to the callers context */
1377 talloc_steal(mem_ctx, state->out_mem_ctx);
1378
1379 /* Return result */
1380 *result = state->orig.out.result;
1381
1382 tevent_req_received(req);
1383 return NT_STATUS_OK;
1384 }
1385
1386 NTSTATUS rpccli_spoolss_SetPrinter(struct rpc_pipe_client *cli,
1387 TALLOC_CTX *mem_ctx,
1388 struct policy_handle *handle /* [in] [ref] */,
1389 struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */,
1390 struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
1391 struct sec_desc_buf *secdesc_ctr /* [in] [ref] */,
1392 enum spoolss_PrinterControl command /* [in] */,
1393 WERROR *werror)
1394 {
1395 struct spoolss_SetPrinter r;
1396 NTSTATUS status;
1397
1398 /* In parameters */
1399 r.in.handle = handle;
1400 r.in.info_ctr = info_ctr;
1401 r.in.devmode_ctr = devmode_ctr;
1402 r.in.secdesc_ctr = secdesc_ctr;
1403 r.in.command = command;
1404
1405 if (DEBUGLEVEL >= 10) {
1406 NDR_PRINT_IN_DEBUG(spoolss_SetPrinter, &r);
1407 }
1408
1409 status = cli->dispatch(cli,
1410 mem_ctx,
1411 &ndr_table_spoolss,
1412 NDR_SPOOLSS_SETPRINTER,
1413 &r);
1414
1415 if (!NT_STATUS_IS_OK(status)) {
1416 return status;
1417 }
1418
1419 if (DEBUGLEVEL >= 10) {
1420 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinter, &r);
1421 }
1422
1423 if (NT_STATUS_IS_ERR(status)) {
1424 return status;
1425 }
1426
1427 /* Return variables */
1428
1429 /* Return result */
1430 if (werror) {
1431 *werror = r.out.result;
1432 }
1433
1434 return werror_to_ntstatus(r.out.result);
1435 }
1436
1437 struct rpccli_spoolss_GetPrinter_state {
1438 struct spoolss_GetPrinter orig;
1439 struct spoolss_GetPrinter tmp;
1440 TALLOC_CTX *out_mem_ctx;
1441 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1442 };
1443
1444 static void rpccli_spoolss_GetPrinter_done(struct tevent_req *subreq);
1445
1446 struct tevent_req *rpccli_spoolss_GetPrinter_send(TALLOC_CTX *mem_ctx,
1447 struct tevent_context *ev,
1448 struct rpc_pipe_client *cli,
1449 struct policy_handle *_handle /* [in] [ref] */,
1450 uint32_t _level /* [in] */,
1451 DATA_BLOB *_buffer /* [in] [unique] */,
1452 uint32_t _offered /* [in] */,
1453 union spoolss_PrinterInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1454 uint32_t *_needed /* [out] [ref] */)
1455 {
1456 struct tevent_req *req;
1457 struct rpccli_spoolss_GetPrinter_state *state;
1458 struct tevent_req *subreq;
1459
1460 req = tevent_req_create(mem_ctx, &state,
1461 struct rpccli_spoolss_GetPrinter_state);
1462 if (req == NULL) {
1463 return NULL;
1464 }
1465 state->out_mem_ctx = NULL;
1466 state->dispatch_recv = cli->dispatch_recv;
1467
1468 /* In parameters */
1469 state->orig.in.handle = _handle;
1470 state->orig.in.level = _level;
1471 state->orig.in.buffer = _buffer;
1472 state->orig.in.offered = _offered;
1473
1474 /* Out parameters */
1475 state->orig.out.info = _info;
1476 state->orig.out.needed = _needed;
1477
1478 /* Result */
1479 ZERO_STRUCT(state->orig.out.result);
1480
1481 if (DEBUGLEVEL >= 10) {
1482 NDR_PRINT_IN_DEBUG(spoolss_GetPrinter, &state->orig);
1483 }
1484
1485 state->out_mem_ctx = talloc_named_const(state, 0,
1486 "rpccli_spoolss_GetPrinter_out_memory");
1487 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1488 return tevent_req_post(req, ev);
1489 }
1490
1491 /* make a temporary copy, that we pass to the dispatch function */
1492 state->tmp = state->orig;
1493
1494 subreq = cli->dispatch_send(state, ev, cli,
1495 &ndr_table_spoolss,
1496 NDR_SPOOLSS_GETPRINTER,
1497 &state->tmp);
1498 if (tevent_req_nomem(subreq, req)) {
1499 return tevent_req_post(req, ev);
1500 }
1501 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinter_done, req);
1502 return req;
1503 }
1504
1505 static void rpccli_spoolss_GetPrinter_done(struct tevent_req *subreq)
1506 {
1507 struct tevent_req *req = tevent_req_callback_data(
1508 subreq, struct tevent_req);
1509 struct rpccli_spoolss_GetPrinter_state *state = tevent_req_data(
1510 req, struct rpccli_spoolss_GetPrinter_state);
1511 NTSTATUS status;
1512 TALLOC_CTX *mem_ctx;
1513
1514 if (state->out_mem_ctx) {
1515 mem_ctx = state->out_mem_ctx;
1516 } else {
1517 mem_ctx = state;
1518 }
1519
1520 status = state->dispatch_recv(subreq, mem_ctx);
1521 TALLOC_FREE(subreq);
1522 if (!NT_STATUS_IS_OK(status)) {
1523 tevent_req_nterror(req, status);
1524 return;
1525 }
1526
1527 /* Copy out parameters */
1528 if (state->orig.out.info && state->tmp.out.info) {
1529 *state->orig.out.info = *state->tmp.out.info;
1530 }
1531 *state->orig.out.needed = *state->tmp.out.needed;
1532
1533 /* Copy result */
1534 state->orig.out.result = state->tmp.out.result;
1535
1536 /* Reset temporary structure */
1537 ZERO_STRUCT(state->tmp);
1538
1539 if (DEBUGLEVEL >= 10) {
1540 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinter, &state->orig);
1541 }
1542
1543 tevent_req_done(req);
1544 }
1545
1546 NTSTATUS rpccli_spoolss_GetPrinter_recv(struct tevent_req *req,
1547 TALLOC_CTX *mem_ctx,
1548 WERROR *result)
1549 {
1550 struct rpccli_spoolss_GetPrinter_state *state = tevent_req_data(
1551 req, struct rpccli_spoolss_GetPrinter_state);
1552 NTSTATUS status;
1553
1554 if (tevent_req_is_nterror(req, &status)) {
1555 tevent_req_received(req);
1556 return status;
1557 }
1558
1559 /* Steal possbile out parameters to the callers context */
1560 talloc_steal(mem_ctx, state->out_mem_ctx);
1561
1562 /* Return result */
1563 *result = state->orig.out.result;
1564
1565 tevent_req_received(req);
1566 return NT_STATUS_OK;
1567 }
1568
1569 NTSTATUS rpccli_spoolss_GetPrinter(struct rpc_pipe_client *cli,
1570 TALLOC_CTX *mem_ctx,
1571 struct policy_handle *handle /* [in] [ref] */,
1572 uint32_t level /* [in] */,
1573 DATA_BLOB *buffer /* [in] [unique] */,
1574 uint32_t offered /* [in] */,
1575 union spoolss_PrinterInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1576 uint32_t *needed /* [out] [ref] */,
1577 WERROR *werror)
1578 {
1579 struct spoolss_GetPrinter r;
1580 NTSTATUS status;
1581
1582 /* In parameters */
1583 r.in.handle = handle;
1584 r.in.level = level;
1585 r.in.buffer = buffer;
1586 r.in.offered = offered;
1587
1588 if (DEBUGLEVEL >= 10) {
1589 NDR_PRINT_IN_DEBUG(spoolss_GetPrinter, &r);
1590 }
1591
1592 status = cli->dispatch(cli,
1593 mem_ctx,
1594 &ndr_table_spoolss,
1595 NDR_SPOOLSS_GETPRINTER,
1596 &r);
1597
1598 if (!NT_STATUS_IS_OK(status)) {
1599 return status;
1600 }
1601
1602 if (DEBUGLEVEL >= 10) {
1603 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinter, &r);
1604 }
1605
1606 if (NT_STATUS_IS_ERR(status)) {
1607 return status;
1608 }
1609
1610 /* Return variables */
1611 if (info && r.out.info) {
1612 *info = *r.out.info;
1613 }
1614 *needed = *r.out.needed;
1615
1616 /* Return result */
1617 if (werror) {
1618 *werror = r.out.result;
1619 }
1620
1621 return werror_to_ntstatus(r.out.result);
1622 }
1623
1624 struct rpccli_spoolss_AddPrinterDriver_state {
1625 struct spoolss_AddPrinterDriver orig;
1626 struct spoolss_AddPrinterDriver tmp;
1627 TALLOC_CTX *out_mem_ctx;
1628 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1629 };
1630
1631 static void rpccli_spoolss_AddPrinterDriver_done(struct tevent_req *subreq);
1632
1633 struct tevent_req *rpccli_spoolss_AddPrinterDriver_send(TALLOC_CTX *mem_ctx,
1634 struct tevent_context *ev,
1635 struct rpc_pipe_client *cli,
1636 const char *_servername /* [in] [unique,charset(UTF16)] */,
1637 struct spoolss_AddDriverInfoCtr *_info_ctr /* [in] [ref] */)
1638 {
1639 struct tevent_req *req;
1640 struct rpccli_spoolss_AddPrinterDriver_state *state;
1641 struct tevent_req *subreq;
1642
1643 req = tevent_req_create(mem_ctx, &state,
1644 struct rpccli_spoolss_AddPrinterDriver_state);
1645 if (req == NULL) {
1646 return NULL;
1647 }
1648 state->out_mem_ctx = NULL;
1649 state->dispatch_recv = cli->dispatch_recv;
1650
1651 /* In parameters */
1652 state->orig.in.servername = _servername;
1653 state->orig.in.info_ctr = _info_ctr;
1654
1655 /* Out parameters */
1656
1657 /* Result */
1658 ZERO_STRUCT(state->orig.out.result);
1659
1660 if (DEBUGLEVEL >= 10) {
1661 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterDriver, &state->orig);
1662 }
1663
1664 /* make a temporary copy, that we pass to the dispatch function */
1665 state->tmp = state->orig;
1666
1667 subreq = cli->dispatch_send(state, ev, cli,
1668 &ndr_table_spoolss,
1669 NDR_SPOOLSS_ADDPRINTERDRIVER,
1670 &state->tmp);
1671 if (tevent_req_nomem(subreq, req)) {
1672 return tevent_req_post(req, ev);
1673 }
1674 tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterDriver_done, req);
1675 return req;
1676 }
1677
1678 static void rpccli_spoolss_AddPrinterDriver_done(struct tevent_req *subreq)
1679 {
1680 struct tevent_req *req = tevent_req_callback_data(
1681 subreq, struct tevent_req);
1682 struct rpccli_spoolss_AddPrinterDriver_state *state = tevent_req_data(
1683 req, struct rpccli_spoolss_AddPrinterDriver_state);
1684 NTSTATUS status;
1685 TALLOC_CTX *mem_ctx;
1686
1687 if (state->out_mem_ctx) {
1688 mem_ctx = state->out_mem_ctx;
1689 } else {
1690 mem_ctx = state;
1691 }
1692
1693 status = state->dispatch_recv(subreq, mem_ctx);
1694 TALLOC_FREE(subreq);
1695 if (!NT_STATUS_IS_OK(status)) {
1696 tevent_req_nterror(req, status);
1697 return;
1698 }
1699
1700 /* Copy out parameters */
1701
1702 /* Copy result */
1703 state->orig.out.result = state->tmp.out.result;
1704
1705 /* Reset temporary structure */
1706 ZERO_STRUCT(state->tmp);
1707
1708 if (DEBUGLEVEL >= 10) {
1709 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterDriver, &state->orig);
1710 }
1711
1712 tevent_req_done(req);
1713 }
1714
1715 NTSTATUS rpccli_spoolss_AddPrinterDriver_recv(struct tevent_req *req,
1716 TALLOC_CTX *mem_ctx,
1717 WERROR *result)
1718 {
1719 struct rpccli_spoolss_AddPrinterDriver_state *state = tevent_req_data(
1720 req, struct rpccli_spoolss_AddPrinterDriver_state);
1721 NTSTATUS status;
1722
1723 if (tevent_req_is_nterror(req, &status)) {
1724 tevent_req_received(req);
1725 return status;
1726 }
1727
1728 /* Steal possbile out parameters to the callers context */
1729 talloc_steal(mem_ctx, state->out_mem_ctx);
1730
1731 /* Return result */
1732 *result = state->orig.out.result;
1733
1734 tevent_req_received(req);
1735 return NT_STATUS_OK;
1736 }
1737
1738 NTSTATUS rpccli_spoolss_AddPrinterDriver(struct rpc_pipe_client *cli,
1739 TALLOC_CTX *mem_ctx,
1740 const char *servername /* [in] [unique,charset(UTF16)] */,
1741 struct spoolss_AddDriverInfoCtr *info_ctr /* [in] [ref] */,
1742 WERROR *werror)
1743 {
1744 struct spoolss_AddPrinterDriver r;
1745 NTSTATUS status;
1746
1747 /* In parameters */
1748 r.in.servername = servername;
1749 r.in.info_ctr = info_ctr;
1750
1751 if (DEBUGLEVEL >= 10) {
1752 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterDriver, &r);
1753 }
1754
1755 status = cli->dispatch(cli,
1756 mem_ctx,
1757 &ndr_table_spoolss,
1758 NDR_SPOOLSS_ADDPRINTERDRIVER,
1759 &r);
1760
1761 if (!NT_STATUS_IS_OK(status)) {
1762 return status;
1763 }
1764
1765 if (DEBUGLEVEL >= 10) {
1766 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterDriver, &r);
1767 }
1768
1769 if (NT_STATUS_IS_ERR(status)) {
1770 return status;
1771 }
1772
1773 /* Return variables */
1774
1775 /* Return result */
1776 if (werror) {
1777 *werror = r.out.result;
1778 }
1779
1780 return werror_to_ntstatus(r.out.result);
1781 }
1782
1783 struct rpccli_spoolss_EnumPrinterDrivers_state {
1784 struct spoolss_EnumPrinterDrivers orig;
1785 struct spoolss_EnumPrinterDrivers tmp;
1786 TALLOC_CTX *out_mem_ctx;
1787 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1788 };
1789
1790 static void rpccli_spoolss_EnumPrinterDrivers_done(struct tevent_req *subreq);
1791
1792 struct tevent_req *rpccli_spoolss_EnumPrinterDrivers_send(TALLOC_CTX *mem_ctx,
1793 struct tevent_context *ev,
1794 struct rpc_pipe_client *cli,
1795 const char *_server /* [in] [unique,charset(UTF16)] */,
1796 const char *_environment /* [in] [unique,charset(UTF16)] */,
1797 uint32_t _level /* [in] */,
1798 DATA_BLOB *_buffer /* [in] [unique] */,
1799 uint32_t _offered /* [in] */,
1800 uint32_t *_count /* [out] [ref] */,
1801 union spoolss_DriverInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
1802 uint32_t *_needed /* [out] [ref] */)
1803 {
1804 struct tevent_req *req;
1805 struct rpccli_spoolss_EnumPrinterDrivers_state *state;
1806 struct tevent_req *subreq;
1807
1808 req = tevent_req_create(mem_ctx, &state,
1809 struct rpccli_spoolss_EnumPrinterDrivers_state);
1810 if (req == NULL) {
1811 return NULL;
1812 }
1813 state->out_mem_ctx = NULL;
1814 state->dispatch_recv = cli->dispatch_recv;
1815
1816 /* In parameters */
1817 state->orig.in.server = _server;
1818 state->orig.in.environment = _environment;
1819 state->orig.in.level = _level;
1820 state->orig.in.buffer = _buffer;
1821 state->orig.in.offered = _offered;
1822
1823 /* Out parameters */
1824 state->orig.out.count = _count;
1825 state->orig.out.info = _info;
1826 state->orig.out.needed = _needed;
1827
1828 /* Result */
1829 ZERO_STRUCT(state->orig.out.result);
1830
1831 if (DEBUGLEVEL >= 10) {
1832 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterDrivers, &state->orig);
1833 }
1834
1835 state->out_mem_ctx = talloc_named_const(state, 0,
1836 "rpccli_spoolss_EnumPrinterDrivers_out_memory");
1837 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1838 return tevent_req_post(req, ev);
1839 }
1840
1841 /* make a temporary copy, that we pass to the dispatch function */
1842 state->tmp = state->orig;
1843
1844 subreq = cli->dispatch_send(state, ev, cli,
1845 &ndr_table_spoolss,
1846 NDR_SPOOLSS_ENUMPRINTERDRIVERS,
1847 &state->tmp);
1848 if (tevent_req_nomem(subreq, req)) {
1849 return tevent_req_post(req, ev);
1850 }
1851 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinterDrivers_done, req);
1852 return req;
1853 }
1854
1855 static void rpccli_spoolss_EnumPrinterDrivers_done(struct tevent_req *subreq)
1856 {
1857 struct tevent_req *req = tevent_req_callback_data(
1858 subreq, struct tevent_req);
1859 struct rpccli_spoolss_EnumPrinterDrivers_state *state = tevent_req_data(
1860 req, struct rpccli_spoolss_EnumPrinterDrivers_state);
1861 NTSTATUS status;
1862 TALLOC_CTX *mem_ctx;
1863
1864 if (state->out_mem_ctx) {
1865 mem_ctx = state->out_mem_ctx;
1866 } else {
1867 mem_ctx = state;
1868 }
1869
1870 status = state->dispatch_recv(subreq, mem_ctx);
1871 TALLOC_FREE(subreq);
1872 if (!NT_STATUS_IS_OK(status)) {
1873 tevent_req_nterror(req, status);
1874 return;
1875 }
1876
1877 /* Copy out parameters */
1878 *state->orig.out.count = *state->tmp.out.count;
1879 *state->orig.out.info = *state->tmp.out.info;
1880 *state->orig.out.needed = *state->tmp.out.needed;
1881
1882 /* Copy result */
1883 state->orig.out.result = state->tmp.out.result;
1884
1885 /* Reset temporary structure */
1886 ZERO_STRUCT(state->tmp);
1887
1888 if (DEBUGLEVEL >= 10) {
1889 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterDrivers, &state->orig);
1890 }
1891
1892 tevent_req_done(req);
1893 }
1894
1895 NTSTATUS rpccli_spoolss_EnumPrinterDrivers_recv(struct tevent_req *req,
1896 TALLOC_CTX *mem_ctx,
1897 WERROR *result)
1898 {
1899 struct rpccli_spoolss_EnumPrinterDrivers_state *state = tevent_req_data(
1900 req, struct rpccli_spoolss_EnumPrinterDrivers_state);
1901 NTSTATUS status;
1902
1903 if (tevent_req_is_nterror(req, &status)) {
1904 tevent_req_received(req);
1905 return status;
1906 }
1907
1908 /* Steal possbile out parameters to the callers context */
1909 talloc_steal(mem_ctx, state->out_mem_ctx);
1910
1911 /* Return result */
1912 *result = state->orig.out.result;
1913
1914 tevent_req_received(req);
1915 return NT_STATUS_OK;
1916 }
1917
1918 NTSTATUS rpccli_spoolss_EnumPrinterDrivers(struct rpc_pipe_client *cli,
1919 TALLOC_CTX *mem_ctx,
1920 const char *server /* [in] [unique,charset(UTF16)] */,
1921 const char *environment /* [in] [unique,charset(UTF16)] */,
1922 uint32_t level /* [in] */,
1923 DATA_BLOB *buffer /* [in] [unique] */,
1924 uint32_t offered /* [in] */,
1925 uint32_t *count /* [out] [ref] */,
1926 union spoolss_DriverInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
1927 uint32_t *needed /* [out] [ref] */,
1928 WERROR *werror)
1929 {
1930 struct spoolss_EnumPrinterDrivers r;
1931 NTSTATUS status;
1932
1933 /* In parameters */
1934 r.in.server = server;
1935 r.in.environment = environment;
1936 r.in.level = level;
1937 r.in.buffer = buffer;
1938 r.in.offered = offered;
1939
1940 if (DEBUGLEVEL >= 10) {
1941 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterDrivers, &r);
1942 }
1943
1944 status = cli->dispatch(cli,
1945 mem_ctx,
1946 &ndr_table_spoolss,
1947 NDR_SPOOLSS_ENUMPRINTERDRIVERS,
1948 &r);
1949
1950 if (!NT_STATUS_IS_OK(status)) {
1951 return status;
1952 }
1953
1954 if (DEBUGLEVEL >= 10) {
1955 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterDrivers, &r);
1956 }
1957
1958 if (NT_STATUS_IS_ERR(status)) {
1959 return status;
1960 }
1961
1962 /* Return variables */
1963 *count = *r.out.count;
1964 *info = *r.out.info;
1965 *needed = *r.out.needed;
1966
1967 /* Return result */
1968 if (werror) {
1969 *werror = r.out.result;
1970 }
1971
1972 return werror_to_ntstatus(r.out.result);
1973 }
1974
1975 struct rpccli_spoolss_GetPrinterDriver_state {
1976 struct spoolss_GetPrinterDriver orig;
1977 struct spoolss_GetPrinterDriver tmp;
1978 TALLOC_CTX *out_mem_ctx;
1979 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1980 };
1981
1982 static void rpccli_spoolss_GetPrinterDriver_done(struct tevent_req *subreq);
1983
1984 struct tevent_req *rpccli_spoolss_GetPrinterDriver_send(TALLOC_CTX *mem_ctx,
1985 struct tevent_context *ev,
1986 struct rpc_pipe_client *cli,
1987 struct policy_handle *_handle /* [in] [ref] */,
1988 const char *_architecture /* [in] [unique,charset(UTF16)] */,
1989 uint32_t _level /* [in] */,
1990 DATA_BLOB *_buffer /* [in] [unique] */,
1991 uint32_t _offered /* [in] */,
1992 union spoolss_DriverInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1993 uint32_t *_needed /* [out] [ref] */)
1994 {
1995 struct tevent_req *req;
1996 struct rpccli_spoolss_GetPrinterDriver_state *state;
1997 struct tevent_req *subreq;
1998
1999 req = tevent_req_create(mem_ctx, &state,
2000 struct rpccli_spoolss_GetPrinterDriver_state);
2001 if (req == NULL) {
2002 return NULL;
2003 }
2004 state->out_mem_ctx = NULL;
2005 state->dispatch_recv = cli->dispatch_recv;
2006
2007 /* In parameters */
2008 state->orig.in.handle = _handle;
2009 state->orig.in.architecture = _architecture;
2010 state->orig.in.level = _level;
2011 state->orig.in.buffer = _buffer;
2012 state->orig.in.offered = _offered;
2013
2014 /* Out parameters */
2015 state->orig.out.info = _info;
2016 state->orig.out.needed = _needed;
2017
2018 /* Result */
2019 ZERO_STRUCT(state->orig.out.result);
2020
2021 if (DEBUGLEVEL >= 10) {
2022 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriver, &state->orig);
2023 }
2024
2025 state->out_mem_ctx = talloc_named_const(state, 0,
2026 "rpccli_spoolss_GetPrinterDriver_out_memory");
2027 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2028 return tevent_req_post(req, ev);
2029 }
2030
2031 /* make a temporary copy, that we pass to the dispatch function */
2032 state->tmp = state->orig;
2033
2034 subreq = cli->dispatch_send(state, ev, cli,
2035 &ndr_table_spoolss,
2036 NDR_SPOOLSS_GETPRINTERDRIVER,
2037 &state->tmp);
2038 if (tevent_req_nomem(subreq, req)) {
2039 return tevent_req_post(req, ev);
2040 }
2041 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriver_done, req);
2042 return req;
2043 }
2044
2045 static void rpccli_spoolss_GetPrinterDriver_done(struct tevent_req *subreq)
2046 {
2047 struct tevent_req *req = tevent_req_callback_data(
2048 subreq, struct tevent_req);
2049 struct rpccli_spoolss_GetPrinterDriver_state *state = tevent_req_data(
2050 req, struct rpccli_spoolss_GetPrinterDriver_state);
2051 NTSTATUS status;
2052 TALLOC_CTX *mem_ctx;
2053
2054 if (state->out_mem_ctx) {
2055 mem_ctx = state->out_mem_ctx;
2056 } else {
2057 mem_ctx = state;
2058 }
2059
2060 status = state->dispatch_recv(subreq, mem_ctx);
2061 TALLOC_FREE(subreq);
2062 if (!NT_STATUS_IS_OK(status)) {
2063 tevent_req_nterror(req, status);
2064 return;
2065 }
2066
2067 /* Copy out parameters */
2068 if (state->orig.out.info && state->tmp.out.info) {
2069 *state->orig.out.info = *state->tmp.out.info;
2070 }
2071 *state->orig.out.needed = *state->tmp.out.needed;
2072
2073 /* Copy result */
2074 state->orig.out.result = state->tmp.out.result;
2075
2076 /* Reset temporary structure */
2077 ZERO_STRUCT(state->tmp);
2078
2079 if (DEBUGLEVEL >= 10) {
2080 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriver, &state->orig);
2081 }
2082
2083 tevent_req_done(req);
2084 }
2085
2086 NTSTATUS rpccli_spoolss_GetPrinterDriver_recv(struct tevent_req *req,
2087 TALLOC_CTX *mem_ctx,
2088 WERROR *result)
2089 {
2090 struct rpccli_spoolss_GetPrinterDriver_state *state = tevent_req_data(
2091 req, struct rpccli_spoolss_GetPrinterDriver_state);
2092 NTSTATUS status;
2093
2094 if (tevent_req_is_nterror(req, &status)) {
2095 tevent_req_received(req);
2096 return status;
2097 }
2098
2099 /* Steal possbile out parameters to the callers context */
2100 talloc_steal(mem_ctx, state->out_mem_ctx);
2101
2102 /* Return result */
2103 *result = state->orig.out.result;
2104
2105 tevent_req_received(req);
2106 return NT_STATUS_OK;
2107 }
2108
2109 NTSTATUS rpccli_spoolss_GetPrinterDriver(struct rpc_pipe_client *cli,
2110 TALLOC_CTX *mem_ctx,
2111 struct policy_handle *handle /* [in] [ref] */,
2112 const char *architecture /* [in] [unique,charset(UTF16)] */,
2113 uint32_t level /* [in] */,
2114 DATA_BLOB *buffer /* [in] [unique] */,
2115 uint32_t offered /* [in] */,
2116 union spoolss_DriverInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
2117 uint32_t *needed /* [out] [ref] */,
2118 WERROR *werror)
2119 {
2120 struct spoolss_GetPrinterDriver r;
2121 NTSTATUS status;
2122
2123 /* In parameters */
2124 r.in.handle = handle;
2125 r.in.architecture = architecture;
2126 r.in.level = level;
2127 r.in.buffer = buffer;
2128 r.in.offered = offered;
2129
2130 if (DEBUGLEVEL >= 10) {
2131 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriver, &r);
2132 }
2133
2134 status = cli->dispatch(cli,
2135 mem_ctx,
2136 &ndr_table_spoolss,
2137 NDR_SPOOLSS_GETPRINTERDRIVER,
2138 &r);
2139
2140 if (!NT_STATUS_IS_OK(status)) {
2141 return status;
2142 }
2143
2144 if (DEBUGLEVEL >= 10) {
2145 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriver, &r);
2146 }
2147
2148 if (NT_STATUS_IS_ERR(status)) {
2149 return status;
2150 }
2151
2152 /* Return variables */
2153 if (info && r.out.info) {
2154 *info = *r.out.info;
2155 }
2156 *needed = *r.out.needed;
2157
2158 /* Return result */
2159 if (werror) {
2160 *werror = r.out.result;
2161 }
2162
2163 return werror_to_ntstatus(r.out.result);
2164 }
2165
2166 struct rpccli_spoolss_GetPrinterDriverDirectory_state {
2167 struct spoolss_GetPrinterDriverDirectory orig;
2168 struct spoolss_GetPrinterDriverDirectory tmp;
2169 TALLOC_CTX *out_mem_ctx;
2170 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2171 };
2172
2173 static void rpccli_spoolss_GetPrinterDriverDirectory_done(struct tevent_req *subreq);
2174
2175 struct tevent_req *rpccli_spoolss_GetPrinterDriverDirectory_send(TALLOC_CTX *mem_ctx,
2176 struct tevent_context *ev,
2177 struct rpc_pipe_client *cli,
2178 const char *_server /* [in] [unique,charset(UTF16)] */,
2179 const char *_environment /* [in] [unique,charset(UTF16)] */,
2180 uint32_t _level /* [in] */,
2181 DATA_BLOB *_buffer /* [in] [unique] */,
2182 uint32_t _offered /* [in] */,
2183 union spoolss_DriverDirectoryInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
2184 uint32_t *_needed /* [out] [ref] */)
2185 {
2186 struct tevent_req *req;
2187 struct rpccli_spoolss_GetPrinterDriverDirectory_state *state;
2188 struct tevent_req *subreq;
2189
2190 req = tevent_req_create(mem_ctx, &state,
2191 struct rpccli_spoolss_GetPrinterDriverDirectory_state);
2192 if (req == NULL) {
2193 return NULL;
2194 }
2195 state->out_mem_ctx = NULL;
2196 state->dispatch_recv = cli->dispatch_recv;
2197
2198 /* In parameters */
2199 state->orig.in.server = _server;
2200 state->orig.in.environment = _environment;
2201 state->orig.in.level = _level;
2202 state->orig.in.buffer = _buffer;
2203 state->orig.in.offered = _offered;
2204
2205 /* Out parameters */
2206 state->orig.out.info = _info;
2207 state->orig.out.needed = _needed;
2208
2209 /* Result */
2210 ZERO_STRUCT(state->orig.out.result);
2211
2212 if (DEBUGLEVEL >= 10) {
2213 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverDirectory, &state->orig);
2214 }
2215
2216 state->out_mem_ctx = talloc_named_const(state, 0,
2217 "rpccli_spoolss_GetPrinterDriverDirectory_out_memory");
2218 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2219 return tevent_req_post(req, ev);
2220 }
2221
2222 /* make a temporary copy, that we pass to the dispatch function */
2223 state->tmp = state->orig;
2224
2225 subreq = cli->dispatch_send(state, ev, cli,
2226 &ndr_table_spoolss,
2227 NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY,
2228 &state->tmp);
2229 if (tevent_req_nomem(subreq, req)) {
2230 return tevent_req_post(req, ev);
2231 }
2232 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriverDirectory_done, req);
2233 return req;
2234 }
2235
2236 static void rpccli_spoolss_GetPrinterDriverDirectory_done(struct tevent_req *subreq)
2237 {
2238 struct tevent_req *req = tevent_req_callback_data(
2239 subreq, struct tevent_req);
2240 struct rpccli_spoolss_GetPrinterDriverDirectory_state *state = tevent_req_data(
2241 req, struct rpccli_spoolss_GetPrinterDriverDirectory_state);
2242 NTSTATUS status;
2243 TALLOC_CTX *mem_ctx;
2244
2245 if (state->out_mem_ctx) {
2246 mem_ctx = state->out_mem_ctx;
2247 } else {
2248 mem_ctx = state;
2249 }
2250
2251 status = state->dispatch_recv(subreq, mem_ctx);
2252 TALLOC_FREE(subreq);
2253 if (!NT_STATUS_IS_OK(status)) {
2254 tevent_req_nterror(req, status);
2255 return;
2256 }
2257
2258 /* Copy out parameters */
2259 if (state->orig.out.info && state->tmp.out.info) {
2260 *state->orig.out.info = *state->tmp.out.info;
2261 }
2262 *state->orig.out.needed = *state->tmp.out.needed;
2263
2264 /* Copy result */
2265 state->orig.out.result = state->tmp.out.result;
2266
2267 /* Reset temporary structure */
2268 ZERO_STRUCT(state->tmp);
2269
2270 if (DEBUGLEVEL >= 10) {
2271 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverDirectory, &state->orig);
2272 }
2273
2274 tevent_req_done(req);
2275 }
2276
2277 NTSTATUS rpccli_spoolss_GetPrinterDriverDirectory_recv(struct tevent_req *req,
2278 TALLOC_CTX *mem_ctx,
2279 WERROR *result)
2280 {
2281 struct rpccli_spoolss_GetPrinterDriverDirectory_state *state = tevent_req_data(
2282 req, struct rpccli_spoolss_GetPrinterDriverDirectory_state);
2283 NTSTATUS status;
2284
2285 if (tevent_req_is_nterror(req, &status)) {
2286 tevent_req_received(req);
2287 return status;
2288 }
2289
2290 /* Steal possbile out parameters to the callers context */
2291 talloc_steal(mem_ctx, state->out_mem_ctx);
2292
2293 /* Return result */
2294 *result = state->orig.out.result;
2295
2296 tevent_req_received(req);
2297 return NT_STATUS_OK;
2298 }
2299
2300 NTSTATUS rpccli_spoolss_GetPrinterDriverDirectory(struct rpc_pipe_client *cli,
2301 TALLOC_CTX *mem_ctx,
2302 const char *server /* [in] [unique,charset(UTF16)] */,
2303 const char *environment /* [in] [unique,charset(UTF16)] */,
2304 uint32_t level /* [in] */,
2305 DATA_BLOB *buffer /* [in] [unique] */,
2306 uint32_t offered /* [in] */,
2307 union spoolss_DriverDirectoryInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
2308 uint32_t *needed /* [out] [ref] */,
2309 WERROR *werror)
2310 {
2311 struct spoolss_GetPrinterDriverDirectory r;
2312 NTSTATUS status;
2313
2314 /* In parameters */
2315 r.in.server = server;
2316 r.in.environment = environment;
2317 r.in.level = level;
2318 r.in.buffer = buffer;
2319 r.in.offered = offered;
2320
2321 if (DEBUGLEVEL >= 10) {
2322 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverDirectory, &r);
2323 }
2324
2325 status = cli->dispatch(cli,
2326 mem_ctx,
2327 &ndr_table_spoolss,
2328 NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY,
2329 &r);
2330
2331 if (!NT_STATUS_IS_OK(status)) {
2332 return status;
2333 }
2334
2335 if (DEBUGLEVEL >= 10) {
2336 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverDirectory, &r);
2337 }
2338
2339 if (NT_STATUS_IS_ERR(status)) {
2340 return status;
2341 }
2342
2343 /* Return variables */
2344 if (info && r.out.info) {
2345 *info = *r.out.info;
2346 }
2347 *needed = *r.out.needed;
2348
2349 /* Return result */
2350 if (werror) {
2351 *werror = r.out.result;
2352 }
2353
2354 return werror_to_ntstatus(r.out.result);
2355 }
2356
2357 struct rpccli_spoolss_DeletePrinterDriver_state {
2358 struct spoolss_DeletePrinterDriver orig;
2359 struct spoolss_DeletePrinterDriver tmp;
2360 TALLOC_CTX *out_mem_ctx;
2361 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2362 };
2363
2364 static void rpccli_spoolss_DeletePrinterDriver_done(struct tevent_req *subreq);
2365
2366 struct tevent_req *rpccli_spoolss_DeletePrinterDriver_send(TALLOC_CTX *mem_ctx,
2367 struct tevent_context *ev,
2368 struct rpc_pipe_client *cli,
2369 const char *_server /* [in] [unique,charset(UTF16)] */,
2370 const char *_architecture /* [in] [charset(UTF16)] */,
2371 const char *_driver /* [in] [charset(UTF16)] */)
2372 {
2373 struct tevent_req *req;
2374 struct rpccli_spoolss_DeletePrinterDriver_state *state;
2375 struct tevent_req *subreq;
2376
2377 req = tevent_req_create(mem_ctx, &state,
2378 struct rpccli_spoolss_DeletePrinterDriver_state);
2379 if (req == NULL) {
2380 return NULL;
2381 }
2382 state->out_mem_ctx = NULL;
2383 state->dispatch_recv = cli->dispatch_recv;
2384
2385 /* In parameters */
2386 state->orig.in.server = _server;
2387 state->orig.in.architecture = _architecture;
2388 state->orig.in.driver = _driver;
2389
2390 /* Out parameters */
2391
2392 /* Result */
2393 ZERO_STRUCT(state->orig.out.result);
2394
2395 if (DEBUGLEVEL >= 10) {
2396 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDriver, &state->orig);
2397 }
2398
2399 /* make a temporary copy, that we pass to the dispatch function */
2400 state->tmp = state->orig;
2401
2402 subreq = cli->dispatch_send(state, ev, cli,
2403 &ndr_table_spoolss,
2404 NDR_SPOOLSS_DELETEPRINTERDRIVER,
2405 &state->tmp);
2406 if (tevent_req_nomem(subreq, req)) {
2407 return tevent_req_post(req, ev);
2408 }
2409 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterDriver_done, req);
2410 return req;
2411 }
2412
2413 static void rpccli_spoolss_DeletePrinterDriver_done(struct tevent_req *subreq)
2414 {
2415 struct tevent_req *req = tevent_req_callback_data(
2416 subreq, struct tevent_req);
2417 struct rpccli_spoolss_DeletePrinterDriver_state *state = tevent_req_data(
2418 req, struct rpccli_spoolss_DeletePrinterDriver_state);
2419 NTSTATUS status;
2420 TALLOC_CTX *mem_ctx;
2421
2422 if (state->out_mem_ctx) {
2423 mem_ctx = state->out_mem_ctx;
2424 } else {
2425 mem_ctx = state;
2426 }
2427
2428 status = state->dispatch_recv(subreq, mem_ctx);
2429 TALLOC_FREE(subreq);
2430 if (!NT_STATUS_IS_OK(status)) {
2431 tevent_req_nterror(req, status);
2432 return;
2433 }
2434
2435 /* Copy out parameters */
2436
2437 /* Copy result */
2438 state->orig.out.result = state->tmp.out.result;
2439
2440 /* Reset temporary structure */
2441 ZERO_STRUCT(state->tmp);
2442
2443 if (DEBUGLEVEL >= 10) {
2444 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDriver, &state->orig);
2445 }
2446
2447 tevent_req_done(req);
2448 }
2449
2450 NTSTATUS rpccli_spoolss_DeletePrinterDriver_recv(struct tevent_req *req,
2451 TALLOC_CTX *mem_ctx,
2452 WERROR *result)
2453 {
2454 struct rpccli_spoolss_DeletePrinterDriver_state *state = tevent_req_data(
2455 req, struct rpccli_spoolss_DeletePrinterDriver_state);
2456 NTSTATUS status;
2457
2458 if (tevent_req_is_nterror(req, &status)) {
2459 tevent_req_received(req);
2460 return status;
2461 }
2462
2463 /* Steal possbile out parameters to the callers context */
2464 talloc_steal(mem_ctx, state->out_mem_ctx);
2465
2466 /* Return result */
2467 *result = state->orig.out.result;
2468
2469 tevent_req_received(req);
2470 return NT_STATUS_OK;
2471 }
2472
2473 NTSTATUS rpccli_spoolss_DeletePrinterDriver(struct rpc_pipe_client *cli,
2474 TALLOC_CTX *mem_ctx,
2475 const char *server /* [in] [unique,charset(UTF16)] */,
2476 const char *architecture /* [in] [charset(UTF16)] */,
2477 const char *driver /* [in] [charset(UTF16)] */,
2478 WERROR *werror)
2479 {
2480 struct spoolss_DeletePrinterDriver r;
2481 NTSTATUS status;
2482
2483 /* In parameters */
2484 r.in.server = server;
2485 r.in.architecture = architecture;
2486 r.in.driver = driver;
2487
2488 if (DEBUGLEVEL >= 10) {
2489 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDriver, &r);
2490 }
2491
2492 status = cli->dispatch(cli,
2493 mem_ctx,
2494 &ndr_table_spoolss,
2495 NDR_SPOOLSS_DELETEPRINTERDRIVER,
2496 &r);
2497
2498 if (!NT_STATUS_IS_OK(status)) {
2499 return status;
2500 }
2501
2502 if (DEBUGLEVEL >= 10) {
2503 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDriver, &r);
2504 }
2505
2506 if (NT_STATUS_IS_ERR(status)) {
2507 return status;
2508 }
2509
2510 /* Return variables */
2511
2512 /* Return result */
2513 if (werror) {
2514 *werror = r.out.result;
2515 }
2516
2517 return werror_to_ntstatus(r.out.result);
2518 }
2519
2520 struct rpccli_spoolss_AddPrintProcessor_state {
2521 struct spoolss_AddPrintProcessor orig;
2522 struct spoolss_AddPrintProcessor tmp;
2523 TALLOC_CTX *out_mem_ctx;
2524 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2525 };
2526
2527 static void rpccli_spoolss_AddPrintProcessor_done(struct tevent_req *subreq);
2528
2529 struct tevent_req *rpccli_spoolss_AddPrintProcessor_send(TALLOC_CTX *mem_ctx,
2530 struct tevent_context *ev,
2531 struct rpc_pipe_client *cli,
2532 const char *_server /* [in] [unique,charset(UTF16)] */,
2533 const char *_architecture /* [in] [charset(UTF16)] */,
2534 const char *_path_name /* [in] [charset(UTF16)] */,
2535 const char *_print_processor_name /* [in] [charset(UTF16)] */)
2536 {
2537 struct tevent_req *req;
2538 struct rpccli_spoolss_AddPrintProcessor_state *state;
2539 struct tevent_req *subreq;
2540
2541 req = tevent_req_create(mem_ctx, &state,
2542 struct rpccli_spoolss_AddPrintProcessor_state);
2543 if (req == NULL) {
2544 return NULL;
2545 }
2546 state->out_mem_ctx = NULL;
2547 state->dispatch_recv = cli->dispatch_recv;
2548
2549 /* In parameters */
2550 state->orig.in.server = _server;
2551 state->orig.in.architecture = _architecture;
2552 state->orig.in.path_name = _path_name;
2553 state->orig.in.print_processor_name = _print_processor_name;
2554
2555 /* Out parameters */
2556
2557 /* Result */
2558 ZERO_STRUCT(state->orig.out.result);
2559
2560 if (DEBUGLEVEL >= 10) {
2561 NDR_PRINT_IN_DEBUG(spoolss_AddPrintProcessor, &state->orig);
2562 }
2563
2564 /* make a temporary copy, that we pass to the dispatch function */
2565 state->tmp = state->orig;
2566
2567 subreq = cli->dispatch_send(state, ev, cli,
2568 &ndr_table_spoolss,
2569 NDR_SPOOLSS_ADDPRINTPROCESSOR,
2570 &state->tmp);
2571 if (tevent_req_nomem(subreq, req)) {
2572 return tevent_req_post(req, ev);
2573 }
2574 tevent_req_set_callback(subreq, rpccli_spoolss_AddPrintProcessor_done, req);
2575 return req;
2576 }
2577
2578 static void rpccli_spoolss_AddPrintProcessor_done(struct tevent_req *subreq)
2579 {
2580 struct tevent_req *req = tevent_req_callback_data(
2581 subreq, struct tevent_req);
2582 struct rpccli_spoolss_AddPrintProcessor_state *state = tevent_req_data(
2583 req, struct rpccli_spoolss_AddPrintProcessor_state);
2584 NTSTATUS status;
2585 TALLOC_CTX *mem_ctx;
2586
2587 if (state->out_mem_ctx) {
2588 mem_ctx = state->out_mem_ctx;
2589 } else {
2590 mem_ctx = state;
2591 }
2592
2593 status = state->dispatch_recv(subreq, mem_ctx);
2594 TALLOC_FREE(subreq);
2595 if (!NT_STATUS_IS_OK(status)) {
2596 tevent_req_nterror(req, status);
2597 return;
2598 }
2599
2600 /* Copy out parameters */
2601
2602 /* Copy result */
2603 state->orig.out.result = state->tmp.out.result;
2604
2605 /* Reset temporary structure */
2606 ZERO_STRUCT(state->tmp);
2607
2608 if (DEBUGLEVEL >= 10) {
2609 NDR_PRINT_OUT_DEBUG(spoolss_AddPrintProcessor, &state->orig);
2610 }
2611
2612 tevent_req_done(req);
2613 }
2614
2615 NTSTATUS rpccli_spoolss_AddPrintProcessor_recv(struct tevent_req *req,
2616 TALLOC_CTX *mem_ctx,
2617 WERROR *result)
2618 {
2619 struct rpccli_spoolss_AddPrintProcessor_state *state = tevent_req_data(
2620 req, struct rpccli_spoolss_AddPrintProcessor_state);
2621 NTSTATUS status;
2622
2623 if (tevent_req_is_nterror(req, &status)) {
2624 tevent_req_received(req);
2625 return status;
2626 }
2627
2628 /* Steal possbile out parameters to the callers context */
2629 talloc_steal(mem_ctx, state->out_mem_ctx);
2630
2631 /* Return result */
2632 *result = state->orig.out.result;
2633
2634 tevent_req_received(req);
2635 return NT_STATUS_OK;
2636 }
2637
2638 NTSTATUS rpccli_spoolss_AddPrintProcessor(struct rpc_pipe_client *cli,
2639 TALLOC_CTX *mem_ctx,
2640 const char *server /* [in] [unique,charset(UTF16)] */,
2641 const char *architecture /* [in] [charset(UTF16)] */,
2642 const char *path_name /* [in] [charset(UTF16)] */,
2643 const char *print_processor_name /* [in] [charset(UTF16)] */,
2644 WERROR *werror)
2645 {
2646 struct spoolss_AddPrintProcessor r;
2647 NTSTATUS status;
2648
2649 /* In parameters */
2650 r.in.server = server;
2651 r.in.architecture = architecture;
2652 r.in.path_name = path_name;
2653 r.in.print_processor_name = print_processor_name;
2654
2655 if (DEBUGLEVEL >= 10) {
2656 NDR_PRINT_IN_DEBUG(spoolss_AddPrintProcessor, &r);
2657 }
2658
2659 status = cli->dispatch(cli,
2660 mem_ctx,
2661 &ndr_table_spoolss,
2662 NDR_SPOOLSS_ADDPRINTPROCESSOR,
2663 &r);
2664
2665 if (!NT_STATUS_IS_OK(status)) {
2666 return status;
2667 }
2668
2669 if (DEBUGLEVEL >= 10) {
2670 NDR_PRINT_OUT_DEBUG(spoolss_AddPrintProcessor, &r);
2671 }
2672
2673 if (NT_STATUS_IS_ERR(status)) {
2674 return status;
2675 }
2676
2677 /* Return variables */
2678
2679 /* Return result */
2680 if (werror) {
2681 *werror = r.out.result;
2682 }
2683
2684 return werror_to_ntstatus(r.out.result);
2685 }
2686
2687 struct rpccli_spoolss_EnumPrintProcessors_state {
2688 struct spoolss_EnumPrintProcessors orig;
2689 struct spoolss_EnumPrintProcessors tmp;
2690 TALLOC_CTX *out_mem_ctx;
2691 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2692 };
2693
2694 static void rpccli_spoolss_EnumPrintProcessors_done(struct tevent_req *subreq);
2695
2696 struct tevent_req *rpccli_spoolss_EnumPrintProcessors_send(TALLOC_CTX *mem_ctx,
2697 struct tevent_context *ev,
2698 struct rpc_pipe_client *cli,
2699 const char *_servername /* [in] [unique,charset(UTF16)] */,
2700 const char *_environment /* [in] [unique,charset(UTF16)] */,
2701 uint32_t _level /* [in] */,
2702 DATA_BLOB *_buffer /* [in] [unique] */,
2703 uint32_t _offered /* [in] */,
2704 uint32_t *_count /* [out] [ref] */,
2705 union spoolss_PrintProcessorInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
2706 uint32_t *_needed /* [out] [ref] */)
2707 {
2708 struct tevent_req *req;
2709 struct rpccli_spoolss_EnumPrintProcessors_state *state;
2710 struct tevent_req *subreq;
2711
2712 req = tevent_req_create(mem_ctx, &state,
2713 struct rpccli_spoolss_EnumPrintProcessors_state);
2714 if (req == NULL) {
2715 return NULL;
2716 }
2717 state->out_mem_ctx = NULL;
2718 state->dispatch_recv = cli->dispatch_recv;
2719
2720 /* In parameters */
2721 state->orig.in.servername = _servername;
2722 state->orig.in.environment = _environment;
2723 state->orig.in.level = _level;
2724 state->orig.in.buffer = _buffer;
2725 state->orig.in.offered = _offered;
2726
2727 /* Out parameters */
2728 state->orig.out.count = _count;
2729 state->orig.out.info = _info;
2730 state->orig.out.needed = _needed;
2731
2732 /* Result */
2733 ZERO_STRUCT(state->orig.out.result);
2734
2735 if (DEBUGLEVEL >= 10) {
2736 NDR_PRINT_IN_DEBUG(spoolss_EnumPrintProcessors, &state->orig);
2737 }
2738
2739 state->out_mem_ctx = talloc_named_const(state, 0,
2740 "rpccli_spoolss_EnumPrintProcessors_out_memory");
2741 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2742 return tevent_req_post(req, ev);
2743 }
2744
2745 /* make a temporary copy, that we pass to the dispatch function */
2746 state->tmp = state->orig;
2747
2748 subreq = cli->dispatch_send(state, ev, cli,
2749 &ndr_table_spoolss,
2750 NDR_SPOOLSS_ENUMPRINTPROCESSORS,
2751 &state->tmp);
2752 if (tevent_req_nomem(subreq, req)) {
2753 return tevent_req_post(req, ev);
2754 }
2755 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrintProcessors_done, req);
2756 return req;
2757 }
2758
2759 static void rpccli_spoolss_EnumPrintProcessors_done(struct tevent_req *subreq)
2760 {
2761 struct tevent_req *req = tevent_req_callback_data(
2762 subreq, struct tevent_req);
2763 struct rpccli_spoolss_EnumPrintProcessors_state *state = tevent_req_data(
2764 req, struct rpccli_spoolss_EnumPrintProcessors_state);
2765 NTSTATUS status;
2766 TALLOC_CTX *mem_ctx;
2767
2768 if (state->out_mem_ctx) {
2769 mem_ctx = state->out_mem_ctx;
2770 } else {
2771 mem_ctx = state;
2772 }
2773
2774 status = state->dispatch_recv(subreq, mem_ctx);
2775 TALLOC_FREE(subreq);
2776 if (!NT_STATUS_IS_OK(status)) {
2777 tevent_req_nterror(req, status);
2778 return;
2779 }
2780
2781 /* Copy out parameters */
2782 *state->orig.out.count = *state->tmp.out.count;
2783 *state->orig.out.info = *state->tmp.out.info;
2784 *state->orig.out.needed = *state->tmp.out.needed;
2785
2786 /* Copy result */
2787 state->orig.out.result = state->tmp.out.result;
2788
2789 /* Reset temporary structure */
2790 ZERO_STRUCT(state->tmp);
2791
2792 if (DEBUGLEVEL >= 10) {
2793 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrintProcessors, &state->orig);
2794 }
2795
2796 tevent_req_done(req);
2797 }
2798
2799 NTSTATUS rpccli_spoolss_EnumPrintProcessors_recv(struct tevent_req *req,
2800 TALLOC_CTX *mem_ctx,
2801 WERROR *result)
2802 {
2803 struct rpccli_spoolss_EnumPrintProcessors_state *state = tevent_req_data(
2804 req, struct rpccli_spoolss_EnumPrintProcessors_state);
2805 NTSTATUS status;
2806
2807 if (tevent_req_is_nterror(req, &status)) {
2808 tevent_req_received(req);
2809 return status;
2810 }
2811
2812 /* Steal possbile out parameters to the callers context */
2813 talloc_steal(mem_ctx, state->out_mem_ctx);
2814
2815 /* Return result */
2816 *result = state->orig.out.result;
2817
2818 tevent_req_received(req);
2819 return NT_STATUS_OK;
2820 }
2821
2822 NTSTATUS rpccli_spoolss_EnumPrintProcessors(struct rpc_pipe_client *cli,
2823 TALLOC_CTX *mem_ctx,
2824 const char *servername /* [in] [unique,charset(UTF16)] */,
2825 const char *environment /* [in] [unique,charset(UTF16)] */,
2826 uint32_t level /* [in] */,
2827 DATA_BLOB *buffer /* [in] [unique] */,
2828 uint32_t offered /* [in] */,
2829 uint32_t *count /* [out] [ref] */,
2830 union spoolss_PrintProcessorInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
2831 uint32_t *needed /* [out] [ref] */,
2832 WERROR *werror)
2833 {
2834 struct spoolss_EnumPrintProcessors r;
2835 NTSTATUS status;
2836
2837 /* In parameters */
2838 r.in.servername = servername;
2839 r.in.environment = environment;
2840 r.in.level = level;
2841 r.in.buffer = buffer;
2842 r.in.offered = offered;
2843
2844 if (DEBUGLEVEL >= 10) {
2845 NDR_PRINT_IN_DEBUG(spoolss_EnumPrintProcessors, &r);
2846 }
2847
2848 status = cli->dispatch(cli,
2849 mem_ctx,
2850 &ndr_table_spoolss,
2851 NDR_SPOOLSS_ENUMPRINTPROCESSORS,
2852 &r);
2853
2854 if (!NT_STATUS_IS_OK(status)) {
2855 return status;
2856 }
2857
2858 if (DEBUGLEVEL >= 10) {
2859 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrintProcessors, &r);
2860 }
2861
2862 if (NT_STATUS_IS_ERR(status)) {
2863 return status;
2864 }
2865
2866 /* Return variables */
2867 *count = *r.out.count;
2868 *info = *r.out.info;
2869 *needed = *r.out.needed;
2870
2871 /* Return result */
2872 if (werror) {
2873 *werror = r.out.result;
2874 }
2875
2876 return werror_to_ntstatus(r.out.result);
2877 }
2878
2879 struct rpccli_spoolss_GetPrintProcessorDirectory_state {
2880 struct spoolss_GetPrintProcessorDirectory orig;
2881 struct spoolss_GetPrintProcessorDirectory tmp;
2882 TALLOC_CTX *out_mem_ctx;
2883 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2884 };
2885
2886 static void rpccli_spoolss_GetPrintProcessorDirectory_done(struct tevent_req *subreq);
2887
2888 struct tevent_req *rpccli_spoolss_GetPrintProcessorDirectory_send(TALLOC_CTX *mem_ctx,
2889 struct tevent_context *ev,
2890 struct rpc_pipe_client *cli,
2891 const char *_server /* [in] [unique,charset(UTF16)] */,
2892 const char *_environment /* [in] [unique,charset(UTF16)] */,
2893 uint32_t _level /* [in] */,
2894 DATA_BLOB *_buffer /* [in] [unique] */,
2895 uint32_t _offered /* [in] */,
2896 union spoolss_PrintProcessorDirectoryInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
2897 uint32_t *_needed /* [out] [ref] */)
2898 {
2899 struct tevent_req *req;
2900 struct rpccli_spoolss_GetPrintProcessorDirectory_state *state;
2901 struct tevent_req *subreq;
2902
2903 req = tevent_req_create(mem_ctx, &state,
2904 struct rpccli_spoolss_GetPrintProcessorDirectory_state);
2905 if (req == NULL) {
2906 return NULL;
2907 }
2908 state->out_mem_ctx = NULL;
2909 state->dispatch_recv = cli->dispatch_recv;
2910
2911 /* In parameters */
2912 state->orig.in.server = _server;
2913 state->orig.in.environment = _environment;
2914 state->orig.in.level = _level;
2915 state->orig.in.buffer = _buffer;
2916 state->orig.in.offered = _offered;
2917
2918 /* Out parameters */
2919 state->orig.out.info = _info;
2920 state->orig.out.needed = _needed;
2921
2922 /* Result */
2923 ZERO_STRUCT(state->orig.out.result);
2924
2925 if (DEBUGLEVEL >= 10) {
2926 NDR_PRINT_IN_DEBUG(spoolss_GetPrintProcessorDirectory, &state->orig);
2927 }
2928
2929 state->out_mem_ctx = talloc_named_const(state, 0,
2930 "rpccli_spoolss_GetPrintProcessorDirectory_out_memory");
2931 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2932 return tevent_req_post(req, ev);
2933 }
2934
2935 /* make a temporary copy, that we pass to the dispatch function */
2936 state->tmp = state->orig;
2937
2938 subreq = cli->dispatch_send(state, ev, cli,
2939 &ndr_table_spoolss,
2940 NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY,
2941 &state->tmp);
2942 if (tevent_req_nomem(subreq, req)) {
2943 return tevent_req_post(req, ev);
2944 }
2945 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrintProcessorDirectory_done, req);
2946 return req;
2947 }
2948
2949 static void rpccli_spoolss_GetPrintProcessorDirectory_done(struct tevent_req *subreq)
2950 {
2951 struct tevent_req *req = tevent_req_callback_data(
2952 subreq, struct tevent_req);
2953 struct rpccli_spoolss_GetPrintProcessorDirectory_state *state = tevent_req_data(
2954 req, struct rpccli_spoolss_GetPrintProcessorDirectory_state);
2955 NTSTATUS status;
2956 TALLOC_CTX *mem_ctx;
2957
2958 if (state->out_mem_ctx) {
2959 mem_ctx = state->out_mem_ctx;
2960 } else {
2961 mem_ctx = state;
2962 }
2963
2964 status = state->dispatch_recv(subreq, mem_ctx);
2965 TALLOC_FREE(subreq);
2966 if (!NT_STATUS_IS_OK(status)) {
2967 tevent_req_nterror(req, status);
2968 return;
2969 }
2970
2971 /* Copy out parameters */
2972 if (state->orig.out.info && state->tmp.out.info) {
2973 *state->orig.out.info = *state->tmp.out.info;
2974 }
2975 *state->orig.out.needed = *state->tmp.out.needed;
2976
2977 /* Copy result */
2978 state->orig.out.result = state->tmp.out.result;
2979
2980 /* Reset temporary structure */
2981 ZERO_STRUCT(state->tmp);
2982
2983 if (DEBUGLEVEL >= 10) {
2984 NDR_PRINT_OUT_DEBUG(spoolss_GetPrintProcessorDirectory, &state->orig);
2985 }
2986
2987 tevent_req_done(req);
2988 }
2989
2990 NTSTATUS rpccli_spoolss_GetPrintProcessorDirectory_recv(struct tevent_req *req,
2991 TALLOC_CTX *mem_ctx,
2992 WERROR *result)
2993 {
2994 struct rpccli_spoolss_GetPrintProcessorDirectory_state *state = tevent_req_data(
2995 req, struct rpccli_spoolss_GetPrintProcessorDirectory_state);
2996 NTSTATUS status;
2997
2998 if (tevent_req_is_nterror(req, &status)) {
2999 tevent_req_received(req);
3000 return status;
3001 }
3002
3003 /* Steal possbile out parameters to the callers context */
3004 talloc_steal(mem_ctx, state->out_mem_ctx);
3005
3006 /* Return result */
3007 *result = state->orig.out.result;
3008
3009 tevent_req_received(req);
3010 return NT_STATUS_OK;
3011 }
3012
3013 NTSTATUS rpccli_spoolss_GetPrintProcessorDirectory(struct rpc_pipe_client *cli,
3014 TALLOC_CTX *mem_ctx,
3015 const char *server /* [in] [unique,charset(UTF16)] */,
3016 const char *environment /* [in] [unique,charset(UTF16)] */,
3017 uint32_t level /* [in] */,
3018 DATA_BLOB *buffer /* [in] [unique] */,
3019 uint32_t offered /* [in] */,
3020 union spoolss_PrintProcessorDirectoryInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
3021 uint32_t *needed /* [out] [ref] */,
3022 WERROR *werror)
3023 {
3024 struct spoolss_GetPrintProcessorDirectory r;
3025 NTSTATUS status;
3026
3027 /* In parameters */
3028 r.in.server = server;
3029 r.in.environment = environment;
3030 r.in.level = level;
3031 r.in.buffer = buffer;
3032 r.in.offered = offered;
3033
3034 if (DEBUGLEVEL >= 10) {
3035 NDR_PRINT_IN_DEBUG(spoolss_GetPrintProcessorDirectory, &r);
3036 }
3037
3038 status = cli->dispatch(cli,
3039 mem_ctx,
3040 &ndr_table_spoolss,
3041 NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY,
3042 &r);
3043
3044 if (!NT_STATUS_IS_OK(status)) {
3045 return status;
3046 }
3047
3048 if (DEBUGLEVEL >= 10) {
3049 NDR_PRINT_OUT_DEBUG(spoolss_GetPrintProcessorDirectory, &r);
3050 }
3051
3052 if (NT_STATUS_IS_ERR(status)) {
3053 return status;
3054 }
3055
3056 /* Return variables */
3057 if (info && r.out.info) {
3058 *info = *r.out.info;
3059 }
3060 *needed = *r.out.needed;
3061
3062 /* Return result */
3063 if (werror) {
3064 *werror = r.out.result;
3065 }
3066
3067 return werror_to_ntstatus(r.out.result);
3068 }
3069
3070 struct rpccli_spoolss_StartDocPrinter_state {
3071 struct spoolss_StartDocPrinter orig;
3072 struct spoolss_StartDocPrinter tmp;
3073 TALLOC_CTX *out_mem_ctx;
3074 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3075 };
3076
3077 static void rpccli_spoolss_StartDocPrinter_done(struct tevent_req *subreq);
3078
3079 struct tevent_req *rpccli_spoolss_StartDocPrinter_send(TALLOC_CTX *mem_ctx,
3080 struct tevent_context *ev,
3081 struct rpc_pipe_client *cli,
3082 struct policy_handle *_handle /* [in] [ref] */,
3083 uint32_t _level /* [in] */,
3084 union spoolss_DocumentInfo _info /* [in] [switch_is(level)] */,
3085 uint32_t *_job_id /* [out] [ref] */)
3086 {
3087 struct tevent_req *req;
3088 struct rpccli_spoolss_StartDocPrinter_state *state;
3089 struct tevent_req *subreq;
3090
3091 req = tevent_req_create(mem_ctx, &state,
3092 struct rpccli_spoolss_StartDocPrinter_state);
3093 if (req == NULL) {
3094 return NULL;
3095 }
3096 state->out_mem_ctx = NULL;
3097 state->dispatch_recv = cli->dispatch_recv;
3098
3099 /* In parameters */
3100 state->orig.in.handle = _handle;
3101 state->orig.in.level = _level;
3102 state->orig.in.info = _info;
3103
3104 /* Out parameters */
3105 state->orig.out.job_id = _job_id;
3106
3107 /* Result */
3108 ZERO_STRUCT(state->orig.out.result);
3109
3110 if (DEBUGLEVEL >= 10) {
3111 NDR_PRINT_IN_DEBUG(spoolss_StartDocPrinter, &state->orig);
3112 }
3113
3114 state->out_mem_ctx = talloc_named_const(state, 0,
3115 "rpccli_spoolss_StartDocPrinter_out_memory");
3116 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3117 return tevent_req_post(req, ev);
3118 }
3119
3120 /* make a temporary copy, that we pass to the dispatch function */
3121 state->tmp = state->orig;
3122
3123 subreq = cli->dispatch_send(state, ev, cli,
3124 &ndr_table_spoolss,
3125 NDR_SPOOLSS_STARTDOCPRINTER,
3126 &state->tmp);
3127 if (tevent_req_nomem(subreq, req)) {
3128 return tevent_req_post(req, ev);
3129 }
3130 tevent_req_set_callback(subreq, rpccli_spoolss_StartDocPrinter_done, req);
3131 return req;
3132 }
3133
3134 static void rpccli_spoolss_StartDocPrinter_done(struct tevent_req *subreq)
3135 {
3136 struct tevent_req *req = tevent_req_callback_data(
3137 subreq, struct tevent_req);
3138 struct rpccli_spoolss_StartDocPrinter_state *state = tevent_req_data(
3139 req, struct rpccli_spoolss_StartDocPrinter_state);
3140 NTSTATUS status;
3141 TALLOC_CTX *mem_ctx;
3142
3143 if (state->out_mem_ctx) {
3144 mem_ctx = state->out_mem_ctx;
3145 } else {
3146 mem_ctx = state;
3147 }
3148
3149 status = state->dispatch_recv(subreq, mem_ctx);
3150 TALLOC_FREE(subreq);
3151 if (!NT_STATUS_IS_OK(status)) {
3152 tevent_req_nterror(req, status);
3153 return;
3154 }
3155
3156 /* Copy out parameters */
3157 *state->orig.out.job_id = *state->tmp.out.job_id;
3158
3159 /* Copy result */
3160 state->orig.out.result = state->tmp.out.result;
3161
3162 /* Reset temporary structure */
3163 ZERO_STRUCT(state->tmp);
3164
3165 if (DEBUGLEVEL >= 10) {
3166 NDR_PRINT_OUT_DEBUG(spoolss_StartDocPrinter, &state->orig);
3167 }
3168
3169 tevent_req_done(req);
3170 }
3171
3172 NTSTATUS rpccli_spoolss_StartDocPrinter_recv(struct tevent_req *req,
3173 TALLOC_CTX *mem_ctx,
3174 WERROR *result)
3175 {
3176 struct rpccli_spoolss_StartDocPrinter_state *state = tevent_req_data(
3177 req, struct rpccli_spoolss_StartDocPrinter_state);
3178 NTSTATUS status;
3179
3180 if (tevent_req_is_nterror(req, &status)) {
3181 tevent_req_received(req);
3182 return status;
3183 }
3184
3185 /* Steal possbile out parameters to the callers context */
3186 talloc_steal(mem_ctx, state->out_mem_ctx);
3187
3188 /* Return result */
3189 *result = state->orig.out.result;
3190
3191 tevent_req_received(req);
3192 return NT_STATUS_OK;
3193 }
3194
3195 NTSTATUS rpccli_spoolss_StartDocPrinter(struct rpc_pipe_client *cli,
3196 TALLOC_CTX *mem_ctx,
3197 struct policy_handle *handle /* [in] [ref] */,
3198 uint32_t level /* [in] */,
3199 union spoolss_DocumentInfo info /* [in] [switch_is(level)] */,
3200 uint32_t *job_id /* [out] [ref] */,
3201 WERROR *werror)
3202 {
3203 struct spoolss_StartDocPrinter r;
3204 NTSTATUS status;
3205
3206 /* In parameters */
3207 r.in.handle = handle;
3208 r.in.level = level;
3209 r.in.info = info;
3210
3211 if (DEBUGLEVEL >= 10) {
3212 NDR_PRINT_IN_DEBUG(spoolss_StartDocPrinter, &r);
3213 }
3214
3215 status = cli->dispatch(cli,
3216 mem_ctx,
3217 &ndr_table_spoolss,
3218 NDR_SPOOLSS_STARTDOCPRINTER,
3219 &r);
3220
3221 if (!NT_STATUS_IS_OK(status)) {
3222 return status;
3223 }
3224
3225 if (DEBUGLEVEL >= 10) {
3226 NDR_PRINT_OUT_DEBUG(spoolss_StartDocPrinter, &r);
3227 }
3228
3229 if (NT_STATUS_IS_ERR(status)) {
3230 return status;
3231 }
3232
3233 /* Return variables */
3234 *job_id = *r.out.job_id;
3235
3236 /* Return result */
3237 if (werror) {
3238 *werror = r.out.result;
3239 }
3240
3241 return werror_to_ntstatus(r.out.result);
3242 }
3243
3244 struct rpccli_spoolss_StartPagePrinter_state {
3245 struct spoolss_StartPagePrinter orig;
3246 struct spoolss_StartPagePrinter tmp;
3247 TALLOC_CTX *out_mem_ctx;
3248 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3249 };
3250
3251 static void rpccli_spoolss_StartPagePrinter_done(struct tevent_req *subreq);
3252
3253 struct tevent_req *rpccli_spoolss_StartPagePrinter_send(TALLOC_CTX *mem_ctx,
3254 struct tevent_context *ev,
3255 struct rpc_pipe_client *cli,
3256 struct policy_handle *_handle /* [in] [ref] */)
3257 {
3258 struct tevent_req *req;
3259 struct rpccli_spoolss_StartPagePrinter_state *state;
3260 struct tevent_req *subreq;
3261
3262 req = tevent_req_create(mem_ctx, &state,
3263 struct rpccli_spoolss_StartPagePrinter_state);
3264 if (req == NULL) {
3265 return NULL;
3266 }
3267 state->out_mem_ctx = NULL;
3268 state->dispatch_recv = cli->dispatch_recv;
3269
3270 /* In parameters */
3271 state->orig.in.handle = _handle;
3272
3273 /* Out parameters */
3274
3275 /* Result */
3276 ZERO_STRUCT(state->orig.out.result);
3277
3278 if (DEBUGLEVEL >= 10) {
3279 NDR_PRINT_IN_DEBUG(spoolss_StartPagePrinter, &state->orig);
3280 }
3281
3282 /* make a temporary copy, that we pass to the dispatch function */
3283 state->tmp = state->orig;
3284
3285 subreq = cli->dispatch_send(state, ev, cli,
3286 &ndr_table_spoolss,
3287 NDR_SPOOLSS_STARTPAGEPRINTER,
3288 &state->tmp);
3289 if (tevent_req_nomem(subreq, req)) {
3290 return tevent_req_post(req, ev);
3291 }
3292 tevent_req_set_callback(subreq, rpccli_spoolss_StartPagePrinter_done, req);
3293 return req;
3294 }
3295
3296 static void rpccli_spoolss_StartPagePrinter_done(struct tevent_req *subreq)
3297 {
3298 struct tevent_req *req = tevent_req_callback_data(
3299 subreq, struct tevent_req);
3300 struct rpccli_spoolss_StartPagePrinter_state *state = tevent_req_data(
3301 req, struct rpccli_spoolss_StartPagePrinter_state);
3302 NTSTATUS status;
3303 TALLOC_CTX *mem_ctx;
3304
3305 if (state->out_mem_ctx) {
3306 mem_ctx = state->out_mem_ctx;
3307 } else {
3308 mem_ctx = state;
3309 }
3310
3311 status = state->dispatch_recv(subreq, mem_ctx);
3312 TALLOC_FREE(subreq);
3313 if (!NT_STATUS_IS_OK(status)) {
3314 tevent_req_nterror(req, status);
3315 return;
3316 }
3317
3318 /* Copy out parameters */
3319
3320 /* Copy result */
3321 state->orig.out.result = state->tmp.out.result;
3322
3323 /* Reset temporary structure */
3324 ZERO_STRUCT(state->tmp);
3325
3326 if (DEBUGLEVEL >= 10) {
3327 NDR_PRINT_OUT_DEBUG(spoolss_StartPagePrinter, &state->orig);
3328 }
3329
3330 tevent_req_done(req);
3331 }
3332
3333 NTSTATUS rpccli_spoolss_StartPagePrinter_recv(struct tevent_req *req,
3334 TALLOC_CTX *mem_ctx,
3335 WERROR *result)
3336 {
3337 struct rpccli_spoolss_StartPagePrinter_state *state = tevent_req_data(
3338 req, struct rpccli_spoolss_StartPagePrinter_state);
3339 NTSTATUS status;
3340
3341 if (tevent_req_is_nterror(req, &status)) {
3342 tevent_req_received(req);
3343 return status;
3344 }
3345
3346 /* Steal possbile out parameters to the callers context */
3347 talloc_steal(mem_ctx, state->out_mem_ctx);
3348
3349 /* Return result */
3350 *result = state->orig.out.result;
3351
3352 tevent_req_received(req);
3353 return NT_STATUS_OK;
3354 }
3355
3356 NTSTATUS rpccli_spoolss_StartPagePrinter(struct rpc_pipe_client *cli,
3357 TALLOC_CTX *mem_ctx,
3358 struct policy_handle *handle /* [in] [ref] */,
3359 WERROR *werror)
3360 {
3361 struct spoolss_StartPagePrinter r;
3362 NTSTATUS status;
3363
3364 /* In parameters */
3365 r.in.handle = handle;
3366
3367 if (DEBUGLEVEL >= 10) {
3368 NDR_PRINT_IN_DEBUG(spoolss_StartPagePrinter, &r);
3369 }
3370
3371 status = cli->dispatch(cli,
3372 mem_ctx,
3373 &ndr_table_spoolss,
3374 NDR_SPOOLSS_STARTPAGEPRINTER,
3375 &r);
3376
3377 if (!NT_STATUS_IS_OK(status)) {
3378 return status;
3379 }
3380
3381 if (DEBUGLEVEL >= 10) {
3382 NDR_PRINT_OUT_DEBUG(spoolss_StartPagePrinter, &r);
3383 }
3384
3385 if (NT_STATUS_IS_ERR(status)) {
3386 return status;
3387 }
3388
3389 /* Return variables */
3390
3391 /* Return result */
3392 if (werror) {
3393 *werror = r.out.result;
3394 }
3395
3396 return werror_to_ntstatus(r.out.result);
3397 }
3398
3399 struct rpccli_spoolss_WritePrinter_state {
3400 struct spoolss_WritePrinter orig;
3401 struct spoolss_WritePrinter tmp;
3402 TALLOC_CTX *out_mem_ctx;
3403 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3404 };
3405
3406 static void rpccli_spoolss_WritePrinter_done(struct tevent_req *subreq);
3407
3408 struct tevent_req *rpccli_spoolss_WritePrinter_send(TALLOC_CTX *mem_ctx,
3409 struct tevent_context *ev,
3410 struct rpc_pipe_client *cli,
3411 struct policy_handle *_handle /* [in] [ref] */,
3412 DATA_BLOB _data /* [in] */,
3413 uint32_t __data_size /* [in] [value(r->in.data.length)] */,
3414 uint32_t *_num_written /* [out] [ref] */)
3415 {
3416 struct tevent_req *req;
3417 struct rpccli_spoolss_WritePrinter_state *state;
3418 struct tevent_req *subreq;
3419
3420 req = tevent_req_create(mem_ctx, &state,
3421 struct rpccli_spoolss_WritePrinter_state);
3422 if (req == NULL) {
3423 return NULL;
3424 }
3425 state->out_mem_ctx = NULL;
3426 state->dispatch_recv = cli->dispatch_recv;
3427
3428 /* In parameters */
3429 state->orig.in.handle = _handle;
3430 state->orig.in.data = _data;
3431 state->orig.in._data_size = __data_size;
3432
3433 /* Out parameters */
3434 state->orig.out.num_written = _num_written;
3435
3436 /* Result */
3437 ZERO_STRUCT(state->orig.out.result);
3438
3439 if (DEBUGLEVEL >= 10) {
3440 NDR_PRINT_IN_DEBUG(spoolss_WritePrinter, &state->orig);
3441 }
3442
3443 state->out_mem_ctx = talloc_named_const(state, 0,
3444 "rpccli_spoolss_WritePrinter_out_memory");
3445 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3446 return tevent_req_post(req, ev);
3447 }
3448
3449 /* make a temporary copy, that we pass to the dispatch function */
3450 state->tmp = state->orig;
3451
3452 subreq = cli->dispatch_send(state, ev, cli,
3453 &ndr_table_spoolss,
3454 NDR_SPOOLSS_WRITEPRINTER,
3455 &state->tmp);
3456 if (tevent_req_nomem(subreq, req)) {
3457 return tevent_req_post(req, ev);
3458 }
3459 tevent_req_set_callback(subreq, rpccli_spoolss_WritePrinter_done, req);
3460 return req;
3461 }
3462
3463 static void rpccli_spoolss_WritePrinter_done(struct tevent_req *subreq)
3464 {
3465 struct tevent_req *req = tevent_req_callback_data(
3466 subreq, struct tevent_req);
3467 struct rpccli_spoolss_WritePrinter_state *state = tevent_req_data(
3468 req, struct rpccli_spoolss_WritePrinter_state);
3469 NTSTATUS status;
3470 TALLOC_CTX *mem_ctx;
3471
3472 if (state->out_mem_ctx) {
3473 mem_ctx = state->out_mem_ctx;
3474 } else {
3475 mem_ctx = state;
3476 }
3477
3478 status = state->dispatch_recv(subreq, mem_ctx);
3479 TALLOC_FREE(subreq);
3480 if (!NT_STATUS_IS_OK(status)) {
3481 tevent_req_nterror(req, status);
3482 return;
3483 }
3484
3485 /* Copy out parameters */
3486 *state->orig.out.num_written = *state->tmp.out.num_written;
3487
3488 /* Copy result */
3489 state->orig.out.result = state->tmp.out.result;
3490
3491 /* Reset temporary structure */
3492 ZERO_STRUCT(state->tmp);
3493
3494 if (DEBUGLEVEL >= 10) {
3495 NDR_PRINT_OUT_DEBUG(spoolss_WritePrinter, &state->orig);
3496 }
3497
3498 tevent_req_done(req);
3499 }
3500
3501 NTSTATUS rpccli_spoolss_WritePrinter_recv(struct tevent_req *req,
3502 TALLOC_CTX *mem_ctx,
3503 WERROR *result)
3504 {
3505 struct rpccli_spoolss_WritePrinter_state *state = tevent_req_data(
3506 req, struct rpccli_spoolss_WritePrinter_state);
3507 NTSTATUS status;
3508
3509 if (tevent_req_is_nterror(req, &status)) {
3510 tevent_req_received(req);
3511 return status;
3512 }
3513
3514 /* Steal possbile out parameters to the callers context */
3515 talloc_steal(mem_ctx, state->out_mem_ctx);
3516
3517 /* Return result */
3518 *result = state->orig.out.result;
3519
3520 tevent_req_received(req);
3521 return NT_STATUS_OK;
3522 }
3523
3524 NTSTATUS rpccli_spoolss_WritePrinter(struct rpc_pipe_client *cli,
3525 TALLOC_CTX *mem_ctx,
3526 struct policy_handle *handle /* [in] [ref] */,
3527 DATA_BLOB data /* [in] */,
3528 uint32_t _data_size /* [in] [value(r->in.data.length)] */,
3529 uint32_t *num_written /* [out] [ref] */,
3530 WERROR *werror)
3531 {
3532 struct spoolss_WritePrinter r;
3533 NTSTATUS status;
3534
3535 /* In parameters */
3536 r.in.handle = handle;
3537 r.in.data = data;
3538 r.in._data_size = _data_size;
3539
3540 if (DEBUGLEVEL >= 10) {
3541 NDR_PRINT_IN_DEBUG(spoolss_WritePrinter, &r);
3542 }
3543
3544 status = cli->dispatch(cli,
3545 mem_ctx,
3546 &ndr_table_spoolss,
3547 NDR_SPOOLSS_WRITEPRINTER,
3548 &r);
3549
3550 if (!NT_STATUS_IS_OK(status)) {
3551 return status;
3552 }
3553
3554 if (DEBUGLEVEL >= 10) {
3555 NDR_PRINT_OUT_DEBUG(spoolss_WritePrinter, &r);
3556 }
3557
3558 if (NT_STATUS_IS_ERR(status)) {
3559 return status;
3560 }
3561
3562 /* Return variables */
3563 *num_written = *r.out.num_written;
3564
3565 /* Return result */
3566 if (werror) {
3567 *werror = r.out.result;
3568 }
3569
3570 return werror_to_ntstatus(r.out.result);
3571 }
3572
3573 struct rpccli_spoolss_EndPagePrinter_state {
3574 struct spoolss_EndPagePrinter orig;
3575 struct spoolss_EndPagePrinter tmp;
3576 TALLOC_CTX *out_mem_ctx;
3577 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3578 };
3579
3580 static void rpccli_spoolss_EndPagePrinter_done(struct tevent_req *subreq);
3581
3582 struct tevent_req *rpccli_spoolss_EndPagePrinter_send(TALLOC_CTX *mem_ctx,
3583 struct tevent_context *ev,
3584 struct rpc_pipe_client *cli,
3585 struct policy_handle *_handle /* [in] [ref] */)
3586 {
3587 struct tevent_req *req;
3588 struct rpccli_spoolss_EndPagePrinter_state *state;
3589 struct tevent_req *subreq;
3590
3591 req = tevent_req_create(mem_ctx, &state,
3592 struct rpccli_spoolss_EndPagePrinter_state);
3593 if (req == NULL) {
3594 return NULL;
3595 }
3596 state->out_mem_ctx = NULL;
3597 state->dispatch_recv = cli->dispatch_recv;
3598
3599 /* In parameters */
3600 state->orig.in.handle = _handle;
3601
3602 /* Out parameters */
3603
3604 /* Result */
3605 ZERO_STRUCT(state->orig.out.result);
3606
3607 if (DEBUGLEVEL >= 10) {
3608 NDR_PRINT_IN_DEBUG(spoolss_EndPagePrinter, &state->orig);
3609 }
3610
3611 /* make a temporary copy, that we pass to the dispatch function */
3612 state->tmp = state->orig;
3613
3614 subreq = cli->dispatch_send(state, ev, cli,
3615 &ndr_table_spoolss,
3616 NDR_SPOOLSS_ENDPAGEPRINTER,
3617 &state->tmp);
3618 if (tevent_req_nomem(subreq, req)) {
3619 return tevent_req_post(req, ev);
3620 }
3621 tevent_req_set_callback(subreq, rpccli_spoolss_EndPagePrinter_done, req);
3622 return req;
3623 }
3624
3625 static void rpccli_spoolss_EndPagePrinter_done(struct tevent_req *subreq)
3626 {
3627 struct tevent_req *req = tevent_req_callback_data(
3628 subreq, struct tevent_req);
3629 struct rpccli_spoolss_EndPagePrinter_state *state = tevent_req_data(
3630 req, struct rpccli_spoolss_EndPagePrinter_state);
3631 NTSTATUS status;
3632 TALLOC_CTX *mem_ctx;
3633
3634 if (state->out_mem_ctx) {
3635 mem_ctx = state->out_mem_ctx;
3636 } else {
3637 mem_ctx = state;
3638 }
3639
3640 status = state->dispatch_recv(subreq, mem_ctx);
3641 TALLOC_FREE(subreq);
3642 if (!NT_STATUS_IS_OK(status)) {
3643 tevent_req_nterror(req, status);
3644 return;
3645 }
3646
3647 /* Copy out parameters */
3648
3649 /* Copy result */
3650 state->orig.out.result = state->tmp.out.result;
3651
3652 /* Reset temporary structure */
3653 ZERO_STRUCT(state->tmp);
3654
3655 if (DEBUGLEVEL >= 10) {
3656 NDR_PRINT_OUT_DEBUG(spoolss_EndPagePrinter, &state->orig);
3657 }
3658
3659 tevent_req_done(req);
3660 }
3661
3662 NTSTATUS rpccli_spoolss_EndPagePrinter_recv(struct tevent_req *req,
3663 TALLOC_CTX *mem_ctx,
3664 WERROR *result)
3665 {
3666 struct rpccli_spoolss_EndPagePrinter_state *state = tevent_req_data(
3667 req, struct rpccli_spoolss_EndPagePrinter_state);
3668 NTSTATUS status;
3669
3670 if (tevent_req_is_nterror(req, &status)) {
3671 tevent_req_received(req);
3672 return status;
3673 }
3674
3675 /* Steal possbile out parameters to the callers context */
3676 talloc_steal(mem_ctx, state->out_mem_ctx);
3677
3678 /* Return result */
3679 *result = state->orig.out.result;
3680
3681 tevent_req_received(req);
3682 return NT_STATUS_OK;
3683 }
3684
3685 NTSTATUS rpccli_spoolss_EndPagePrinter(struct rpc_pipe_client *cli,
3686 TALLOC_CTX *mem_ctx,
3687 struct policy_handle *handle /* [in] [ref] */,
3688 WERROR *werror)
3689 {
3690 struct spoolss_EndPagePrinter r;
3691 NTSTATUS status;
3692
3693 /* In parameters */
3694 r.in.handle = handle;
3695
3696 if (DEBUGLEVEL >= 10) {
3697 NDR_PRINT_IN_DEBUG(spoolss_EndPagePrinter, &r);
3698 }
3699
3700 status = cli->dispatch(cli,
3701 mem_ctx,
3702 &ndr_table_spoolss,
3703 NDR_SPOOLSS_ENDPAGEPRINTER,
3704 &r);
3705
3706 if (!NT_STATUS_IS_OK(status)) {
3707 return status;
3708 }
3709
3710 if (DEBUGLEVEL >= 10) {
3711 NDR_PRINT_OUT_DEBUG(spoolss_EndPagePrinter, &r);
3712 }
3713
3714 if (NT_STATUS_IS_ERR(status)) {
3715 return status;
3716 }
3717
3718 /* Return variables */
3719
3720 /* Return result */
3721 if (werror) {
3722 *werror = r.out.result;
3723 }
3724
3725 return werror_to_ntstatus(r.out.result);
3726 }
3727
3728 struct rpccli_spoolss_AbortPrinter_state {
3729 struct spoolss_AbortPrinter orig;
3730 struct spoolss_AbortPrinter tmp;
3731 TALLOC_CTX *out_mem_ctx;
3732 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3733 };
3734
3735 static void rpccli_spoolss_AbortPrinter_done(struct tevent_req *subreq);
3736
3737 struct tevent_req *rpccli_spoolss_AbortPrinter_send(TALLOC_CTX *mem_ctx,
3738 struct tevent_context *ev,
3739 struct rpc_pipe_client *cli,
3740 struct policy_handle *_handle /* [in] [ref] */)
3741 {
3742 struct tevent_req *req;
3743 struct rpccli_spoolss_AbortPrinter_state *state;
3744 struct tevent_req *subreq;
3745
3746 req = tevent_req_create(mem_ctx, &state,
3747 struct rpccli_spoolss_AbortPrinter_state);
3748 if (req == NULL) {
3749 return NULL;
3750 }
3751 state->out_mem_ctx = NULL;
3752 state->dispatch_recv = cli->dispatch_recv;
3753
3754 /* In parameters */
3755 state->orig.in.handle = _handle;
3756
3757 /* Out parameters */
3758
3759 /* Result */
3760 ZERO_STRUCT(state->orig.out.result);
3761
3762 if (DEBUGLEVEL >= 10) {
3763 NDR_PRINT_IN_DEBUG(spoolss_AbortPrinter, &state->orig);
3764 }
3765
3766 /* make a temporary copy, that we pass to the dispatch function */
3767 state->tmp = state->orig;
3768
3769 subreq = cli->dispatch_send(state, ev, cli,
3770 &ndr_table_spoolss,
3771 NDR_SPOOLSS_ABORTPRINTER,
3772 &state->tmp);
3773 if (tevent_req_nomem(subreq, req)) {
3774 return tevent_req_post(req, ev);
3775 }
3776 tevent_req_set_callback(subreq, rpccli_spoolss_AbortPrinter_done, req);
3777 return req;
3778 }
3779
3780 static void rpccli_spoolss_AbortPrinter_done(struct tevent_req *subreq)
3781 {
3782 struct tevent_req *req = tevent_req_callback_data(
3783 subreq, struct tevent_req);
3784 struct rpccli_spoolss_AbortPrinter_state *state = tevent_req_data(
3785 req, struct rpccli_spoolss_AbortPrinter_state);
3786 NTSTATUS status;
3787 TALLOC_CTX *mem_ctx;
3788
3789 if (state->out_mem_ctx) {
3790 mem_ctx = state->out_mem_ctx;
3791 } else {
3792 mem_ctx = state;
3793 }
3794
3795 status = state->dispatch_recv(subreq, mem_ctx);
3796 TALLOC_FREE(subreq);
3797 if (!NT_STATUS_IS_OK(status)) {
3798 tevent_req_nterror(req, status);
3799 return;
3800 }
3801
3802 /* Copy out parameters */
3803
3804 /* Copy result */
3805 state->orig.out.result = state->tmp.out.result;
3806
3807 /* Reset temporary structure */
3808 ZERO_STRUCT(state->tmp);
3809
3810 if (DEBUGLEVEL >= 10) {
3811 NDR_PRINT_OUT_DEBUG(spoolss_AbortPrinter, &state->orig);
3812 }
3813
3814 tevent_req_done(req);
3815 }
3816
3817 NTSTATUS rpccli_spoolss_AbortPrinter_recv(struct tevent_req *req,
3818 TALLOC_CTX *mem_ctx,
3819 WERROR *result)
3820 {
3821 struct rpccli_spoolss_AbortPrinter_state *state = tevent_req_data(
3822 req, struct rpccli_spoolss_AbortPrinter_state);
3823 NTSTATUS status;
3824
3825 if (tevent_req_is_nterror(req, &status)) {
3826 tevent_req_received(req);
3827 return status;
3828 }
3829
3830 /* Steal possbile out parameters to the callers context */
3831 talloc_steal(mem_ctx, state->out_mem_ctx);
3832
3833 /* Return result */
3834 *result = state->orig.out.result;
3835
3836 tevent_req_received(req);
3837 return NT_STATUS_OK;
3838 }
3839
3840 NTSTATUS rpccli_spoolss_AbortPrinter(struct rpc_pipe_client *cli,
3841 TALLOC_CTX *mem_ctx,
3842 struct policy_handle *handle /* [in] [ref] */,
3843 WERROR *werror)
3844 {
3845 struct spoolss_AbortPrinter r;
3846 NTSTATUS status;
3847
3848 /* In parameters */
3849 r.in.handle = handle;
3850
3851 if (DEBUGLEVEL >= 10) {
3852 NDR_PRINT_IN_DEBUG(spoolss_AbortPrinter, &r);
3853 }
3854
3855 status = cli->dispatch(cli,
3856 mem_ctx,
3857 &ndr_table_spoolss,
3858 NDR_SPOOLSS_ABORTPRINTER,
3859 &r);
3860
3861 if (!NT_STATUS_IS_OK(status)) {
3862 return status;
3863 }
3864
3865 if (DEBUGLEVEL >= 10) {
3866 NDR_PRINT_OUT_DEBUG(spoolss_AbortPrinter, &r);
3867 }
3868
3869 if (NT_STATUS_IS_ERR(status)) {
3870 return status;
3871 }
3872
3873 /* Return variables */
3874
3875 /* Return result */
3876 if (werror) {
3877 *werror = r.out.result;
3878 }
3879
3880 return werror_to_ntstatus(r.out.result);
3881 }
3882
3883 struct rpccli_spoolss_ReadPrinter_state {
3884 struct spoolss_ReadPrinter orig;
3885 struct spoolss_ReadPrinter tmp;
3886 TALLOC_CTX *out_mem_ctx;
3887 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3888 };
3889
3890 static void rpccli_spoolss_ReadPrinter_done(struct tevent_req *subreq);
3891
3892 struct tevent_req *rpccli_spoolss_ReadPrinter_send(TALLOC_CTX *mem_ctx,
3893 struct tevent_context *ev,
3894 struct rpc_pipe_client *cli,
3895 struct policy_handle *_handle /* [in] [ref] */,
3896 uint8_t *_data /* [out] [ref,size_is(data_size)] */,
3897 uint32_t _data_size /* [in] */,
3898 uint32_t *__data_size /* [out] [ref] */)
3899 {
3900 struct tevent_req *req;
3901 struct rpccli_spoolss_ReadPrinter_state *state;
3902 struct tevent_req *subreq;
3903
3904 req = tevent_req_create(mem_ctx, &state,
3905 struct rpccli_spoolss_ReadPrinter_state);
3906 if (req == NULL) {
3907 return NULL;
3908 }
3909 state->out_mem_ctx = NULL;
3910 state->dispatch_recv = cli->dispatch_recv;
3911
3912 /* In parameters */
3913 state->orig.in.handle = _handle;
3914 state->orig.in.data_size = _data_size;
3915
3916 /* Out parameters */
3917 state->orig.out.data = _data;
3918 state->orig.out._data_size = __data_size;
3919
3920 /* Result */
3921 ZERO_STRUCT(state->orig.out.result);
3922
3923 if (DEBUGLEVEL >= 10) {
3924 NDR_PRINT_IN_DEBUG(spoolss_ReadPrinter, &state->orig);
3925 }
3926
3927 state->out_mem_ctx = talloc_named_const(state, 0,
3928 "rpccli_spoolss_ReadPrinter_out_memory");
3929 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3930 return tevent_req_post(req, ev);
3931 }
3932
3933 /* make a temporary copy, that we pass to the dispatch function */
3934 state->tmp = state->orig;
3935
3936 subreq = cli->dispatch_send(state, ev, cli,
3937 &ndr_table_spoolss,
3938 NDR_SPOOLSS_READPRINTER,
3939 &state->tmp);
3940 if (tevent_req_nomem(subreq, req)) {
3941 return tevent_req_post(req, ev);
3942 }
3943 tevent_req_set_callback(subreq, rpccli_spoolss_ReadPrinter_done, req);
3944 return req;
3945 }
3946
3947 static void rpccli_spoolss_ReadPrinter_done(struct tevent_req *subreq)
3948 {
3949 struct tevent_req *req = tevent_req_callback_data(
3950 subreq, struct tevent_req);
3951 struct rpccli_spoolss_ReadPrinter_state *state = tevent_req_data(
3952 req, struct rpccli_spoolss_ReadPrinter_state);
3953 NTSTATUS status;
3954 TALLOC_CTX *mem_ctx;
3955
3956 if (state->out_mem_ctx) {
3957 mem_ctx = state->out_mem_ctx;
3958 } else {
3959 mem_ctx = state;
3960 }
3961
3962 status = state->dispatch_recv(subreq, mem_ctx);
3963 TALLOC_FREE(subreq);
3964 if (!NT_STATUS_IS_OK(status)) {
3965 tevent_req_nterror(req, status);
3966 return;
3967 }
3968
3969 /* Copy out parameters */
3970 memcpy(state->orig.out.data, state->tmp.out.data, state->tmp.in.data_size * sizeof(*state->orig.out.data));
3971 *state->orig.out._data_size = *state->tmp.out._data_size;
3972
3973 /* Copy result */
3974 state->orig.out.result = state->tmp.out.result;
3975
3976 /* Reset temporary structure */
3977 ZERO_STRUCT(state->tmp);
3978
3979 if (DEBUGLEVEL >= 10) {
3980 NDR_PRINT_OUT_DEBUG(spoolss_ReadPrinter, &state->orig);
3981 }
3982
3983 tevent_req_done(req);
3984 }
3985
3986 NTSTATUS rpccli_spoolss_ReadPrinter_recv(struct tevent_req *req,
3987 TALLOC_CTX *mem_ctx,
3988 WERROR *result)
3989 {
3990 struct rpccli_spoolss_ReadPrinter_state *state = tevent_req_data(
3991 req, struct rpccli_spoolss_ReadPrinter_state);
3992 NTSTATUS status;
3993
3994 if (tevent_req_is_nterror(req, &status)) {
3995 tevent_req_received(req);
3996 return status;
3997 }
3998
3999 /* Steal possbile out parameters to the callers context */
4000 talloc_steal(mem_ctx, state->out_mem_ctx);
4001
4002 /* Return result */
4003 *result = state->orig.out.result;
4004
4005 tevent_req_received(req);
4006 return NT_STATUS_OK;
4007 }
4008
4009 NTSTATUS rpccli_spoolss_ReadPrinter(struct rpc_pipe_client *cli,
4010 TALLOC_CTX *mem_ctx,
4011 struct policy_handle *handle /* [in] [ref] */,
4012 uint8_t *data /* [out] [ref,size_is(data_size)] */,
4013 uint32_t data_size /* [in] */,
4014 uint32_t *_data_size /* [out] [ref] */,
4015 WERROR *werror)
4016 {
4017 struct spoolss_ReadPrinter r;
4018 NTSTATUS status;
4019
4020 /* In parameters */
4021 r.in.handle = handle;
4022 r.in.data_size = data_size;
4023
4024 if (DEBUGLEVEL >= 10) {
4025 NDR_PRINT_IN_DEBUG(spoolss_ReadPrinter, &r);
4026 }
4027
4028 status = cli->dispatch(cli,
4029 mem_ctx,
4030 &ndr_table_spoolss,
4031 NDR_SPOOLSS_READPRINTER,
4032 &r);
4033
4034 if (!NT_STATUS_IS_OK(status)) {
4035 return status;
4036 }
4037
4038 if (DEBUGLEVEL >= 10) {
4039 NDR_PRINT_OUT_DEBUG(spoolss_ReadPrinter, &r);
4040 }
4041
4042 if (NT_STATUS_IS_ERR(status)) {
4043 return status;
4044 }
4045
4046 /* Return variables */
4047 memcpy(data, r.out.data, r.in.data_size * sizeof(*data));
4048 *_data_size = *r.out._data_size;
4049
4050 /* Return result */
4051 if (werror) {
4052 *werror = r.out.result;
4053 }
4054
4055 return werror_to_ntstatus(r.out.result);
4056 }
4057
4058 struct rpccli_spoolss_EndDocPrinter_state {
4059 struct spoolss_EndDocPrinter orig;
4060 struct spoolss_EndDocPrinter tmp;
4061 TALLOC_CTX *out_mem_ctx;
4062 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4063 };
4064
4065 static void rpccli_spoolss_EndDocPrinter_done(struct tevent_req *subreq);
4066
4067 struct tevent_req *rpccli_spoolss_EndDocPrinter_send(TALLOC_CTX *mem_ctx,
4068 struct tevent_context *ev,
4069 struct rpc_pipe_client *cli,
4070 struct policy_handle *_handle /* [in] [ref] */)
4071 {
4072 struct tevent_req *req;
4073 struct rpccli_spoolss_EndDocPrinter_state *state;
4074 struct tevent_req *subreq;
4075
4076 req = tevent_req_create(mem_ctx, &state,
4077 struct rpccli_spoolss_EndDocPrinter_state);
4078 if (req == NULL) {
4079 return NULL;
4080 }
4081 state->out_mem_ctx = NULL;
4082 state->dispatch_recv = cli->dispatch_recv;
4083
4084 /* In parameters */
4085 state->orig.in.handle = _handle;
4086
4087 /* Out parameters */
4088
4089 /* Result */
4090 ZERO_STRUCT(state->orig.out.result);
4091
4092 if (DEBUGLEVEL >= 10) {
4093 NDR_PRINT_IN_DEBUG(spoolss_EndDocPrinter, &state->orig);
4094 }
4095
4096 /* make a temporary copy, that we pass to the dispatch function */
4097 state->tmp = state->orig;
4098
4099 subreq = cli->dispatch_send(state, ev, cli,
4100 &ndr_table_spoolss,
4101 NDR_SPOOLSS_ENDDOCPRINTER,
4102 &state->tmp);
4103 if (tevent_req_nomem(subreq, req)) {
4104 return tevent_req_post(req, ev);
4105 }
4106 tevent_req_set_callback(subreq, rpccli_spoolss_EndDocPrinter_done, req);
4107 return req;
4108 }
4109
4110 static void rpccli_spoolss_EndDocPrinter_done(struct tevent_req *subreq)
4111 {
4112 struct tevent_req *req = tevent_req_callback_data(
4113 subreq, struct tevent_req);
4114 struct rpccli_spoolss_EndDocPrinter_state *state = tevent_req_data(
4115 req, struct rpccli_spoolss_EndDocPrinter_state);
4116 NTSTATUS status;
4117 TALLOC_CTX *mem_ctx;
4118
4119 if (state->out_mem_ctx) {
4120 mem_ctx = state->out_mem_ctx;
4121 } else {
4122 mem_ctx = state;
4123 }
4124
4125 status = state->dispatch_recv(subreq, mem_ctx);
4126 TALLOC_FREE(subreq);
4127 if (!NT_STATUS_IS_OK(status)) {
4128 tevent_req_nterror(req, status);
4129 return;
4130 }
4131
4132 /* Copy out parameters */
4133
4134 /* Copy result */
4135 state->orig.out.result = state->tmp.out.result;
4136
4137 /* Reset temporary structure */
4138 ZERO_STRUCT(state->tmp);
4139
4140 if (DEBUGLEVEL >= 10) {
4141 NDR_PRINT_OUT_DEBUG(spoolss_EndDocPrinter, &state->orig);
4142 }
4143
4144 tevent_req_done(req);
4145 }
4146
4147 NTSTATUS rpccli_spoolss_EndDocPrinter_recv(struct tevent_req *req,
4148 TALLOC_CTX *mem_ctx,
4149 WERROR *result)
4150 {
4151 struct rpccli_spoolss_EndDocPrinter_state *state = tevent_req_data(
4152 req, struct rpccli_spoolss_EndDocPrinter_state);
4153 NTSTATUS status;
4154
4155 if (tevent_req_is_nterror(req, &status)) {
4156 tevent_req_received(req);
4157 return status;
4158 }
4159
4160 /* Steal possbile out parameters to the callers context */
4161 talloc_steal(mem_ctx, state->out_mem_ctx);
4162
4163 /* Return result */
4164 *result = state->orig.out.result;
4165
4166 tevent_req_received(req);
4167 return NT_STATUS_OK;
4168 }
4169
4170 NTSTATUS rpccli_spoolss_EndDocPrinter(struct rpc_pipe_client *cli,
4171 TALLOC_CTX *mem_ctx,
4172 struct policy_handle *handle /* [in] [ref] */,
4173 WERROR *werror)
4174 {
4175 struct spoolss_EndDocPrinter r;
4176 NTSTATUS status;
4177
4178 /* In parameters */
4179 r.in.handle = handle;
4180
4181 if (DEBUGLEVEL >= 10) {
4182 NDR_PRINT_IN_DEBUG(spoolss_EndDocPrinter, &r);
4183 }
4184
4185 status = cli->dispatch(cli,
4186 mem_ctx,
4187 &ndr_table_spoolss,
4188 NDR_SPOOLSS_ENDDOCPRINTER,
4189 &r);
4190
4191 if (!NT_STATUS_IS_OK(status)) {
4192 return status;
4193 }
4194
4195 if (DEBUGLEVEL >= 10) {
4196 NDR_PRINT_OUT_DEBUG(spoolss_EndDocPrinter, &r);
4197 }
4198
4199 if (NT_STATUS_IS_ERR(status)) {
4200 return status;
4201 }
4202
4203 /* Return variables */
4204
4205 /* Return result */
4206 if (werror) {
4207 *werror = r.out.result;
4208 }
4209
4210 return werror_to_ntstatus(r.out.result);
4211 }
4212
4213 struct rpccli_spoolss_AddJob_state {
4214 struct spoolss_AddJob orig;
4215 struct spoolss_AddJob tmp;
4216 TALLOC_CTX *out_mem_ctx;
4217 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4218 };
4219
4220 static void rpccli_spoolss_AddJob_done(struct tevent_req *subreq);
4221
4222 struct tevent_req *rpccli_spoolss_AddJob_send(TALLOC_CTX *mem_ctx,
4223 struct tevent_context *ev,
4224 struct rpc_pipe_client *cli,
4225 struct policy_handle *_handle /* [in] [ref] */,
4226 uint32_t _level /* [in] */,
4227 uint8_t *_buffer /* [in,out] [unique,size_is(offered)] */,
4228 uint32_t _offered /* [in] */,
4229 uint32_t *_needed /* [out] [ref] */)
4230 {
4231 struct tevent_req *req;
4232 struct rpccli_spoolss_AddJob_state *state;
4233 struct tevent_req *subreq;
4234
4235 req = tevent_req_create(mem_ctx, &state,
4236 struct rpccli_spoolss_AddJob_state);
4237 if (req == NULL) {
4238 return NULL;
4239 }
4240 state->out_mem_ctx = NULL;
4241 state->dispatch_recv = cli->dispatch_recv;
4242
4243 /* In parameters */
4244 state->orig.in.handle = _handle;
4245 state->orig.in.level = _level;
4246 state->orig.in.buffer = _buffer;
4247 state->orig.in.offered = _offered;
4248
4249 /* Out parameters */
4250 state->orig.out.buffer = _buffer;
4251 state->orig.out.needed = _needed;
4252
4253 /* Result */
4254 ZERO_STRUCT(state->orig.out.result);
4255
4256 if (DEBUGLEVEL >= 10) {
4257 NDR_PRINT_IN_DEBUG(spoolss_AddJob, &state->orig);
4258 }
4259
4260 state->out_mem_ctx = talloc_named_const(state, 0,
4261 "rpccli_spoolss_AddJob_out_memory");
4262 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4263 return tevent_req_post(req, ev);
4264 }
4265
4266 /* make a temporary copy, that we pass to the dispatch function */
4267 state->tmp = state->orig;
4268
4269 subreq = cli->dispatch_send(state, ev, cli,
4270 &ndr_table_spoolss,
4271 NDR_SPOOLSS_ADDJOB,
4272 &state->tmp);
4273 if (tevent_req_nomem(subreq, req)) {
4274 return tevent_req_post(req, ev);
4275 }
4276 tevent_req_set_callback(subreq, rpccli_spoolss_AddJob_done, req);
4277 return req;
4278 }
4279
4280 static void rpccli_spoolss_AddJob_done(struct tevent_req *subreq)
4281 {
4282 struct tevent_req *req = tevent_req_callback_data(
4283 subreq, struct tevent_req);
4284 struct rpccli_spoolss_AddJob_state *state = tevent_req_data(
4285 req, struct rpccli_spoolss_AddJob_state);
4286 NTSTATUS status;
4287 TALLOC_CTX *mem_ctx;
4288
4289 if (state->out_mem_ctx) {
4290 mem_ctx = state->out_mem_ctx;
4291 } else {
4292 mem_ctx = state;
4293 }
4294
4295 status = state->dispatch_recv(subreq, mem_ctx);
4296 TALLOC_FREE(subreq);
4297 if (!NT_STATUS_IS_OK(status)) {
4298 tevent_req_nterror(req, status);
4299 return;
4300 }
4301
4302 /* Copy out parameters */
4303 if (state->orig.out.buffer && state->tmp.out.buffer) {
4304 memcpy(state->orig.out.buffer, state->tmp.out.buffer, state->tmp.in.offered * sizeof(*state->orig.out.buffer));
4305 }
4306 *state->orig.out.needed = *state->tmp.out.needed;
4307
4308 /* Copy result */
4309 state->orig.out.result = state->tmp.out.result;
4310
4311 /* Reset temporary structure */
4312 ZERO_STRUCT(state->tmp);
4313
4314 if (DEBUGLEVEL >= 10) {
4315 NDR_PRINT_OUT_DEBUG(spoolss_AddJob, &state->orig);
4316 }
4317
4318 tevent_req_done(req);
4319 }
4320
4321 NTSTATUS rpccli_spoolss_AddJob_recv(struct tevent_req *req,
4322 TALLOC_CTX *mem_ctx,
4323 WERROR *result)
4324 {
4325 struct rpccli_spoolss_AddJob_state *state = tevent_req_data(
4326 req, struct rpccli_spoolss_AddJob_state);
4327 NTSTATUS status;
4328
4329 if (tevent_req_is_nterror(req, &status)) {
4330 tevent_req_received(req);
4331 return status;
4332 }
4333
4334 /* Steal possbile out parameters to the callers context */
4335 talloc_steal(mem_ctx, state->out_mem_ctx);
4336
4337 /* Return result */
4338 *result = state->orig.out.result;
4339
4340 tevent_req_received(req);
4341 return NT_STATUS_OK;
4342 }
4343
4344 NTSTATUS rpccli_spoolss_AddJob(struct rpc_pipe_client *cli,
4345 TALLOC_CTX *mem_ctx,
4346 struct policy_handle *handle /* [in] [ref] */,
4347 uint32_t level /* [in] */,
4348 uint8_t *buffer /* [in,out] [unique,size_is(offered)] */,
4349 uint32_t offered /* [in] */,
4350 uint32_t *needed /* [out] [ref] */,
4351 WERROR *werror)
4352 {
4353 struct spoolss_AddJob r;
4354 NTSTATUS status;
4355
4356 /* In parameters */
4357 r.in.handle = handle;
4358 r.in.level = level;
4359 r.in.buffer = buffer;
4360 r.in.offered = offered;
4361
4362 if (DEBUGLEVEL >= 10) {
4363 NDR_PRINT_IN_DEBUG(spoolss_AddJob, &r);
4364 }
4365
4366 status = cli->dispatch(cli,
4367 mem_ctx,
4368 &ndr_table_spoolss,
4369 NDR_SPOOLSS_ADDJOB,
4370 &r);
4371
4372 if (!NT_STATUS_IS_OK(status)) {
4373 return status;
4374 }
4375
4376 if (DEBUGLEVEL >= 10) {
4377 NDR_PRINT_OUT_DEBUG(spoolss_AddJob, &r);
4378 }
4379
4380 if (NT_STATUS_IS_ERR(status)) {
4381 return status;
4382 }
4383
4384 /* Return variables */
4385 if (buffer && r.out.buffer) {
4386 memcpy(buffer, r.out.buffer, r.in.offered * sizeof(*buffer));
4387 }
4388 *needed = *r.out.needed;
4389
4390 /* Return result */
4391 if (werror) {
4392 *werror = r.out.result;
4393 }
4394
4395 return werror_to_ntstatus(r.out.result);
4396 }
4397
4398 struct rpccli_spoolss_ScheduleJob_state {
4399 struct spoolss_ScheduleJob orig;
4400 struct spoolss_ScheduleJob tmp;
4401 TALLOC_CTX *out_mem_ctx;
4402 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4403 };
4404
4405 static void rpccli_spoolss_ScheduleJob_done(struct tevent_req *subreq);
4406
4407 struct tevent_req *rpccli_spoolss_ScheduleJob_send(TALLOC_CTX *mem_ctx,
4408 struct tevent_context *ev,
4409 struct rpc_pipe_client *cli,
4410 struct policy_handle *_handle /* [in] [ref] */,
4411 uint32_t _jobid /* [in] */)
4412 {
4413 struct tevent_req *req;
4414 struct rpccli_spoolss_ScheduleJob_state *state;
4415 struct tevent_req *subreq;
4416
4417 req = tevent_req_create(mem_ctx, &state,
4418 struct rpccli_spoolss_ScheduleJob_state);
4419 if (req == NULL) {
4420 return NULL;
4421 }
4422 state->out_mem_ctx = NULL;
4423 state->dispatch_recv = cli->dispatch_recv;
4424
4425 /* In parameters */
4426 state->orig.in.handle = _handle;
4427 state->orig.in.jobid = _jobid;
4428
4429 /* Out parameters */
4430
4431 /* Result */
4432 ZERO_STRUCT(state->orig.out.result);
4433
4434 if (DEBUGLEVEL >= 10) {
4435 NDR_PRINT_IN_DEBUG(spoolss_ScheduleJob, &state->orig);
4436 }
4437
4438 /* make a temporary copy, that we pass to the dispatch function */
4439 state->tmp = state->orig;
4440
4441 subreq = cli->dispatch_send(state, ev, cli,
4442 &ndr_table_spoolss,
4443 NDR_SPOOLSS_SCHEDULEJOB,
4444 &state->tmp);
4445 if (tevent_req_nomem(subreq, req)) {
4446 return tevent_req_post(req, ev);
4447 }
4448 tevent_req_set_callback(subreq, rpccli_spoolss_ScheduleJob_done, req);
4449 return req;
4450 }
4451
4452 static void rpccli_spoolss_ScheduleJob_done(struct tevent_req *subreq)
4453 {
4454 struct tevent_req *req = tevent_req_callback_data(
4455 subreq, struct tevent_req);
4456 struct rpccli_spoolss_ScheduleJob_state *state = tevent_req_data(
4457 req, struct rpccli_spoolss_ScheduleJob_state);
4458 NTSTATUS status;
4459 TALLOC_CTX *mem_ctx;
4460
4461 if (state->out_mem_ctx) {
4462 mem_ctx = state->out_mem_ctx;
4463 } else {
4464 mem_ctx = state;
4465 }
4466
4467 status = state->dispatch_recv(subreq, mem_ctx);
4468 TALLOC_FREE(subreq);
4469 if (!NT_STATUS_IS_OK(status)) {
4470 tevent_req_nterror(req, status);
4471 return;
4472 }
4473
4474 /* Copy out parameters */
4475
4476 /* Copy result */
4477 state->orig.out.result = state->tmp.out.result;
4478
4479 /* Reset temporary structure */
4480 ZERO_STRUCT(state->tmp);
4481
4482 if (DEBUGLEVEL >= 10) {
4483 NDR_PRINT_OUT_DEBUG(spoolss_ScheduleJob, &state->orig);
4484 }
4485
4486 tevent_req_done(req);
4487 }
4488
4489 NTSTATUS rpccli_spoolss_ScheduleJob_recv(struct tevent_req *req,
4490 TALLOC_CTX *mem_ctx,
4491 WERROR *result)
4492 {
4493 struct rpccli_spoolss_ScheduleJob_state *state = tevent_req_data(
4494 req, struct rpccli_spoolss_ScheduleJob_state);
4495 NTSTATUS status;
4496
4497 if (tevent_req_is_nterror(req, &status)) {
4498 tevent_req_received(req);
4499 return status;
4500 }
4501
4502 /* Steal possbile out parameters to the callers context */
4503 talloc_steal(mem_ctx, state->out_mem_ctx);
4504
4505 /* Return result */
4506 *result = state->orig.out.result;
4507
4508 tevent_req_received(req);
4509 return NT_STATUS_OK;
4510 }
4511
4512 NTSTATUS rpccli_spoolss_ScheduleJob(struct rpc_pipe_client *cli,
4513 TALLOC_CTX *mem_ctx,
4514 struct policy_handle *handle /* [in] [ref] */,
4515 uint32_t jobid /* [in] */,
4516 WERROR *werror)
4517 {
4518 struct spoolss_ScheduleJob r;
4519 NTSTATUS status;
4520
4521 /* In parameters */
4522 r.in.handle = handle;
4523 r.in.jobid = jobid;
4524
4525 if (DEBUGLEVEL >= 10) {
4526 NDR_PRINT_IN_DEBUG(spoolss_ScheduleJob, &r);
4527 }
4528
4529 status = cli->dispatch(cli,
4530 mem_ctx,
4531 &ndr_table_spoolss,
4532 NDR_SPOOLSS_SCHEDULEJOB,
4533 &r);
4534
4535 if (!NT_STATUS_IS_OK(status)) {
4536 return status;
4537 }
4538
4539 if (DEBUGLEVEL >= 10) {
4540 NDR_PRINT_OUT_DEBUG(spoolss_ScheduleJob, &r);
4541 }
4542
4543 if (NT_STATUS_IS_ERR(status)) {
4544 return status;
4545 }
4546
4547 /* Return variables */
4548
4549 /* Return result */
4550 if (werror) {
4551 *werror = r.out.result;
4552 }
4553
4554 return werror_to_ntstatus(r.out.result);
4555 }
4556
4557 struct rpccli_spoolss_GetPrinterData_state {
4558 struct spoolss_GetPrinterData orig;
4559 struct spoolss_GetPrinterData tmp;
4560 TALLOC_CTX *out_mem_ctx;
4561 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4562 };
4563
4564 static void rpccli_spoolss_GetPrinterData_done(struct tevent_req *subreq);
4565
4566 struct tevent_req *rpccli_spoolss_GetPrinterData_send(TALLOC_CTX *mem_ctx,
4567 struct tevent_context *ev,
4568 struct rpc_pipe_client *cli,
4569 struct policy_handle *_handle /* [in] [ref] */,
4570 const char *_value_name /* [in] [charset(UTF16)] */,
4571 uint32_t _offered /* [in] */,
4572 enum winreg_Type *_type /* [out] [ref] */,
4573 union spoolss_PrinterData *_data /* [out] [subcontext_size(offered),ref,subcontext(4),switch_is(*type)] */,
4574 uint32_t *_needed /* [out] [ref] */)
4575 {
4576 struct tevent_req *req;
4577 struct rpccli_spoolss_GetPrinterData_state *state;
4578 struct tevent_req *subreq;
4579
4580 req = tevent_req_create(mem_ctx, &state,
4581 struct rpccli_spoolss_GetPrinterData_state);
4582 if (req == NULL) {
4583 return NULL;
4584 }
4585 state->out_mem_ctx = NULL;
4586 state->dispatch_recv = cli->dispatch_recv;
4587
4588 /* In parameters */
4589 state->orig.in.handle = _handle;
4590 state->orig.in.value_name = _value_name;
4591 state->orig.in.offered = _offered;
4592
4593 /* Out parameters */
4594 state->orig.out.type = _type;
4595 state->orig.out.data = _data;
4596 state->orig.out.needed = _needed;
4597
4598 /* Result */
4599 ZERO_STRUCT(state->orig.out.result);
4600
4601 if (DEBUGLEVEL >= 10) {
4602 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterData, &state->orig);
4603 }
4604
4605 state->out_mem_ctx = talloc_named_const(state, 0,
4606 "rpccli_spoolss_GetPrinterData_out_memory");
4607 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4608 return tevent_req_post(req, ev);
4609 }
4610
4611 /* make a temporary copy, that we pass to the dispatch function */
4612 state->tmp = state->orig;
4613
4614 subreq = cli->dispatch_send(state, ev, cli,
4615 &ndr_table_spoolss,
4616 NDR_SPOOLSS_GETPRINTERDATA,
4617 &state->tmp);
4618 if (tevent_req_nomem(subreq, req)) {
4619 return tevent_req_post(req, ev);
4620 }
4621 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterData_done, req);
4622 return req;
4623 }
4624
4625 static void rpccli_spoolss_GetPrinterData_done(struct tevent_req *subreq)
4626 {
4627 struct tevent_req *req = tevent_req_callback_data(
4628 subreq, struct tevent_req);
4629 struct rpccli_spoolss_GetPrinterData_state *state = tevent_req_data(
4630 req, struct rpccli_spoolss_GetPrinterData_state);
4631 NTSTATUS status;
4632 TALLOC_CTX *mem_ctx;
4633
4634 if (state->out_mem_ctx) {
4635 mem_ctx = state->out_mem_ctx;
4636 } else {
4637 mem_ctx = state;
4638 }
4639
4640 status = state->dispatch_recv(subreq, mem_ctx);
4641 TALLOC_FREE(subreq);
4642 if (!NT_STATUS_IS_OK(status)) {
4643 tevent_req_nterror(req, status);
4644 return;
4645 }
4646
4647 /* Copy out parameters */
4648 *state->orig.out.type = *state->tmp.out.type;
4649 *state->orig.out.data = *state->tmp.out.data;
4650 *state->orig.out.needed = *state->tmp.out.needed;
4651
4652 /* Copy result */
4653 state->orig.out.result = state->tmp.out.result;
4654
4655 /* Reset temporary structure */
4656 ZERO_STRUCT(state->tmp);
4657
4658 if (DEBUGLEVEL >= 10) {
4659 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterData, &state->orig);
4660 }
4661
4662 tevent_req_done(req);
4663 }
4664
4665 NTSTATUS rpccli_spoolss_GetPrinterData_recv(struct tevent_req *req,
4666 TALLOC_CTX *mem_ctx,
4667 WERROR *result)
4668 {
4669 struct rpccli_spoolss_GetPrinterData_state *state = tevent_req_data(
4670 req, struct rpccli_spoolss_GetPrinterData_state);
4671 NTSTATUS status;
4672
4673 if (tevent_req_is_nterror(req, &status)) {
4674 tevent_req_received(req);
4675 return status;
4676 }
4677
4678 /* Steal possbile out parameters to the callers context */
4679 talloc_steal(mem_ctx, state->out_mem_ctx);
4680
4681 /* Return result */
4682 *result = state->orig.out.result;
4683
4684 tevent_req_received(req);
4685 return NT_STATUS_OK;
4686 }
4687
4688 NTSTATUS rpccli_spoolss_GetPrinterData(struct rpc_pipe_client *cli,
4689 TALLOC_CTX *mem_ctx,
4690 struct policy_handle *handle /* [in] [ref] */,
4691 const char *value_name /* [in] [charset(UTF16)] */,
4692 uint32_t offered /* [in] */,
4693 enum winreg_Type *type /* [out] [ref] */,
4694 union spoolss_PrinterData *data /* [out] [subcontext_size(offered),ref,subcontext(4),switch_is(*type)] */,
4695 uint32_t *needed /* [out] [ref] */,
4696 WERROR *werror)
4697 {
4698 struct spoolss_GetPrinterData r;
4699 NTSTATUS status;
4700
4701 /* In parameters */
4702 r.in.handle = handle;
4703 r.in.value_name = value_name;
4704 r.in.offered = offered;
4705
4706 if (DEBUGLEVEL >= 10) {
4707 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterData, &r);
4708 }
4709
4710 status = cli->dispatch(cli,
4711 mem_ctx,
4712 &ndr_table_spoolss,
4713 NDR_SPOOLSS_GETPRINTERDATA,
4714 &r);
4715
4716 if (!NT_STATUS_IS_OK(status)) {
4717 return status;
4718 }
4719
4720 if (DEBUGLEVEL >= 10) {
4721 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterData, &r);
4722 }
4723
4724 if (NT_STATUS_IS_ERR(status)) {
4725 return status;
4726 }
4727
4728 /* Return variables */
4729 *type = *r.out.type;
4730 *data = *r.out.data;
4731 *needed = *r.out.needed;
4732
4733 /* Return result */
4734 if (werror) {
4735 *werror = r.out.result;
4736 }
4737
4738 return werror_to_ntstatus(r.out.result);
4739 }
4740
4741 struct rpccli_spoolss_SetPrinterData_state {
4742 struct spoolss_SetPrinterData orig;
4743 struct spoolss_SetPrinterData tmp;
4744 TALLOC_CTX *out_mem_ctx;
4745 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4746 };
4747
4748 static void rpccli_spoolss_SetPrinterData_done(struct tevent_req *subreq);
4749
4750 struct tevent_req *rpccli_spoolss_SetPrinterData_send(TALLOC_CTX *mem_ctx,
4751 struct tevent_context *ev,
4752 struct rpc_pipe_client *cli,
4753 struct policy_handle *_handle /* [in] [ref] */,
4754 const char *_value_name /* [in] [charset(UTF16)] */,
4755 enum winreg_Type _type /* [in] */,
4756 union spoolss_PrinterData _data /* [in] [subcontext(4),switch_is(type)] */,
4757 uint32_t __offered /* [in] [value(ndr_size_spoolss_PrinterData(&data,type,ndr->iconv_convenience,flags))] */)
4758 {
4759 struct tevent_req *req;
4760 struct rpccli_spoolss_SetPrinterData_state *state;
4761 struct tevent_req *subreq;
4762
4763 req = tevent_req_create(mem_ctx, &state,
4764 struct rpccli_spoolss_SetPrinterData_state);
4765 if (req == NULL) {
4766 return NULL;
4767 }
4768 state->out_mem_ctx = NULL;
4769 state->dispatch_recv = cli->dispatch_recv;
4770
4771 /* In parameters */
4772 state->orig.in.handle = _handle;
4773 state->orig.in.value_name = _value_name;
4774 state->orig.in.type = _type;
4775 state->orig.in.data = _data;
4776 state->orig.in._offered = __offered;
4777
4778 /* Out parameters */
4779
4780 /* Result */
4781 ZERO_STRUCT(state->orig.out.result);
4782
4783 if (DEBUGLEVEL >= 10) {
4784 NDR_PRINT_IN_DEBUG(spoolss_SetPrinterData, &state->orig);
4785 }
4786
4787 /* make a temporary copy, that we pass to the dispatch function */
4788 state->tmp = state->orig;
4789
4790 subreq = cli->dispatch_send(state, ev, cli,
4791 &ndr_table_spoolss,
4792 NDR_SPOOLSS_SETPRINTERDATA,
4793 &state->tmp);
4794 if (tevent_req_nomem(subreq, req)) {
4795 return tevent_req_post(req, ev);
4796 }
4797 tevent_req_set_callback(subreq, rpccli_spoolss_SetPrinterData_done, req);
4798 return req;
4799 }
4800
4801 static void rpccli_spoolss_SetPrinterData_done(struct tevent_req *subreq)
4802 {
4803 struct tevent_req *req = tevent_req_callback_data(
4804 subreq, struct tevent_req);
4805 struct rpccli_spoolss_SetPrinterData_state *state = tevent_req_data(
4806 req, struct rpccli_spoolss_SetPrinterData_state);
4807 NTSTATUS status;
4808 TALLOC_CTX *mem_ctx;
4809
4810 if (state->out_mem_ctx) {
4811 mem_ctx = state->out_mem_ctx;
4812 } else {
4813 mem_ctx = state;
4814 }
4815
4816 status = state->dispatch_recv(subreq, mem_ctx);
4817 TALLOC_FREE(subreq);
4818 if (!NT_STATUS_IS_OK(status)) {
4819 tevent_req_nterror(req, status);
4820 return;
4821 }
4822
4823 /* Copy out parameters */
4824
4825 /* Copy result */
4826 state->orig.out.result = state->tmp.out.result;
4827
4828 /* Reset temporary structure */
4829 ZERO_STRUCT(state->tmp);
4830
4831 if (DEBUGLEVEL >= 10) {
4832 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinterData, &state->orig);
4833 }
4834
4835 tevent_req_done(req);
4836 }
4837
4838 NTSTATUS rpccli_spoolss_SetPrinterData_recv(struct tevent_req *req,
4839 TALLOC_CTX *mem_ctx,
4840 WERROR *result)
4841 {
4842 struct rpccli_spoolss_SetPrinterData_state *state = tevent_req_data(
4843 req, struct rpccli_spoolss_SetPrinterData_state);
4844 NTSTATUS status;
4845
4846 if (tevent_req_is_nterror(req, &status)) {
4847 tevent_req_received(req);
4848 return status;
4849 }
4850
4851 /* Steal possbile out parameters to the callers context */
4852 talloc_steal(mem_ctx, state->out_mem_ctx);
4853
4854 /* Return result */
4855 *result = state->orig.out.result;
4856
4857 tevent_req_received(req);
4858 return NT_STATUS_OK;
4859 }
4860
4861 NTSTATUS rpccli_spoolss_SetPrinterData(struct rpc_pipe_client *cli,
4862 TALLOC_CTX *mem_ctx,
4863 struct policy_handle *handle /* [in] [ref] */,
4864 const char *value_name /* [in] [charset(UTF16)] */,
4865 enum winreg_Type type /* [in] */,
4866 union spoolss_PrinterData data /* [in] [subcontext(4),switch_is(type)] */,
4867 uint32_t _offered /* [in] [value(ndr_size_spoolss_PrinterData(&data,type,ndr->iconv_convenience,flags))] */,
4868 WERROR *werror)
4869 {
4870 struct spoolss_SetPrinterData r;
4871 NTSTATUS status;
4872
4873 /* In parameters */
4874 r.in.handle = handle;
4875 r.in.value_name = value_name;
4876 r.in.type = type;
4877 r.in.data = data;
4878 r.in._offered = _offered;
4879
4880 if (DEBUGLEVEL >= 10) {
4881 NDR_PRINT_IN_DEBUG(spoolss_SetPrinterData, &r);
4882 }
4883
4884 status = cli->dispatch(cli,
4885 mem_ctx,
4886 &ndr_table_spoolss,
4887 NDR_SPOOLSS_SETPRINTERDATA,
4888 &r);
4889
4890 if (!NT_STATUS_IS_OK(status)) {
4891 return status;
4892 }
4893
4894 if (DEBUGLEVEL >= 10) {
4895 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinterData, &r);
4896 }
4897
4898 if (NT_STATUS_IS_ERR(status)) {
4899 return status;
4900 }
4901
4902 /* Return variables */
4903
4904 /* Return result */
4905 if (werror) {
4906 *werror = r.out.result;
4907 }
4908
4909 return werror_to_ntstatus(r.out.result);
4910 }
4911
4912 struct rpccli_spoolss_WaitForPrinterChange_state {
4913 struct spoolss_WaitForPrinterChange orig;
4914 struct spoolss_WaitForPrinterChange tmp;
4915 TALLOC_CTX *out_mem_ctx;
4916 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4917 };
4918
4919 static void rpccli_spoolss_WaitForPrinterChange_done(struct tevent_req *subreq);
4920
4921 struct tevent_req *rpccli_spoolss_WaitForPrinterChange_send(TALLOC_CTX *mem_ctx,
4922 struct tevent_context *ev,
4923 struct rpc_pipe_client *cli)
4924 {
4925 struct tevent_req *req;
4926 struct rpccli_spoolss_WaitForPrinterChange_state *state;
4927 struct tevent_req *subreq;
4928
4929 req = tevent_req_create(mem_ctx, &state,
4930 struct rpccli_spoolss_WaitForPrinterChange_state);
4931 if (req == NULL) {
4932 return NULL;
4933 }
4934 state->out_mem_ctx = NULL;
4935 state->dispatch_recv = cli->dispatch_recv;
4936
4937 /* In parameters */
4938
4939 /* Out parameters */
4940
4941 /* Result */
4942 ZERO_STRUCT(state->orig.out.result);
4943
4944 if (DEBUGLEVEL >= 10) {
4945 NDR_PRINT_IN_DEBUG(spoolss_WaitForPrinterChange, &state->orig);
4946 }
4947
4948 /* make a temporary copy, that we pass to the dispatch function */
4949 state->tmp = state->orig;
4950
4951 subreq = cli->dispatch_send(state, ev, cli,
4952 &ndr_table_spoolss,
4953 NDR_SPOOLSS_WAITFORPRINTERCHANGE,
4954 &state->tmp);
4955 if (tevent_req_nomem(subreq, req)) {
4956 return tevent_req_post(req, ev);
4957 }
4958 tevent_req_set_callback(subreq, rpccli_spoolss_WaitForPrinterChange_done, req);
4959 return req;
4960 }
4961
4962 static void rpccli_spoolss_WaitForPrinterChange_done(struct tevent_req *subreq)
4963 {
4964 struct tevent_req *req = tevent_req_callback_data(
4965 subreq, struct tevent_req);
4966 struct rpccli_spoolss_WaitForPrinterChange_state *state = tevent_req_data(
4967 req, struct rpccli_spoolss_WaitForPrinterChange_state);
4968 NTSTATUS status;
4969 TALLOC_CTX *mem_ctx;
4970
4971 if (state->out_mem_ctx) {
4972 mem_ctx = state->out_mem_ctx;
4973 } else {
4974 mem_ctx = state;
4975 }
4976
4977 status = state->dispatch_recv(subreq, mem_ctx);
4978 TALLOC_FREE(subreq);
4979 if (!NT_STATUS_IS_OK(status)) {
4980 tevent_req_nterror(req, status);
4981 return;
4982 }
4983
4984 /* Copy out parameters */
4985
4986 /* Copy result */
4987 state->orig.out.result = state->tmp.out.result;
4988
4989 /* Reset temporary structure */
4990 ZERO_STRUCT(state->tmp);
4991
4992 if (DEBUGLEVEL >= 10) {
4993 NDR_PRINT_OUT_DEBUG(spoolss_WaitForPrinterChange, &state->orig);
4994 }
4995
4996 tevent_req_done(req);
4997 }
4998
4999 NTSTATUS rpccli_spoolss_WaitForPrinterChange_recv(struct tevent_req *req,
5000 TALLOC_CTX *mem_ctx,
5001 WERROR *result)
5002 {
5003 struct rpccli_spoolss_WaitForPrinterChange_state *state = tevent_req_data(
5004 req, struct rpccli_spoolss_WaitForPrinterChange_state);
5005 NTSTATUS status;
5006
5007 if (tevent_req_is_nterror(req, &status)) {
5008 tevent_req_received(req);
5009 return status;
5010 }
5011
5012 /* Steal possbile out parameters to the callers context */
5013 talloc_steal(mem_ctx, state->out_mem_ctx);
5014
5015 /* Return result */
5016 *result = state->orig.out.result;
5017
5018 tevent_req_received(req);
5019 return NT_STATUS_OK;
5020 }
5021
5022 NTSTATUS rpccli_spoolss_WaitForPrinterChange(struct rpc_pipe_client *cli,
5023 TALLOC_CTX *mem_ctx,
5024 WERROR *werror)
5025 {
5026 struct spoolss_WaitForPrinterChange r;
5027 NTSTATUS status;
5028
5029 /* In parameters */
5030
5031 if (DEBUGLEVEL >= 10) {
5032 NDR_PRINT_IN_DEBUG(spoolss_WaitForPrinterChange, &r);
5033 }
5034
5035 status = cli->dispatch(cli,
5036 mem_ctx,
5037 &ndr_table_spoolss,
5038 NDR_SPOOLSS_WAITFORPRINTERCHANGE,
5039 &r);
5040
5041 if (!NT_STATUS_IS_OK(status)) {
5042 return status;
5043 }
5044
5045 if (DEBUGLEVEL >= 10) {
5046 NDR_PRINT_OUT_DEBUG(spoolss_WaitForPrinterChange, &r);
5047 }
5048
5049 if (NT_STATUS_IS_ERR(status)) {
5050 return status;
5051 }
5052
5053 /* Return variables */
5054
5055 /* Return result */
5056 if (werror) {
5057 *werror = r.out.result;
5058 }
5059
5060 return werror_to_ntstatus(r.out.result);
5061 }
5062
5063 struct rpccli_spoolss_ClosePrinter_state {
5064 struct spoolss_ClosePrinter orig;
5065 struct spoolss_ClosePrinter tmp;
5066 TALLOC_CTX *out_mem_ctx;
5067 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5068 };
5069
5070 static void rpccli_spoolss_ClosePrinter_done(struct tevent_req *subreq);
5071
5072 struct tevent_req *rpccli_spoolss_ClosePrinter_send(TALLOC_CTX *mem_ctx,
5073 struct tevent_context *ev,
5074 struct rpc_pipe_client *cli,
5075 struct policy_handle *_handle /* [in,out] [ref] */)
5076 {
5077 struct tevent_req *req;
5078 struct rpccli_spoolss_ClosePrinter_state *state;
5079 struct tevent_req *subreq;
5080
5081 req = tevent_req_create(mem_ctx, &state,
5082 struct rpccli_spoolss_ClosePrinter_state);
5083 if (req == NULL) {
5084 return NULL;
5085 }
5086 state->out_mem_ctx = NULL;
5087 state->dispatch_recv = cli->dispatch_recv;
5088
5089 /* In parameters */
5090 state->orig.in.handle = _handle;
5091
5092 /* Out parameters */
5093 state->orig.out.handle = _handle;
5094
5095 /* Result */
5096 ZERO_STRUCT(state->orig.out.result);
5097
5098 if (DEBUGLEVEL >= 10) {
5099 NDR_PRINT_IN_DEBUG(spoolss_ClosePrinter, &state->orig);
5100 }
5101
5102 state->out_mem_ctx = talloc_named_const(state, 0,
5103 "rpccli_spoolss_ClosePrinter_out_memory");
5104 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5105 return tevent_req_post(req, ev);
5106 }
5107
5108 /* make a temporary copy, that we pass to the dispatch function */
5109 state->tmp = state->orig;
5110
5111 subreq = cli->dispatch_send(state, ev, cli,
5112 &ndr_table_spoolss,
5113 NDR_SPOOLSS_CLOSEPRINTER,
5114 &state->tmp);
5115 if (tevent_req_nomem(subreq, req)) {
5116 return tevent_req_post(req, ev);
5117 }
5118 tevent_req_set_callback(subreq, rpccli_spoolss_ClosePrinter_done, req);
5119 return req;
5120 }
5121
5122 static void rpccli_spoolss_ClosePrinter_done(struct tevent_req *subreq)
5123 {
5124 struct tevent_req *req = tevent_req_callback_data(
5125 subreq, struct tevent_req);
5126 struct rpccli_spoolss_ClosePrinter_state *state = tevent_req_data(
5127 req, struct rpccli_spoolss_ClosePrinter_state);
5128 NTSTATUS status;
5129 TALLOC_CTX *mem_ctx;
5130
5131 if (state->out_mem_ctx) {
5132 mem_ctx = state->out_mem_ctx;
5133 } else {
5134 mem_ctx = state;
5135 }
5136
5137 status = state->dispatch_recv(subreq, mem_ctx);
5138 TALLOC_FREE(subreq);
5139 if (!NT_STATUS_IS_OK(status)) {
5140 tevent_req_nterror(req, status);
5141 return;
5142 }
5143
5144 /* Copy out parameters */
5145 *state->orig.out.handle = *state->tmp.out.handle;
5146
5147 /* Copy result */
5148 state->orig.out.result = state->tmp.out.result;
5149
5150 /* Reset temporary structure */
5151 ZERO_STRUCT(state->tmp);
5152
5153 if (DEBUGLEVEL >= 10) {
5154 NDR_PRINT_OUT_DEBUG(spoolss_ClosePrinter, &state->orig);
5155 }
5156
5157 tevent_req_done(req);
5158 }
5159
5160 NTSTATUS rpccli_spoolss_ClosePrinter_recv(struct tevent_req *req,
5161 TALLOC_CTX *mem_ctx,
5162 WERROR *result)
5163 {
5164 struct rpccli_spoolss_ClosePrinter_state *state = tevent_req_data(
5165 req, struct rpccli_spoolss_ClosePrinter_state);
5166 NTSTATUS status;
5167
5168 if (tevent_req_is_nterror(req, &status)) {
5169 tevent_req_received(req);
5170 return status;
5171 }
5172
5173 /* Steal possbile out parameters to the callers context */
5174 talloc_steal(mem_ctx, state->out_mem_ctx);
5175
5176 /* Return result */
5177 *result = state->orig.out.result;
5178
5179 tevent_req_received(req);
5180 return NT_STATUS_OK;
5181 }
5182
5183 NTSTATUS rpccli_spoolss_ClosePrinter(struct rpc_pipe_client *cli,
5184 TALLOC_CTX *mem_ctx,
5185 struct policy_handle *handle /* [in,out] [ref] */,
5186 WERROR *werror)
5187 {
5188 struct spoolss_ClosePrinter r;
5189 NTSTATUS status;
5190
5191 /* In parameters */
5192 r.in.handle = handle;
5193
5194 if (DEBUGLEVEL >= 10) {
5195 NDR_PRINT_IN_DEBUG(spoolss_ClosePrinter, &r);
5196 }
5197
5198 status = cli->dispatch(cli,
5199 mem_ctx,
5200 &ndr_table_spoolss,
5201 NDR_SPOOLSS_CLOSEPRINTER,
5202 &r);
5203
5204 if (!NT_STATUS_IS_OK(status)) {
5205 return status;
5206 }
5207
5208 if (DEBUGLEVEL >= 10) {
5209 NDR_PRINT_OUT_DEBUG(spoolss_ClosePrinter, &r);
5210 }
5211
5212 if (NT_STATUS_IS_ERR(status)) {
5213 return status;
5214 }
5215
5216 /* Return variables */
5217 *handle = *r.out.handle;
5218
5219 /* Return result */
5220 if (werror) {
5221 *werror = r.out.result;
5222 }
5223
5224 return werror_to_ntstatus(r.out.result);
5225 }
5226
5227 struct rpccli_spoolss_AddForm_state {
5228 struct spoolss_AddForm orig;
5229 struct spoolss_AddForm tmp;
5230 TALLOC_CTX *out_mem_ctx;
5231 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5232 };
5233
5234 static void rpccli_spoolss_AddForm_done(struct tevent_req *subreq);
5235
5236 struct tevent_req *rpccli_spoolss_AddForm_send(TALLOC_CTX *mem_ctx,
5237 struct tevent_context *ev,
5238 struct rpc_pipe_client *cli,
5239 struct policy_handle *_handle /* [in] [ref] */,
5240 uint32_t _level /* [in] */,
5241 union spoolss_AddFormInfo _info /* [in] [switch_is(level)] */)
5242 {
5243 struct tevent_req *req;
5244 struct rpccli_spoolss_AddForm_state *state;
5245 struct tevent_req *subreq;
5246
5247 req = tevent_req_create(mem_ctx, &state,
5248 struct rpccli_spoolss_AddForm_state);
5249 if (req == NULL) {
5250 return NULL;
5251 }
5252 state->out_mem_ctx = NULL;
5253 state->dispatch_recv = cli->dispatch_recv;
5254
5255 /* In parameters */
5256 state->orig.in.handle = _handle;
5257 state->orig.in.level = _level;
5258 state->orig.in.info = _info;
5259
5260 /* Out parameters */
5261
5262 /* Result */
5263 ZERO_STRUCT(state->orig.out.result);
5264
5265 if (DEBUGLEVEL >= 10) {
5266 NDR_PRINT_IN_DEBUG(spoolss_AddForm, &state->orig);
5267 }
5268
5269 /* make a temporary copy, that we pass to the dispatch function */
5270 state->tmp = state->orig;
5271
5272 subreq = cli->dispatch_send(state, ev, cli,
5273 &ndr_table_spoolss,
5274 NDR_SPOOLSS_ADDFORM,
5275 &state->tmp);
5276 if (tevent_req_nomem(subreq, req)) {
5277 return tevent_req_post(req, ev);
5278 }
5279 tevent_req_set_callback(subreq, rpccli_spoolss_AddForm_done, req);
5280 return req;
5281 }
5282
5283 static void rpccli_spoolss_AddForm_done(struct tevent_req *subreq)
5284 {
5285 struct tevent_req *req = tevent_req_callback_data(
5286 subreq, struct tevent_req);
5287 struct rpccli_spoolss_AddForm_state *state = tevent_req_data(
5288 req, struct rpccli_spoolss_AddForm_state);
5289 NTSTATUS status;
5290 TALLOC_CTX *mem_ctx;
5291
5292 if (state->out_mem_ctx) {
5293 mem_ctx = state->out_mem_ctx;
5294 } else {
5295 mem_ctx = state;
5296 }
5297
5298 status = state->dispatch_recv(subreq, mem_ctx);
5299 TALLOC_FREE(subreq);
5300 if (!NT_STATUS_IS_OK(status)) {
5301 tevent_req_nterror(req, status);
5302 return;
5303 }
5304
5305 /* Copy out parameters */
5306
5307 /* Copy result */
5308 state->orig.out.result = state->tmp.out.result;
5309
5310 /* Reset temporary structure */
5311 ZERO_STRUCT(state->tmp);
5312
5313 if (DEBUGLEVEL >= 10) {
5314 NDR_PRINT_OUT_DEBUG(spoolss_AddForm, &state->orig);
5315 }
5316
5317 tevent_req_done(req);
5318 }
5319
5320 NTSTATUS rpccli_spoolss_AddForm_recv(struct tevent_req *req,
5321 TALLOC_CTX *mem_ctx,
5322 WERROR *result)
5323 {
5324 struct rpccli_spoolss_AddForm_state *state = tevent_req_data(
5325 req, struct rpccli_spoolss_AddForm_state);
5326 NTSTATUS status;
5327
5328 if (tevent_req_is_nterror(req, &status)) {
5329 tevent_req_received(req);
5330 return status;
5331 }
5332
5333 /* Steal possbile out parameters to the callers context */
5334 talloc_steal(mem_ctx, state->out_mem_ctx);
5335
5336 /* Return result */
5337 *result = state->orig.out.result;
5338
5339 tevent_req_received(req);
5340 return NT_STATUS_OK;
5341 }
5342
5343 NTSTATUS rpccli_spoolss_AddForm(struct rpc_pipe_client *cli,
5344 TALLOC_CTX *mem_ctx,
5345 struct policy_handle *handle /* [in] [ref] */,
5346 uint32_t level /* [in] */,
5347 union spoolss_AddFormInfo info /* [in] [switch_is(level)] */,
5348 WERROR *werror)
5349 {
5350 struct spoolss_AddForm r;
5351 NTSTATUS status;
5352
5353 /* In parameters */
5354 r.in.handle = handle;
5355 r.in.level = level;
5356 r.in.info = info;
5357
5358 if (DEBUGLEVEL >= 10) {
5359 NDR_PRINT_IN_DEBUG(spoolss_AddForm, &r);
5360 }
5361
5362 status = cli->dispatch(cli,
5363 mem_ctx,
5364 &ndr_table_spoolss,
5365 NDR_SPOOLSS_ADDFORM,
5366 &r);
5367
5368 if (!NT_STATUS_IS_OK(status)) {
5369 return status;
5370 }
5371
5372 if (DEBUGLEVEL >= 10) {
5373 NDR_PRINT_OUT_DEBUG(spoolss_AddForm, &r);
5374 }
5375
5376 if (NT_STATUS_IS_ERR(status)) {
5377 return status;
5378 }
5379
5380 /* Return variables */
5381
5382 /* Return result */
5383 if (werror) {
5384 *werror = r.out.result;
5385 }
5386
5387 return werror_to_ntstatus(r.out.result);
5388 }
5389
5390 struct rpccli_spoolss_DeleteForm_state {
5391 struct spoolss_DeleteForm orig;
5392 struct spoolss_DeleteForm tmp;
5393 TALLOC_CTX *out_mem_ctx;
5394 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5395 };
5396
5397 static void rpccli_spoolss_DeleteForm_done(struct tevent_req *subreq);
5398
5399 struct tevent_req *rpccli_spoolss_DeleteForm_send(TALLOC_CTX *mem_ctx,
5400 struct tevent_context *ev,
5401 struct rpc_pipe_client *cli,
5402 struct policy_handle *_handle /* [in] [ref] */,
5403 const char *_form_name /* [in] [charset(UTF16)] */)
5404 {
5405 struct tevent_req *req;
5406 struct rpccli_spoolss_DeleteForm_state *state;
5407 struct tevent_req *subreq;
5408
5409 req = tevent_req_create(mem_ctx, &state,
5410 struct rpccli_spoolss_DeleteForm_state);
5411 if (req == NULL) {
5412 return NULL;
5413 }
5414 state->out_mem_ctx = NULL;
5415 state->dispatch_recv = cli->dispatch_recv;
5416
5417 /* In parameters */
5418 state->orig.in.handle = _handle;
5419 state->orig.in.form_name = _form_name;
5420
5421 /* Out parameters */
5422
5423 /* Result */
5424 ZERO_STRUCT(state->orig.out.result);
5425
5426 if (DEBUGLEVEL >= 10) {
5427 NDR_PRINT_IN_DEBUG(spoolss_DeleteForm, &state->orig);
5428 }
5429
5430 /* make a temporary copy, that we pass to the dispatch function */
5431 state->tmp = state->orig;
5432
5433 subreq = cli->dispatch_send(state, ev, cli,
5434 &ndr_table_spoolss,
5435 NDR_SPOOLSS_DELETEFORM,
5436 &state->tmp);
5437 if (tevent_req_nomem(subreq, req)) {
5438 return tevent_req_post(req, ev);
5439 }
5440 tevent_req_set_callback(subreq, rpccli_spoolss_DeleteForm_done, req);
5441 return req;
5442 }
5443
5444 static void rpccli_spoolss_DeleteForm_done(struct tevent_req *subreq)
5445 {
5446 struct tevent_req *req = tevent_req_callback_data(
5447 subreq, struct tevent_req);
5448 struct rpccli_spoolss_DeleteForm_state *state = tevent_req_data(
5449 req, struct rpccli_spoolss_DeleteForm_state);
5450 NTSTATUS status;
5451 TALLOC_CTX *mem_ctx;
5452
5453 if (state->out_mem_ctx) {
5454 mem_ctx = state->out_mem_ctx;
5455 } else {
5456 mem_ctx = state;
5457 }
5458
5459 status = state->dispatch_recv(subreq, mem_ctx);
5460 TALLOC_FREE(subreq);
5461 if (!NT_STATUS_IS_OK(status)) {
5462 tevent_req_nterror(req, status);
5463 return;
5464 }
5465
5466 /* Copy out parameters */
5467
5468 /* Copy result */
5469 state->orig.out.result = state->tmp.out.result;
5470
5471 /* Reset temporary structure */
5472 ZERO_STRUCT(state->tmp);
5473
5474 if (DEBUGLEVEL >= 10) {
5475 NDR_PRINT_OUT_DEBUG(spoolss_DeleteForm, &state->orig);
5476 }
5477
5478 tevent_req_done(req);
5479 }
5480
5481 NTSTATUS rpccli_spoolss_DeleteForm_recv(struct tevent_req *req,
5482 TALLOC_CTX *mem_ctx,
5483 WERROR *result)
5484 {
5485 struct rpccli_spoolss_DeleteForm_state *state = tevent_req_data(
5486 req, struct rpccli_spoolss_DeleteForm_state);
5487 NTSTATUS status;
5488
5489 if (tevent_req_is_nterror(req, &status)) {
5490 tevent_req_received(req);
5491 return status;
5492 }
5493
5494 /* Steal possbile out parameters to the callers context */
5495 talloc_steal(mem_ctx, state->out_mem_ctx);
5496
5497 /* Return result */
5498 *result = state->orig.out.result;
5499
5500 tevent_req_received(req);
5501 return NT_STATUS_OK;
5502 }
5503
5504 NTSTATUS rpccli_spoolss_DeleteForm(struct rpc_pipe_client *cli,
5505 TALLOC_CTX *mem_ctx,
5506 struct policy_handle *handle /* [in] [ref] */,
5507 const char *form_name /* [in] [charset(UTF16)] */,
5508 WERROR *werror)
5509 {
5510 struct spoolss_DeleteForm r;
5511 NTSTATUS status;
5512
5513 /* In parameters */
5514 r.in.handle = handle;
5515 r.in.form_name = form_name;
5516
5517 if (DEBUGLEVEL >= 10) {
5518 NDR_PRINT_IN_DEBUG(spoolss_DeleteForm, &r);
5519 }
5520
5521 status = cli->dispatch(cli,
5522 mem_ctx,
5523 &ndr_table_spoolss,
5524 NDR_SPOOLSS_DELETEFORM,
5525 &r);
5526
5527 if (!NT_STATUS_IS_OK(status)) {
5528 return status;
5529 }
5530
5531 if (DEBUGLEVEL >= 10) {
5532 NDR_PRINT_OUT_DEBUG(spoolss_DeleteForm, &r);
5533 }
5534
5535 if (NT_STATUS_IS_ERR(status)) {
5536 return status;
5537 }
5538
5539 /* Return variables */
5540
5541 /* Return result */
5542 if (werror) {
5543 *werror = r.out.result;
5544 }
5545
5546 return werror_to_ntstatus(r.out.result);
5547 }
5548
5549 struct rpccli_spoolss_GetForm_state {
5550 struct spoolss_GetForm orig;
5551 struct spoolss_GetForm tmp;
5552 TALLOC_CTX *out_mem_ctx;
5553 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5554 };
5555
5556 static void rpccli_spoolss_GetForm_done(struct tevent_req *subreq);
5557
5558 struct tevent_req *rpccli_spoolss_GetForm_send(TALLOC_CTX *mem_ctx,
5559 struct tevent_context *ev,
5560 struct rpc_pipe_client *cli,
5561 struct policy_handle *_handle /* [in] [ref] */,
5562 const char *_form_name /* [in] [charset(UTF16)] */,
5563 uint32_t _level /* [in] */,
5564 DATA_BLOB *_buffer /* [in] [unique] */,
5565 uint32_t _offered /* [in] */,
5566 union spoolss_FormInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
5567 uint32_t *_needed /* [out] [ref] */)
5568 {
5569 struct tevent_req *req;
5570 struct rpccli_spoolss_GetForm_state *state;
5571 struct tevent_req *subreq;
5572
5573 req = tevent_req_create(mem_ctx, &state,
5574 struct rpccli_spoolss_GetForm_state);
5575 if (req == NULL) {
5576 return NULL;
5577 }
5578 state->out_mem_ctx = NULL;
5579 state->dispatch_recv = cli->dispatch_recv;
5580
5581 /* In parameters */
5582 state->orig.in.handle = _handle;
5583 state->orig.in.form_name = _form_name;
5584 state->orig.in.level = _level;
5585 state->orig.in.buffer = _buffer;
5586 state->orig.in.offered = _offered;
5587
5588 /* Out parameters */
5589 state->orig.out.info = _info;
5590 state->orig.out.needed = _needed;
5591
5592 /* Result */
5593 ZERO_STRUCT(state->orig.out.result);
5594
5595 if (DEBUGLEVEL >= 10) {
5596 NDR_PRINT_IN_DEBUG(spoolss_GetForm, &state->orig);
5597 }
5598
5599 state->out_mem_ctx = talloc_named_const(state, 0,
5600 "rpccli_spoolss_GetForm_out_memory");
5601 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5602 return tevent_req_post(req, ev);
5603 }
5604
5605 /* make a temporary copy, that we pass to the dispatch function */
5606 state->tmp = state->orig;
5607
5608 subreq = cli->dispatch_send(state, ev, cli,
5609 &ndr_table_spoolss,
5610 NDR_SPOOLSS_GETFORM,
5611 &state->tmp);
5612 if (tevent_req_nomem(subreq, req)) {
5613 return tevent_req_post(req, ev);
5614 }
5615 tevent_req_set_callback(subreq, rpccli_spoolss_GetForm_done, req);
5616 return req;
5617 }
5618
5619 static void rpccli_spoolss_GetForm_done(struct tevent_req *subreq)
5620 {
5621 struct tevent_req *req = tevent_req_callback_data(
5622 subreq, struct tevent_req);
5623 struct rpccli_spoolss_GetForm_state *state = tevent_req_data(
5624 req, struct rpccli_spoolss_GetForm_state);
5625 NTSTATUS status;
5626 TALLOC_CTX *mem_ctx;
5627
5628 if (state->out_mem_ctx) {
5629 mem_ctx = state->out_mem_ctx;
5630 } else {
5631 mem_ctx = state;
5632 }
5633
5634 status = state->dispatch_recv(subreq, mem_ctx);
5635 TALLOC_FREE(subreq);
5636 if (!NT_STATUS_IS_OK(status)) {
5637 tevent_req_nterror(req, status);
5638 return;
5639 }
5640
5641 /* Copy out parameters */
5642 if (state->orig.out.info && state->tmp.out.info) {
5643 *state->orig.out.info = *state->tmp.out.info;
5644 }
5645 *state->orig.out.needed = *state->tmp.out.needed;
5646
5647 /* Copy result */
5648 state->orig.out.result = state->tmp.out.result;
5649
5650 /* Reset temporary structure */
5651 ZERO_STRUCT(state->tmp);
5652
5653 if (DEBUGLEVEL >= 10) {
5654 NDR_PRINT_OUT_DEBUG(spoolss_GetForm, &state->orig);
5655 }
5656
5657 tevent_req_done(req);
5658 }
5659
5660 NTSTATUS rpccli_spoolss_GetForm_recv(struct tevent_req *req,
5661 TALLOC_CTX *mem_ctx,
5662 WERROR *result)
5663 {
5664 struct rpccli_spoolss_GetForm_state *state = tevent_req_data(
5665 req, struct rpccli_spoolss_GetForm_state);
5666 NTSTATUS status;
5667
5668 if (tevent_req_is_nterror(req, &status)) {
5669 tevent_req_received(req);
5670 return status;
5671 }
5672
5673 /* Steal possbile out parameters to the callers context */
5674 talloc_steal(mem_ctx, state->out_mem_ctx);
5675
5676 /* Return result */
5677 *result = state->orig.out.result;
5678
5679 tevent_req_received(req);
5680 return NT_STATUS_OK;
5681 }
5682
5683 NTSTATUS rpccli_spoolss_GetForm(struct rpc_pipe_client *cli,
5684 TALLOC_CTX *mem_ctx,
5685 struct policy_handle *handle /* [in] [ref] */,
5686 const char *form_name /* [in] [charset(UTF16)] */,
5687 uint32_t level /* [in] */,
5688 DATA_BLOB *buffer /* [in] [unique] */,
5689 uint32_t offered /* [in] */,
5690 union spoolss_FormInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
5691 uint32_t *needed /* [out] [ref] */,
5692 WERROR *werror)
5693 {
5694 struct spoolss_GetForm r;
5695 NTSTATUS status;
5696
5697 /* In parameters */
5698 r.in.handle = handle;
5699 r.in.form_name = form_name;
5700 r.in.level = level;
5701 r.in.buffer = buffer;
5702 r.in.offered = offered;
5703
5704 if (DEBUGLEVEL >= 10) {
5705 NDR_PRINT_IN_DEBUG(spoolss_GetForm, &r);
5706 }
5707
5708 status = cli->dispatch(cli,
5709 mem_ctx,
5710 &ndr_table_spoolss,
5711 NDR_SPOOLSS_GETFORM,
5712 &r);
5713
5714 if (!NT_STATUS_IS_OK(status)) {
5715 return status;
5716 }
5717
5718 if (DEBUGLEVEL >= 10) {
5719 NDR_PRINT_OUT_DEBUG(spoolss_GetForm, &r);
5720 }
5721
5722 if (NT_STATUS_IS_ERR(status)) {
5723 return status;
5724 }
5725
5726 /* Return variables */
5727 if (info && r.out.info) {
5728 *info = *r.out.info;
5729 }
5730 *needed = *r.out.needed;
5731
5732 /* Return result */
5733 if (werror) {
5734 *werror = r.out.result;
5735 }
5736
5737 return werror_to_ntstatus(r.out.result);
5738 }
5739
5740 struct rpccli_spoolss_SetForm_state {
5741 struct spoolss_SetForm orig;
5742 struct spoolss_SetForm tmp;
5743 TALLOC_CTX *out_mem_ctx;
5744 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5745 };
5746
5747 static void rpccli_spoolss_SetForm_done(struct tevent_req *subreq);
5748
5749 struct tevent_req *rpccli_spoolss_SetForm_send(TALLOC_CTX *mem_ctx,
5750 struct tevent_context *ev,
5751 struct rpc_pipe_client *cli,
5752 struct policy_handle *_handle /* [in] [ref] */,
5753 const char *_form_name /* [in] [charset(UTF16)] */,
5754 uint32_t _level /* [in] */,
5755 union spoolss_AddFormInfo _info /* [in] [switch_is(level)] */)
5756 {
5757 struct tevent_req *req;
5758 struct rpccli_spoolss_SetForm_state *state;
5759 struct tevent_req *subreq;
5760
5761 req = tevent_req_create(mem_ctx, &state,
5762 struct rpccli_spoolss_SetForm_state);
5763 if (req == NULL) {
5764 return NULL;
5765 }
5766 state->out_mem_ctx = NULL;
5767 state->dispatch_recv = cli->dispatch_recv;
5768
5769 /* In parameters */
5770 state->orig.in.handle = _handle;
5771 state->orig.in.form_name = _form_name;
5772 state->orig.in.level = _level;
5773 state->orig.in.info = _info;
5774
5775 /* Out parameters */
5776
5777 /* Result */
5778 ZERO_STRUCT(state->orig.out.result);
5779
5780 if (DEBUGLEVEL >= 10) {
5781 NDR_PRINT_IN_DEBUG(spoolss_SetForm, &state->orig);
5782 }
5783
5784 /* make a temporary copy, that we pass to the dispatch function */
5785 state->tmp = state->orig;
5786
5787 subreq = cli->dispatch_send(state, ev, cli,
5788 &ndr_table_spoolss,
5789 NDR_SPOOLSS_SETFORM,
5790 &state->tmp);
5791 if (tevent_req_nomem(subreq, req)) {
5792 return tevent_req_post(req, ev);
5793 }
5794 tevent_req_set_callback(subreq, rpccli_spoolss_SetForm_done, req);
5795 return req;
5796 }
5797
5798 static void rpccli_spoolss_SetForm_done(struct tevent_req *subreq)
5799 {
5800 struct tevent_req *req = tevent_req_callback_data(
5801 subreq, struct tevent_req);
5802 struct rpccli_spoolss_SetForm_state *state = tevent_req_data(
5803 req, struct rpccli_spoolss_SetForm_state);
5804 NTSTATUS status;
5805 TALLOC_CTX *mem_ctx;
5806
5807 if (state->out_mem_ctx) {
5808 mem_ctx = state->out_mem_ctx;
5809 } else {
5810 mem_ctx = state;
5811 }
5812
5813 status = state->dispatch_recv(subreq, mem_ctx);
5814 TALLOC_FREE(subreq);
5815 if (!NT_STATUS_IS_OK(status)) {
5816 tevent_req_nterror(req, status);
5817 return;
5818 }
5819
5820 /* Copy out parameters */
5821
5822 /* Copy result */
5823 state->orig.out.result = state->tmp.out.result;
5824
5825 /* Reset temporary structure */
5826 ZERO_STRUCT(state->tmp);
5827
5828 if (DEBUGLEVEL >= 10) {
5829 NDR_PRINT_OUT_DEBUG(spoolss_SetForm, &state->orig);
5830 }
5831
5832 tevent_req_done(req);
5833 }
5834
5835 NTSTATUS rpccli_spoolss_SetForm_recv(struct tevent_req *req,
5836 TALLOC_CTX *mem_ctx,
5837 WERROR *result)
5838 {
5839 struct rpccli_spoolss_SetForm_state *state = tevent_req_data(
5840 req, struct rpccli_spoolss_SetForm_state);
5841 NTSTATUS status;
5842
5843 if (tevent_req_is_nterror(req, &status)) {
5844 tevent_req_received(req);
5845 return status;
5846 }
5847
5848 /* Steal possbile out parameters to the callers context */
5849 talloc_steal(mem_ctx, state->out_mem_ctx);
5850
5851 /* Return result */
5852 *result = state->orig.out.result;
5853
5854 tevent_req_received(req);
5855 return NT_STATUS_OK;
5856 }
5857
5858 NTSTATUS rpccli_spoolss_SetForm(struct rpc_pipe_client *cli,
5859 TALLOC_CTX *mem_ctx,
5860 struct policy_handle *handle /* [in] [ref] */,
5861 const char *form_name /* [in] [charset(UTF16)] */,
5862 uint32_t level /* [in] */,
5863 union spoolss_AddFormInfo info /* [in] [switch_is(level)] */,
5864 WERROR *werror)
5865 {
5866 struct spoolss_SetForm r;
5867 NTSTATUS status;
5868
5869 /* In parameters */
5870 r.in.handle = handle;
5871 r.in.form_name = form_name;
5872 r.in.level = level;
5873 r.in.info = info;
5874
5875 if (DEBUGLEVEL >= 10) {
5876 NDR_PRINT_IN_DEBUG(spoolss_SetForm, &r);
5877 }
5878
5879 status = cli->dispatch(cli,
5880 mem_ctx,
5881 &ndr_table_spoolss,
5882 NDR_SPOOLSS_SETFORM,
5883 &r);
5884
5885 if (!NT_STATUS_IS_OK(status)) {
5886 return status;
5887 }
5888
5889 if (DEBUGLEVEL >= 10) {
5890 NDR_PRINT_OUT_DEBUG(spoolss_SetForm, &r);
5891 }
5892
5893 if (NT_STATUS_IS_ERR(status)) {
5894 return status;
5895 }
5896
5897 /* Return variables */
5898
5899 /* Return result */
5900 if (werror) {
5901 *werror = r.out.result;
5902 }
5903
5904 return werror_to_ntstatus(r.out.result);
5905 }
5906
5907 struct rpccli_spoolss_EnumForms_state {
5908 struct spoolss_EnumForms orig;
5909 struct spoolss_EnumForms tmp;
5910 TALLOC_CTX *out_mem_ctx;
5911 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5912 };
5913
5914 static void rpccli_spoolss_EnumForms_done(struct tevent_req *subreq);
5915
5916 struct tevent_req *rpccli_spoolss_EnumForms_send(TALLOC_CTX *mem_ctx,
5917 struct tevent_context *ev,
5918 struct rpc_pipe_client *cli,
5919 struct policy_handle *_handle /* [in] [ref] */,
5920 uint32_t _level /* [in] */,
5921 DATA_BLOB *_buffer /* [in] [unique] */,
5922 uint32_t _offered /* [in] */,
5923 uint32_t *_count /* [out] [ref] */,
5924 union spoolss_FormInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5925 uint32_t *_needed /* [out] [ref] */)
5926 {
5927 struct tevent_req *req;
5928 struct rpccli_spoolss_EnumForms_state *state;
5929 struct tevent_req *subreq;
5930
5931 req = tevent_req_create(mem_ctx, &state,
5932 struct rpccli_spoolss_EnumForms_state);
5933 if (req == NULL) {
5934 return NULL;
5935 }
5936 state->out_mem_ctx = NULL;
5937 state->dispatch_recv = cli->dispatch_recv;
5938
5939 /* In parameters */
5940 state->orig.in.handle = _handle;
5941 state->orig.in.level = _level;
5942 state->orig.in.buffer = _buffer;
5943 state->orig.in.offered = _offered;
5944
5945 /* Out parameters */
5946 state->orig.out.count = _count;
5947 state->orig.out.info = _info;
5948 state->orig.out.needed = _needed;
5949
5950 /* Result */
5951 ZERO_STRUCT(state->orig.out.result);
5952
5953 if (DEBUGLEVEL >= 10) {
5954 NDR_PRINT_IN_DEBUG(spoolss_EnumForms, &state->orig);
5955 }
5956
5957 state->out_mem_ctx = talloc_named_const(state, 0,
5958 "rpccli_spoolss_EnumForms_out_memory");
5959 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5960 return tevent_req_post(req, ev);
5961 }
5962
5963 /* make a temporary copy, that we pass to the dispatch function */
5964 state->tmp = state->orig;
5965
5966 subreq = cli->dispatch_send(state, ev, cli,
5967 &ndr_table_spoolss,
5968 NDR_SPOOLSS_ENUMFORMS,
5969 &state->tmp);
5970 if (tevent_req_nomem(subreq, req)) {
5971 return tevent_req_post(req, ev);
5972 }
5973 tevent_req_set_callback(subreq, rpccli_spoolss_EnumForms_done, req);
5974 return req;
5975 }
5976
5977 static void rpccli_spoolss_EnumForms_done(struct tevent_req *subreq)
5978 {
5979 struct tevent_req *req = tevent_req_callback_data(
5980 subreq, struct tevent_req);
5981 struct rpccli_spoolss_EnumForms_state *state = tevent_req_data(
5982 req, struct rpccli_spoolss_EnumForms_state);
5983 NTSTATUS status;
5984 TALLOC_CTX *mem_ctx;
5985
5986 if (state->out_mem_ctx) {
5987 mem_ctx = state->out_mem_ctx;
5988 } else {
5989 mem_ctx = state;
5990 }
5991
5992 status = state->dispatch_recv(subreq, mem_ctx);
5993 TALLOC_FREE(subreq);
5994 if (!NT_STATUS_IS_OK(status)) {
5995 tevent_req_nterror(req, status);
5996 return;
5997 }
5998
5999 /* Copy out parameters */
6000 *state->orig.out.count = *state->tmp.out.count;
6001 *state->orig.out.info = *state->tmp.out.info;
6002 *state->orig.out.needed = *state->tmp.out.needed;
6003
6004 /* Copy result */
6005 state->orig.out.result = state->tmp.out.result;
6006
6007 /* Reset temporary structure */
6008 ZERO_STRUCT(state->tmp);
6009
6010 if (DEBUGLEVEL >= 10) {
6011 NDR_PRINT_OUT_DEBUG(spoolss_EnumForms, &state->orig);
6012 }
6013
6014 tevent_req_done(req);
6015 }
6016
6017 NTSTATUS rpccli_spoolss_EnumForms_recv(struct tevent_req *req,
6018 TALLOC_CTX *mem_ctx,
6019 WERROR *result)
6020 {
6021 struct rpccli_spoolss_EnumForms_state *state = tevent_req_data(
6022 req, struct rpccli_spoolss_EnumForms_state);
6023 NTSTATUS status;
6024
6025 if (tevent_req_is_nterror(req, &status)) {
6026 tevent_req_received(req);
6027 return status;
6028 }
6029
6030 /* Steal possbile out parameters to the callers context */
6031 talloc_steal(mem_ctx, state->out_mem_ctx);
6032
6033 /* Return result */
6034 *result = state->orig.out.result;
6035
6036 tevent_req_received(req);
6037 return NT_STATUS_OK;
6038 }
6039
6040 NTSTATUS rpccli_spoolss_EnumForms(struct rpc_pipe_client *cli,
6041 TALLOC_CTX *mem_ctx,
6042 struct policy_handle *handle /* [in] [ref] */,
6043 uint32_t level /* [in] */,
6044 DATA_BLOB *buffer /* [in] [unique] */,
6045 uint32_t offered /* [in] */,
6046 uint32_t *count /* [out] [ref] */,
6047 union spoolss_FormInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
6048 uint32_t *needed /* [out] [ref] */,
6049 WERROR *werror)
6050 {
6051 struct spoolss_EnumForms r;
6052 NTSTATUS status;
6053
6054 /* In parameters */
6055 r.in.handle = handle;
6056 r.in.level = level;
6057 r.in.buffer = buffer;
6058 r.in.offered = offered;
6059
6060 if (DEBUGLEVEL >= 10) {
6061 NDR_PRINT_IN_DEBUG(spoolss_EnumForms, &r);
6062 }
6063
6064 status = cli->dispatch(cli,
6065 mem_ctx,
6066 &ndr_table_spoolss,
6067 NDR_SPOOLSS_ENUMFORMS,
6068 &r);
6069
6070 if (!NT_STATUS_IS_OK(status)) {
6071 return status;
6072 }
6073
6074 if (DEBUGLEVEL >= 10) {
6075 NDR_PRINT_OUT_DEBUG(spoolss_EnumForms, &r);
6076 }
6077
6078 if (NT_STATUS_IS_ERR(status)) {
6079 return status;
6080 }
6081
6082 /* Return variables */
6083 *count = *r.out.count;
6084 *info = *r.out.info;
6085 *needed = *r.out.needed;
6086
6087 /* Return result */
6088 if (werror) {
6089 *werror = r.out.result;
6090 }
6091
6092 return werror_to_ntstatus(r.out.result);
6093 }
6094
6095 struct rpccli_spoolss_EnumPorts_state {
6096 struct spoolss_EnumPorts orig;
6097 struct spoolss_EnumPorts tmp;
6098 TALLOC_CTX *out_mem_ctx;
6099 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6100 };
6101
6102 static void rpccli_spoolss_EnumPorts_done(struct tevent_req *subreq);
6103
6104 struct tevent_req *rpccli_spoolss_EnumPorts_send(TALLOC_CTX *mem_ctx,
6105 struct tevent_context *ev,
6106 struct rpc_pipe_client *cli,
6107 const char *_servername /* [in] [unique,charset(UTF16)] */,
6108 uint32_t _level /* [in] */,
6109 DATA_BLOB *_buffer /* [in] [unique] */,
6110 uint32_t _offered /* [in] */,
6111 uint32_t *_count /* [out] [ref] */,
6112 union spoolss_PortInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
6113 uint32_t *_needed /* [out] [ref] */)
6114 {
6115 struct tevent_req *req;
6116 struct rpccli_spoolss_EnumPorts_state *state;
6117 struct tevent_req *subreq;
6118
6119 req = tevent_req_create(mem_ctx, &state,
6120 struct rpccli_spoolss_EnumPorts_state);
6121 if (req == NULL) {
6122 return NULL;
6123 }
6124 state->out_mem_ctx = NULL;
6125 state->dispatch_recv = cli->dispatch_recv;
6126
6127 /* In parameters */
6128 state->orig.in.servername = _servername;
6129 state->orig.in.level = _level;
6130 state->orig.in.buffer = _buffer;
6131 state->orig.in.offered = _offered;
6132
6133 /* Out parameters */
6134 state->orig.out.count = _count;
6135 state->orig.out.info = _info;
6136 state->orig.out.needed = _needed;
6137
6138 /* Result */
6139 ZERO_STRUCT(state->orig.out.result);
6140
6141 if (DEBUGLEVEL >= 10) {
6142 NDR_PRINT_IN_DEBUG(spoolss_EnumPorts, &state->orig);
6143 }
6144
6145 state->out_mem_ctx = talloc_named_const(state, 0,
6146 "rpccli_spoolss_EnumPorts_out_memory");
6147 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6148 return tevent_req_post(req, ev);
6149 }
6150
6151 /* make a temporary copy, that we pass to the dispatch function */
6152 state->tmp = state->orig;
6153
6154 subreq = cli->dispatch_send(state, ev, cli,
6155 &ndr_table_spoolss,
6156 NDR_SPOOLSS_ENUMPORTS,
6157 &state->tmp);
6158 if (tevent_req_nomem(subreq, req)) {
6159 return tevent_req_post(req, ev);
6160 }
6161 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPorts_done, req);
6162 return req;
6163 }
6164
6165 static void rpccli_spoolss_EnumPorts_done(struct tevent_req *subreq)
6166 {
6167 struct tevent_req *req = tevent_req_callback_data(
6168 subreq, struct tevent_req);
6169 struct rpccli_spoolss_EnumPorts_state *state = tevent_req_data(
6170 req, struct rpccli_spoolss_EnumPorts_state);
6171 NTSTATUS status;
6172 TALLOC_CTX *mem_ctx;
6173
6174 if (state->out_mem_ctx) {
6175 mem_ctx = state->out_mem_ctx;
6176 } else {
6177 mem_ctx = state;
6178 }
6179
6180 status = state->dispatch_recv(subreq, mem_ctx);
6181 TALLOC_FREE(subreq);
6182 if (!NT_STATUS_IS_OK(status)) {
6183 tevent_req_nterror(req, status);
6184 return;
6185 }
6186
6187 /* Copy out parameters */
6188 *state->orig.out.count = *state->tmp.out.count;
6189 *state->orig.out.info = *state->tmp.out.info;
6190 *state->orig.out.needed = *state->tmp.out.needed;
6191
6192 /* Copy result */
6193 state->orig.out.result = state->tmp.out.result;
6194
6195 /* Reset temporary structure */
6196 ZERO_STRUCT(state->tmp);
6197
6198 if (DEBUGLEVEL >= 10) {
6199 NDR_PRINT_OUT_DEBUG(spoolss_EnumPorts, &state->orig);
6200 }
6201
6202 tevent_req_done(req);
6203 }
6204
6205 NTSTATUS rpccli_spoolss_EnumPorts_recv(struct tevent_req *req,
6206 TALLOC_CTX *mem_ctx,
6207 WERROR *result)
6208 {
6209 struct rpccli_spoolss_EnumPorts_state *state = tevent_req_data(
6210 req, struct rpccli_spoolss_EnumPorts_state);
6211 NTSTATUS status;
6212
6213 if (tevent_req_is_nterror(req, &status)) {
6214 tevent_req_received(req);
6215 return status;
6216 }
6217
6218 /* Steal possbile out parameters to the callers context */
6219 talloc_steal(mem_ctx, state->out_mem_ctx);
6220
6221 /* Return result */
6222 *result = state->orig.out.result;
6223
6224 tevent_req_received(req);
6225 return NT_STATUS_OK;
6226 }
6227
6228 NTSTATUS rpccli_spoolss_EnumPorts(struct rpc_pipe_client *cli,
6229 TALLOC_CTX *mem_ctx,
6230 const char *servername /* [in] [unique,charset(UTF16)] */,
6231 uint32_t level /* [in] */,
6232 DATA_BLOB *buffer /* [in] [unique] */,
6233 uint32_t offered /* [in] */,
6234 uint32_t *count /* [out] [ref] */,
6235 union spoolss_PortInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
6236 uint32_t *needed /* [out] [ref] */,
6237 WERROR *werror)
6238 {
6239 struct spoolss_EnumPorts r;
6240 NTSTATUS status;
6241
6242 /* In parameters */
6243 r.in.servername = servername;
6244 r.in.level = level;
6245 r.in.buffer = buffer;
6246 r.in.offered = offered;
6247
6248 if (DEBUGLEVEL >= 10) {
6249 NDR_PRINT_IN_DEBUG(spoolss_EnumPorts, &r);
6250 }
6251
6252 status = cli->dispatch(cli,
6253 mem_ctx,
6254 &ndr_table_spoolss,
6255 NDR_SPOOLSS_ENUMPORTS,
6256 &r);
6257
6258 if (!NT_STATUS_IS_OK(status)) {
6259 return status;
6260 }
6261
6262 if (DEBUGLEVEL >= 10) {
6263 NDR_PRINT_OUT_DEBUG(spoolss_EnumPorts, &r);
6264 }
6265
6266 if (NT_STATUS_IS_ERR(status)) {
6267 return status;
6268 }
6269
6270 /* Return variables */
6271 *count = *r.out.count;
6272 *info = *r.out.info;
6273 *needed = *r.out.needed;
6274
6275 /* Return result */
6276 if (werror) {
6277 *werror = r.out.result;
6278 }
6279
6280 return werror_to_ntstatus(r.out.result);
6281 }
6282
6283 struct rpccli_spoolss_EnumMonitors_state {
6284 struct spoolss_EnumMonitors orig;
6285 struct spoolss_EnumMonitors tmp;
6286 TALLOC_CTX *out_mem_ctx;
6287 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6288 };
6289
6290 static void rpccli_spoolss_EnumMonitors_done(struct tevent_req *subreq);
6291
6292 struct tevent_req *rpccli_spoolss_EnumMonitors_send(TALLOC_CTX *mem_ctx,
6293 struct tevent_context *ev,
6294 struct rpc_pipe_client *cli,
6295 const char *_servername /* [in] [unique,charset(UTF16)] */,
6296 uint32_t _level /* [in] */,
6297 DATA_BLOB *_buffer /* [in] [unique] */,
6298 uint32_t _offered /* [in] */,
6299 uint32_t *_count /* [out] [ref] */,
6300 union spoolss_MonitorInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
6301 uint32_t *_needed /* [out] [ref] */)
6302 {
6303 struct tevent_req *req;
6304 struct rpccli_spoolss_EnumMonitors_state *state;
6305 struct tevent_req *subreq;
6306
6307 req = tevent_req_create(mem_ctx, &state,
6308 struct rpccli_spoolss_EnumMonitors_state);
6309 if (req == NULL) {
6310 return NULL;
6311 }
6312 state->out_mem_ctx = NULL;
6313 state->dispatch_recv = cli->dispatch_recv;
6314
6315 /* In parameters */
6316 state->orig.in.servername = _servername;
6317 state->orig.in.level = _level;
6318 state->orig.in.buffer = _buffer;
6319 state->orig.in.offered = _offered;
6320
6321 /* Out parameters */
6322 state->orig.out.count = _count;
6323 state->orig.out.info = _info;
6324 state->orig.out.needed = _needed;
6325
6326 /* Result */
6327 ZERO_STRUCT(state->orig.out.result);
6328
6329 if (DEBUGLEVEL >= 10) {
6330 NDR_PRINT_IN_DEBUG(spoolss_EnumMonitors, &state->orig);
6331 }
6332
6333 state->out_mem_ctx = talloc_named_const(state, 0,
6334 "rpccli_spoolss_EnumMonitors_out_memory");
6335 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6336 return tevent_req_post(req, ev);
6337 }
6338
6339 /* make a temporary copy, that we pass to the dispatch function */
6340 state->tmp = state->orig;
6341
6342 subreq = cli->dispatch_send(state, ev, cli,
6343 &ndr_table_spoolss,
6344 NDR_SPOOLSS_ENUMMONITORS,
6345 &state->tmp);
6346 if (tevent_req_nomem(subreq, req)) {
6347 return tevent_req_post(req, ev);
6348 }
6349 tevent_req_set_callback(subreq, rpccli_spoolss_EnumMonitors_done, req);
6350 return req;
6351 }
6352
6353 static void rpccli_spoolss_EnumMonitors_done(struct tevent_req *subreq)
6354 {
6355 struct tevent_req *req = tevent_req_callback_data(
6356 subreq, struct tevent_req);
6357 struct rpccli_spoolss_EnumMonitors_state *state = tevent_req_data(
6358 req, struct rpccli_spoolss_EnumMonitors_state);
6359 NTSTATUS status;
6360 TALLOC_CTX *mem_ctx;
6361
6362 if (state->out_mem_ctx) {
6363 mem_ctx = state->out_mem_ctx;
6364 } else {
6365 mem_ctx = state;
6366 }
6367
6368 status = state->dispatch_recv(subreq, mem_ctx);
6369 TALLOC_FREE(subreq);
6370 if (!NT_STATUS_IS_OK(status)) {
6371 tevent_req_nterror(req, status);
6372 return;
6373 }
6374
6375 /* Copy out parameters */
6376 *state->orig.out.count = *state->tmp.out.count;
6377 *state->orig.out.info = *state->tmp.out.info;
6378 *state->orig.out.needed = *state->tmp.out.needed;
6379
6380 /* Copy result */
6381 state->orig.out.result = state->tmp.out.result;
6382
6383 /* Reset temporary structure */
6384 ZERO_STRUCT(state->tmp);
6385
6386 if (DEBUGLEVEL >= 10) {
6387 NDR_PRINT_OUT_DEBUG(spoolss_EnumMonitors, &state->orig);
6388 }
6389
6390 tevent_req_done(req);
6391 }
6392
6393 NTSTATUS rpccli_spoolss_EnumMonitors_recv(struct tevent_req *req,
6394 TALLOC_CTX *mem_ctx,
6395 WERROR *result)
6396 {
6397 struct rpccli_spoolss_EnumMonitors_state *state = tevent_req_data(
6398 req, struct rpccli_spoolss_EnumMonitors_state);
6399 NTSTATUS status;
6400
6401 if (tevent_req_is_nterror(req, &status)) {
6402 tevent_req_received(req);
6403 return status;
6404 }
6405
6406 /* Steal possbile out parameters to the callers context */
6407 talloc_steal(mem_ctx, state->out_mem_ctx);
6408
6409 /* Return result */
6410 *result = state->orig.out.result;
6411
6412 tevent_req_received(req);
6413 return NT_STATUS_OK;
6414 }
6415
6416 NTSTATUS rpccli_spoolss_EnumMonitors(struct rpc_pipe_client *cli,
6417 TALLOC_CTX *mem_ctx,
6418 const char *servername /* [in] [unique,charset(UTF16)] */,
6419 uint32_t level /* [in] */,
6420 DATA_BLOB *buffer /* [in] [unique] */,
6421 uint32_t offered /* [in] */,
6422 uint32_t *count /* [out] [ref] */,
6423 union spoolss_MonitorInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
6424 uint32_t *needed /* [out] [ref] */,
6425 WERROR *werror)
6426 {
6427 struct spoolss_EnumMonitors r;
6428 NTSTATUS status;
6429
6430 /* In parameters */
6431 r.in.servername = servername;
6432 r.in.level = level;
6433 r.in.buffer = buffer;
6434 r.in.offered = offered;
6435
6436 if (DEBUGLEVEL >= 10) {
6437 NDR_PRINT_IN_DEBUG(spoolss_EnumMonitors, &r);
6438 }
6439
6440 status = cli->dispatch(cli,
6441 mem_ctx,
6442 &ndr_table_spoolss,
6443 NDR_SPOOLSS_ENUMMONITORS,
6444 &r);
6445
6446 if (!NT_STATUS_IS_OK(status)) {
6447 return status;
6448 }
6449
6450 if (DEBUGLEVEL >= 10) {
6451 NDR_PRINT_OUT_DEBUG(spoolss_EnumMonitors, &r);
6452 }
6453
6454 if (NT_STATUS_IS_ERR(status)) {
6455 return status;
6456 }
6457
6458 /* Return variables */
6459 *count = *r.out.count;
6460 *info = *r.out.info;
6461 *needed = *r.out.needed;
6462
6463 /* Return result */
6464 if (werror) {
6465 *werror = r.out.result;
6466 }
6467
6468 return werror_to_ntstatus(r.out.result);
6469 }
6470
6471 struct rpccli_spoolss_AddPort_state {
6472 struct spoolss_AddPort orig;
6473 struct spoolss_AddPort tmp;
6474 TALLOC_CTX *out_mem_ctx;
6475 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6476 };
6477
6478 static void rpccli_spoolss_AddPort_done(struct tevent_req *subreq);
6479
6480 struct tevent_req *rpccli_spoolss_AddPort_send(TALLOC_CTX *mem_ctx,
6481 struct tevent_context *ev,
6482 struct rpc_pipe_client *cli,
6483 const char *_server_name /* [in] [unique,charset(UTF16)] */,
6484 uint32_t _unknown /* [in] */,
6485 const char *_monitor_name /* [in] [charset(UTF16)] */)
6486 {
6487 struct tevent_req *req;
6488 struct rpccli_spoolss_AddPort_state *state;
6489 struct tevent_req *subreq;
6490
6491 req = tevent_req_create(mem_ctx, &state,
6492 struct rpccli_spoolss_AddPort_state);
6493 if (req == NULL) {
6494 return NULL;
6495 }
6496 state->out_mem_ctx = NULL;
6497 state->dispatch_recv = cli->dispatch_recv;
6498
6499 /* In parameters */
6500 state->orig.in.server_name = _server_name;
6501 state->orig.in.unknown = _unknown;
6502 state->orig.in.monitor_name = _monitor_name;
6503
6504 /* Out parameters */
6505
6506 /* Result */
6507 ZERO_STRUCT(state->orig.out.result);
6508
6509 if (DEBUGLEVEL >= 10) {
6510 NDR_PRINT_IN_DEBUG(spoolss_AddPort, &state->orig);
6511 }
6512
6513 /* make a temporary copy, that we pass to the dispatch function */
6514 state->tmp = state->orig;
6515
6516 subreq = cli->dispatch_send(state, ev, cli,
6517 &ndr_table_spoolss,
6518 NDR_SPOOLSS_ADDPORT,
6519 &state->tmp);
6520 if (tevent_req_nomem(subreq, req)) {
6521 return tevent_req_post(req, ev);
6522 }
6523 tevent_req_set_callback(subreq, rpccli_spoolss_AddPort_done, req);
6524 return req;
6525 }
6526
6527 static void rpccli_spoolss_AddPort_done(struct tevent_req *subreq)
6528 {
6529 struct tevent_req *req = tevent_req_callback_data(
6530 subreq, struct tevent_req);
6531 struct rpccli_spoolss_AddPort_state *state = tevent_req_data(
6532 req, struct rpccli_spoolss_AddPort_state);
6533 NTSTATUS status;
6534 TALLOC_CTX *mem_ctx;
6535
6536 if (state->out_mem_ctx) {
6537 mem_ctx = state->out_mem_ctx;
6538 } else {
6539 mem_ctx = state;
6540 }
6541
6542 status = state->dispatch_recv(subreq, mem_ctx);
6543 TALLOC_FREE(subreq);
6544 if (!NT_STATUS_IS_OK(status)) {
6545 tevent_req_nterror(req, status);
6546 return;
6547 }
6548
6549 /* Copy out parameters */
6550
6551 /* Copy result */
6552 state->orig.out.result = state->tmp.out.result;
6553
6554 /* Reset temporary structure */
6555 ZERO_STRUCT(state->tmp);
6556
6557 if (DEBUGLEVEL >= 10) {
6558 NDR_PRINT_OUT_DEBUG(spoolss_AddPort, &state->orig);
6559 }
6560
6561 tevent_req_done(req);
6562 }
6563
6564 NTSTATUS rpccli_spoolss_AddPort_recv(struct tevent_req *req,
6565 TALLOC_CTX *mem_ctx,
6566 WERROR *result)
6567 {
6568 struct rpccli_spoolss_AddPort_state *state = tevent_req_data(
6569 req, struct rpccli_spoolss_AddPort_state);
6570 NTSTATUS status;
6571
6572 if (tevent_req_is_nterror(req, &status)) {
6573 tevent_req_received(req);
6574 return status;
6575 }
6576
6577 /* Steal possbile out parameters to the callers context */
6578 talloc_steal(mem_ctx, state->out_mem_ctx);
6579
6580 /* Return result */
6581 *result = state->orig.out.result;
6582
6583 tevent_req_received(req);
6584 return NT_STATUS_OK;
6585 }
6586
6587 NTSTATUS rpccli_spoolss_AddPort(struct rpc_pipe_client *cli,
6588 TALLOC_CTX *mem_ctx,
6589 const char *server_name /* [in] [unique,charset(UTF16)] */,
6590 uint32_t unknown /* [in] */,
6591 const char *monitor_name /* [in] [charset(UTF16)] */,
6592 WERROR *werror)
6593 {
6594 struct spoolss_AddPort r;
6595 NTSTATUS status;
6596
6597 /* In parameters */
6598 r.in.server_name = server_name;
6599 r.in.unknown = unknown;
6600 r.in.monitor_name = monitor_name;
6601
6602 if (DEBUGLEVEL >= 10) {
6603 NDR_PRINT_IN_DEBUG(spoolss_AddPort, &r);
6604 }
6605
6606 status = cli->dispatch(cli,
6607 mem_ctx,
6608 &ndr_table_spoolss,
6609 NDR_SPOOLSS_ADDPORT,
6610 &r);
6611
6612 if (!NT_STATUS_IS_OK(status)) {
6613 return status;
6614 }
6615
6616 if (DEBUGLEVEL >= 10) {
6617 NDR_PRINT_OUT_DEBUG(spoolss_AddPort, &r);
6618 }
6619
6620 if (NT_STATUS_IS_ERR(status)) {
6621 return status;
6622 }
6623
6624 /* Return variables */
6625
6626 /* Return result */
6627 if (werror) {
6628 *werror = r.out.result;
6629 }
6630
6631 return werror_to_ntstatus(r.out.result);
6632 }
6633
6634 struct rpccli_spoolss_ConfigurePort_state {
6635 struct spoolss_ConfigurePort orig;
6636 struct spoolss_ConfigurePort tmp;
6637 TALLOC_CTX *out_mem_ctx;
6638 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6639 };
6640
6641 static void rpccli_spoolss_ConfigurePort_done(struct tevent_req *subreq);
6642
6643 struct tevent_req *rpccli_spoolss_ConfigurePort_send(TALLOC_CTX *mem_ctx,
6644 struct tevent_context *ev,
6645 struct rpc_pipe_client *cli)
6646 {
6647 struct tevent_req *req;
6648 struct rpccli_spoolss_ConfigurePort_state *state;
6649 struct tevent_req *subreq;
6650
6651 req = tevent_req_create(mem_ctx, &state,
6652 struct rpccli_spoolss_ConfigurePort_state);
6653 if (req == NULL) {
6654 return NULL;
6655 }
6656 state->out_mem_ctx = NULL;
6657 state->dispatch_recv = cli->dispatch_recv;
6658
6659 /* In parameters */
6660
6661 /* Out parameters */
6662
6663 /* Result */
6664 ZERO_STRUCT(state->orig.out.result);
6665
6666 if (DEBUGLEVEL >= 10) {
6667 NDR_PRINT_IN_DEBUG(spoolss_ConfigurePort, &state->orig);
6668 }
6669
6670 /* make a temporary copy, that we pass to the dispatch function */
6671 state->tmp = state->orig;
6672
6673 subreq = cli->dispatch_send(state, ev, cli,
6674 &ndr_table_spoolss,
6675 NDR_SPOOLSS_CONFIGUREPORT,
6676 &state->tmp);
6677 if (tevent_req_nomem(subreq, req)) {
6678 return tevent_req_post(req, ev);
6679 }
6680 tevent_req_set_callback(subreq, rpccli_spoolss_ConfigurePort_done, req);
6681 return req;
6682 }
6683
6684 static void rpccli_spoolss_ConfigurePort_done(struct tevent_req *subreq)
6685 {
6686 struct tevent_req *req = tevent_req_callback_data(
6687 subreq, struct tevent_req);
6688 struct rpccli_spoolss_ConfigurePort_state *state = tevent_req_data(
6689 req, struct rpccli_spoolss_ConfigurePort_state);
6690 NTSTATUS status;
6691 TALLOC_CTX *mem_ctx;
6692
6693 if (state->out_mem_ctx) {
6694 mem_ctx = state->out_mem_ctx;
6695 } else {
6696 mem_ctx = state;
6697 }
6698
6699 status = state->dispatch_recv(subreq, mem_ctx);
6700 TALLOC_FREE(subreq);
6701 if (!NT_STATUS_IS_OK(status)) {
6702 tevent_req_nterror(req, status);
6703 return;
6704 }
6705
6706 /* Copy out parameters */
6707
6708 /* Copy result */
6709 state->orig.out.result = state->tmp.out.result;
6710
6711 /* Reset temporary structure */
6712 ZERO_STRUCT(state->tmp);
6713
6714 if (DEBUGLEVEL >= 10) {
6715 NDR_PRINT_OUT_DEBUG(spoolss_ConfigurePort, &state->orig);
6716 }
6717
6718 tevent_req_done(req);
6719 }
6720
6721 NTSTATUS rpccli_spoolss_ConfigurePort_recv(struct tevent_req *req,
6722 TALLOC_CTX *mem_ctx,
6723 WERROR *result)
6724 {
6725 struct rpccli_spoolss_ConfigurePort_state *state = tevent_req_data(
6726 req, struct rpccli_spoolss_ConfigurePort_state);
6727 NTSTATUS status;
6728
6729 if (tevent_req_is_nterror(req, &status)) {
6730 tevent_req_received(req);
6731 return status;
6732 }
6733
6734 /* Steal possbile out parameters to the callers context */
6735 talloc_steal(mem_ctx, state->out_mem_ctx);
6736
6737 /* Return result */
6738 *result = state->orig.out.result;
6739
6740 tevent_req_received(req);
6741 return NT_STATUS_OK;
6742 }
6743
6744 NTSTATUS rpccli_spoolss_ConfigurePort(struct rpc_pipe_client *cli,
6745 TALLOC_CTX *mem_ctx,
6746 WERROR *werror)
6747 {
6748 struct spoolss_ConfigurePort r;
6749 NTSTATUS status;
6750
6751 /* In parameters */
6752
6753 if (DEBUGLEVEL >= 10) {
6754 NDR_PRINT_IN_DEBUG(spoolss_ConfigurePort, &r);
6755 }
6756
6757 status = cli->dispatch(cli,
6758 mem_ctx,
6759 &ndr_table_spoolss,
6760 NDR_SPOOLSS_CONFIGUREPORT,
6761 &r);
6762
6763 if (!NT_STATUS_IS_OK(status)) {
6764 return status;
6765 }
6766
6767 if (DEBUGLEVEL >= 10) {
6768 NDR_PRINT_OUT_DEBUG(spoolss_ConfigurePort, &r);
6769 }
6770
6771 if (NT_STATUS_IS_ERR(status)) {
6772 return status;
6773 }
6774
6775 /* Return variables */
6776
6777 /* Return result */
6778 if (werror) {
6779 *werror = r.out.result;
6780 }
6781
6782 return werror_to_ntstatus(r.out.result);
6783 }
6784
6785 struct rpccli_spoolss_DeletePort_state {
6786 struct spoolss_DeletePort orig;
6787 struct spoolss_DeletePort tmp;
6788 TALLOC_CTX *out_mem_ctx;
6789 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6790 };
6791
6792 static void rpccli_spoolss_DeletePort_done(struct tevent_req *subreq);
6793
6794 struct tevent_req *rpccli_spoolss_DeletePort_send(TALLOC_CTX *mem_ctx,
6795 struct tevent_context *ev,
6796 struct rpc_pipe_client *cli)
6797 {
6798 struct tevent_req *req;
6799 struct rpccli_spoolss_DeletePort_state *state;
6800 struct tevent_req *subreq;
6801
6802 req = tevent_req_create(mem_ctx, &state,
6803 struct rpccli_spoolss_DeletePort_state);
6804 if (req == NULL) {
6805 return NULL;
6806 }
6807 state->out_mem_ctx = NULL;
6808 state->dispatch_recv = cli->dispatch_recv;
6809
6810 /* In parameters */
6811
6812 /* Out parameters */
6813
6814 /* Result */
6815 ZERO_STRUCT(state->orig.out.result);
6816
6817 if (DEBUGLEVEL >= 10) {
6818 NDR_PRINT_IN_DEBUG(spoolss_DeletePort, &state->orig);
6819 }
6820
6821 /* make a temporary copy, that we pass to the dispatch function */
6822 state->tmp = state->orig;
6823
6824 subreq = cli->dispatch_send(state, ev, cli,
6825 &ndr_table_spoolss,
6826 NDR_SPOOLSS_DELETEPORT,
6827 &state->tmp);
6828 if (tevent_req_nomem(subreq, req)) {
6829 return tevent_req_post(req, ev);
6830 }
6831 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePort_done, req);
6832 return req;
6833 }
6834
6835 static void rpccli_spoolss_DeletePort_done(struct tevent_req *subreq)
6836 {
6837 struct tevent_req *req = tevent_req_callback_data(
6838 subreq, struct tevent_req);
6839 struct rpccli_spoolss_DeletePort_state *state = tevent_req_data(
6840 req, struct rpccli_spoolss_DeletePort_state);
6841 NTSTATUS status;
6842 TALLOC_CTX *mem_ctx;
6843
6844 if (state->out_mem_ctx) {
6845 mem_ctx = state->out_mem_ctx;
6846 } else {
6847 mem_ctx = state;
6848 }
6849
6850 status = state->dispatch_recv(subreq, mem_ctx);
6851 TALLOC_FREE(subreq);
6852 if (!NT_STATUS_IS_OK(status)) {
6853 tevent_req_nterror(req, status);
6854 return;
6855 }
6856
6857 /* Copy out parameters */
6858
6859 /* Copy result */
6860 state->orig.out.result = state->tmp.out.result;
6861
6862 /* Reset temporary structure */
6863 ZERO_STRUCT(state->tmp);
6864
6865 if (DEBUGLEVEL >= 10) {
6866 NDR_PRINT_OUT_DEBUG(spoolss_DeletePort, &state->orig);
6867 }
6868
6869 tevent_req_done(req);
6870 }
6871
6872 NTSTATUS rpccli_spoolss_DeletePort_recv(struct tevent_req *req,
6873 TALLOC_CTX *mem_ctx,
6874 WERROR *result)
6875 {
6876 struct rpccli_spoolss_DeletePort_state *state = tevent_req_data(
6877 req, struct rpccli_spoolss_DeletePort_state);
6878 NTSTATUS status;
6879
6880 if (tevent_req_is_nterror(req, &status)) {
6881 tevent_req_received(req);
6882 return status;
6883 }
6884
6885 /* Steal possbile out parameters to the callers context */
6886 talloc_steal(mem_ctx, state->out_mem_ctx);
6887
6888 /* Return result */
6889 *result = state->orig.out.result;
6890
6891 tevent_req_received(req);
6892 return NT_STATUS_OK;
6893 }
6894
6895 NTSTATUS rpccli_spoolss_DeletePort(struct rpc_pipe_client *cli,
6896 TALLOC_CTX *mem_ctx,
6897 WERROR *werror)
6898 {
6899 struct spoolss_DeletePort r;
6900 NTSTATUS status;
6901
6902 /* In parameters */
6903
6904 if (DEBUGLEVEL >= 10) {
6905 NDR_PRINT_IN_DEBUG(spoolss_DeletePort, &r);
6906 }
6907
6908 status = cli->dispatch(cli,
6909 mem_ctx,
6910 &ndr_table_spoolss,
6911 NDR_SPOOLSS_DELETEPORT,
6912 &r);
6913
6914 if (!NT_STATUS_IS_OK(status)) {
6915 return status;
6916 }
6917
6918 if (DEBUGLEVEL >= 10) {
6919 NDR_PRINT_OUT_DEBUG(spoolss_DeletePort, &r);
6920 }
6921
6922 if (NT_STATUS_IS_ERR(status)) {
6923 return status;
6924 }
6925
6926 /* Return variables */
6927
6928 /* Return result */
6929 if (werror) {
6930 *werror = r.out.result;
6931 }
6932
6933 return werror_to_ntstatus(r.out.result);
6934 }
6935
6936 struct rpccli_spoolss_CreatePrinterIC_state {
6937 struct spoolss_CreatePrinterIC orig;
6938 struct spoolss_CreatePrinterIC tmp;
6939 TALLOC_CTX *out_mem_ctx;
6940 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6941 };
6942
6943 static void rpccli_spoolss_CreatePrinterIC_done(struct tevent_req *subreq);
6944
6945 struct tevent_req *rpccli_spoolss_CreatePrinterIC_send(TALLOC_CTX *mem_ctx,
6946 struct tevent_context *ev,
6947 struct rpc_pipe_client *cli,
6948 struct policy_handle *_handle /* [in] [ref] */,
6949 struct policy_handle *_gdi_handle /* [out] [ref] */,
6950 struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */)
6951 {
6952 struct tevent_req *req;
6953 struct rpccli_spoolss_CreatePrinterIC_state *state;
6954 struct tevent_req *subreq;
6955
6956 req = tevent_req_create(mem_ctx, &state,
6957 struct rpccli_spoolss_CreatePrinterIC_state);
6958 if (req == NULL) {
6959 return NULL;
6960 }
6961 state->out_mem_ctx = NULL;
6962 state->dispatch_recv = cli->dispatch_recv;
6963
6964 /* In parameters */
6965 state->orig.in.handle = _handle;
6966 state->orig.in.devmode_ctr = _devmode_ctr;
6967
6968 /* Out parameters */
6969 state->orig.out.gdi_handle = _gdi_handle;
6970
6971 /* Result */
6972 ZERO_STRUCT(state->orig.out.result);
6973
6974 if (DEBUGLEVEL >= 10) {
6975 NDR_PRINT_IN_DEBUG(spoolss_CreatePrinterIC, &state->orig);
6976 }
6977
6978 state->out_mem_ctx = talloc_named_const(state, 0,
6979 "rpccli_spoolss_CreatePrinterIC_out_memory");
6980 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6981 return tevent_req_post(req, ev);
6982 }
6983
6984 /* make a temporary copy, that we pass to the dispatch function */
6985 state->tmp = state->orig;
6986
6987 subreq = cli->dispatch_send(state, ev, cli,
6988 &ndr_table_spoolss,
6989 NDR_SPOOLSS_CREATEPRINTERIC,
6990 &state->tmp);
6991 if (tevent_req_nomem(subreq, req)) {
6992 return tevent_req_post(req, ev);
6993 }
6994 tevent_req_set_callback(subreq, rpccli_spoolss_CreatePrinterIC_done, req);
6995 return req;
6996 }
6997
6998 static void rpccli_spoolss_CreatePrinterIC_done(struct tevent_req *subreq)
6999 {
7000 struct tevent_req *req = tevent_req_callback_data(
7001 subreq, struct tevent_req);
7002 struct rpccli_spoolss_CreatePrinterIC_state *state = tevent_req_data(
7003 req, struct rpccli_spoolss_CreatePrinterIC_state);
7004 NTSTATUS status;
7005 TALLOC_CTX *mem_ctx;
7006
7007 if (state->out_mem_ctx) {
7008 mem_ctx = state->out_mem_ctx;
7009 } else {
7010 mem_ctx = state;
7011 }
7012
7013 status = state->dispatch_recv(subreq, mem_ctx);
7014 TALLOC_FREE(subreq);
7015 if (!NT_STATUS_IS_OK(status)) {
7016 tevent_req_nterror(req, status);
7017 return;
7018 }
7019
7020 /* Copy out parameters */
7021 *state->orig.out.gdi_handle = *state->tmp.out.gdi_handle;
7022
7023 /* Copy result */
7024 state->orig.out.result = state->tmp.out.result;
7025
7026 /* Reset temporary structure */
7027 ZERO_STRUCT(state->tmp);
7028
7029 if (DEBUGLEVEL >= 10) {
7030 NDR_PRINT_OUT_DEBUG(spoolss_CreatePrinterIC, &state->orig);
7031 }
7032
7033 tevent_req_done(req);
7034 }
7035
7036 NTSTATUS rpccli_spoolss_CreatePrinterIC_recv(struct tevent_req *req,
7037 TALLOC_CTX *mem_ctx,
7038 WERROR *result)
7039 {
7040 struct rpccli_spoolss_CreatePrinterIC_state *state = tevent_req_data(
7041 req, struct rpccli_spoolss_CreatePrinterIC_state);
7042 NTSTATUS status;
7043
7044 if (tevent_req_is_nterror(req, &status)) {
7045 tevent_req_received(req);
7046 return status;
7047 }
7048
7049 /* Steal possbile out parameters to the callers context */
7050 talloc_steal(mem_ctx, state->out_mem_ctx);
7051
7052 /* Return result */
7053 *result = state->orig.out.result;
7054
7055 tevent_req_received(req);
7056 return NT_STATUS_OK;
7057 }
7058
7059 NTSTATUS rpccli_spoolss_CreatePrinterIC(struct rpc_pipe_client *cli,
7060 TALLOC_CTX *mem_ctx,
7061 struct policy_handle *handle /* [in] [ref] */,
7062 struct policy_handle *gdi_handle /* [out] [ref] */,
7063 struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
7064 WERROR *werror)
7065 {
7066 struct spoolss_CreatePrinterIC r;
7067 NTSTATUS status;
7068
7069 /* In parameters */
7070 r.in.handle = handle;
7071 r.in.devmode_ctr = devmode_ctr;
7072
7073 if (DEBUGLEVEL >= 10) {
7074 NDR_PRINT_IN_DEBUG(spoolss_CreatePrinterIC, &r);
7075 }
7076
7077 status = cli->dispatch(cli,
7078 mem_ctx,
7079 &ndr_table_spoolss,
7080 NDR_SPOOLSS_CREATEPRINTERIC,
7081 &r);
7082
7083 if (!NT_STATUS_IS_OK(status)) {
7084 return status;
7085 }
7086
7087 if (DEBUGLEVEL >= 10) {
7088 NDR_PRINT_OUT_DEBUG(spoolss_CreatePrinterIC, &r);
7089 }
7090
7091 if (NT_STATUS_IS_ERR(status)) {
7092 return status;
7093 }
7094
7095 /* Return variables */
7096 *gdi_handle = *r.out.gdi_handle;
7097
7098 /* Return result */
7099 if (werror) {
7100 *werror = r.out.result;
7101 }
7102
7103 return werror_to_ntstatus(r.out.result);
7104 }
7105
7106 struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state {
7107 struct spoolss_PlayGDIScriptOnPrinterIC orig;
7108 struct spoolss_PlayGDIScriptOnPrinterIC tmp;
7109 TALLOC_CTX *out_mem_ctx;
7110 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7111 };
7112
7113 static void rpccli_spoolss_PlayGDIScriptOnPrinterIC_done(struct tevent_req *subreq);
7114
7115 struct tevent_req *rpccli_spoolss_PlayGDIScriptOnPrinterIC_send(TALLOC_CTX *mem_ctx,
7116 struct tevent_context *ev,
7117 struct rpc_pipe_client *cli)
7118 {
7119 struct tevent_req *req;
7120 struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state *state;
7121 struct tevent_req *subreq;
7122
7123 req = tevent_req_create(mem_ctx, &state,
7124 struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state);
7125 if (req == NULL) {
7126 return NULL;
7127 }
7128 state->out_mem_ctx = NULL;
7129 state->dispatch_recv = cli->dispatch_recv;
7130
7131 /* In parameters */
7132
7133 /* Out parameters */
7134
7135 /* Result */
7136 ZERO_STRUCT(state->orig.out.result);
7137
7138 if (DEBUGLEVEL >= 10) {
7139 NDR_PRINT_IN_DEBUG(spoolss_PlayGDIScriptOnPrinterIC, &state->orig);
7140 }
7141
7142 /* make a temporary copy, that we pass to the dispatch function */
7143 state->tmp = state->orig;
7144
7145 subreq = cli->dispatch_send(state, ev, cli,
7146 &ndr_table_spoolss,
7147 NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC,
7148 &state->tmp);
7149 if (tevent_req_nomem(subreq, req)) {
7150 return tevent_req_post(req, ev);
7151 }
7152 tevent_req_set_callback(subreq, rpccli_spoolss_PlayGDIScriptOnPrinterIC_done, req);
7153 return req;
7154 }
7155
7156 static void rpccli_spoolss_PlayGDIScriptOnPrinterIC_done(struct tevent_req *subreq)
7157 {
7158 struct tevent_req *req = tevent_req_callback_data(
7159 subreq, struct tevent_req);
7160 struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state *state = tevent_req_data(
7161 req, struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state);
7162 NTSTATUS status;
7163 TALLOC_CTX *mem_ctx;
7164
7165 if (state->out_mem_ctx) {
7166 mem_ctx = state->out_mem_ctx;
7167 } else {
7168 mem_ctx = state;
7169 }
7170
7171 status = state->dispatch_recv(subreq, mem_ctx);
7172 TALLOC_FREE(subreq);
7173 if (!NT_STATUS_IS_OK(status)) {
7174 tevent_req_nterror(req, status);
7175 return;
7176 }
7177
7178 /* Copy out parameters */
7179
7180 /* Copy result */
7181 state->orig.out.result = state->tmp.out.result;
7182
7183 /* Reset temporary structure */
7184 ZERO_STRUCT(state->tmp);
7185
7186 if (DEBUGLEVEL >= 10) {
7187 NDR_PRINT_OUT_DEBUG(spoolss_PlayGDIScriptOnPrinterIC, &state->orig);
7188 }
7189
7190 tevent_req_done(req);
7191 }
7192
7193 NTSTATUS rpccli_spoolss_PlayGDIScriptOnPrinterIC_recv(struct tevent_req *req,
7194 TALLOC_CTX *mem_ctx,
7195 WERROR *result)
7196 {
7197 struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state *state = tevent_req_data(
7198 req, struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state);
7199 NTSTATUS status;
7200
7201 if (tevent_req_is_nterror(req, &status)) {
7202 tevent_req_received(req);
7203 return status;
7204 }
7205
7206 /* Steal possbile out parameters to the callers context */
7207 talloc_steal(mem_ctx, state->out_mem_ctx);
7208
7209 /* Return result */
7210 *result = state->orig.out.result;
7211
7212 tevent_req_received(req);
7213 return NT_STATUS_OK;
7214 }
7215
7216 NTSTATUS rpccli_spoolss_PlayGDIScriptOnPrinterIC(struct rpc_pipe_client *cli,
7217 TALLOC_CTX *mem_ctx,
7218 WERROR *werror)
7219 {
7220 struct spoolss_PlayGDIScriptOnPrinterIC r;
7221 NTSTATUS status;
7222
7223 /* In parameters */
7224
7225 if (DEBUGLEVEL >= 10) {
7226 NDR_PRINT_IN_DEBUG(spoolss_PlayGDIScriptOnPrinterIC, &r);
7227 }
7228
7229 status = cli->dispatch(cli,
7230 mem_ctx,
7231 &ndr_table_spoolss,
7232 NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC,
7233 &r);
7234
7235 if (!NT_STATUS_IS_OK(status)) {
7236 return status;
7237 }
7238
7239 if (DEBUGLEVEL >= 10) {
7240 NDR_PRINT_OUT_DEBUG(spoolss_PlayGDIScriptOnPrinterIC, &r);
7241 }
7242
7243 if (NT_STATUS_IS_ERR(status)) {
7244 return status;
7245 }
7246
7247 /* Return variables */
7248
7249 /* Return result */
7250 if (werror) {
7251 *werror = r.out.result;
7252 }
7253
7254 return werror_to_ntstatus(r.out.result);
7255 }
7256
7257 struct rpccli_spoolss_DeletePrinterIC_state {
7258 struct spoolss_DeletePrinterIC orig;
7259 struct spoolss_DeletePrinterIC tmp;
7260 TALLOC_CTX *out_mem_ctx;
7261 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7262 };
7263
7264 static void rpccli_spoolss_DeletePrinterIC_done(struct tevent_req *subreq);
7265
7266 struct tevent_req *rpccli_spoolss_DeletePrinterIC_send(TALLOC_CTX *mem_ctx,
7267 struct tevent_context *ev,
7268 struct rpc_pipe_client *cli,
7269 struct policy_handle *_gdi_handle /* [in,out] [ref] */)
7270 {
7271 struct tevent_req *req;
7272 struct rpccli_spoolss_DeletePrinterIC_state *state;
7273 struct tevent_req *subreq;
7274
7275 req = tevent_req_create(mem_ctx, &state,
7276 struct rpccli_spoolss_DeletePrinterIC_state);
7277 if (req == NULL) {
7278 return NULL;
7279 }
7280 state->out_mem_ctx = NULL;
7281 state->dispatch_recv = cli->dispatch_recv;
7282
7283 /* In parameters */
7284 state->orig.in.gdi_handle = _gdi_handle;
7285
7286 /* Out parameters */
7287 state->orig.out.gdi_handle = _gdi_handle;
7288
7289 /* Result */
7290 ZERO_STRUCT(state->orig.out.result);
7291
7292 if (DEBUGLEVEL >= 10) {
7293 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterIC, &state->orig);
7294 }
7295
7296 state->out_mem_ctx = talloc_named_const(state, 0,
7297 "rpccli_spoolss_DeletePrinterIC_out_memory");
7298 if (tevent_req_nomem(state->out_mem_ctx, req)) {
7299 return tevent_req_post(req, ev);
7300 }
7301
7302 /* make a temporary copy, that we pass to the dispatch function */
7303 state->tmp = state->orig;
7304
7305 subreq = cli->dispatch_send(state, ev, cli,
7306 &ndr_table_spoolss,
7307 NDR_SPOOLSS_DELETEPRINTERIC,
7308 &state->tmp);
7309 if (tevent_req_nomem(subreq, req)) {
7310 return tevent_req_post(req, ev);
7311 }
7312 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterIC_done, req);
7313 return req;
7314 }
7315
7316 static void rpccli_spoolss_DeletePrinterIC_done(struct tevent_req *subreq)
7317 {
7318 struct tevent_req *req = tevent_req_callback_data(
7319 subreq, struct tevent_req);
7320 struct rpccli_spoolss_DeletePrinterIC_state *state = tevent_req_data(
7321 req, struct rpccli_spoolss_DeletePrinterIC_state);
7322 NTSTATUS status;
7323 TALLOC_CTX *mem_ctx;
7324
7325 if (state->out_mem_ctx) {
7326 mem_ctx = state->out_mem_ctx;
7327 } else {
7328 mem_ctx = state;
7329 }
7330
7331 status = state->dispatch_recv(subreq, mem_ctx);
7332 TALLOC_FREE(subreq);
7333 if (!NT_STATUS_IS_OK(status)) {
7334 tevent_req_nterror(req, status);
7335 return;
7336 }
7337
7338 /* Copy out parameters */
7339 *state->orig.out.gdi_handle = *state->tmp.out.gdi_handle;
7340
7341 /* Copy result */
7342 state->orig.out.result = state->tmp.out.result;
7343
7344 /* Reset temporary structure */
7345 ZERO_STRUCT(state->tmp);
7346
7347 if (DEBUGLEVEL >= 10) {
7348 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterIC, &state->orig);
7349 }
7350
7351 tevent_req_done(req);
7352 }
7353
7354 NTSTATUS rpccli_spoolss_DeletePrinterIC_recv(struct tevent_req *req,
7355 TALLOC_CTX *mem_ctx,
7356 WERROR *result)
7357 {
7358 struct rpccli_spoolss_DeletePrinterIC_state *state = tevent_req_data(
7359 req, struct rpccli_spoolss_DeletePrinterIC_state);
7360 NTSTATUS status;
7361
7362 if (tevent_req_is_nterror(req, &status)) {
7363 tevent_req_received(req);
7364 return status;
7365 }
7366
7367 /* Steal possbile out parameters to the callers context */
7368 talloc_steal(mem_ctx, state->out_mem_ctx);
7369
7370 /* Return result */
7371 *result = state->orig.out.result;
7372
7373 tevent_req_received(req);
7374 return NT_STATUS_OK;
7375 }
7376
7377 NTSTATUS rpccli_spoolss_DeletePrinterIC(struct rpc_pipe_client *cli,
7378 TALLOC_CTX *mem_ctx,
7379 struct policy_handle *gdi_handle /* [in,out] [ref] */,
7380 WERROR *werror)
7381 {
7382 struct spoolss_DeletePrinterIC r;
7383 NTSTATUS status;
7384
7385 /* In parameters */
7386 r.in.gdi_handle = gdi_handle;
7387
7388 if (DEBUGLEVEL >= 10) {
7389 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterIC, &r);
7390 }
7391
7392 status = cli->dispatch(cli,
7393 mem_ctx,
7394 &ndr_table_spoolss,
7395 NDR_SPOOLSS_DELETEPRINTERIC,
7396 &r);
7397
7398 if (!NT_STATUS_IS_OK(status)) {
7399 return status;
7400 }
7401
7402 if (DEBUGLEVEL >= 10) {
7403 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterIC, &r);
7404 }
7405
7406 if (NT_STATUS_IS_ERR(status)) {
7407 return status;
7408 }
7409
7410 /* Return variables */
7411 *gdi_handle = *r.out.gdi_handle;
7412
7413 /* Return result */
7414 if (werror) {
7415 *werror = r.out.result;
7416 }
7417
7418 return werror_to_ntstatus(r.out.result);
7419 }
7420
7421 struct rpccli_spoolss_AddPrinterConnection_state {
7422 struct spoolss_AddPrinterConnection orig;
7423 struct spoolss_AddPrinterConnection tmp;
7424 TALLOC_CTX *out_mem_ctx;
7425 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7426 };
7427
7428 static void rpccli_spoolss_AddPrinterConnection_done(struct tevent_req *subreq);
7429
7430 struct tevent_req *rpccli_spoolss_AddPrinterConnection_send(TALLOC_CTX *mem_ctx,
7431 struct tevent_context *ev,
7432 struct rpc_pipe_client *cli)
7433 {
7434 struct tevent_req *req;
7435 struct rpccli_spoolss_AddPrinterConnection_state *state;
7436 struct tevent_req *subreq;
7437
7438 req = tevent_req_create(mem_ctx, &state,
7439 struct rpccli_spoolss_AddPrinterConnection_state);
7440 if (req == NULL) {
7441 return NULL;
7442 }
7443 state->out_mem_ctx = NULL;
7444 state->dispatch_recv = cli->dispatch_recv;
7445
7446 /* In parameters */
7447
7448 /* Out parameters */
7449
7450 /* Result */
7451 ZERO_STRUCT(state->orig.out.result);
7452
7453 if (DEBUGLEVEL >= 10) {
7454 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterConnection, &state->orig);
7455 }
7456
7457 /* make a temporary copy, that we pass to the dispatch function */
7458 state->tmp = state->orig;
7459
7460 subreq = cli->dispatch_send(state, ev, cli,
7461 &ndr_table_spoolss,
7462 NDR_SPOOLSS_ADDPRINTERCONNECTION,
7463 &state->tmp);
7464 if (tevent_req_nomem(subreq, req)) {
7465 return tevent_req_post(req, ev);
7466 }
7467 tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterConnection_done, req);
7468 return req;
7469 }
7470
7471 static void rpccli_spoolss_AddPrinterConnection_done(struct tevent_req *subreq)
7472 {
7473 struct tevent_req *req = tevent_req_callback_data(
7474 subreq, struct tevent_req);
7475 struct rpccli_spoolss_AddPrinterConnection_state *state = tevent_req_data(
7476 req, struct rpccli_spoolss_AddPrinterConnection_state);
7477 NTSTATUS status;
7478 TALLOC_CTX *mem_ctx;
7479
7480 if (state->out_mem_ctx) {
7481 mem_ctx = state->out_mem_ctx;
7482 } else {
7483 mem_ctx = state;
7484 }
7485
7486 status = state->dispatch_recv(subreq, mem_ctx);
7487 TALLOC_FREE(subreq);
7488 if (!NT_STATUS_IS_OK(status)) {
7489 tevent_req_nterror(req, status);
7490 return;
7491 }
7492
7493 /* Copy out parameters */
7494
7495 /* Copy result */
7496 state->orig.out.result = state->tmp.out.result;
7497
7498 /* Reset temporary structure */
7499 ZERO_STRUCT(state->tmp);
7500
7501 if (DEBUGLEVEL >= 10) {
7502 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterConnection, &state->orig);
7503 }
7504
7505 tevent_req_done(req);
7506 }
7507
7508 NTSTATUS rpccli_spoolss_AddPrinterConnection_recv(struct tevent_req *req,
7509 TALLOC_CTX *mem_ctx,
7510 WERROR *result)
7511 {
7512 struct rpccli_spoolss_AddPrinterConnection_state *state = tevent_req_data(
7513 req, struct rpccli_spoolss_AddPrinterConnection_state);
7514 NTSTATUS status;
7515
7516 if (tevent_req_is_nterror(req, &status)) {
7517 tevent_req_received(req);
7518 return status;
7519 }
7520
7521 /* Steal possbile out parameters to the callers context */
7522 talloc_steal(mem_ctx, state->out_mem_ctx);
7523
7524 /* Return result */
7525 *result = state->orig.out.result;
7526
7527 tevent_req_received(req);
7528 return NT_STATUS_OK;
7529 }
7530
7531 NTSTATUS rpccli_spoolss_AddPrinterConnection(struct rpc_pipe_client *cli,
7532 TALLOC_CTX *mem_ctx,
7533 WERROR *werror)
7534 {
7535 struct spoolss_AddPrinterConnection r;
7536 NTSTATUS status;
7537
7538 /* In parameters */
7539
7540 if (DEBUGLEVEL >= 10) {
7541 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterConnection, &r);
7542 }
7543
7544 status = cli->dispatch(cli,
7545 mem_ctx,
7546 &ndr_table_spoolss,
7547 NDR_SPOOLSS_ADDPRINTERCONNECTION,
7548 &r);
7549
7550 if (!NT_STATUS_IS_OK(status)) {
7551 return status;
7552 }
7553
7554 if (DEBUGLEVEL >= 10) {
7555 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterConnection, &r);
7556 }
7557
7558 if (NT_STATUS_IS_ERR(status)) {
7559 return status;
7560 }
7561
7562 /* Return variables */
7563
7564 /* Return result */
7565 if (werror) {
7566 *werror = r.out.result;
7567 }
7568
7569 return werror_to_ntstatus(r.out.result);
7570 }
7571
7572 struct rpccli_spoolss_DeletePrinterConnection_state {
7573 struct spoolss_DeletePrinterConnection orig;
7574 struct spoolss_DeletePrinterConnection tmp;
7575 TALLOC_CTX *out_mem_ctx;
7576 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7577 };
7578
7579 static void rpccli_spoolss_DeletePrinterConnection_done(struct tevent_req *subreq);
7580
7581 struct tevent_req *rpccli_spoolss_DeletePrinterConnection_send(TALLOC_CTX *mem_ctx,
7582 struct tevent_context *ev,
7583 struct rpc_pipe_client *cli)
7584 {
7585 struct tevent_req *req;
7586 struct rpccli_spoolss_DeletePrinterConnection_state *state;
7587 struct tevent_req *subreq;
7588
7589 req = tevent_req_create(mem_ctx, &state,
7590 struct rpccli_spoolss_DeletePrinterConnection_state);
7591 if (req == NULL) {
7592 return NULL;
7593 }
7594 state->out_mem_ctx = NULL;
7595 state->dispatch_recv = cli->dispatch_recv;
7596
7597 /* In parameters */
7598
7599 /* Out parameters */
7600
7601 /* Result */
7602 ZERO_STRUCT(state->orig.out.result);
7603
7604 if (DEBUGLEVEL >= 10) {
7605 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterConnection, &state->orig);
7606 }
7607
7608 /* make a temporary copy, that we pass to the dispatch function */
7609 state->tmp = state->orig;
7610
7611 subreq = cli->dispatch_send(state, ev, cli,
7612 &ndr_table_spoolss,
7613 NDR_SPOOLSS_DELETEPRINTERCONNECTION,
7614 &state->tmp);
7615 if (tevent_req_nomem(subreq, req)) {
7616 return tevent_req_post(req, ev);
7617 }
7618 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterConnection_done, req);
7619 return req;
7620 }
7621
7622 static void rpccli_spoolss_DeletePrinterConnection_done(struct tevent_req *subreq)
7623 {
7624 struct tevent_req *req = tevent_req_callback_data(
7625 subreq, struct tevent_req);
7626 struct rpccli_spoolss_DeletePrinterConnection_state *state = tevent_req_data(
7627 req, struct rpccli_spoolss_DeletePrinterConnection_state);
7628 NTSTATUS status;
7629 TALLOC_CTX *mem_ctx;
7630
7631 if (state->out_mem_ctx) {
7632 mem_ctx = state->out_mem_ctx;
7633 } else {
7634 mem_ctx = state;
7635 }
7636
7637 status = state->dispatch_recv(subreq, mem_ctx);
7638 TALLOC_FREE(subreq);
7639 if (!NT_STATUS_IS_OK(status)) {
7640 tevent_req_nterror(req, status);
7641 return;
7642 }
7643
7644 /* Copy out parameters */
7645
7646 /* Copy result */
7647 state->orig.out.result = state->tmp.out.result;
7648
7649 /* Reset temporary structure */
7650 ZERO_STRUCT(state->tmp);
7651
7652 if (DEBUGLEVEL >= 10) {
7653 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterConnection, &state->orig);
7654 }
7655
7656 tevent_req_done(req);
7657 }
7658
7659 NTSTATUS rpccli_spoolss_DeletePrinterConnection_recv(struct tevent_req *req,
7660 TALLOC_CTX *mem_ctx,
7661 WERROR *result)
7662 {
7663 struct rpccli_spoolss_DeletePrinterConnection_state *state = tevent_req_data(
7664 req, struct rpccli_spoolss_DeletePrinterConnection_state);
7665 NTSTATUS status;
7666
7667 if (tevent_req_is_nterror(req, &status)) {
7668 tevent_req_received(req);
7669 return status;
7670 }
7671
7672 /* Steal possbile out parameters to the callers context */
7673 talloc_steal(mem_ctx, state->out_mem_ctx);
7674
7675 /* Return result */
7676 *result = state->orig.out.result;
7677
7678 tevent_req_received(req);
7679 return NT_STATUS_OK;
7680 }
7681
7682 NTSTATUS rpccli_spoolss_DeletePrinterConnection(struct rpc_pipe_client *cli,
7683 TALLOC_CTX *mem_ctx,
7684 WERROR *werror)
7685 {
7686 struct spoolss_DeletePrinterConnection r;
7687 NTSTATUS status;
7688
7689 /* In parameters */
7690
7691 if (DEBUGLEVEL >= 10) {
7692 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterConnection, &r);
7693 }
7694
7695 status = cli->dispatch(cli,
7696 mem_ctx,
7697 &ndr_table_spoolss,
7698 NDR_SPOOLSS_DELETEPRINTERCONNECTION,
7699 &r);
7700
7701 if (!NT_STATUS_IS_OK(status)) {
7702 return status;
7703 }
7704
7705 if (DEBUGLEVEL >= 10) {
7706 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterConnection, &r);
7707 }
7708
7709 if (NT_STATUS_IS_ERR(status)) {
7710 return status;
7711 }
7712
7713 /* Return variables */
7714
7715 /* Return result */
7716 if (werror) {
7717 *werror = r.out.result;
7718 }
7719
7720 return werror_to_ntstatus(r.out.result);
7721 }
7722
7723 struct rpccli_spoolss_PrinterMessageBox_state {
7724 struct spoolss_PrinterMessageBox orig;
7725 struct spoolss_PrinterMessageBox tmp;
7726 TALLOC_CTX *out_mem_ctx;
7727 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7728 };
7729
7730 static void rpccli_spoolss_PrinterMessageBox_done(struct tevent_req *subreq);
7731
7732 struct tevent_req *rpccli_spoolss_PrinterMessageBox_send(TALLOC_CTX *mem_ctx,
7733 struct tevent_context *ev,
7734 struct rpc_pipe_client *cli)
7735 {
7736 struct tevent_req *req;
7737 struct rpccli_spoolss_PrinterMessageBox_state *state;
7738 struct tevent_req *subreq;
7739
7740 req = tevent_req_create(mem_ctx, &state,
7741 struct rpccli_spoolss_PrinterMessageBox_state);
7742 if (req == NULL) {
7743 return NULL;
7744 }
7745 state->out_mem_ctx = NULL;
7746 state->dispatch_recv = cli->dispatch_recv;
7747
7748 /* In parameters */
7749
7750 /* Out parameters */
7751
7752 /* Result */
7753 ZERO_STRUCT(state->orig.out.result);
7754
7755 if (DEBUGLEVEL >= 10) {
7756 NDR_PRINT_IN_DEBUG(spoolss_PrinterMessageBox, &state->orig);
7757 }
7758
7759 /* make a temporary copy, that we pass to the dispatch function */
7760 state->tmp = state->orig;
7761
7762 subreq = cli->dispatch_send(state, ev, cli,
7763 &ndr_table_spoolss,
7764 NDR_SPOOLSS_PRINTERMESSAGEBOX,
7765 &state->tmp);
7766 if (tevent_req_nomem(subreq, req)) {
7767 return tevent_req_post(req, ev);
7768 }
7769 tevent_req_set_callback(subreq, rpccli_spoolss_PrinterMessageBox_done, req);
7770 return req;
7771 }
7772
7773 static void rpccli_spoolss_PrinterMessageBox_done(struct tevent_req *subreq)
7774 {
7775 struct tevent_req *req = tevent_req_callback_data(
7776 subreq, struct tevent_req);
7777 struct rpccli_spoolss_PrinterMessageBox_state *state = tevent_req_data(
7778 req, struct rpccli_spoolss_PrinterMessageBox_state);
7779 NTSTATUS status;
7780 TALLOC_CTX *mem_ctx;
7781
7782 if (state->out_mem_ctx) {
7783 mem_ctx = state->out_mem_ctx;
7784 } else {
7785 mem_ctx = state;
7786 }
7787
7788 status = state->dispatch_recv(subreq, mem_ctx);
7789 TALLOC_FREE(subreq);
7790 if (!NT_STATUS_IS_OK(status)) {
7791 tevent_req_nterror(req, status);
7792 return;
7793 }
7794
7795 /* Copy out parameters */
7796
7797 /* Copy result */
7798 state->orig.out.result = state->tmp.out.result;
7799
7800 /* Reset temporary structure */
7801 ZERO_STRUCT(state->tmp);
7802
7803 if (DEBUGLEVEL >= 10) {
7804 NDR_PRINT_OUT_DEBUG(spoolss_PrinterMessageBox, &state->orig);
7805 }
7806
7807 tevent_req_done(req);
7808 }
7809
7810 NTSTATUS rpccli_spoolss_PrinterMessageBox_recv(struct tevent_req *req,
7811 TALLOC_CTX *mem_ctx,
7812 WERROR *result)
7813 {
7814 struct rpccli_spoolss_PrinterMessageBox_state *state = tevent_req_data(
7815 req, struct rpccli_spoolss_PrinterMessageBox_state);
7816 NTSTATUS status;
7817
7818 if (tevent_req_is_nterror(req, &status)) {
7819 tevent_req_received(req);
7820 return status;
7821 }
7822
7823 /* Steal possbile out parameters to the callers context */
7824 talloc_steal(mem_ctx, state->out_mem_ctx);
7825
7826 /* Return result */
7827 *result = state->orig.out.result;
7828
7829 tevent_req_received(req);
7830 return NT_STATUS_OK;
7831 }
7832
7833 NTSTATUS rpccli_spoolss_PrinterMessageBox(struct rpc_pipe_client *cli,
7834 TALLOC_CTX *mem_ctx,
7835 WERROR *werror)
7836 {
7837 struct spoolss_PrinterMessageBox r;
7838 NTSTATUS status;
7839
7840 /* In parameters */
7841
7842 if (DEBUGLEVEL >= 10) {
7843 NDR_PRINT_IN_DEBUG(spoolss_PrinterMessageBox, &r);
7844 }
7845
7846 status = cli->dispatch(cli,
7847 mem_ctx,
7848 &ndr_table_spoolss,
7849 NDR_SPOOLSS_PRINTERMESSAGEBOX,
7850 &r);
7851
7852 if (!NT_STATUS_IS_OK(status)) {
7853 return status;
7854 }
7855
7856 if (DEBUGLEVEL >= 10) {
7857 NDR_PRINT_OUT_DEBUG(spoolss_PrinterMessageBox, &r);
7858 }
7859
7860 if (NT_STATUS_IS_ERR(status)) {
7861 return status;
7862 }
7863
7864 /* Return variables */
7865
7866 /* Return result */
7867 if (werror) {
7868 *werror = r.out.result;
7869 }
7870
7871 return werror_to_ntstatus(r.out.result);
7872 }
7873
7874 struct rpccli_spoolss_AddMonitor_state {
7875 struct spoolss_AddMonitor orig;
7876 struct spoolss_AddMonitor tmp;
7877 TALLOC_CTX *out_mem_ctx;
7878 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7879 };
7880
7881 static void rpccli_spoolss_AddMonitor_done(struct tevent_req *subreq);
7882
7883 struct tevent_req *rpccli_spoolss_AddMonitor_send(TALLOC_CTX *mem_ctx,
7884 struct tevent_context *ev,
7885 struct rpc_pipe_client *cli)
7886 {
7887 struct tevent_req *req;
7888 struct rpccli_spoolss_AddMonitor_state *state;
7889 struct tevent_req *subreq;
7890
7891 req = tevent_req_create(mem_ctx, &state,
7892 struct rpccli_spoolss_AddMonitor_state);
7893 if (req == NULL) {
7894 return NULL;
7895 }
7896 state->out_mem_ctx = NULL;
7897 state->dispatch_recv = cli->dispatch_recv;
7898
7899 /* In parameters */
7900
7901 /* Out parameters */
7902
7903 /* Result */
7904 ZERO_STRUCT(state->orig.out.result);
7905
7906 if (DEBUGLEVEL >= 10) {
7907 NDR_PRINT_IN_DEBUG(spoolss_AddMonitor, &state->orig);
7908 }
7909
7910 /* make a temporary copy, that we pass to the dispatch function */
7911 state->tmp = state->orig;
7912
7913 subreq = cli->dispatch_send(state, ev, cli,
7914 &ndr_table_spoolss,
7915 NDR_SPOOLSS_ADDMONITOR,
7916 &state->tmp);
7917 if (tevent_req_nomem(subreq, req)) {
7918 return tevent_req_post(req, ev);
7919 }
7920 tevent_req_set_callback(subreq, rpccli_spoolss_AddMonitor_done, req);
7921 return req;
7922 }
7923
7924 static void rpccli_spoolss_AddMonitor_done(struct tevent_req *subreq)
7925 {
7926 struct tevent_req *req = tevent_req_callback_data(
7927 subreq, struct tevent_req);
7928 struct rpccli_spoolss_AddMonitor_state *state = tevent_req_data(
7929 req, struct rpccli_spoolss_AddMonitor_state);
7930 NTSTATUS status;
7931 TALLOC_CTX *mem_ctx;
7932
7933 if (state->out_mem_ctx) {
7934 mem_ctx = state->out_mem_ctx;
7935 } else {
7936 mem_ctx = state;
7937 }
7938
7939 status = state->dispatch_recv(subreq, mem_ctx);
7940 TALLOC_FREE(subreq);
7941 if (!NT_STATUS_IS_OK(status)) {
7942 tevent_req_nterror(req, status);
7943 return;
7944 }
7945
7946 /* Copy out parameters */
7947
7948 /* Copy result */
7949 state->orig.out.result = state->tmp.out.result;
7950
7951 /* Reset temporary structure */
7952 ZERO_STRUCT(state->tmp);
7953
7954 if (DEBUGLEVEL >= 10) {
7955 NDR_PRINT_OUT_DEBUG(spoolss_AddMonitor, &state->orig);
7956 }
7957
7958 tevent_req_done(req);
7959 }
7960
7961 NTSTATUS rpccli_spoolss_AddMonitor_recv(struct tevent_req *req,
7962 TALLOC_CTX *mem_ctx,
7963 WERROR *result)
7964 {
7965 struct rpccli_spoolss_AddMonitor_state *state = tevent_req_data(
7966 req, struct rpccli_spoolss_AddMonitor_state);
7967 NTSTATUS status;
7968
7969 if (tevent_req_is_nterror(req, &status)) {
7970 tevent_req_received(req);
7971 return status;
7972 }
7973
7974 /* Steal possbile out parameters to the callers context */
7975 talloc_steal(mem_ctx, state->out_mem_ctx);
7976
7977 /* Return result */
7978 *result = state->orig.out.result;
7979
7980 tevent_req_received(req);
7981 return NT_STATUS_OK;
7982 }
7983
7984 NTSTATUS rpccli_spoolss_AddMonitor(struct rpc_pipe_client *cli,
7985 TALLOC_CTX *mem_ctx,
7986 WERROR *werror)
7987 {
7988 struct spoolss_AddMonitor r;
7989 NTSTATUS status;
7990
7991 /* In parameters */
7992
7993 if (DEBUGLEVEL >= 10) {
7994 NDR_PRINT_IN_DEBUG(spoolss_AddMonitor, &r);
7995 }
7996
7997 status = cli->dispatch(cli,
7998 mem_ctx,
7999 &ndr_table_spoolss,
8000 NDR_SPOOLSS_ADDMONITOR,
8001 &r);
8002
8003 if (!NT_STATUS_IS_OK(status)) {
8004 return status;
8005 }
8006
8007 if (DEBUGLEVEL >= 10) {
8008 NDR_PRINT_OUT_DEBUG(spoolss_AddMonitor, &r);
8009 }
8010
8011 if (NT_STATUS_IS_ERR(status)) {
8012 return status;
8013 }
8014
8015 /* Return variables */
8016
8017 /* Return result */
8018 if (werror) {
8019 *werror = r.out.result;
8020 }
8021
8022 return werror_to_ntstatus(r.out.result);
8023 }
8024
8025 struct rpccli_spoolss_DeleteMonitor_state {
8026 struct spoolss_DeleteMonitor orig;
8027 struct spoolss_DeleteMonitor tmp;
8028 TALLOC_CTX *out_mem_ctx;
8029 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8030 };
8031
8032 static void rpccli_spoolss_DeleteMonitor_done(struct tevent_req *subreq);
8033
8034 struct tevent_req *rpccli_spoolss_DeleteMonitor_send(TALLOC_CTX *mem_ctx,
8035 struct tevent_context *ev,
8036 struct rpc_pipe_client *cli)
8037 {
8038 struct tevent_req *req;
8039 struct rpccli_spoolss_DeleteMonitor_state *state;
8040 struct tevent_req *subreq;
8041
8042 req = tevent_req_create(mem_ctx, &state,
8043 struct rpccli_spoolss_DeleteMonitor_state);
8044 if (req == NULL) {
8045 return NULL;
8046 }
8047 state->out_mem_ctx = NULL;
8048 state->dispatch_recv = cli->dispatch_recv;
8049
8050 /* In parameters */
8051
8052 /* Out parameters */
8053
8054 /* Result */
8055 ZERO_STRUCT(state->orig.out.result);
8056
8057 if (DEBUGLEVEL >= 10) {
8058 NDR_PRINT_IN_DEBUG(spoolss_DeleteMonitor, &state->orig);
8059 }
8060
8061 /* make a temporary copy, that we pass to the dispatch function */
8062 state->tmp = state->orig;
8063
8064 subreq = cli->dispatch_send(state, ev, cli,
8065 &ndr_table_spoolss,
8066 NDR_SPOOLSS_DELETEMONITOR,
8067 &state->tmp);
8068 if (tevent_req_nomem(subreq, req)) {
8069 return tevent_req_post(req, ev);
8070 }
8071 tevent_req_set_callback(subreq, rpccli_spoolss_DeleteMonitor_done, req);
8072 return req;
8073 }
8074
8075 static void rpccli_spoolss_DeleteMonitor_done(struct tevent_req *subreq)
8076 {
8077 struct tevent_req *req = tevent_req_callback_data(
8078 subreq, struct tevent_req);
8079 struct rpccli_spoolss_DeleteMonitor_state *state = tevent_req_data(
8080 req, struct rpccli_spoolss_DeleteMonitor_state);
8081 NTSTATUS status;
8082 TALLOC_CTX *mem_ctx;
8083
8084 if (state->out_mem_ctx) {
8085 mem_ctx = state->out_mem_ctx;
8086 } else {
8087 mem_ctx = state;
8088 }
8089
8090 status = state->dispatch_recv(subreq, mem_ctx);
8091 TALLOC_FREE(subreq);
8092 if (!NT_STATUS_IS_OK(status)) {
8093 tevent_req_nterror(req, status);
8094 return;
8095 }
8096
8097 /* Copy out parameters */
8098
8099 /* Copy result */
8100 state->orig.out.result = state->tmp.out.result;
8101
8102 /* Reset temporary structure */
8103 ZERO_STRUCT(state->tmp);
8104
8105 if (DEBUGLEVEL >= 10) {
8106 NDR_PRINT_OUT_DEBUG(spoolss_DeleteMonitor, &state->orig);
8107 }
8108
8109 tevent_req_done(req);
8110 }
8111
8112 NTSTATUS rpccli_spoolss_DeleteMonitor_recv(struct tevent_req *req,
8113 TALLOC_CTX *mem_ctx,
8114 WERROR *result)
8115 {
8116 struct rpccli_spoolss_DeleteMonitor_state *state = tevent_req_data(
8117 req, struct rpccli_spoolss_DeleteMonitor_state);
8118 NTSTATUS status;
8119
8120 if (tevent_req_is_nterror(req, &status)) {
8121 tevent_req_received(req);
8122 return status;
8123 }
8124
8125 /* Steal possbile out parameters to the callers context */
8126 talloc_steal(mem_ctx, state->out_mem_ctx);
8127
8128 /* Return result */
8129 *result = state->orig.out.result;
8130
8131 tevent_req_received(req);
8132 return NT_STATUS_OK;
8133 }
8134
8135 NTSTATUS rpccli_spoolss_DeleteMonitor(struct rpc_pipe_client *cli,
8136 TALLOC_CTX *mem_ctx,
8137 WERROR *werror)
8138 {
8139 struct spoolss_DeleteMonitor r;
8140 NTSTATUS status;
8141
8142 /* In parameters */
8143
8144 if (DEBUGLEVEL >= 10) {
8145 NDR_PRINT_IN_DEBUG(spoolss_DeleteMonitor, &r);
8146 }
8147
8148 status = cli->dispatch(cli,
8149 mem_ctx,
8150 &ndr_table_spoolss,
8151 NDR_SPOOLSS_DELETEMONITOR,
8152 &r);
8153
8154 if (!NT_STATUS_IS_OK(status)) {
8155 return status;
8156 }
8157
8158 if (DEBUGLEVEL >= 10) {
8159 NDR_PRINT_OUT_DEBUG(spoolss_DeleteMonitor, &r);
8160 }
8161
8162 if (NT_STATUS_IS_ERR(status)) {
8163 return status;
8164 }
8165
8166 /* Return variables */
8167
8168 /* Return result */
8169 if (werror) {
8170 *werror = r.out.result;
8171 }
8172
8173 return werror_to_ntstatus(r.out.result);
8174 }
8175
8176 struct rpccli_spoolss_DeletePrintProcessor_state {
8177 struct spoolss_DeletePrintProcessor orig;
8178 struct spoolss_DeletePrintProcessor tmp;
8179 TALLOC_CTX *out_mem_ctx;
8180 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8181 };
8182
8183 static void rpccli_spoolss_DeletePrintProcessor_done(struct tevent_req *subreq);
8184
8185 struct tevent_req *rpccli_spoolss_DeletePrintProcessor_send(TALLOC_CTX *mem_ctx,
8186 struct tevent_context *ev,
8187 struct rpc_pipe_client *cli)
8188 {
8189 struct tevent_req *req;
8190 struct rpccli_spoolss_DeletePrintProcessor_state *state;
8191 struct tevent_req *subreq;
8192
8193 req = tevent_req_create(mem_ctx, &state,
8194 struct rpccli_spoolss_DeletePrintProcessor_state);
8195 if (req == NULL) {
8196 return NULL;
8197 }
8198 state->out_mem_ctx = NULL;
8199 state->dispatch_recv = cli->dispatch_recv;
8200
8201 /* In parameters */
8202
8203 /* Out parameters */
8204
8205 /* Result */
8206 ZERO_STRUCT(state->orig.out.result);
8207
8208 if (DEBUGLEVEL >= 10) {
8209 NDR_PRINT_IN_DEBUG(spoolss_DeletePrintProcessor, &state->orig);
8210 }
8211
8212 /* make a temporary copy, that we pass to the dispatch function */
8213 state->tmp = state->orig;
8214
8215 subreq = cli->dispatch_send(state, ev, cli,
8216 &ndr_table_spoolss,
8217 NDR_SPOOLSS_DELETEPRINTPROCESSOR,
8218 &state->tmp);
8219 if (tevent_req_nomem(subreq, req)) {
8220 return tevent_req_post(req, ev);
8221 }
8222 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrintProcessor_done, req);
8223 return req;
8224 }
8225
8226 static void rpccli_spoolss_DeletePrintProcessor_done(struct tevent_req *subreq)
8227 {
8228 struct tevent_req *req = tevent_req_callback_data(
8229 subreq, struct tevent_req);
8230 struct rpccli_spoolss_DeletePrintProcessor_state *state = tevent_req_data(
8231 req, struct rpccli_spoolss_DeletePrintProcessor_state);
8232 NTSTATUS status;
8233 TALLOC_CTX *mem_ctx;
8234
8235 if (state->out_mem_ctx) {
8236 mem_ctx = state->out_mem_ctx;
8237 } else {
8238 mem_ctx = state;
8239 }
8240
8241 status = state->dispatch_recv(subreq, mem_ctx);
8242 TALLOC_FREE(subreq);
8243 if (!NT_STATUS_IS_OK(status)) {
8244 tevent_req_nterror(req, status);
8245 return;
8246 }
8247
8248 /* Copy out parameters */
8249
8250 /* Copy result */
8251 state->orig.out.result = state->tmp.out.result;
8252
8253 /* Reset temporary structure */
8254 ZERO_STRUCT(state->tmp);
8255
8256 if (DEBUGLEVEL >= 10) {
8257 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrintProcessor, &state->orig);
8258 }
8259
8260 tevent_req_done(req);
8261 }
8262
8263 NTSTATUS rpccli_spoolss_DeletePrintProcessor_recv(struct tevent_req *req,
8264 TALLOC_CTX *mem_ctx,
8265 WERROR *result)
8266 {
8267 struct rpccli_spoolss_DeletePrintProcessor_state *state = tevent_req_data(
8268 req, struct rpccli_spoolss_DeletePrintProcessor_state);
8269 NTSTATUS status;
8270
8271 if (tevent_req_is_nterror(req, &status)) {
8272 tevent_req_received(req);
8273 return status;
8274 }
8275
8276 /* Steal possbile out parameters to the callers context */
8277 talloc_steal(mem_ctx, state->out_mem_ctx);
8278
8279 /* Return result */
8280 *result = state->orig.out.result;
8281
8282 tevent_req_received(req);
8283 return NT_STATUS_OK;
8284 }
8285
8286 NTSTATUS rpccli_spoolss_DeletePrintProcessor(struct rpc_pipe_client *cli,
8287 TALLOC_CTX *mem_ctx,
8288 WERROR *werror)
8289 {
8290 struct spoolss_DeletePrintProcessor r;
8291 NTSTATUS status;
8292
8293 /* In parameters */
8294
8295 if (DEBUGLEVEL >= 10) {
8296 NDR_PRINT_IN_DEBUG(spoolss_DeletePrintProcessor, &r);
8297 }
8298
8299 status = cli->dispatch(cli,
8300 mem_ctx,
8301 &ndr_table_spoolss,
8302 NDR_SPOOLSS_DELETEPRINTPROCESSOR,
8303 &r);
8304
8305 if (!NT_STATUS_IS_OK(status)) {
8306 return status;
8307 }
8308
8309 if (DEBUGLEVEL >= 10) {
8310 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrintProcessor, &r);
8311 }
8312
8313 if (NT_STATUS_IS_ERR(status)) {
8314 return status;
8315 }
8316
8317 /* Return variables */
8318
8319 /* Return result */
8320 if (werror) {
8321 *werror = r.out.result;
8322 }
8323
8324 return werror_to_ntstatus(r.out.result);
8325 }
8326
8327 struct rpccli_spoolss_AddPrintProvidor_state {
8328 struct spoolss_AddPrintProvidor orig;
8329 struct spoolss_AddPrintProvidor tmp;
8330 TALLOC_CTX *out_mem_ctx;
8331 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8332 };
8333
8334 static void rpccli_spoolss_AddPrintProvidor_done(struct tevent_req *subreq);
8335
8336 struct tevent_req *rpccli_spoolss_AddPrintProvidor_send(TALLOC_CTX *mem_ctx,
8337 struct tevent_context *ev,
8338 struct rpc_pipe_client *cli)
8339 {
8340 struct tevent_req *req;
8341 struct rpccli_spoolss_AddPrintProvidor_state *state;
8342 struct tevent_req *subreq;
8343
8344 req = tevent_req_create(mem_ctx, &state,
8345 struct rpccli_spoolss_AddPrintProvidor_state);
8346 if (req == NULL) {
8347 return NULL;
8348 }
8349 state->out_mem_ctx = NULL;
8350 state->dispatch_recv = cli->dispatch_recv;
8351
8352 /* In parameters */
8353
8354 /* Out parameters */
8355
8356 /* Result */
8357 ZERO_STRUCT(state->orig.out.result);
8358
8359 if (DEBUGLEVEL >= 10) {
8360 NDR_PRINT_IN_DEBUG(spoolss_AddPrintProvidor, &state->orig);
8361 }
8362
8363 /* make a temporary copy, that we pass to the dispatch function */
8364 state->tmp = state->orig;
8365
8366 subreq = cli->dispatch_send(state, ev, cli,
8367 &ndr_table_spoolss,
8368 NDR_SPOOLSS_ADDPRINTPROVIDOR,
8369 &state->tmp);
8370 if (tevent_req_nomem(subreq, req)) {
8371 return tevent_req_post(req, ev);
8372 }
8373 tevent_req_set_callback(subreq, rpccli_spoolss_AddPrintProvidor_done, req);
8374 return req;
8375 }
8376
8377 static void rpccli_spoolss_AddPrintProvidor_done(struct tevent_req *subreq)
8378 {
8379 struct tevent_req *req = tevent_req_callback_data(
8380 subreq, struct tevent_req);
8381 struct rpccli_spoolss_AddPrintProvidor_state *state = tevent_req_data(
8382 req, struct rpccli_spoolss_AddPrintProvidor_state);
8383 NTSTATUS status;
8384 TALLOC_CTX *mem_ctx;
8385
8386 if (state->out_mem_ctx) {
8387 mem_ctx = state->out_mem_ctx;
8388 } else {
8389 mem_ctx = state;
8390 }
8391
8392 status = state->dispatch_recv(subreq, mem_ctx);
8393 TALLOC_FREE(subreq);
8394 if (!NT_STATUS_IS_OK(status)) {
8395 tevent_req_nterror(req, status);
8396 return;
8397 }
8398
8399 /* Copy out parameters */
8400
8401 /* Copy result */
8402 state->orig.out.result = state->tmp.out.result;
8403
8404 /* Reset temporary structure */
8405 ZERO_STRUCT(state->tmp);
8406
8407 if (DEBUGLEVEL >= 10) {
8408 NDR_PRINT_OUT_DEBUG(spoolss_AddPrintProvidor, &state->orig);
8409 }
8410
8411 tevent_req_done(req);
8412 }
8413
8414 NTSTATUS rpccli_spoolss_AddPrintProvidor_recv(struct tevent_req *req,
8415 TALLOC_CTX *mem_ctx,
8416 WERROR *result)
8417 {
8418 struct rpccli_spoolss_AddPrintProvidor_state *state = tevent_req_data(
8419 req, struct rpccli_spoolss_AddPrintProvidor_state);
8420 NTSTATUS status;
8421
8422 if (tevent_req_is_nterror(req, &status)) {
8423 tevent_req_received(req);
8424 return status;
8425 }
8426
8427 /* Steal possbile out parameters to the callers context */
8428 talloc_steal(mem_ctx, state->out_mem_ctx);
8429
8430 /* Return result */
8431 *result = state->orig.out.result;
8432
8433 tevent_req_received(req);
8434 return NT_STATUS_OK;
8435 }
8436
8437 NTSTATUS rpccli_spoolss_AddPrintProvidor(struct rpc_pipe_client *cli,
8438 TALLOC_CTX *mem_ctx,
8439 WERROR *werror)
8440 {
8441 struct spoolss_AddPrintProvidor r;
8442 NTSTATUS status;
8443
8444 /* In parameters */
8445
8446 if (DEBUGLEVEL >= 10) {
8447 NDR_PRINT_IN_DEBUG(spoolss_AddPrintProvidor, &r);
8448 }
8449
8450 status = cli->dispatch(cli,
8451 mem_ctx,
8452 &ndr_table_spoolss,
8453 NDR_SPOOLSS_ADDPRINTPROVIDOR,
8454 &r);
8455
8456 if (!NT_STATUS_IS_OK(status)) {
8457 return status;
8458 }
8459
8460 if (DEBUGLEVEL >= 10) {
8461 NDR_PRINT_OUT_DEBUG(spoolss_AddPrintProvidor, &r);
8462 }
8463
8464 if (NT_STATUS_IS_ERR(status)) {
8465 return status;
8466 }
8467
8468 /* Return variables */
8469
8470 /* Return result */
8471 if (werror) {
8472 *werror = r.out.result;
8473 }
8474
8475 return werror_to_ntstatus(r.out.result);
8476 }
8477
8478 struct rpccli_spoolss_DeletePrintProvidor_state {
8479 struct spoolss_DeletePrintProvidor orig;
8480 struct spoolss_DeletePrintProvidor tmp;
8481 TALLOC_CTX *out_mem_ctx;
8482 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8483 };
8484
8485 static void rpccli_spoolss_DeletePrintProvidor_done(struct tevent_req *subreq);
8486
8487 struct tevent_req *rpccli_spoolss_DeletePrintProvidor_send(TALLOC_CTX *mem_ctx,
8488 struct tevent_context *ev,
8489 struct rpc_pipe_client *cli)
8490 {
8491 struct tevent_req *req;
8492 struct rpccli_spoolss_DeletePrintProvidor_state *state;
8493 struct tevent_req *subreq;
8494
8495 req = tevent_req_create(mem_ctx, &state,
8496 struct rpccli_spoolss_DeletePrintProvidor_state);
8497 if (req == NULL) {
8498 return NULL;
8499 }
8500 state->out_mem_ctx = NULL;
8501 state->dispatch_recv = cli->dispatch_recv;
8502
8503 /* In parameters */
8504
8505 /* Out parameters */
8506
8507 /* Result */
8508 ZERO_STRUCT(state->orig.out.result);
8509
8510 if (DEBUGLEVEL >= 10) {
8511 NDR_PRINT_IN_DEBUG(spoolss_DeletePrintProvidor, &state->orig);
8512 }
8513
8514 /* make a temporary copy, that we pass to the dispatch function */
8515 state->tmp = state->orig;
8516
8517 subreq = cli->dispatch_send(state, ev, cli,
8518 &ndr_table_spoolss,
8519 NDR_SPOOLSS_DELETEPRINTPROVIDOR,
8520 &state->tmp);
8521 if (tevent_req_nomem(subreq, req)) {
8522 return tevent_req_post(req, ev);
8523 }
8524 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrintProvidor_done, req);
8525 return req;
8526 }
8527
8528 static void rpccli_spoolss_DeletePrintProvidor_done(struct tevent_req *subreq)
8529 {
8530 struct tevent_req *req = tevent_req_callback_data(
8531 subreq, struct tevent_req);
8532 struct rpccli_spoolss_DeletePrintProvidor_state *state = tevent_req_data(
8533 req, struct rpccli_spoolss_DeletePrintProvidor_state);
8534 NTSTATUS status;
8535 TALLOC_CTX *mem_ctx;
8536
8537 if (state->out_mem_ctx) {
8538 mem_ctx = state->out_mem_ctx;
8539 } else {
8540 mem_ctx = state;
8541 }
8542
8543 status = state->dispatch_recv(subreq, mem_ctx);
8544 TALLOC_FREE(subreq);
8545 if (!NT_STATUS_IS_OK(status)) {
8546 tevent_req_nterror(req, status);
8547 return;
8548 }
8549
8550 /* Copy out parameters */
8551
8552 /* Copy result */
8553 state->orig.out.result = state->tmp.out.result;
8554
8555 /* Reset temporary structure */
8556 ZERO_STRUCT(state->tmp);
8557
8558 if (DEBUGLEVEL >= 10) {
8559 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrintProvidor, &state->orig);
8560 }
8561
8562 tevent_req_done(req);
8563 }
8564
8565 NTSTATUS rpccli_spoolss_DeletePrintProvidor_recv(struct tevent_req *req,
8566 TALLOC_CTX *mem_ctx,
8567 WERROR *result)
8568 {
8569 struct rpccli_spoolss_DeletePrintProvidor_state *state = tevent_req_data(
8570 req, struct rpccli_spoolss_DeletePrintProvidor_state);
8571 NTSTATUS status;
8572
8573 if (tevent_req_is_nterror(req, &status)) {
8574 tevent_req_received(req);
8575 return status;
8576 }
8577
8578 /* Steal possbile out parameters to the callers context */
8579 talloc_steal(mem_ctx, state->out_mem_ctx);
8580
8581 /* Return result */
8582 *result = state->orig.out.result;
8583
8584 tevent_req_received(req);
8585 return NT_STATUS_OK;
8586 }
8587
8588 NTSTATUS rpccli_spoolss_DeletePrintProvidor(struct rpc_pipe_client *cli,
8589 TALLOC_CTX *mem_ctx,
8590 WERROR *werror)
8591 {
8592 struct spoolss_DeletePrintProvidor r;
8593 NTSTATUS status;
8594
8595 /* In parameters */
8596
8597 if (DEBUGLEVEL >= 10) {
8598 NDR_PRINT_IN_DEBUG(spoolss_DeletePrintProvidor, &r);
8599 }
8600
8601 status = cli->dispatch(cli,
8602 mem_ctx,
8603 &ndr_table_spoolss,
8604 NDR_SPOOLSS_DELETEPRINTPROVIDOR,
8605 &r);
8606
8607 if (!NT_STATUS_IS_OK(status)) {
8608 return status;
8609 }
8610
8611 if (DEBUGLEVEL >= 10) {
8612 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrintProvidor, &r);
8613 }
8614
8615 if (NT_STATUS_IS_ERR(status)) {
8616 return status;
8617 }
8618
8619 /* Return variables */
8620
8621 /* Return result */
8622 if (werror) {
8623 *werror = r.out.result;
8624 }
8625
8626 return werror_to_ntstatus(r.out.result);
8627 }
8628
8629 struct rpccli_spoolss_EnumPrintProcDataTypes_state {
8630 struct spoolss_EnumPrintProcDataTypes orig;
8631 struct spoolss_EnumPrintProcDataTypes tmp;
8632 TALLOC_CTX *out_mem_ctx;
8633 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8634 };
8635
8636 static void rpccli_spoolss_EnumPrintProcDataTypes_done(struct tevent_req *subreq);
8637
8638 struct tevent_req *rpccli_spoolss_EnumPrintProcDataTypes_send(TALLOC_CTX *mem_ctx,
8639 struct tevent_context *ev,
8640 struct rpc_pipe_client *cli,
8641 const char *_servername /* [in] [unique,charset(UTF16)] */,
8642 const char *_print_processor_name /* [in] [unique,charset(UTF16)] */,
8643 uint32_t _level /* [in] */,
8644 DATA_BLOB *_buffer /* [in] [unique] */,
8645 uint32_t _offered /* [in] */,
8646 uint32_t *_count /* [out] [ref] */,
8647 union spoolss_PrintProcDataTypesInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
8648 uint32_t *_needed /* [out] [ref] */)
8649 {
8650 struct tevent_req *req;
8651 struct rpccli_spoolss_EnumPrintProcDataTypes_state *state;
8652 struct tevent_req *subreq;
8653
8654 req = tevent_req_create(mem_ctx, &state,
8655 struct rpccli_spoolss_EnumPrintProcDataTypes_state);
8656 if (req == NULL) {
8657 return NULL;
8658 }
8659 state->out_mem_ctx = NULL;
8660 state->dispatch_recv = cli->dispatch_recv;
8661
8662 /* In parameters */
8663 state->orig.in.servername = _servername;
8664 state->orig.in.print_processor_name = _print_processor_name;
8665 state->orig.in.level = _level;
8666 state->orig.in.buffer = _buffer;
8667 state->orig.in.offered = _offered;
8668
8669 /* Out parameters */
8670 state->orig.out.count = _count;
8671 state->orig.out.info = _info;
8672 state->orig.out.needed = _needed;
8673
8674 /* Result */
8675 ZERO_STRUCT(state->orig.out.result);
8676
8677 if (DEBUGLEVEL >= 10) {
8678 NDR_PRINT_IN_DEBUG(spoolss_EnumPrintProcDataTypes, &state->orig);
8679 }
8680
8681 state->out_mem_ctx = talloc_named_const(state, 0,
8682 "rpccli_spoolss_EnumPrintProcDataTypes_out_memory");
8683 if (tevent_req_nomem(state->out_mem_ctx, req)) {
8684 return tevent_req_post(req, ev);
8685 }
8686
8687 /* make a temporary copy, that we pass to the dispatch function */
8688 state->tmp = state->orig;
8689
8690 subreq = cli->dispatch_send(state, ev, cli,
8691 &ndr_table_spoolss,
8692 NDR_SPOOLSS_ENUMPRINTPROCDATATYPES,
8693 &state->tmp);
8694 if (tevent_req_nomem(subreq, req)) {
8695 return tevent_req_post(req, ev);
8696 }
8697 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrintProcDataTypes_done, req);
8698 return req;
8699 }
8700
8701 static void rpccli_spoolss_EnumPrintProcDataTypes_done(struct tevent_req *subreq)
8702 {
8703 struct tevent_req *req = tevent_req_callback_data(
8704 subreq, struct tevent_req);
8705 struct rpccli_spoolss_EnumPrintProcDataTypes_state *state = tevent_req_data(
8706 req, struct rpccli_spoolss_EnumPrintProcDataTypes_state);
8707 NTSTATUS status;
8708 TALLOC_CTX *mem_ctx;
8709
8710 if (state->out_mem_ctx) {
8711 mem_ctx = state->out_mem_ctx;
8712 } else {
8713 mem_ctx = state;
8714 }
8715
8716 status = state->dispatch_recv(subreq, mem_ctx);
8717 TALLOC_FREE(subreq);
8718 if (!NT_STATUS_IS_OK(status)) {
8719 tevent_req_nterror(req, status);
8720 return;
8721 }
8722
8723 /* Copy out parameters */
8724 *state->orig.out.count = *state->tmp.out.count;
8725 *state->orig.out.info = *state->tmp.out.info;
8726 *state->orig.out.needed = *state->tmp.out.needed;
8727
8728 /* Copy result */
8729 state->orig.out.result = state->tmp.out.result;
8730
8731 /* Reset temporary structure */
8732 ZERO_STRUCT(state->tmp);
8733
8734 if (DEBUGLEVEL >= 10) {
8735 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrintProcDataTypes, &state->orig);
8736 }
8737
8738 tevent_req_done(req);
8739 }
8740
8741 NTSTATUS rpccli_spoolss_EnumPrintProcDataTypes_recv(struct tevent_req *req,
8742 TALLOC_CTX *mem_ctx,
8743 WERROR *result)
8744 {
8745 struct rpccli_spoolss_EnumPrintProcDataTypes_state *state = tevent_req_data(
8746 req, struct rpccli_spoolss_EnumPrintProcDataTypes_state);
8747 NTSTATUS status;
8748
8749 if (tevent_req_is_nterror(req, &status)) {
8750 tevent_req_received(req);
8751 return status;
8752 }
8753
8754 /* Steal possbile out parameters to the callers context */
8755 talloc_steal(mem_ctx, state->out_mem_ctx);
8756
8757 /* Return result */
8758 *result = state->orig.out.result;
8759
8760 tevent_req_received(req);
8761 return NT_STATUS_OK;
8762 }
8763
8764 NTSTATUS rpccli_spoolss_EnumPrintProcDataTypes(struct rpc_pipe_client *cli,
8765 TALLOC_CTX *mem_ctx,
8766 const char *servername /* [in] [unique,charset(UTF16)] */,
8767 const char *print_processor_name /* [in] [unique,charset(UTF16)] */,
8768 uint32_t level /* [in] */,
8769 DATA_BLOB *buffer /* [in] [unique] */,
8770 uint32_t offered /* [in] */,
8771 uint32_t *count /* [out] [ref] */,
8772 union spoolss_PrintProcDataTypesInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
8773 uint32_t *needed /* [out] [ref] */,
8774 WERROR *werror)
8775 {
8776 struct spoolss_EnumPrintProcDataTypes r;
8777 NTSTATUS status;
8778
8779 /* In parameters */
8780 r.in.servername = servername;
8781 r.in.print_processor_name = print_processor_name;
8782 r.in.level = level;
8783 r.in.buffer = buffer;
8784 r.in.offered = offered;
8785
8786 if (DEBUGLEVEL >= 10) {
8787 NDR_PRINT_IN_DEBUG(spoolss_EnumPrintProcDataTypes, &r);
8788 }
8789
8790 status = cli->dispatch(cli,
8791 mem_ctx,
8792 &ndr_table_spoolss,
8793 NDR_SPOOLSS_ENUMPRINTPROCDATATYPES,
8794 &r);
8795
8796 if (!NT_STATUS_IS_OK(status)) {
8797 return status;
8798 }
8799
8800 if (DEBUGLEVEL >= 10) {
8801 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrintProcDataTypes, &r);
8802 }
8803
8804 if (NT_STATUS_IS_ERR(status)) {
8805 return status;
8806 }
8807
8808 /* Return variables */
8809 *count = *r.out.count;
8810 *info = *r.out.info;
8811 *needed = *r.out.needed;
8812
8813 /* Return result */
8814 if (werror) {
8815 *werror = r.out.result;
8816 }
8817
8818 return werror_to_ntstatus(r.out.result);
8819 }
8820
8821 struct rpccli_spoolss_ResetPrinter_state {
8822 struct spoolss_ResetPrinter orig;
8823 struct spoolss_ResetPrinter tmp;
8824 TALLOC_CTX *out_mem_ctx;
8825 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8826 };
8827
8828 static void rpccli_spoolss_ResetPrinter_done(struct tevent_req *subreq);
8829
8830 struct tevent_req *rpccli_spoolss_ResetPrinter_send(TALLOC_CTX *mem_ctx,
8831 struct tevent_context *ev,
8832 struct rpc_pipe_client *cli,
8833 struct policy_handle *_handle /* [in] [ref] */,
8834 const char *_data_type /* [in] [unique,charset(UTF16)] */,
8835 struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */)
8836 {
8837 struct tevent_req *req;
8838 struct rpccli_spoolss_ResetPrinter_state *state;
8839 struct tevent_req *subreq;
8840
8841 req = tevent_req_create(mem_ctx, &state,
8842 struct rpccli_spoolss_ResetPrinter_state);
8843 if (req == NULL) {
8844 return NULL;
8845 }
8846 state->out_mem_ctx = NULL;
8847 state->dispatch_recv = cli->dispatch_recv;
8848
8849 /* In parameters */
8850 state->orig.in.handle = _handle;
8851 state->orig.in.data_type = _data_type;
8852 state->orig.in.devmode_ctr = _devmode_ctr;
8853
8854 /* Out parameters */
8855
8856 /* Result */
8857 ZERO_STRUCT(state->orig.out.result);
8858
8859 if (DEBUGLEVEL >= 10) {
8860 NDR_PRINT_IN_DEBUG(spoolss_ResetPrinter, &state->orig);
8861 }
8862
8863 /* make a temporary copy, that we pass to the dispatch function */
8864 state->tmp = state->orig;
8865
8866 subreq = cli->dispatch_send(state, ev, cli,
8867 &ndr_table_spoolss,
8868 NDR_SPOOLSS_RESETPRINTER,
8869 &state->tmp);
8870 if (tevent_req_nomem(subreq, req)) {
8871 return tevent_req_post(req, ev);
8872 }
8873 tevent_req_set_callback(subreq, rpccli_spoolss_ResetPrinter_done, req);
8874 return req;
8875 }
8876
8877 static void rpccli_spoolss_ResetPrinter_done(struct tevent_req *subreq)
8878 {
8879 struct tevent_req *req = tevent_req_callback_data(
8880 subreq, struct tevent_req);
8881 struct rpccli_spoolss_ResetPrinter_state *state = tevent_req_data(
8882 req, struct rpccli_spoolss_ResetPrinter_state);
8883 NTSTATUS status;
8884 TALLOC_CTX *mem_ctx;
8885
8886 if (state->out_mem_ctx) {
8887 mem_ctx = state->out_mem_ctx;
8888 } else {
8889 mem_ctx = state;
8890 }
8891
8892 status = state->dispatch_recv(subreq, mem_ctx);
8893 TALLOC_FREE(subreq);
8894 if (!NT_STATUS_IS_OK(status)) {
8895 tevent_req_nterror(req, status);
8896 return;
8897 }
8898
8899 /* Copy out parameters */
8900
8901 /* Copy result */
8902 state->orig.out.result = state->tmp.out.result;
8903
8904 /* Reset temporary structure */
8905 ZERO_STRUCT(state->tmp);
8906
8907 if (DEBUGLEVEL >= 10) {
8908 NDR_PRINT_OUT_DEBUG(spoolss_ResetPrinter, &state->orig);
8909 }
8910
8911 tevent_req_done(req);
8912 }
8913
8914 NTSTATUS rpccli_spoolss_ResetPrinter_recv(struct tevent_req *req,
8915 TALLOC_CTX *mem_ctx,
8916 WERROR *result)
8917 {
8918 struct rpccli_spoolss_ResetPrinter_state *state = tevent_req_data(
8919 req, struct rpccli_spoolss_ResetPrinter_state);
8920 NTSTATUS status;
8921
8922 if (tevent_req_is_nterror(req, &status)) {
8923 tevent_req_received(req);
8924 return status;
8925 }
8926
8927 /* Steal possbile out parameters to the callers context */
8928 talloc_steal(mem_ctx, state->out_mem_ctx);
8929
8930 /* Return result */
8931 *result = state->orig.out.result;
8932
8933 tevent_req_received(req);
8934 return NT_STATUS_OK;
8935 }
8936
8937 NTSTATUS rpccli_spoolss_ResetPrinter(struct rpc_pipe_client *cli,
8938 TALLOC_CTX *mem_ctx,
8939 struct policy_handle *handle /* [in] [ref] */,
8940 const char *data_type /* [in] [unique,charset(UTF16)] */,
8941 struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
8942 WERROR *werror)
8943 {
8944 struct spoolss_ResetPrinter r;
8945 NTSTATUS status;
8946
8947 /* In parameters */
8948 r.in.handle = handle;
8949 r.in.data_type = data_type;
8950 r.in.devmode_ctr = devmode_ctr;
8951
8952 if (DEBUGLEVEL >= 10) {
8953 NDR_PRINT_IN_DEBUG(spoolss_ResetPrinter, &r);
8954 }
8955
8956 status = cli->dispatch(cli,
8957 mem_ctx,
8958 &ndr_table_spoolss,
8959 NDR_SPOOLSS_RESETPRINTER,
8960 &r);
8961
8962 if (!NT_STATUS_IS_OK(status)) {
8963 return status;
8964 }
8965
8966 if (DEBUGLEVEL >= 10) {
8967 NDR_PRINT_OUT_DEBUG(spoolss_ResetPrinter, &r);
8968 }
8969
8970 if (NT_STATUS_IS_ERR(status)) {
8971 return status;
8972 }
8973
8974 /* Return variables */
8975
8976 /* Return result */
8977 if (werror) {
8978 *werror = r.out.result;
8979 }
8980
8981 return werror_to_ntstatus(r.out.result);
8982 }
8983
8984 struct rpccli_spoolss_GetPrinterDriver2_state {
8985 struct spoolss_GetPrinterDriver2 orig;
8986 struct spoolss_GetPrinterDriver2 tmp;
8987 TALLOC_CTX *out_mem_ctx;
8988 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8989 };
8990
8991 static void rpccli_spoolss_GetPrinterDriver2_done(struct tevent_req *subreq);
8992
8993 struct tevent_req *rpccli_spoolss_GetPrinterDriver2_send(TALLOC_CTX *mem_ctx,
8994 struct tevent_context *ev,
8995 struct rpc_pipe_client *cli,
8996 struct policy_handle *_handle /* [in] [ref] */,
8997 const char *_architecture /* [in] [unique,charset(UTF16)] */,
8998 uint32_t _level /* [in] */,
8999 DATA_BLOB *_buffer /* [in] [unique] */,
9000 uint32_t _offered /* [in] */,
9001 uint32_t _client_major_version /* [in] */,
9002 uint32_t _client_minor_version /* [in] */,
9003 union spoolss_DriverInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
9004 uint32_t *_needed /* [out] [ref] */,
9005 uint32_t *_server_major_version /* [out] [ref] */,
9006 uint32_t *_server_minor_version /* [out] [ref] */)
9007 {
9008 struct tevent_req *req;
9009 struct rpccli_spoolss_GetPrinterDriver2_state *state;
9010 struct tevent_req *subreq;
9011
9012 req = tevent_req_create(mem_ctx, &state,
9013 struct rpccli_spoolss_GetPrinterDriver2_state);
9014 if (req == NULL) {
9015 return NULL;
9016 }
9017 state->out_mem_ctx = NULL;
9018 state->dispatch_recv = cli->dispatch_recv;
9019
9020 /* In parameters */
9021 state->orig.in.handle = _handle;
9022 state->orig.in.architecture = _architecture;
9023 state->orig.in.level = _level;
9024 state->orig.in.buffer = _buffer;
9025 state->orig.in.offered = _offered;
9026 state->orig.in.client_major_version = _client_major_version;
9027 state->orig.in.client_minor_version = _client_minor_version;
9028
9029 /* Out parameters */
9030 state->orig.out.info = _info;
9031 state->orig.out.needed = _needed;
9032 state->orig.out.server_major_version = _server_major_version;
9033 state->orig.out.server_minor_version = _server_minor_version;
9034
9035 /* Result */
9036 ZERO_STRUCT(state->orig.out.result);
9037
9038 if (DEBUGLEVEL >= 10) {
9039 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriver2, &state->orig);
9040 }
9041
9042 state->out_mem_ctx = talloc_named_const(state, 0,
9043 "rpccli_spoolss_GetPrinterDriver2_out_memory");
9044 if (tevent_req_nomem(state->out_mem_ctx, req)) {
9045 return tevent_req_post(req, ev);
9046 }
9047
9048 /* make a temporary copy, that we pass to the dispatch function */
9049 state->tmp = state->orig;
9050
9051 subreq = cli->dispatch_send(state, ev, cli,
9052 &ndr_table_spoolss,
9053 NDR_SPOOLSS_GETPRINTERDRIVER2,
9054 &state->tmp);
9055 if (tevent_req_nomem(subreq, req)) {
9056 return tevent_req_post(req, ev);
9057 }
9058 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriver2_done, req);
9059 return req;
9060 }
9061
9062 static void rpccli_spoolss_GetPrinterDriver2_done(struct tevent_req *subreq)
9063 {
9064 struct tevent_req *req = tevent_req_callback_data(
9065 subreq, struct tevent_req);
9066 struct rpccli_spoolss_GetPrinterDriver2_state *state = tevent_req_data(
9067 req, struct rpccli_spoolss_GetPrinterDriver2_state);
9068 NTSTATUS status;
9069 TALLOC_CTX *mem_ctx;
9070
9071 if (state->out_mem_ctx) {
9072 mem_ctx = state->out_mem_ctx;
9073 } else {
9074 mem_ctx = state;
9075 }
9076
9077 status = state->dispatch_recv(subreq, mem_ctx);
9078 TALLOC_FREE(subreq);
9079 if (!NT_STATUS_IS_OK(status)) {
9080 tevent_req_nterror(req, status);
9081 return;
9082 }
9083
9084 /* Copy out parameters */
9085 if (state->orig.out.info && state->tmp.out.info) {
9086 *state->orig.out.info = *state->tmp.out.info;
9087 }
9088 *state->orig.out.needed = *state->tmp.out.needed;
9089 *state->orig.out.server_major_version = *state->tmp.out.server_major_version;
9090 *state->orig.out.server_minor_version = *state->tmp.out.server_minor_version;
9091
9092 /* Copy result */
9093 state->orig.out.result = state->tmp.out.result;
9094
9095 /* Reset temporary structure */
9096 ZERO_STRUCT(state->tmp);
9097
9098 if (DEBUGLEVEL >= 10) {
9099 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriver2, &state->orig);
9100 }
9101
9102 tevent_req_done(req);
9103 }
9104
9105 NTSTATUS rpccli_spoolss_GetPrinterDriver2_recv(struct tevent_req *req,
9106 TALLOC_CTX *mem_ctx,
9107 WERROR *result)
9108 {
9109 struct rpccli_spoolss_GetPrinterDriver2_state *state = tevent_req_data(
9110 req, struct rpccli_spoolss_GetPrinterDriver2_state);
9111 NTSTATUS status;
9112
9113 if (tevent_req_is_nterror(req, &status)) {
9114 tevent_req_received(req);
9115 return status;
9116 }
9117
9118 /* Steal possbile out parameters to the callers context */
9119 talloc_steal(mem_ctx, state->out_mem_ctx);
9120
9121 /* Return result */
9122 *result = state->orig.out.result;
9123
9124 tevent_req_received(req);
9125 return NT_STATUS_OK;
9126 }
9127
9128 NTSTATUS rpccli_spoolss_GetPrinterDriver2(struct rpc_pipe_client *cli,
9129 TALLOC_CTX *mem_ctx,
9130 struct policy_handle *handle /* [in] [ref] */,
9131 const char *architecture /* [in] [unique,charset(UTF16)] */,
9132 uint32_t level /* [in] */,
9133 DATA_BLOB *buffer /* [in] [unique] */,
9134 uint32_t offered /* [in] */,
9135 uint32_t client_major_version /* [in] */,
9136 uint32_t client_minor_version /* [in] */,
9137 union spoolss_DriverInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
9138 uint32_t *needed /* [out] [ref] */,
9139 uint32_t *server_major_version /* [out] [ref] */,
9140 uint32_t *server_minor_version /* [out] [ref] */,
9141 WERROR *werror)
9142 {
9143 struct spoolss_GetPrinterDriver2 r;
9144 NTSTATUS status;
9145
9146 /* In parameters */
9147 r.in.handle = handle;
9148 r.in.architecture = architecture;
9149 r.in.level = level;
9150 r.in.buffer = buffer;
9151 r.in.offered = offered;
9152 r.in.client_major_version = client_major_version;
9153 r.in.client_minor_version = client_minor_version;
9154
9155 if (DEBUGLEVEL >= 10) {
9156 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriver2, &r);
9157 }
9158
9159 status = cli->dispatch(cli,
9160 mem_ctx,
9161 &ndr_table_spoolss,
9162 NDR_SPOOLSS_GETPRINTERDRIVER2,
9163 &r);
9164
9165 if (!NT_STATUS_IS_OK(status)) {
9166 return status;
9167 }
9168
9169 if (DEBUGLEVEL >= 10) {
9170 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriver2, &r);
9171 }
9172
9173 if (NT_STATUS_IS_ERR(status)) {
9174 return status;
9175 }
9176
9177 /* Return variables */
9178 if (info && r.out.info) {
9179 *info = *r.out.info;
9180 }
9181 *needed = *r.out.needed;
9182 *server_major_version = *r.out.server_major_version;
9183 *server_minor_version = *r.out.server_minor_version;
9184
9185 /* Return result */
9186 if (werror) {
9187 *werror = r.out.result;
9188 }
9189
9190 return werror_to_ntstatus(r.out.result);
9191 }
9192
9193 struct rpccli_spoolss_FindFirstPrinterChangeNotification_state {
9194 struct spoolss_FindFirstPrinterChangeNotification orig;
9195 struct spoolss_FindFirstPrinterChangeNotification tmp;
9196 TALLOC_CTX *out_mem_ctx;
9197 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9198 };
9199
9200 static void rpccli_spoolss_FindFirstPrinterChangeNotification_done(struct tevent_req *subreq);
9201
9202 struct tevent_req *rpccli_spoolss_FindFirstPrinterChangeNotification_send(TALLOC_CTX *mem_ctx,
9203 struct tevent_context *ev,
9204 struct rpc_pipe_client *cli)
9205 {
9206 struct tevent_req *req;
9207 struct rpccli_spoolss_FindFirstPrinterChangeNotification_state *state;
9208 struct tevent_req *subreq;
9209
9210 req = tevent_req_create(mem_ctx, &state,
9211 struct rpccli_spoolss_FindFirstPrinterChangeNotification_state);
9212 if (req == NULL) {
9213 return NULL;
9214 }
9215 state->out_mem_ctx = NULL;
9216 state->dispatch_recv = cli->dispatch_recv;
9217
9218 /* In parameters */
9219
9220 /* Out parameters */
9221
9222 /* Result */
9223 ZERO_STRUCT(state->orig.out.result);
9224
9225 if (DEBUGLEVEL >= 10) {
9226 NDR_PRINT_IN_DEBUG(spoolss_FindFirstPrinterChangeNotification, &state->orig);
9227 }
9228
9229 /* make a temporary copy, that we pass to the dispatch function */
9230 state->tmp = state->orig;
9231
9232 subreq = cli->dispatch_send(state, ev, cli,
9233 &ndr_table_spoolss,
9234 NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION,
9235 &state->tmp);
9236 if (tevent_req_nomem(subreq, req)) {
9237 return tevent_req_post(req, ev);
9238 }
9239 tevent_req_set_callback(subreq, rpccli_spoolss_FindFirstPrinterChangeNotification_done, req);
9240 return req;
9241 }
9242
9243 static void rpccli_spoolss_FindFirstPrinterChangeNotification_done(struct tevent_req *subreq)
9244 {
9245 struct tevent_req *req = tevent_req_callback_data(
9246 subreq, struct tevent_req);
9247 struct rpccli_spoolss_FindFirstPrinterChangeNotification_state *state = tevent_req_data(
9248 req, struct rpccli_spoolss_FindFirstPrinterChangeNotification_state);
9249 NTSTATUS status;
9250 TALLOC_CTX *mem_ctx;
9251
9252 if (state->out_mem_ctx) {
9253 mem_ctx = state->out_mem_ctx;
9254 } else {
9255 mem_ctx = state;
9256 }
9257
9258 status = state->dispatch_recv(subreq, mem_ctx);
9259 TALLOC_FREE(subreq);
9260 if (!NT_STATUS_IS_OK(status)) {
9261 tevent_req_nterror(req, status);
9262 return;
9263 }
9264
9265 /* Copy out parameters */
9266
9267 /* Copy result */
9268 state->orig.out.result = state->tmp.out.result;
9269
9270 /* Reset temporary structure */
9271 ZERO_STRUCT(state->tmp);
9272
9273 if (DEBUGLEVEL >= 10) {
9274 NDR_PRINT_OUT_DEBUG(spoolss_FindFirstPrinterChangeNotification, &state->orig);
9275 }
9276
9277 tevent_req_done(req);
9278 }
9279
9280 NTSTATUS rpccli_spoolss_FindFirstPrinterChangeNotification_recv(struct tevent_req *req,
9281 TALLOC_CTX *mem_ctx,
9282 WERROR *result)
9283 {
9284 struct rpccli_spoolss_FindFirstPrinterChangeNotification_state *state = tevent_req_data(
9285 req, struct rpccli_spoolss_FindFirstPrinterChangeNotification_state);
9286 NTSTATUS status;
9287
9288 if (tevent_req_is_nterror(req, &status)) {
9289 tevent_req_received(req);
9290 return status;
9291 }
9292
9293 /* Steal possbile out parameters to the callers context */
9294 talloc_steal(mem_ctx, state->out_mem_ctx);
9295
9296 /* Return result */
9297 *result = state->orig.out.result;
9298
9299 tevent_req_received(req);
9300 return NT_STATUS_OK;
9301 }
9302
9303 NTSTATUS rpccli_spoolss_FindFirstPrinterChangeNotification(struct rpc_pipe_client *cli,
9304 TALLOC_CTX *mem_ctx,
9305 WERROR *werror)
9306 {
9307 struct spoolss_FindFirstPrinterChangeNotification r;
9308 NTSTATUS status;
9309
9310 /* In parameters */
9311
9312 if (DEBUGLEVEL >= 10) {
9313 NDR_PRINT_IN_DEBUG(spoolss_FindFirstPrinterChangeNotification, &r);
9314 }
9315
9316 status = cli->dispatch(cli,
9317 mem_ctx,
9318 &ndr_table_spoolss,
9319 NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION,
9320 &r);
9321
9322 if (!NT_STATUS_IS_OK(status)) {
9323 return status;
9324 }
9325
9326 if (DEBUGLEVEL >= 10) {
9327 NDR_PRINT_OUT_DEBUG(spoolss_FindFirstPrinterChangeNotification, &r);
9328 }
9329
9330 if (NT_STATUS_IS_ERR(status)) {
9331 return status;
9332 }
9333
9334 /* Return variables */
9335
9336 /* Return result */
9337 if (werror) {
9338 *werror = r.out.result;
9339 }
9340
9341 return werror_to_ntstatus(r.out.result);
9342 }
9343
9344 struct rpccli_spoolss_FindNextPrinterChangeNotification_state {
9345 struct spoolss_FindNextPrinterChangeNotification orig;
9346 struct spoolss_FindNextPrinterChangeNotification tmp;
9347 TALLOC_CTX *out_mem_ctx;
9348 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9349 };
9350
9351 static void rpccli_spoolss_FindNextPrinterChangeNotification_done(struct tevent_req *subreq);
9352
9353 struct tevent_req *rpccli_spoolss_FindNextPrinterChangeNotification_send(TALLOC_CTX *mem_ctx,
9354 struct tevent_context *ev,
9355 struct rpc_pipe_client *cli)
9356 {
9357 struct tevent_req *req;
9358 struct rpccli_spoolss_FindNextPrinterChangeNotification_state *state;
9359 struct tevent_req *subreq;
9360
9361 req = tevent_req_create(mem_ctx, &state,
9362 struct rpccli_spoolss_FindNextPrinterChangeNotification_state);
9363 if (req == NULL) {
9364 return NULL;
9365 }
9366 state->out_mem_ctx = NULL;
9367 state->dispatch_recv = cli->dispatch_recv;
9368
9369 /* In parameters */
9370
9371 /* Out parameters */
9372
9373 /* Result */
9374 ZERO_STRUCT(state->orig.out.result);
9375
9376 if (DEBUGLEVEL >= 10) {
9377 NDR_PRINT_IN_DEBUG(spoolss_FindNextPrinterChangeNotification, &state->orig);
9378 }
9379
9380 /* make a temporary copy, that we pass to the dispatch function */
9381 state->tmp = state->orig;
9382
9383 subreq = cli->dispatch_send(state, ev, cli,
9384 &ndr_table_spoolss,
9385 NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION,
9386 &state->tmp);
9387 if (tevent_req_nomem(subreq, req)) {
9388 return tevent_req_post(req, ev);
9389 }
9390 tevent_req_set_callback(subreq, rpccli_spoolss_FindNextPrinterChangeNotification_done, req);
9391 return req;
9392 }
9393
9394 static void rpccli_spoolss_FindNextPrinterChangeNotification_done(struct tevent_req *subreq)
9395 {
9396 struct tevent_req *req = tevent_req_callback_data(
9397 subreq, struct tevent_req);
9398 struct rpccli_spoolss_FindNextPrinterChangeNotification_state *state = tevent_req_data(
9399 req, struct rpccli_spoolss_FindNextPrinterChangeNotification_state);
9400 NTSTATUS status;
9401 TALLOC_CTX *mem_ctx;
9402
9403 if (state->out_mem_ctx) {
9404 mem_ctx = state->out_mem_ctx;
9405 } else {
9406 mem_ctx = state;
9407 }
9408
9409 status = state->dispatch_recv(subreq, mem_ctx);
9410 TALLOC_FREE(subreq);
9411 if (!NT_STATUS_IS_OK(status)) {
9412 tevent_req_nterror(req, status);
9413 return;
9414 }
9415
9416 /* Copy out parameters */
9417
9418 /* Copy result */
9419 state->orig.out.result = state->tmp.out.result;
9420
9421 /* Reset temporary structure */
9422 ZERO_STRUCT(state->tmp);
9423
9424 if (DEBUGLEVEL >= 10) {
9425 NDR_PRINT_OUT_DEBUG(spoolss_FindNextPrinterChangeNotification, &state->orig);
9426 }
9427
9428 tevent_req_done(req);
9429 }
9430
9431 NTSTATUS rpccli_spoolss_FindNextPrinterChangeNotification_recv(struct tevent_req *req,
9432 TALLOC_CTX *mem_ctx,
9433 WERROR *result)
9434 {
9435 struct rpccli_spoolss_FindNextPrinterChangeNotification_state *state = tevent_req_data(
9436 req, struct rpccli_spoolss_FindNextPrinterChangeNotification_state);
9437 NTSTATUS status;
9438
9439 if (tevent_req_is_nterror(req, &status)) {
9440 tevent_req_received(req);
9441 return status;
9442 }
9443
9444 /* Steal possbile out parameters to the callers context */
9445 talloc_steal(mem_ctx, state->out_mem_ctx);
9446
9447 /* Return result */
9448 *result = state->orig.out.result;
9449
9450 tevent_req_received(req);
9451 return NT_STATUS_OK;
9452 }
9453
9454 NTSTATUS rpccli_spoolss_FindNextPrinterChangeNotification(struct rpc_pipe_client *cli,
9455 TALLOC_CTX *mem_ctx,
9456 WERROR *werror)
9457 {
9458 struct spoolss_FindNextPrinterChangeNotification r;
9459 NTSTATUS status;
9460
9461 /* In parameters */
9462
9463 if (DEBUGLEVEL >= 10) {
9464 NDR_PRINT_IN_DEBUG(spoolss_FindNextPrinterChangeNotification, &r);
9465 }
9466
9467 status = cli->dispatch(cli,
9468 mem_ctx,
9469 &ndr_table_spoolss,
9470 NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION,
9471 &r);
9472
9473 if (!NT_STATUS_IS_OK(status)) {
9474 return status;
9475 }
9476
9477 if (DEBUGLEVEL >= 10) {
9478 NDR_PRINT_OUT_DEBUG(spoolss_FindNextPrinterChangeNotification, &r);
9479 }
9480
9481 if (NT_STATUS_IS_ERR(status)) {
9482 return status;
9483 }
9484
9485 /* Return variables */
9486
9487 /* Return result */
9488 if (werror) {
9489 *werror = r.out.result;
9490 }
9491
9492 return werror_to_ntstatus(r.out.result);
9493 }
9494
9495 struct rpccli_spoolss_FindClosePrinterNotify_state {
9496 struct spoolss_FindClosePrinterNotify orig;
9497 struct spoolss_FindClosePrinterNotify tmp;
9498 TALLOC_CTX *out_mem_ctx;
9499 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9500 };
9501
9502 static void rpccli_spoolss_FindClosePrinterNotify_done(struct tevent_req *subreq);
9503
9504 struct tevent_req *rpccli_spoolss_FindClosePrinterNotify_send(TALLOC_CTX *mem_ctx,
9505 struct tevent_context *ev,
9506 struct rpc_pipe_client *cli,
9507 struct policy_handle *_handle /* [in] [ref] */)
9508 {
9509 struct tevent_req *req;
9510 struct rpccli_spoolss_FindClosePrinterNotify_state *state;
9511 struct tevent_req *subreq;
9512
9513 req = tevent_req_create(mem_ctx, &state,
9514 struct rpccli_spoolss_FindClosePrinterNotify_state);
9515 if (req == NULL) {
9516 return NULL;
9517 }
9518 state->out_mem_ctx = NULL;
9519 state->dispatch_recv = cli->dispatch_recv;
9520
9521 /* In parameters */
9522 state->orig.in.handle = _handle;
9523
9524 /* Out parameters */
9525
9526 /* Result */
9527 ZERO_STRUCT(state->orig.out.result);
9528
9529 if (DEBUGLEVEL >= 10) {
9530 NDR_PRINT_IN_DEBUG(spoolss_FindClosePrinterNotify, &state->orig);
9531 }
9532
9533 /* make a temporary copy, that we pass to the dispatch function */
9534 state->tmp = state->orig;
9535
9536 subreq = cli->dispatch_send(state, ev, cli,
9537 &ndr_table_spoolss,
9538 NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY,
9539 &state->tmp);
9540 if (tevent_req_nomem(subreq, req)) {
9541 return tevent_req_post(req, ev);
9542 }
9543 tevent_req_set_callback(subreq, rpccli_spoolss_FindClosePrinterNotify_done, req);
9544 return req;
9545 }
9546
9547 static void rpccli_spoolss_FindClosePrinterNotify_done(struct tevent_req *subreq)
9548 {
9549 struct tevent_req *req = tevent_req_callback_data(
9550 subreq, struct tevent_req);
9551 struct rpccli_spoolss_FindClosePrinterNotify_state *state = tevent_req_data(
9552 req, struct rpccli_spoolss_FindClosePrinterNotify_state);
9553 NTSTATUS status;
9554 TALLOC_CTX *mem_ctx;
9555
9556 if (state->out_mem_ctx) {
9557 mem_ctx = state->out_mem_ctx;
9558 } else {
9559 mem_ctx = state;
9560 }
9561
9562 status = state->dispatch_recv(subreq, mem_ctx);
9563 TALLOC_FREE(subreq);
9564 if (!NT_STATUS_IS_OK(status)) {
9565 tevent_req_nterror(req, status);
9566 return;
9567 }
9568
9569 /* Copy out parameters */
9570
9571 /* Copy result */
9572 state->orig.out.result = state->tmp.out.result;
9573
9574 /* Reset temporary structure */
9575 ZERO_STRUCT(state->tmp);
9576
9577 if (DEBUGLEVEL >= 10) {
9578 NDR_PRINT_OUT_DEBUG(spoolss_FindClosePrinterNotify, &state->orig);
9579 }
9580
9581 tevent_req_done(req);
9582 }
9583
9584 NTSTATUS rpccli_spoolss_FindClosePrinterNotify_recv(struct tevent_req *req,
9585 TALLOC_CTX *mem_ctx,
9586 WERROR *result)
9587 {
9588 struct rpccli_spoolss_FindClosePrinterNotify_state *state = tevent_req_data(
9589 req, struct rpccli_spoolss_FindClosePrinterNotify_state);
9590 NTSTATUS status;
9591
9592 if (tevent_req_is_nterror(req, &status)) {
9593 tevent_req_received(req);
9594 return status;
9595 }
9596
9597 /* Steal possbile out parameters to the callers context */
9598 talloc_steal(mem_ctx, state->out_mem_ctx);
9599
9600 /* Return result */
9601 *result = state->orig.out.result;
9602
9603 tevent_req_received(req);
9604 return NT_STATUS_OK;
9605 }
9606
9607 NTSTATUS rpccli_spoolss_FindClosePrinterNotify(struct rpc_pipe_client *cli,
9608 TALLOC_CTX *mem_ctx,
9609 struct policy_handle *handle /* [in] [ref] */,
9610 WERROR *werror)
9611 {
9612 struct spoolss_FindClosePrinterNotify r;
9613 NTSTATUS status;
9614
9615 /* In parameters */
9616 r.in.handle = handle;
9617
9618 if (DEBUGLEVEL >= 10) {
9619 NDR_PRINT_IN_DEBUG(spoolss_FindClosePrinterNotify, &r);
9620 }
9621
9622 status = cli->dispatch(cli,
9623 mem_ctx,
9624 &ndr_table_spoolss,
9625 NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY,
9626 &r);
9627
9628 if (!NT_STATUS_IS_OK(status)) {
9629 return status;
9630 }
9631
9632 if (DEBUGLEVEL >= 10) {
9633 NDR_PRINT_OUT_DEBUG(spoolss_FindClosePrinterNotify, &r);
9634 }
9635
9636 if (NT_STATUS_IS_ERR(status)) {
9637 return status;
9638 }
9639
9640 /* Return variables */
9641
9642 /* Return result */
9643 if (werror) {
9644 *werror = r.out.result;
9645 }
9646
9647 return werror_to_ntstatus(r.out.result);
9648 }
9649
9650 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state {
9651 struct spoolss_RouterFindFirstPrinterChangeNotificationOld orig;
9652 struct spoolss_RouterFindFirstPrinterChangeNotificationOld tmp;
9653 TALLOC_CTX *out_mem_ctx;
9654 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9655 };
9656
9657 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_done(struct tevent_req *subreq);
9658
9659 struct tevent_req *rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_send(TALLOC_CTX *mem_ctx,
9660 struct tevent_context *ev,
9661 struct rpc_pipe_client *cli)
9662 {
9663 struct tevent_req *req;
9664 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state *state;
9665 struct tevent_req *subreq;
9666
9667 req = tevent_req_create(mem_ctx, &state,
9668 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state);
9669 if (req == NULL) {
9670 return NULL;
9671 }
9672 state->out_mem_ctx = NULL;
9673 state->dispatch_recv = cli->dispatch_recv;
9674
9675 /* In parameters */
9676
9677 /* Out parameters */
9678
9679 /* Result */
9680 ZERO_STRUCT(state->orig.out.result);
9681
9682 if (DEBUGLEVEL >= 10) {
9683 NDR_PRINT_IN_DEBUG(spoolss_RouterFindFirstPrinterChangeNotificationOld, &state->orig);
9684 }
9685
9686 /* make a temporary copy, that we pass to the dispatch function */
9687 state->tmp = state->orig;
9688
9689 subreq = cli->dispatch_send(state, ev, cli,
9690 &ndr_table_spoolss,
9691 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD,
9692 &state->tmp);
9693 if (tevent_req_nomem(subreq, req)) {
9694 return tevent_req_post(req, ev);
9695 }
9696 tevent_req_set_callback(subreq, rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_done, req);
9697 return req;
9698 }
9699
9700 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_done(struct tevent_req *subreq)
9701 {
9702 struct tevent_req *req = tevent_req_callback_data(
9703 subreq, struct tevent_req);
9704 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state *state = tevent_req_data(
9705 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state);
9706 NTSTATUS status;
9707 TALLOC_CTX *mem_ctx;
9708
9709 if (state->out_mem_ctx) {
9710 mem_ctx = state->out_mem_ctx;
9711 } else {
9712 mem_ctx = state;
9713 }
9714
9715 status = state->dispatch_recv(subreq, mem_ctx);
9716 TALLOC_FREE(subreq);
9717 if (!NT_STATUS_IS_OK(status)) {
9718 tevent_req_nterror(req, status);
9719 return;
9720 }
9721
9722 /* Copy out parameters */
9723
9724 /* Copy result */
9725 state->orig.out.result = state->tmp.out.result;
9726
9727 /* Reset temporary structure */
9728 ZERO_STRUCT(state->tmp);
9729
9730 if (DEBUGLEVEL >= 10) {
9731 NDR_PRINT_OUT_DEBUG(spoolss_RouterFindFirstPrinterChangeNotificationOld, &state->orig);
9732 }
9733
9734 tevent_req_done(req);
9735 }
9736
9737 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_recv(struct tevent_req *req,
9738 TALLOC_CTX *mem_ctx,
9739 WERROR *result)
9740 {
9741 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state *state = tevent_req_data(
9742 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state);
9743 NTSTATUS status;
9744
9745 if (tevent_req_is_nterror(req, &status)) {
9746 tevent_req_received(req);
9747 return status;
9748 }
9749
9750 /* Steal possbile out parameters to the callers context */
9751 talloc_steal(mem_ctx, state->out_mem_ctx);
9752
9753 /* Return result */
9754 *result = state->orig.out.result;
9755
9756 tevent_req_received(req);
9757 return NT_STATUS_OK;
9758 }
9759
9760 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct rpc_pipe_client *cli,
9761 TALLOC_CTX *mem_ctx,
9762 WERROR *werror)
9763 {
9764 struct spoolss_RouterFindFirstPrinterChangeNotificationOld r;
9765 NTSTATUS status;
9766
9767 /* In parameters */
9768
9769 if (DEBUGLEVEL >= 10) {
9770 NDR_PRINT_IN_DEBUG(spoolss_RouterFindFirstPrinterChangeNotificationOld, &r);
9771 }
9772
9773 status = cli->dispatch(cli,
9774 mem_ctx,
9775 &ndr_table_spoolss,
9776 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD,
9777 &r);
9778
9779 if (!NT_STATUS_IS_OK(status)) {
9780 return status;
9781 }
9782
9783 if (DEBUGLEVEL >= 10) {
9784 NDR_PRINT_OUT_DEBUG(spoolss_RouterFindFirstPrinterChangeNotificationOld, &r);
9785 }
9786
9787 if (NT_STATUS_IS_ERR(status)) {
9788 return status;
9789 }
9790
9791 /* Return variables */
9792
9793 /* Return result */
9794 if (werror) {
9795 *werror = r.out.result;
9796 }
9797
9798 return werror_to_ntstatus(r.out.result);
9799 }
9800
9801 struct rpccli_spoolss_ReplyOpenPrinter_state {
9802 struct spoolss_ReplyOpenPrinter orig;
9803 struct spoolss_ReplyOpenPrinter tmp;
9804 TALLOC_CTX *out_mem_ctx;
9805 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9806 };
9807
9808 static void rpccli_spoolss_ReplyOpenPrinter_done(struct tevent_req *subreq);
9809
9810 struct tevent_req *rpccli_spoolss_ReplyOpenPrinter_send(TALLOC_CTX *mem_ctx,
9811 struct tevent_context *ev,
9812 struct rpc_pipe_client *cli,
9813 const char *_server_name /* [in] [charset(UTF16)] */,
9814 uint32_t _printer_local /* [in] */,
9815 enum winreg_Type _type /* [in] */,
9816 uint32_t _bufsize /* [in] [range(0,512)] */,
9817 uint8_t *_buffer /* [in] [unique,size_is(bufsize)] */,
9818 struct policy_handle *_handle /* [out] [ref] */)
9819 {
9820 struct tevent_req *req;
9821 struct rpccli_spoolss_ReplyOpenPrinter_state *state;
9822 struct tevent_req *subreq;
9823
9824 req = tevent_req_create(mem_ctx, &state,
9825 struct rpccli_spoolss_ReplyOpenPrinter_state);
9826 if (req == NULL) {
9827 return NULL;
9828 }
9829 state->out_mem_ctx = NULL;
9830 state->dispatch_recv = cli->dispatch_recv;
9831
9832 /* In parameters */
9833 state->orig.in.server_name = _server_name;
9834 state->orig.in.printer_local = _printer_local;
9835 state->orig.in.type = _type;
9836 state->orig.in.bufsize = _bufsize;
9837 state->orig.in.buffer = _buffer;
9838
9839 /* Out parameters */
9840 state->orig.out.handle = _handle;
9841
9842 /* Result */
9843 ZERO_STRUCT(state->orig.out.result);
9844
9845 if (DEBUGLEVEL >= 10) {
9846 NDR_PRINT_IN_DEBUG(spoolss_ReplyOpenPrinter, &state->orig);
9847 }
9848
9849 state->out_mem_ctx = talloc_named_const(state, 0,
9850 "rpccli_spoolss_ReplyOpenPrinter_out_memory");
9851 if (tevent_req_nomem(state->out_mem_ctx, req)) {
9852 return tevent_req_post(req, ev);
9853 }
9854
9855 /* make a temporary copy, that we pass to the dispatch function */
9856 state->tmp = state->orig;
9857
9858 subreq = cli->dispatch_send(state, ev, cli,
9859 &ndr_table_spoolss,
9860 NDR_SPOOLSS_REPLYOPENPRINTER,
9861 &state->tmp);
9862 if (tevent_req_nomem(subreq, req)) {
9863 return tevent_req_post(req, ev);
9864 }
9865 tevent_req_set_callback(subreq, rpccli_spoolss_ReplyOpenPrinter_done, req);
9866 return req;
9867 }
9868
9869 static void rpccli_spoolss_ReplyOpenPrinter_done(struct tevent_req *subreq)
9870 {
9871 struct tevent_req *req = tevent_req_callback_data(
9872 subreq, struct tevent_req);
9873 struct rpccli_spoolss_ReplyOpenPrinter_state *state = tevent_req_data(
9874 req, struct rpccli_spoolss_ReplyOpenPrinter_state);
9875 NTSTATUS status;
9876 TALLOC_CTX *mem_ctx;
9877
9878 if (state->out_mem_ctx) {
9879 mem_ctx = state->out_mem_ctx;
9880 } else {
9881 mem_ctx = state;
9882 }
9883
9884 status = state->dispatch_recv(subreq, mem_ctx);
9885 TALLOC_FREE(subreq);
9886 if (!NT_STATUS_IS_OK(status)) {
9887 tevent_req_nterror(req, status);
9888 return;
9889 }
9890
9891 /* Copy out parameters */
9892 *state->orig.out.handle = *state->tmp.out.handle;
9893
9894 /* Copy result */
9895 state->orig.out.result = state->tmp.out.result;
9896
9897 /* Reset temporary structure */
9898 ZERO_STRUCT(state->tmp);
9899
9900 if (DEBUGLEVEL >= 10) {
9901 NDR_PRINT_OUT_DEBUG(spoolss_ReplyOpenPrinter, &state->orig);
9902 }
9903
9904 tevent_req_done(req);
9905 }
9906
9907 NTSTATUS rpccli_spoolss_ReplyOpenPrinter_recv(struct tevent_req *req,
9908 TALLOC_CTX *mem_ctx,
9909 WERROR *result)
9910 {
9911 struct rpccli_spoolss_ReplyOpenPrinter_state *state = tevent_req_data(
9912 req, struct rpccli_spoolss_ReplyOpenPrinter_state);
9913 NTSTATUS status;
9914
9915 if (tevent_req_is_nterror(req, &status)) {
9916 tevent_req_received(req);
9917 return status;
9918 }
9919
9920 /* Steal possbile out parameters to the callers context */
9921 talloc_steal(mem_ctx, state->out_mem_ctx);
9922
9923 /* Return result */
9924 *result = state->orig.out.result;
9925
9926 tevent_req_received(req);
9927 return NT_STATUS_OK;
9928 }
9929
9930 NTSTATUS rpccli_spoolss_ReplyOpenPrinter(struct rpc_pipe_client *cli,
9931 TALLOC_CTX *mem_ctx,
9932 const char *server_name /* [in] [charset(UTF16)] */,
9933 uint32_t printer_local /* [in] */,
9934 enum winreg_Type type /* [in] */,
9935 uint32_t bufsize /* [in] [range(0,512)] */,
9936 uint8_t *buffer /* [in] [unique,size_is(bufsize)] */,
9937 struct policy_handle *handle /* [out] [ref] */,
9938 WERROR *werror)
9939 {
9940 struct spoolss_ReplyOpenPrinter r;
9941 NTSTATUS status;
9942
9943 /* In parameters */
9944 r.in.server_name = server_name;
9945 r.in.printer_local = printer_local;
9946 r.in.type = type;
9947 r.in.bufsize = bufsize;
9948 r.in.buffer = buffer;
9949
9950 if (DEBUGLEVEL >= 10) {
9951 NDR_PRINT_IN_DEBUG(spoolss_ReplyOpenPrinter, &r);
9952 }
9953
9954 status = cli->dispatch(cli,
9955 mem_ctx,
9956 &ndr_table_spoolss,
9957 NDR_SPOOLSS_REPLYOPENPRINTER,
9958 &r);
9959
9960 if (!NT_STATUS_IS_OK(status)) {
9961 return status;
9962 }
9963
9964 if (DEBUGLEVEL >= 10) {
9965 NDR_PRINT_OUT_DEBUG(spoolss_ReplyOpenPrinter, &r);
9966 }
9967
9968 if (NT_STATUS_IS_ERR(status)) {
9969 return status;
9970 }
9971
9972 /* Return variables */
9973 *handle = *r.out.handle;
9974
9975 /* Return result */
9976 if (werror) {
9977 *werror = r.out.result;
9978 }
9979
9980 return werror_to_ntstatus(r.out.result);
9981 }
9982
9983 struct rpccli_spoolss_RouterReplyPrinter_state {
9984 struct spoolss_RouterReplyPrinter orig;
9985 struct spoolss_RouterReplyPrinter tmp;
9986 TALLOC_CTX *out_mem_ctx;
9987 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9988 };
9989
9990 static void rpccli_spoolss_RouterReplyPrinter_done(struct tevent_req *subreq);
9991
9992 struct tevent_req *rpccli_spoolss_RouterReplyPrinter_send(TALLOC_CTX *mem_ctx,
9993 struct tevent_context *ev,
9994 struct rpc_pipe_client *cli,
9995 struct policy_handle *_handle /* [in] [ref] */,
9996 uint32_t _flags /* [in] */,
9997 uint32_t _bufsize /* [in] [range(0,512)] */,
9998 uint8_t *_buffer /* [in] [unique,size_is(bufsize)] */)
9999 {
10000 struct tevent_req *req;
10001 struct rpccli_spoolss_RouterReplyPrinter_state *state;
10002 struct tevent_req *subreq;
10003
10004 req = tevent_req_create(mem_ctx, &state,
10005 struct rpccli_spoolss_RouterReplyPrinter_state);
10006 if (req == NULL) {
10007 return NULL;
10008 }
10009 state->out_mem_ctx = NULL;
10010 state->dispatch_recv = cli->dispatch_recv;
10011
10012 /* In parameters */
10013 state->orig.in.handle = _handle;
10014 state->orig.in.flags = _flags;
10015 state->orig.in.bufsize = _bufsize;
10016 state->orig.in.buffer = _buffer;
10017
10018 /* Out parameters */
10019
10020 /* Result */
10021 ZERO_STRUCT(state->orig.out.result);
10022
10023 if (DEBUGLEVEL >= 10) {
10024 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinter, &state->orig);
10025 }
10026
10027 /* make a temporary copy, that we pass to the dispatch function */
10028 state->tmp = state->orig;
10029
10030 subreq = cli->dispatch_send(state, ev, cli,
10031 &ndr_table_spoolss,
10032 NDR_SPOOLSS_ROUTERREPLYPRINTER,
10033 &state->tmp);
10034 if (tevent_req_nomem(subreq, req)) {
10035 return tevent_req_post(req, ev);
10036 }
10037 tevent_req_set_callback(subreq, rpccli_spoolss_RouterReplyPrinter_done, req);
10038 return req;
10039 }
10040
10041 static void rpccli_spoolss_RouterReplyPrinter_done(struct tevent_req *subreq)
10042 {
10043 struct tevent_req *req = tevent_req_callback_data(
10044 subreq, struct tevent_req);
10045 struct rpccli_spoolss_RouterReplyPrinter_state *state = tevent_req_data(
10046 req, struct rpccli_spoolss_RouterReplyPrinter_state);
10047 NTSTATUS status;
10048 TALLOC_CTX *mem_ctx;
10049
10050 if (state->out_mem_ctx) {
10051 mem_ctx = state->out_mem_ctx;
10052 } else {
10053 mem_ctx = state;
10054 }
10055
10056 status = state->dispatch_recv(subreq, mem_ctx);
10057 TALLOC_FREE(subreq);
10058 if (!NT_STATUS_IS_OK(status)) {
10059 tevent_req_nterror(req, status);
10060 return;
10061 }
10062
10063 /* Copy out parameters */
10064
10065 /* Copy result */
10066 state->orig.out.result = state->tmp.out.result;
10067
10068 /* Reset temporary structure */
10069 ZERO_STRUCT(state->tmp);
10070
10071 if (DEBUGLEVEL >= 10) {
10072 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinter, &state->orig);
10073 }
10074
10075 tevent_req_done(req);
10076 }
10077
10078 NTSTATUS rpccli_spoolss_RouterReplyPrinter_recv(struct tevent_req *req,
10079 TALLOC_CTX *mem_ctx,
10080 WERROR *result)
10081 {
10082 struct rpccli_spoolss_RouterReplyPrinter_state *state = tevent_req_data(
10083 req, struct rpccli_spoolss_RouterReplyPrinter_state);
10084 NTSTATUS status;
10085
10086 if (tevent_req_is_nterror(req, &status)) {
10087 tevent_req_received(req);
10088 return status;
10089 }
10090
10091 /* Steal possbile out parameters to the callers context */
10092 talloc_steal(mem_ctx, state->out_mem_ctx);
10093
10094 /* Return result */
10095 *result = state->orig.out.result;
10096
10097 tevent_req_received(req);
10098 return NT_STATUS_OK;
10099 }
10100
10101 NTSTATUS rpccli_spoolss_RouterReplyPrinter(struct rpc_pipe_client *cli,
10102 TALLOC_CTX *mem_ctx,
10103 struct policy_handle *handle /* [in] [ref] */,
10104 uint32_t flags /* [in] */,
10105 uint32_t bufsize /* [in] [range(0,512)] */,
10106 uint8_t *buffer /* [in] [unique,size_is(bufsize)] */,
10107 WERROR *werror)
10108 {
10109 struct spoolss_RouterReplyPrinter r;
10110 NTSTATUS status;
10111
10112 /* In parameters */
10113 r.in.handle = handle;
10114 r.in.flags = flags;
10115 r.in.bufsize = bufsize;
10116 r.in.buffer = buffer;
10117
10118 if (DEBUGLEVEL >= 10) {
10119 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinter, &r);
10120 }
10121
10122 status = cli->dispatch(cli,
10123 mem_ctx,
10124 &ndr_table_spoolss,
10125 NDR_SPOOLSS_ROUTERREPLYPRINTER,
10126 &r);
10127
10128 if (!NT_STATUS_IS_OK(status)) {
10129 return status;
10130 }
10131
10132 if (DEBUGLEVEL >= 10) {
10133 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinter, &r);
10134 }
10135
10136 if (NT_STATUS_IS_ERR(status)) {
10137 return status;
10138 }
10139
10140 /* Return variables */
10141
10142 /* Return result */
10143 if (werror) {
10144 *werror = r.out.result;
10145 }
10146
10147 return werror_to_ntstatus(r.out.result);
10148 }
10149
10150 struct rpccli_spoolss_ReplyClosePrinter_state {
10151 struct spoolss_ReplyClosePrinter orig;
10152 struct spoolss_ReplyClosePrinter tmp;
10153 TALLOC_CTX *out_mem_ctx;
10154 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10155 };
10156
10157 static void rpccli_spoolss_ReplyClosePrinter_done(struct tevent_req *subreq);
10158
10159 struct tevent_req *rpccli_spoolss_ReplyClosePrinter_send(TALLOC_CTX *mem_ctx,
10160 struct tevent_context *ev,
10161 struct rpc_pipe_client *cli,
10162 struct policy_handle *_handle /* [in,out] [ref] */)
10163 {
10164 struct tevent_req *req;
10165 struct rpccli_spoolss_ReplyClosePrinter_state *state;
10166 struct tevent_req *subreq;
10167
10168 req = tevent_req_create(mem_ctx, &state,
10169 struct rpccli_spoolss_ReplyClosePrinter_state);
10170 if (req == NULL) {
10171 return NULL;
10172 }
10173 state->out_mem_ctx = NULL;
10174 state->dispatch_recv = cli->dispatch_recv;
10175
10176 /* In parameters */
10177 state->orig.in.handle = _handle;
10178
10179 /* Out parameters */
10180 state->orig.out.handle = _handle;
10181
10182 /* Result */
10183 ZERO_STRUCT(state->orig.out.result);
10184
10185 if (DEBUGLEVEL >= 10) {
10186 NDR_PRINT_IN_DEBUG(spoolss_ReplyClosePrinter, &state->orig);
10187 }
10188
10189 state->out_mem_ctx = talloc_named_const(state, 0,
10190 "rpccli_spoolss_ReplyClosePrinter_out_memory");
10191 if (tevent_req_nomem(state->out_mem_ctx, req)) {
10192 return tevent_req_post(req, ev);
10193 }
10194
10195 /* make a temporary copy, that we pass to the dispatch function */
10196 state->tmp = state->orig;
10197
10198 subreq = cli->dispatch_send(state, ev, cli,
10199 &ndr_table_spoolss,
10200 NDR_SPOOLSS_REPLYCLOSEPRINTER,
10201 &state->tmp);
10202 if (tevent_req_nomem(subreq, req)) {
10203 return tevent_req_post(req, ev);
10204 }
10205 tevent_req_set_callback(subreq, rpccli_spoolss_ReplyClosePrinter_done, req);
10206 return req;
10207 }
10208
10209 static void rpccli_spoolss_ReplyClosePrinter_done(struct tevent_req *subreq)
10210 {
10211 struct tevent_req *req = tevent_req_callback_data(
10212 subreq, struct tevent_req);
10213 struct rpccli_spoolss_ReplyClosePrinter_state *state = tevent_req_data(
10214 req, struct rpccli_spoolss_ReplyClosePrinter_state);
10215 NTSTATUS status;
10216 TALLOC_CTX *mem_ctx;
10217
10218 if (state->out_mem_ctx) {
10219 mem_ctx = state->out_mem_ctx;
10220 } else {
10221 mem_ctx = state;
10222 }
10223
10224 status = state->dispatch_recv(subreq, mem_ctx);
10225 TALLOC_FREE(subreq);
10226 if (!NT_STATUS_IS_OK(status)) {
10227 tevent_req_nterror(req, status);
10228 return;
10229 }
10230
10231 /* Copy out parameters */
10232 *state->orig.out.handle = *state->tmp.out.handle;
10233
10234 /* Copy result */
10235 state->orig.out.result = state->tmp.out.result;
10236
10237 /* Reset temporary structure */
10238 ZERO_STRUCT(state->tmp);
10239
10240 if (DEBUGLEVEL >= 10) {
10241 NDR_PRINT_OUT_DEBUG(spoolss_ReplyClosePrinter, &state->orig);
10242 }
10243
10244 tevent_req_done(req);
10245 }
10246
10247 NTSTATUS rpccli_spoolss_ReplyClosePrinter_recv(struct tevent_req *req,
10248 TALLOC_CTX *mem_ctx,
10249 WERROR *result)
10250 {
10251 struct rpccli_spoolss_ReplyClosePrinter_state *state = tevent_req_data(
10252 req, struct rpccli_spoolss_ReplyClosePrinter_state);
10253 NTSTATUS status;
10254
10255 if (tevent_req_is_nterror(req, &status)) {
10256 tevent_req_received(req);
10257 return status;
10258 }
10259
10260 /* Steal possbile out parameters to the callers context */
10261 talloc_steal(mem_ctx, state->out_mem_ctx);
10262
10263 /* Return result */
10264 *result = state->orig.out.result;
10265
10266 tevent_req_received(req);
10267 return NT_STATUS_OK;
10268 }
10269
10270 NTSTATUS rpccli_spoolss_ReplyClosePrinter(struct rpc_pipe_client *cli,
10271 TALLOC_CTX *mem_ctx,
10272 struct policy_handle *handle /* [in,out] [ref] */,
10273 WERROR *werror)
10274 {
10275 struct spoolss_ReplyClosePrinter r;
10276 NTSTATUS status;
10277
10278 /* In parameters */
10279 r.in.handle = handle;
10280
10281 if (DEBUGLEVEL >= 10) {
10282 NDR_PRINT_IN_DEBUG(spoolss_ReplyClosePrinter, &r);
10283 }
10284
10285 status = cli->dispatch(cli,
10286 mem_ctx,
10287 &ndr_table_spoolss,
10288 NDR_SPOOLSS_REPLYCLOSEPRINTER,
10289 &r);
10290
10291 if (!NT_STATUS_IS_OK(status)) {
10292 return status;
10293 }
10294
10295 if (DEBUGLEVEL >= 10) {
10296 NDR_PRINT_OUT_DEBUG(spoolss_ReplyClosePrinter, &r);
10297 }
10298
10299 if (NT_STATUS_IS_ERR(status)) {
10300 return status;
10301 }
10302
10303 /* Return variables */
10304 *handle = *r.out.handle;
10305
10306 /* Return result */
10307 if (werror) {
10308 *werror = r.out.result;
10309 }
10310
10311 return werror_to_ntstatus(r.out.result);
10312 }
10313
10314 struct rpccli_spoolss_AddPortEx_state {
10315 struct spoolss_AddPortEx orig;
10316 struct spoolss_AddPortEx tmp;
10317 TALLOC_CTX *out_mem_ctx;
10318 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10319 };
10320
10321 static void rpccli_spoolss_AddPortEx_done(struct tevent_req *subreq);
10322
10323 struct tevent_req *rpccli_spoolss_AddPortEx_send(TALLOC_CTX *mem_ctx,
10324 struct tevent_context *ev,
10325 struct rpc_pipe_client *cli)
10326 {
10327 struct tevent_req *req;
10328 struct rpccli_spoolss_AddPortEx_state *state;
10329 struct tevent_req *subreq;
10330
10331 req = tevent_req_create(mem_ctx, &state,
10332 struct rpccli_spoolss_AddPortEx_state);
10333 if (req == NULL) {
10334 return NULL;
10335 }
10336 state->out_mem_ctx = NULL;
10337 state->dispatch_recv = cli->dispatch_recv;
10338
10339 /* In parameters */
10340
10341 /* Out parameters */
10342
10343 /* Result */
10344 ZERO_STRUCT(state->orig.out.result);
10345
10346 if (DEBUGLEVEL >= 10) {
10347 NDR_PRINT_IN_DEBUG(spoolss_AddPortEx, &state->orig);
10348 }
10349
10350 /* make a temporary copy, that we pass to the dispatch function */
10351 state->tmp = state->orig;
10352
10353 subreq = cli->dispatch_send(state, ev, cli,
10354 &ndr_table_spoolss,
10355 NDR_SPOOLSS_ADDPORTEX,
10356 &state->tmp);
10357 if (tevent_req_nomem(subreq, req)) {
10358 return tevent_req_post(req, ev);
10359 }
10360 tevent_req_set_callback(subreq, rpccli_spoolss_AddPortEx_done, req);
10361 return req;
10362 }
10363
10364 static void rpccli_spoolss_AddPortEx_done(struct tevent_req *subreq)
10365 {
10366 struct tevent_req *req = tevent_req_callback_data(
10367 subreq, struct tevent_req);
10368 struct rpccli_spoolss_AddPortEx_state *state = tevent_req_data(
10369 req, struct rpccli_spoolss_AddPortEx_state);
10370 NTSTATUS status;
10371 TALLOC_CTX *mem_ctx;
10372
10373 if (state->out_mem_ctx) {
10374 mem_ctx = state->out_mem_ctx;
10375 } else {
10376 mem_ctx = state;
10377 }
10378
10379 status = state->dispatch_recv(subreq, mem_ctx);
10380 TALLOC_FREE(subreq);
10381 if (!NT_STATUS_IS_OK(status)) {
10382 tevent_req_nterror(req, status);
10383 return;
10384 }
10385
10386 /* Copy out parameters */
10387
10388 /* Copy result */
10389 state->orig.out.result = state->tmp.out.result;
10390
10391 /* Reset temporary structure */
10392 ZERO_STRUCT(state->tmp);
10393
10394 if (DEBUGLEVEL >= 10) {
10395 NDR_PRINT_OUT_DEBUG(spoolss_AddPortEx, &state->orig);
10396 }
10397
10398 tevent_req_done(req);
10399 }
10400
10401 NTSTATUS rpccli_spoolss_AddPortEx_recv(struct tevent_req *req,
10402 TALLOC_CTX *mem_ctx,
10403 WERROR *result)
10404 {
10405 struct rpccli_spoolss_AddPortEx_state *state = tevent_req_data(
10406 req, struct rpccli_spoolss_AddPortEx_state);
10407 NTSTATUS status;
10408
10409 if (tevent_req_is_nterror(req, &status)) {
10410 tevent_req_received(req);
10411 return status;
10412 }
10413
10414 /* Steal possbile out parameters to the callers context */
10415 talloc_steal(mem_ctx, state->out_mem_ctx);
10416
10417 /* Return result */
10418 *result = state->orig.out.result;
10419
10420 tevent_req_received(req);
10421 return NT_STATUS_OK;
10422 }
10423
10424 NTSTATUS rpccli_spoolss_AddPortEx(struct rpc_pipe_client *cli,
10425 TALLOC_CTX *mem_ctx,
10426 WERROR *werror)
10427 {
10428 struct spoolss_AddPortEx r;
10429 NTSTATUS status;
10430
10431 /* In parameters */
10432
10433 if (DEBUGLEVEL >= 10) {
10434 NDR_PRINT_IN_DEBUG(spoolss_AddPortEx, &r);
10435 }
10436
10437 status = cli->dispatch(cli,
10438 mem_ctx,
10439 &ndr_table_spoolss,
10440 NDR_SPOOLSS_ADDPORTEX,
10441 &r);
10442
10443 if (!NT_STATUS_IS_OK(status)) {
10444 return status;
10445 }
10446
10447 if (DEBUGLEVEL >= 10) {
10448 NDR_PRINT_OUT_DEBUG(spoolss_AddPortEx, &r);
10449 }
10450
10451 if (NT_STATUS_IS_ERR(status)) {
10452 return status;
10453 }
10454
10455 /* Return variables */
10456
10457 /* Return result */
10458 if (werror) {
10459 *werror = r.out.result;
10460 }
10461
10462 return werror_to_ntstatus(r.out.result);
10463 }
10464
10465 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state {
10466 struct spoolss_RouterFindFirstPrinterChangeNotification orig;
10467 struct spoolss_RouterFindFirstPrinterChangeNotification tmp;
10468 TALLOC_CTX *out_mem_ctx;
10469 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10470 };
10471
10472 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotification_done(struct tevent_req *subreq);
10473
10474 struct tevent_req *rpccli_spoolss_RouterFindFirstPrinterChangeNotification_send(TALLOC_CTX *mem_ctx,
10475 struct tevent_context *ev,
10476 struct rpc_pipe_client *cli)
10477 {
10478 struct tevent_req *req;
10479 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state *state;
10480 struct tevent_req *subreq;
10481
10482 req = tevent_req_create(mem_ctx, &state,
10483 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state);
10484 if (req == NULL) {
10485 return NULL;
10486 }
10487 state->out_mem_ctx = NULL;
10488 state->dispatch_recv = cli->dispatch_recv;
10489
10490 /* In parameters */
10491
10492 /* Out parameters */
10493
10494 /* Result */
10495 ZERO_STRUCT(state->orig.out.result);
10496
10497 if (DEBUGLEVEL >= 10) {
10498 NDR_PRINT_IN_DEBUG(spoolss_RouterFindFirstPrinterChangeNotification, &state->orig);
10499 }
10500
10501 /* make a temporary copy, that we pass to the dispatch function */
10502 state->tmp = state->orig;
10503
10504 subreq = cli->dispatch_send(state, ev, cli,
10505 &ndr_table_spoolss,
10506 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION,
10507 &state->tmp);
10508 if (tevent_req_nomem(subreq, req)) {
10509 return tevent_req_post(req, ev);
10510 }
10511 tevent_req_set_callback(subreq, rpccli_spoolss_RouterFindFirstPrinterChangeNotification_done, req);
10512 return req;
10513 }
10514
10515 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotification_done(struct tevent_req *subreq)
10516 {
10517 struct tevent_req *req = tevent_req_callback_data(
10518 subreq, struct tevent_req);
10519 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state *state = tevent_req_data(
10520 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state);
10521 NTSTATUS status;
10522 TALLOC_CTX *mem_ctx;
10523
10524 if (state->out_mem_ctx) {
10525 mem_ctx = state->out_mem_ctx;
10526 } else {
10527 mem_ctx = state;
10528 }
10529
10530 status = state->dispatch_recv(subreq, mem_ctx);
10531 TALLOC_FREE(subreq);
10532 if (!NT_STATUS_IS_OK(status)) {
10533 tevent_req_nterror(req, status);
10534 return;
10535 }
10536
10537 /* Copy out parameters */
10538
10539 /* Copy result */
10540 state->orig.out.result = state->tmp.out.result;
10541
10542 /* Reset temporary structure */
10543 ZERO_STRUCT(state->tmp);
10544
10545 if (DEBUGLEVEL >= 10) {
10546 NDR_PRINT_OUT_DEBUG(spoolss_RouterFindFirstPrinterChangeNotification, &state->orig);
10547 }
10548
10549 tevent_req_done(req);
10550 }
10551
10552 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotification_recv(struct tevent_req *req,
10553 TALLOC_CTX *mem_ctx,
10554 WERROR *result)
10555 {
10556 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state *state = tevent_req_data(
10557 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state);
10558 NTSTATUS status;
10559
10560 if (tevent_req_is_nterror(req, &status)) {
10561 tevent_req_received(req);
10562 return status;
10563 }
10564
10565 /* Steal possbile out parameters to the callers context */
10566 talloc_steal(mem_ctx, state->out_mem_ctx);
10567
10568 /* Return result */
10569 *result = state->orig.out.result;
10570
10571 tevent_req_received(req);
10572 return NT_STATUS_OK;
10573 }
10574
10575 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotification(struct rpc_pipe_client *cli,
10576 TALLOC_CTX *mem_ctx,
10577 WERROR *werror)
10578 {
10579 struct spoolss_RouterFindFirstPrinterChangeNotification r;
10580 NTSTATUS status;
10581
10582 /* In parameters */
10583
10584 if (DEBUGLEVEL >= 10) {
10585 NDR_PRINT_IN_DEBUG(spoolss_RouterFindFirstPrinterChangeNotification, &r);
10586 }
10587
10588 status = cli->dispatch(cli,
10589 mem_ctx,
10590 &ndr_table_spoolss,
10591 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION,
10592 &r);
10593
10594 if (!NT_STATUS_IS_OK(status)) {
10595 return status;
10596 }
10597
10598 if (DEBUGLEVEL >= 10) {
10599 NDR_PRINT_OUT_DEBUG(spoolss_RouterFindFirstPrinterChangeNotification, &r);
10600 }
10601
10602 if (NT_STATUS_IS_ERR(status)) {
10603 return status;
10604 }
10605
10606 /* Return variables */
10607
10608 /* Return result */
10609 if (werror) {
10610 *werror = r.out.result;
10611 }
10612
10613 return werror_to_ntstatus(r.out.result);
10614 }
10615
10616 struct rpccli_spoolss_SpoolerInit_state {
10617 struct spoolss_SpoolerInit orig;
10618 struct spoolss_SpoolerInit tmp;
10619 TALLOC_CTX *out_mem_ctx;
10620 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10621 };
10622
10623 static void rpccli_spoolss_SpoolerInit_done(struct tevent_req *subreq);
10624
10625 struct tevent_req *rpccli_spoolss_SpoolerInit_send(TALLOC_CTX *mem_ctx,
10626 struct tevent_context *ev,
10627 struct rpc_pipe_client *cli)
10628 {
10629 struct tevent_req *req;
10630 struct rpccli_spoolss_SpoolerInit_state *state;
10631 struct tevent_req *subreq;
10632
10633 req = tevent_req_create(mem_ctx, &state,
10634 struct rpccli_spoolss_SpoolerInit_state);
10635 if (req == NULL) {
10636 return NULL;
10637 }
10638 state->out_mem_ctx = NULL;
10639 state->dispatch_recv = cli->dispatch_recv;
10640
10641 /* In parameters */
10642
10643 /* Out parameters */
10644
10645 /* Result */
10646 ZERO_STRUCT(state->orig.out.result);
10647
10648 if (DEBUGLEVEL >= 10) {
10649 NDR_PRINT_IN_DEBUG(spoolss_SpoolerInit, &state->orig);
10650 }
10651
10652 /* make a temporary copy, that we pass to the dispatch function */
10653 state->tmp = state->orig;
10654
10655 subreq = cli->dispatch_send(state, ev, cli,
10656 &ndr_table_spoolss,
10657 NDR_SPOOLSS_SPOOLERINIT,
10658 &state->tmp);
10659 if (tevent_req_nomem(subreq, req)) {
10660 return tevent_req_post(req, ev);
10661 }
10662 tevent_req_set_callback(subreq, rpccli_spoolss_SpoolerInit_done, req);
10663 return req;
10664 }
10665
10666 static void rpccli_spoolss_SpoolerInit_done(struct tevent_req *subreq)
10667 {
10668 struct tevent_req *req = tevent_req_callback_data(
10669 subreq, struct tevent_req);
10670 struct rpccli_spoolss_SpoolerInit_state *state = tevent_req_data(
10671 req, struct rpccli_spoolss_SpoolerInit_state);
10672 NTSTATUS status;
10673 TALLOC_CTX *mem_ctx;
10674
10675 if (state->out_mem_ctx) {
10676 mem_ctx = state->out_mem_ctx;
10677 } else {
10678 mem_ctx = state;
10679 }
10680
10681 status = state->dispatch_recv(subreq, mem_ctx);
10682 TALLOC_FREE(subreq);
10683 if (!NT_STATUS_IS_OK(status)) {
10684 tevent_req_nterror(req, status);
10685 return;
10686 }
10687
10688 /* Copy out parameters */
10689
10690 /* Copy result */
10691 state->orig.out.result = state->tmp.out.result;
10692
10693 /* Reset temporary structure */
10694 ZERO_STRUCT(state->tmp);
10695
10696 if (DEBUGLEVEL >= 10) {
10697 NDR_PRINT_OUT_DEBUG(spoolss_SpoolerInit, &state->orig);
10698 }
10699
10700 tevent_req_done(req);
10701 }
10702
10703 NTSTATUS rpccli_spoolss_SpoolerInit_recv(struct tevent_req *req,
10704 TALLOC_CTX *mem_ctx,
10705 WERROR *result)
10706 {
10707 struct rpccli_spoolss_SpoolerInit_state *state = tevent_req_data(
10708 req, struct rpccli_spoolss_SpoolerInit_state);
10709 NTSTATUS status;
10710
10711 if (tevent_req_is_nterror(req, &status)) {
10712 tevent_req_received(req);
10713 return status;
10714 }
10715
10716 /* Steal possbile out parameters to the callers context */
10717 talloc_steal(mem_ctx, state->out_mem_ctx);
10718
10719 /* Return result */
10720 *result = state->orig.out.result;
10721
10722 tevent_req_received(req);
10723 return NT_STATUS_OK;
10724 }
10725
10726 NTSTATUS rpccli_spoolss_SpoolerInit(struct rpc_pipe_client *cli,
10727 TALLOC_CTX *mem_ctx,
10728 WERROR *werror)
10729 {
10730 struct spoolss_SpoolerInit r;
10731 NTSTATUS status;
10732
10733 /* In parameters */
10734
10735 if (DEBUGLEVEL >= 10) {
10736 NDR_PRINT_IN_DEBUG(spoolss_SpoolerInit, &r);
10737 }
10738
10739 status = cli->dispatch(cli,
10740 mem_ctx,
10741 &ndr_table_spoolss,
10742 NDR_SPOOLSS_SPOOLERINIT,
10743 &r);
10744
10745 if (!NT_STATUS_IS_OK(status)) {
10746 return status;
10747 }
10748
10749 if (DEBUGLEVEL >= 10) {
10750 NDR_PRINT_OUT_DEBUG(spoolss_SpoolerInit, &r);
10751 }
10752
10753 if (NT_STATUS_IS_ERR(status)) {
10754 return status;
10755 }
10756
10757 /* Return variables */
10758
10759 /* Return result */
10760 if (werror) {
10761 *werror = r.out.result;
10762 }
10763
10764 return werror_to_ntstatus(r.out.result);
10765 }
10766
10767 struct rpccli_spoolss_ResetPrinterEx_state {
10768 struct spoolss_ResetPrinterEx orig;
10769 struct spoolss_ResetPrinterEx tmp;
10770 TALLOC_CTX *out_mem_ctx;
10771 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10772 };
10773
10774 static void rpccli_spoolss_ResetPrinterEx_done(struct tevent_req *subreq);
10775
10776 struct tevent_req *rpccli_spoolss_ResetPrinterEx_send(TALLOC_CTX *mem_ctx,
10777 struct tevent_context *ev,
10778 struct rpc_pipe_client *cli)
10779 {
10780 struct tevent_req *req;
10781 struct rpccli_spoolss_ResetPrinterEx_state *state;
10782 struct tevent_req *subreq;
10783
10784 req = tevent_req_create(mem_ctx, &state,
10785 struct rpccli_spoolss_ResetPrinterEx_state);
10786 if (req == NULL) {
10787 return NULL;
10788 }
10789 state->out_mem_ctx = NULL;
10790 state->dispatch_recv = cli->dispatch_recv;
10791
10792 /* In parameters */
10793
10794 /* Out parameters */
10795
10796 /* Result */
10797 ZERO_STRUCT(state->orig.out.result);
10798
10799 if (DEBUGLEVEL >= 10) {
10800 NDR_PRINT_IN_DEBUG(spoolss_ResetPrinterEx, &state->orig);
10801 }
10802
10803 /* make a temporary copy, that we pass to the dispatch function */
10804 state->tmp = state->orig;
10805
10806 subreq = cli->dispatch_send(state, ev, cli,
10807 &ndr_table_spoolss,
10808 NDR_SPOOLSS_RESETPRINTEREX,
10809 &state->tmp);
10810 if (tevent_req_nomem(subreq, req)) {
10811 return tevent_req_post(req, ev);
10812 }
10813 tevent_req_set_callback(subreq, rpccli_spoolss_ResetPrinterEx_done, req);
10814 return req;
10815 }
10816
10817 static void rpccli_spoolss_ResetPrinterEx_done(struct tevent_req *subreq)
10818 {
10819 struct tevent_req *req = tevent_req_callback_data(
10820 subreq, struct tevent_req);
10821 struct rpccli_spoolss_ResetPrinterEx_state *state = tevent_req_data(
10822 req, struct rpccli_spoolss_ResetPrinterEx_state);
10823 NTSTATUS status;
10824 TALLOC_CTX *mem_ctx;
10825
10826 if (state->out_mem_ctx) {
10827 mem_ctx = state->out_mem_ctx;
10828 } else {
10829 mem_ctx = state;
10830 }
10831
10832 status = state->dispatch_recv(subreq, mem_ctx);
10833 TALLOC_FREE(subreq);
10834 if (!NT_STATUS_IS_OK(status)) {
10835 tevent_req_nterror(req, status);
10836 return;
10837 }
10838
10839 /* Copy out parameters */
10840
10841 /* Copy result */
10842 state->orig.out.result = state->tmp.out.result;
10843
10844 /* Reset temporary structure */
10845 ZERO_STRUCT(state->tmp);
10846
10847 if (DEBUGLEVEL >= 10) {
10848 NDR_PRINT_OUT_DEBUG(spoolss_ResetPrinterEx, &state->orig);
10849 }
10850
10851 tevent_req_done(req);
10852 }
10853
10854 NTSTATUS rpccli_spoolss_ResetPrinterEx_recv(struct tevent_req *req,
10855 TALLOC_CTX *mem_ctx,
10856 WERROR *result)
10857 {
10858 struct rpccli_spoolss_ResetPrinterEx_state *state = tevent_req_data(
10859 req, struct rpccli_spoolss_ResetPrinterEx_state);
10860 NTSTATUS status;
10861
10862 if (tevent_req_is_nterror(req, &status)) {
10863 tevent_req_received(req);
10864 return status;
10865 }
10866
10867 /* Steal possbile out parameters to the callers context */
10868 talloc_steal(mem_ctx, state->out_mem_ctx);
10869
10870 /* Return result */
10871 *result = state->orig.out.result;
10872
10873 tevent_req_received(req);
10874 return NT_STATUS_OK;
10875 }
10876
10877 NTSTATUS rpccli_spoolss_ResetPrinterEx(struct rpc_pipe_client *cli,
10878 TALLOC_CTX *mem_ctx,
10879 WERROR *werror)
10880 {
10881 struct spoolss_ResetPrinterEx r;
10882 NTSTATUS status;
10883
10884 /* In parameters */
10885
10886 if (DEBUGLEVEL >= 10) {
10887 NDR_PRINT_IN_DEBUG(spoolss_ResetPrinterEx, &r);
10888 }
10889
10890 status = cli->dispatch(cli,
10891 mem_ctx,
10892 &ndr_table_spoolss,
10893 NDR_SPOOLSS_RESETPRINTEREX,
10894 &r);
10895
10896 if (!NT_STATUS_IS_OK(status)) {
10897 return status;
10898 }
10899
10900 if (DEBUGLEVEL >= 10) {
10901 NDR_PRINT_OUT_DEBUG(spoolss_ResetPrinterEx, &r);
10902 }
10903
10904 if (NT_STATUS_IS_ERR(status)) {
10905 return status;
10906 }
10907
10908 /* Return variables */
10909
10910 /* Return result */
10911 if (werror) {
10912 *werror = r.out.result;
10913 }
10914
10915 return werror_to_ntstatus(r.out.result);
10916 }
10917
10918 struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state {
10919 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx orig;
10920 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx tmp;
10921 TALLOC_CTX *out_mem_ctx;
10922 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10923 };
10924
10925 static void rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_done(struct tevent_req *subreq);
10926
10927 struct tevent_req *rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_send(TALLOC_CTX *mem_ctx,
10928 struct tevent_context *ev,
10929 struct rpc_pipe_client *cli,
10930 struct policy_handle *_handle /* [in] [ref] */,
10931 uint32_t _flags /* [in] */,
10932 uint32_t _options /* [in] */,
10933 const char *_local_machine /* [in] [unique,charset(UTF16)] */,
10934 uint32_t _printer_local /* [in] */,
10935 struct spoolss_NotifyOption *_notify_options /* [in] [unique] */)
10936 {
10937 struct tevent_req *req;
10938 struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state *state;
10939 struct tevent_req *subreq;
10940
10941 req = tevent_req_create(mem_ctx, &state,
10942 struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state);
10943 if (req == NULL) {
10944 return NULL;
10945 }
10946 state->out_mem_ctx = NULL;
10947 state->dispatch_recv = cli->dispatch_recv;
10948
10949 /* In parameters */
10950 state->orig.in.handle = _handle;
10951 state->orig.in.flags = _flags;
10952 state->orig.in.options = _options;
10953 state->orig.in.local_machine = _local_machine;
10954 state->orig.in.printer_local = _printer_local;
10955 state->orig.in.notify_options = _notify_options;
10956
10957 /* Out parameters */
10958
10959 /* Result */
10960 ZERO_STRUCT(state->orig.out.result);
10961
10962 if (DEBUGLEVEL >= 10) {
10963 NDR_PRINT_IN_DEBUG(spoolss_RemoteFindFirstPrinterChangeNotifyEx, &state->orig);
10964 }
10965
10966 /* make a temporary copy, that we pass to the dispatch function */
10967 state->tmp = state->orig;
10968
10969 subreq = cli->dispatch_send(state, ev, cli,
10970 &ndr_table_spoolss,
10971 NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX,
10972 &state->tmp);
10973 if (tevent_req_nomem(subreq, req)) {
10974 return tevent_req_post(req, ev);
10975 }
10976 tevent_req_set_callback(subreq, rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_done, req);
10977 return req;
10978 }
10979
10980 static void rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_done(struct tevent_req *subreq)
10981 {
10982 struct tevent_req *req = tevent_req_callback_data(
10983 subreq, struct tevent_req);
10984 struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state *state = tevent_req_data(
10985 req, struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state);
10986 NTSTATUS status;
10987 TALLOC_CTX *mem_ctx;
10988
10989 if (state->out_mem_ctx) {
10990 mem_ctx = state->out_mem_ctx;
10991 } else {
10992 mem_ctx = state;
10993 }
10994
10995 status = state->dispatch_recv(subreq, mem_ctx);
10996 TALLOC_FREE(subreq);
10997 if (!NT_STATUS_IS_OK(status)) {
10998 tevent_req_nterror(req, status);
10999 return;
11000 }
11001
11002 /* Copy out parameters */
11003
11004 /* Copy result */
11005 state->orig.out.result = state->tmp.out.result;
11006
11007 /* Reset temporary structure */
11008 ZERO_STRUCT(state->tmp);
11009
11010 if (DEBUGLEVEL >= 10) {
11011 NDR_PRINT_OUT_DEBUG(spoolss_RemoteFindFirstPrinterChangeNotifyEx, &state->orig);
11012 }
11013
11014 tevent_req_done(req);
11015 }
11016
11017 NTSTATUS rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_recv(struct tevent_req *req,
11018 TALLOC_CTX *mem_ctx,
11019 WERROR *result)
11020 {
11021 struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state *state = tevent_req_data(
11022 req, struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state);
11023 NTSTATUS status;
11024
11025 if (tevent_req_is_nterror(req, &status)) {
11026 tevent_req_received(req);
11027 return status;
11028 }
11029
11030 /* Steal possbile out parameters to the callers context */
11031 talloc_steal(mem_ctx, state->out_mem_ctx);
11032
11033 /* Return result */
11034 *result = state->orig.out.result;
11035
11036 tevent_req_received(req);
11037 return NT_STATUS_OK;
11038 }
11039
11040 NTSTATUS rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct rpc_pipe_client *cli,
11041 TALLOC_CTX *mem_ctx,
11042 struct policy_handle *handle /* [in] [ref] */,
11043 uint32_t flags /* [in] */,
11044 uint32_t options /* [in] */,
11045 const char *local_machine /* [in] [unique,charset(UTF16)] */,
11046 uint32_t printer_local /* [in] */,
11047 struct spoolss_NotifyOption *notify_options /* [in] [unique] */,
11048 WERROR *werror)
11049 {
11050 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx r;
11051 NTSTATUS status;
11052
11053 /* In parameters */
11054 r.in.handle = handle;
11055 r.in.flags = flags;
11056 r.in.options = options;
11057 r.in.local_machine = local_machine;
11058 r.in.printer_local = printer_local;
11059 r.in.notify_options = notify_options;
11060
11061 if (DEBUGLEVEL >= 10) {
11062 NDR_PRINT_IN_DEBUG(spoolss_RemoteFindFirstPrinterChangeNotifyEx, &r);
11063 }
11064
11065 status = cli->dispatch(cli,
11066 mem_ctx,
11067 &ndr_table_spoolss,
11068 NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX,
11069 &r);
11070
11071 if (!NT_STATUS_IS_OK(status)) {
11072 return status;
11073 }
11074
11075 if (DEBUGLEVEL >= 10) {
11076 NDR_PRINT_OUT_DEBUG(spoolss_RemoteFindFirstPrinterChangeNotifyEx, &r);
11077 }
11078
11079 if (NT_STATUS_IS_ERR(status)) {
11080 return status;
11081 }
11082
11083 /* Return variables */
11084
11085 /* Return result */
11086 if (werror) {
11087 *werror = r.out.result;
11088 }
11089
11090 return werror_to_ntstatus(r.out.result);
11091 }
11092
11093 struct rpccli_spoolss_RouterReplyPrinterEx_state {
11094 struct spoolss_RouterReplyPrinterEx orig;
11095 struct spoolss_RouterReplyPrinterEx tmp;
11096 TALLOC_CTX *out_mem_ctx;
11097 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11098 };
11099
11100 static void rpccli_spoolss_RouterReplyPrinterEx_done(struct tevent_req *subreq);
11101
11102 struct tevent_req *rpccli_spoolss_RouterReplyPrinterEx_send(TALLOC_CTX *mem_ctx,
11103 struct tevent_context *ev,
11104 struct rpc_pipe_client *cli,
11105 struct policy_handle *_handle /* [in] [ref] */,
11106 uint32_t _color /* [in] */,
11107 uint32_t _flags /* [in] */,
11108 uint32_t *_reply_result /* [out] [ref] */,
11109 uint32_t _reply_type /* [in] */,
11110 union spoolss_ReplyPrinterInfo _info /* [in] [switch_is(reply_type)] */)
11111 {
11112 struct tevent_req *req;
11113 struct rpccli_spoolss_RouterReplyPrinterEx_state *state;
11114 struct tevent_req *subreq;
11115
11116 req = tevent_req_create(mem_ctx, &state,
11117 struct rpccli_spoolss_RouterReplyPrinterEx_state);
11118 if (req == NULL) {
11119 return NULL;
11120 }
11121 state->out_mem_ctx = NULL;
11122 state->dispatch_recv = cli->dispatch_recv;
11123
11124 /* In parameters */
11125 state->orig.in.handle = _handle;
11126 state->orig.in.color = _color;
11127 state->orig.in.flags = _flags;
11128 state->orig.in.reply_type = _reply_type;
11129 state->orig.in.info = _info;
11130
11131 /* Out parameters */
11132 state->orig.out.reply_result = _reply_result;
11133
11134 /* Result */
11135 ZERO_STRUCT(state->orig.out.result);
11136
11137 if (DEBUGLEVEL >= 10) {
11138 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinterEx, &state->orig);
11139 }
11140
11141 state->out_mem_ctx = talloc_named_const(state, 0,
11142 "rpccli_spoolss_RouterReplyPrinterEx_out_memory");
11143 if (tevent_req_nomem(state->out_mem_ctx, req)) {
11144 return tevent_req_post(req, ev);
11145 }
11146
11147 /* make a temporary copy, that we pass to the dispatch function */
11148 state->tmp = state->orig;
11149
11150 subreq = cli->dispatch_send(state, ev, cli,
11151 &ndr_table_spoolss,
11152 NDR_SPOOLSS_ROUTERREPLYPRINTEREX,
11153 &state->tmp);
11154 if (tevent_req_nomem(subreq, req)) {
11155 return tevent_req_post(req, ev);
11156 }
11157 tevent_req_set_callback(subreq, rpccli_spoolss_RouterReplyPrinterEx_done, req);
11158 return req;
11159 }
11160
11161 static void rpccli_spoolss_RouterReplyPrinterEx_done(struct tevent_req *subreq)
11162 {
11163 struct tevent_req *req = tevent_req_callback_data(
11164 subreq, struct tevent_req);
11165 struct rpccli_spoolss_RouterReplyPrinterEx_state *state = tevent_req_data(
11166 req, struct rpccli_spoolss_RouterReplyPrinterEx_state);
11167 NTSTATUS status;
11168 TALLOC_CTX *mem_ctx;
11169
11170 if (state->out_mem_ctx) {
11171 mem_ctx = state->out_mem_ctx;
11172 } else {
11173 mem_ctx = state;
11174 }
11175
11176 status = state->dispatch_recv(subreq, mem_ctx);
11177 TALLOC_FREE(subreq);
11178 if (!NT_STATUS_IS_OK(status)) {
11179 tevent_req_nterror(req, status);
11180 return;
11181 }
11182
11183 /* Copy out parameters */
11184 *state->orig.out.reply_result = *state->tmp.out.reply_result;
11185
11186 /* Copy result */
11187 state->orig.out.result = state->tmp.out.result;
11188
11189 /* Reset temporary structure */
11190 ZERO_STRUCT(state->tmp);
11191
11192 if (DEBUGLEVEL >= 10) {
11193 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinterEx, &state->orig);
11194 }
11195
11196 tevent_req_done(req);
11197 }
11198
11199 NTSTATUS rpccli_spoolss_RouterReplyPrinterEx_recv(struct tevent_req *req,
11200 TALLOC_CTX *mem_ctx,
11201 WERROR *result)
11202 {
11203 struct rpccli_spoolss_RouterReplyPrinterEx_state *state = tevent_req_data(
11204 req, struct rpccli_spoolss_RouterReplyPrinterEx_state);
11205 NTSTATUS status;
11206
11207 if (tevent_req_is_nterror(req, &status)) {
11208 tevent_req_received(req);
11209 return status;
11210 }
11211
11212 /* Steal possbile out parameters to the callers context */
11213 talloc_steal(mem_ctx, state->out_mem_ctx);
11214
11215 /* Return result */
11216 *result = state->orig.out.result;
11217
11218 tevent_req_received(req);
11219 return NT_STATUS_OK;
11220 }
11221
11222 NTSTATUS rpccli_spoolss_RouterReplyPrinterEx(struct rpc_pipe_client *cli,
11223 TALLOC_CTX *mem_ctx,
11224 struct policy_handle *handle /* [in] [ref] */,
11225 uint32_t color /* [in] */,
11226 uint32_t flags /* [in] */,
11227 uint32_t *reply_result /* [out] [ref] */,
11228 uint32_t reply_type /* [in] */,
11229 union spoolss_ReplyPrinterInfo info /* [in] [switch_is(reply_type)] */,
11230 WERROR *werror)
11231 {
11232 struct spoolss_RouterReplyPrinterEx r;
11233 NTSTATUS status;
11234
11235 /* In parameters */
11236 r.in.handle = handle;
11237 r.in.color = color;
11238 r.in.flags = flags;
11239 r.in.reply_type = reply_type;
11240 r.in.info = info;
11241
11242 if (DEBUGLEVEL >= 10) {
11243 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinterEx, &r);
11244 }
11245
11246 status = cli->dispatch(cli,
11247 mem_ctx,
11248 &ndr_table_spoolss,
11249 NDR_SPOOLSS_ROUTERREPLYPRINTEREX,
11250 &r);
11251
11252 if (!NT_STATUS_IS_OK(status)) {
11253 return status;
11254 }
11255
11256 if (DEBUGLEVEL >= 10) {
11257 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinterEx, &r);
11258 }
11259
11260 if (NT_STATUS_IS_ERR(status)) {
11261 return status;
11262 }
11263
11264 /* Return variables */
11265 *reply_result = *r.out.reply_result;
11266
11267 /* Return result */
11268 if (werror) {
11269 *werror = r.out.result;
11270 }
11271
11272 return werror_to_ntstatus(r.out.result);
11273 }
11274
11275 struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state {
11276 struct spoolss_RouterRefreshPrinterChangeNotify orig;
11277 struct spoolss_RouterRefreshPrinterChangeNotify tmp;
11278 TALLOC_CTX *out_mem_ctx;
11279 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11280 };
11281
11282 static void rpccli_spoolss_RouterRefreshPrinterChangeNotify_done(struct tevent_req *subreq);
11283
11284 struct tevent_req *rpccli_spoolss_RouterRefreshPrinterChangeNotify_send(TALLOC_CTX *mem_ctx,
11285 struct tevent_context *ev,
11286 struct rpc_pipe_client *cli,
11287 struct policy_handle *_handle /* [in] [ref] */,
11288 uint32_t _change_low /* [in] */,
11289 struct spoolss_NotifyOption *_options /* [in] [unique] */,
11290 struct spoolss_NotifyInfo **_info /* [out] [ref] */)
11291 {
11292 struct tevent_req *req;
11293 struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state *state;
11294 struct tevent_req *subreq;
11295
11296 req = tevent_req_create(mem_ctx, &state,
11297 struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state);
11298 if (req == NULL) {
11299 return NULL;
11300 }
11301 state->out_mem_ctx = NULL;
11302 state->dispatch_recv = cli->dispatch_recv;
11303
11304 /* In parameters */
11305 state->orig.in.handle = _handle;
11306 state->orig.in.change_low = _change_low;
11307 state->orig.in.options = _options;
11308
11309 /* Out parameters */
11310 state->orig.out.info = _info;
11311
11312 /* Result */
11313 ZERO_STRUCT(state->orig.out.result);
11314
11315 if (DEBUGLEVEL >= 10) {
11316 NDR_PRINT_IN_DEBUG(spoolss_RouterRefreshPrinterChangeNotify, &state->orig);
11317 }
11318
11319 state->out_mem_ctx = talloc_named_const(state, 0,
11320 "rpccli_spoolss_RouterRefreshPrinterChangeNotify_out_memory");
11321 if (tevent_req_nomem(state->out_mem_ctx, req)) {
11322 return tevent_req_post(req, ev);
11323 }
11324
11325 /* make a temporary copy, that we pass to the dispatch function */
11326 state->tmp = state->orig;
11327
11328 subreq = cli->dispatch_send(state, ev, cli,
11329 &ndr_table_spoolss,
11330 NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY,
11331 &state->tmp);
11332 if (tevent_req_nomem(subreq, req)) {
11333 return tevent_req_post(req, ev);
11334 }
11335 tevent_req_set_callback(subreq, rpccli_spoolss_RouterRefreshPrinterChangeNotify_done, req);
11336 return req;
11337 }
11338
11339 static void rpccli_spoolss_RouterRefreshPrinterChangeNotify_done(struct tevent_req *subreq)
11340 {
11341 struct tevent_req *req = tevent_req_callback_data(
11342 subreq, struct tevent_req);
11343 struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state *state = tevent_req_data(
11344 req, struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state);
11345 NTSTATUS status;
11346 TALLOC_CTX *mem_ctx;
11347
11348 if (state->out_mem_ctx) {
11349 mem_ctx = state->out_mem_ctx;
11350 } else {
11351 mem_ctx = state;
11352 }
11353
11354 status = state->dispatch_recv(subreq, mem_ctx);
11355 TALLOC_FREE(subreq);
11356 if (!NT_STATUS_IS_OK(status)) {
11357 tevent_req_nterror(req, status);
11358 return;
11359 }
11360
11361 /* Copy out parameters */
11362 *state->orig.out.info = *state->tmp.out.info;
11363
11364 /* Copy result */
11365 state->orig.out.result = state->tmp.out.result;
11366
11367 /* Reset temporary structure */
11368 ZERO_STRUCT(state->tmp);
11369
11370 if (DEBUGLEVEL >= 10) {
11371 NDR_PRINT_OUT_DEBUG(spoolss_RouterRefreshPrinterChangeNotify, &state->orig);
11372 }
11373
11374 tevent_req_done(req);
11375 }
11376
11377 NTSTATUS rpccli_spoolss_RouterRefreshPrinterChangeNotify_recv(struct tevent_req *req,
11378 TALLOC_CTX *mem_ctx,
11379 WERROR *result)
11380 {
11381 struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state *state = tevent_req_data(
11382 req, struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state);
11383 NTSTATUS status;
11384
11385 if (tevent_req_is_nterror(req, &status)) {
11386 tevent_req_received(req);
11387 return status;
11388 }
11389
11390 /* Steal possbile out parameters to the callers context */
11391 talloc_steal(mem_ctx, state->out_mem_ctx);
11392
11393 /* Return result */
11394 *result = state->orig.out.result;
11395
11396 tevent_req_received(req);
11397 return NT_STATUS_OK;
11398 }
11399
11400 NTSTATUS rpccli_spoolss_RouterRefreshPrinterChangeNotify(struct rpc_pipe_client *cli,
11401 TALLOC_CTX *mem_ctx,
11402 struct policy_handle *handle /* [in] [ref] */,
11403 uint32_t change_low /* [in] */,
11404 struct spoolss_NotifyOption *options /* [in] [unique] */,
11405 struct spoolss_NotifyInfo **info /* [out] [ref] */,
11406 WERROR *werror)
11407 {
11408 struct spoolss_RouterRefreshPrinterChangeNotify r;
11409 NTSTATUS status;
11410
11411 /* In parameters */
11412 r.in.handle = handle;
11413 r.in.change_low = change_low;
11414 r.in.options = options;
11415
11416 if (DEBUGLEVEL >= 10) {
11417 NDR_PRINT_IN_DEBUG(spoolss_RouterRefreshPrinterChangeNotify, &r);
11418 }
11419
11420 status = cli->dispatch(cli,
11421 mem_ctx,
11422 &ndr_table_spoolss,
11423 NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY,
11424 &r);
11425
11426 if (!NT_STATUS_IS_OK(status)) {
11427 return status;
11428 }
11429
11430 if (DEBUGLEVEL >= 10) {
11431 NDR_PRINT_OUT_DEBUG(spoolss_RouterRefreshPrinterChangeNotify, &r);
11432 }
11433
11434 if (NT_STATUS_IS_ERR(status)) {
11435 return status;
11436 }
11437
11438 /* Return variables */
11439 *info = *r.out.info;
11440
11441 /* Return result */
11442 if (werror) {
11443 *werror = r.out.result;
11444 }
11445
11446 return werror_to_ntstatus(r.out.result);
11447 }
11448
11449 struct rpccli_spoolss_44_state {
11450 struct spoolss_44 orig;
11451 struct spoolss_44 tmp;
11452 TALLOC_CTX *out_mem_ctx;
11453 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11454 };
11455
11456 static void rpccli_spoolss_44_done(struct tevent_req *subreq);
11457
11458 struct tevent_req *rpccli_spoolss_44_send(TALLOC_CTX *mem_ctx,
11459 struct tevent_context *ev,
11460 struct rpc_pipe_client *cli)
11461 {
11462 struct tevent_req *req;
11463 struct rpccli_spoolss_44_state *state;
11464 struct tevent_req *subreq;
11465
11466 req = tevent_req_create(mem_ctx, &state,
11467 struct rpccli_spoolss_44_state);
11468 if (req == NULL) {
11469 return NULL;
11470 }
11471 state->out_mem_ctx = NULL;
11472 state->dispatch_recv = cli->dispatch_recv;
11473
11474 /* In parameters */
11475
11476 /* Out parameters */
11477
11478 /* Result */
11479 ZERO_STRUCT(state->orig.out.result);
11480
11481 if (DEBUGLEVEL >= 10) {
11482 NDR_PRINT_IN_DEBUG(spoolss_44, &state->orig);
11483 }
11484
11485 /* make a temporary copy, that we pass to the dispatch function */
11486 state->tmp = state->orig;
11487
11488 subreq = cli->dispatch_send(state, ev, cli,
11489 &ndr_table_spoolss,
11490 NDR_SPOOLSS_44,
11491 &state->tmp);
11492 if (tevent_req_nomem(subreq, req)) {
11493 return tevent_req_post(req, ev);
11494 }
11495 tevent_req_set_callback(subreq, rpccli_spoolss_44_done, req);
11496 return req;
11497 }
11498
11499 static void rpccli_spoolss_44_done(struct tevent_req *subreq)
11500 {
11501 struct tevent_req *req = tevent_req_callback_data(
11502 subreq, struct tevent_req);
11503 struct rpccli_spoolss_44_state *state = tevent_req_data(
11504 req, struct rpccli_spoolss_44_state);
11505 NTSTATUS status;
11506 TALLOC_CTX *mem_ctx;
11507
11508 if (state->out_mem_ctx) {
11509 mem_ctx = state->out_mem_ctx;
11510 } else {
11511 mem_ctx = state;
11512 }
11513
11514 status = state->dispatch_recv(subreq, mem_ctx);
11515 TALLOC_FREE(subreq);
11516 if (!NT_STATUS_IS_OK(status)) {
11517 tevent_req_nterror(req, status);
11518 return;
11519 }
11520
11521 /* Copy out parameters */
11522
11523 /* Copy result */
11524 state->orig.out.result = state->tmp.out.result;
11525
11526 /* Reset temporary structure */
11527 ZERO_STRUCT(state->tmp);
11528
11529 if (DEBUGLEVEL >= 10) {
11530 NDR_PRINT_OUT_DEBUG(spoolss_44, &state->orig);
11531 }
11532
11533 tevent_req_done(req);
11534 }
11535
11536 NTSTATUS rpccli_spoolss_44_recv(struct tevent_req *req,
11537 TALLOC_CTX *mem_ctx,
11538 WERROR *result)
11539 {
11540 struct rpccli_spoolss_44_state *state = tevent_req_data(
11541 req, struct rpccli_spoolss_44_state);
11542 NTSTATUS status;
11543
11544 if (tevent_req_is_nterror(req, &status)) {
11545 tevent_req_received(req);
11546 return status;
11547 }
11548
11549 /* Steal possbile out parameters to the callers context */
11550 talloc_steal(mem_ctx, state->out_mem_ctx);
11551
11552 /* Return result */
11553 *result = state->orig.out.result;
11554
11555 tevent_req_received(req);
11556 return NT_STATUS_OK;
11557 }
11558
11559 NTSTATUS rpccli_spoolss_44(struct rpc_pipe_client *cli,
11560 TALLOC_CTX *mem_ctx,
11561 WERROR *werror)
11562 {
11563 struct spoolss_44 r;
11564 NTSTATUS status;
11565
11566 /* In parameters */
11567
11568 if (DEBUGLEVEL >= 10) {
11569 NDR_PRINT_IN_DEBUG(spoolss_44, &r);
11570 }
11571
11572 status = cli->dispatch(cli,
11573 mem_ctx,
11574 &ndr_table_spoolss,
11575 NDR_SPOOLSS_44,
11576 &r);
11577
11578 if (!NT_STATUS_IS_OK(status)) {
11579 return status;
11580 }
11581
11582 if (DEBUGLEVEL >= 10) {
11583 NDR_PRINT_OUT_DEBUG(spoolss_44, &r);
11584 }
11585
11586 if (NT_STATUS_IS_ERR(status)) {
11587 return status;
11588 }
11589
11590 /* Return variables */
11591
11592 /* Return result */
11593 if (werror) {
11594 *werror = r.out.result;
11595 }
11596
11597 return werror_to_ntstatus(r.out.result);
11598 }
11599
11600 struct rpccli_spoolss_OpenPrinterEx_state {
11601 struct spoolss_OpenPrinterEx orig;
11602 struct spoolss_OpenPrinterEx tmp;
11603 TALLOC_CTX *out_mem_ctx;
11604 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11605 };
11606
11607 static void rpccli_spoolss_OpenPrinterEx_done(struct tevent_req *subreq);
11608
11609 struct tevent_req *rpccli_spoolss_OpenPrinterEx_send(TALLOC_CTX *mem_ctx,
11610 struct tevent_context *ev,
11611 struct rpc_pipe_client *cli,
11612 const char *_printername /* [in] [unique,charset(UTF16)] */,
11613 const char *_datatype /* [in] [unique,charset(UTF16)] */,
11614 struct spoolss_DevmodeContainer _devmode_ctr /* [in] */,
11615 uint32_t _access_mask /* [in] */,
11616 uint32_t _level /* [in] */,
11617 union spoolss_UserLevel _userlevel /* [in] [switch_is(level)] */,
11618 struct policy_handle *_handle /* [out] [ref] */)
11619 {
11620 struct tevent_req *req;
11621 struct rpccli_spoolss_OpenPrinterEx_state *state;
11622 struct tevent_req *subreq;
11623
11624 req = tevent_req_create(mem_ctx, &state,
11625 struct rpccli_spoolss_OpenPrinterEx_state);
11626 if (req == NULL) {
11627 return NULL;
11628 }
11629 state->out_mem_ctx = NULL;
11630 state->dispatch_recv = cli->dispatch_recv;
11631
11632 /* In parameters */
11633 state->orig.in.printername = _printername;
11634 state->orig.in.datatype = _datatype;
11635 state->orig.in.devmode_ctr = _devmode_ctr;
11636 state->orig.in.access_mask = _access_mask;
11637 state->orig.in.level = _level;
11638 state->orig.in.userlevel = _userlevel;
11639
11640 /* Out parameters */
11641 state->orig.out.handle = _handle;
11642
11643 /* Result */
11644 ZERO_STRUCT(state->orig.out.result);
11645
11646 if (DEBUGLEVEL >= 10) {
11647 NDR_PRINT_IN_DEBUG(spoolss_OpenPrinterEx, &state->orig);
11648 }
11649
11650 state->out_mem_ctx = talloc_named_const(state, 0,
11651 "rpccli_spoolss_OpenPrinterEx_out_memory");
11652 if (tevent_req_nomem(state->out_mem_ctx, req)) {
11653 return tevent_req_post(req, ev);
11654 }
11655
11656 /* make a temporary copy, that we pass to the dispatch function */
11657 state->tmp = state->orig;
11658
11659 subreq = cli->dispatch_send(state, ev, cli,
11660 &ndr_table_spoolss,
11661 NDR_SPOOLSS_OPENPRINTEREX,
11662 &state->tmp);
11663 if (tevent_req_nomem(subreq, req)) {
11664 return tevent_req_post(req, ev);
11665 }
11666 tevent_req_set_callback(subreq, rpccli_spoolss_OpenPrinterEx_done, req);
11667 return req;
11668 }
11669
11670 static void rpccli_spoolss_OpenPrinterEx_done(struct tevent_req *subreq)
11671 {
11672 struct tevent_req *req = tevent_req_callback_data(
11673 subreq, struct tevent_req);
11674 struct rpccli_spoolss_OpenPrinterEx_state *state = tevent_req_data(
11675 req, struct rpccli_spoolss_OpenPrinterEx_state);
11676 NTSTATUS status;
11677 TALLOC_CTX *mem_ctx;
11678
11679 if (state->out_mem_ctx) {
11680 mem_ctx = state->out_mem_ctx;
11681 } else {
11682 mem_ctx = state;
11683 }
11684
11685 status = state->dispatch_recv(subreq, mem_ctx);
11686 TALLOC_FREE(subreq);
11687 if (!NT_STATUS_IS_OK(status)) {
11688 tevent_req_nterror(req, status);
11689 return;
11690 }
11691
11692 /* Copy out parameters */
11693 *state->orig.out.handle = *state->tmp.out.handle;
11694
11695 /* Copy result */
11696 state->orig.out.result = state->tmp.out.result;
11697
11698 /* Reset temporary structure */
11699 ZERO_STRUCT(state->tmp);
11700
11701 if (DEBUGLEVEL >= 10) {
11702 NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinterEx, &state->orig);
11703 }
11704
11705 tevent_req_done(req);
11706 }
11707
11708 NTSTATUS rpccli_spoolss_OpenPrinterEx_recv(struct tevent_req *req,
11709 TALLOC_CTX *mem_ctx,
11710 WERROR *result)
11711 {
11712 struct rpccli_spoolss_OpenPrinterEx_state *state = tevent_req_data(
11713 req, struct rpccli_spoolss_OpenPrinterEx_state);
11714 NTSTATUS status;
11715
11716 if (tevent_req_is_nterror(req, &status)) {
11717 tevent_req_received(req);
11718 return status;
11719 }
11720
11721 /* Steal possbile out parameters to the callers context */
11722 talloc_steal(mem_ctx, state->out_mem_ctx);
11723
11724 /* Return result */
11725 *result = state->orig.out.result;
11726
11727 tevent_req_received(req);
11728 return NT_STATUS_OK;
11729 }
11730
11731 NTSTATUS rpccli_spoolss_OpenPrinterEx(struct rpc_pipe_client *cli,
11732 TALLOC_CTX *mem_ctx,
11733 const char *printername /* [in] [unique,charset(UTF16)] */,
11734 const char *datatype /* [in] [unique,charset(UTF16)] */,
11735 struct spoolss_DevmodeContainer devmode_ctr /* [in] */,
11736 uint32_t access_mask /* [in] */,
11737 uint32_t level /* [in] */,
11738 union spoolss_UserLevel userlevel /* [in] [switch_is(level)] */,
11739 struct policy_handle *handle /* [out] [ref] */,
11740 WERROR *werror)
11741 {
11742 struct spoolss_OpenPrinterEx r;
11743 NTSTATUS status;
11744
11745 /* In parameters */
11746 r.in.printername = printername;
11747 r.in.datatype = datatype;
11748 r.in.devmode_ctr = devmode_ctr;
11749 r.in.access_mask = access_mask;
11750 r.in.level = level;
11751 r.in.userlevel = userlevel;
11752
11753 if (DEBUGLEVEL >= 10) {
11754 NDR_PRINT_IN_DEBUG(spoolss_OpenPrinterEx, &r);
11755 }
11756
11757 status = cli->dispatch(cli,
11758 mem_ctx,
11759 &ndr_table_spoolss,
11760 NDR_SPOOLSS_OPENPRINTEREX,
11761 &r);
11762
11763 if (!NT_STATUS_IS_OK(status)) {
11764 return status;
11765 }
11766
11767 if (DEBUGLEVEL >= 10) {
11768 NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinterEx, &r);
11769 }
11770
11771 if (NT_STATUS_IS_ERR(status)) {
11772 return status;
11773 }
11774
11775 /* Return variables */
11776 *handle = *r.out.handle;
11777
11778 /* Return result */
11779 if (werror) {
11780 *werror = r.out.result;
11781 }
11782
11783 return werror_to_ntstatus(r.out.result);
11784 }
11785
11786 struct rpccli_spoolss_AddPrinterEx_state {
11787 struct spoolss_AddPrinterEx orig;
11788 struct spoolss_AddPrinterEx tmp;
11789 TALLOC_CTX *out_mem_ctx;
11790 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11791 };
11792
11793 static void rpccli_spoolss_AddPrinterEx_done(struct tevent_req *subreq);
11794
11795 struct tevent_req *rpccli_spoolss_AddPrinterEx_send(TALLOC_CTX *mem_ctx,
11796 struct tevent_context *ev,
11797 struct rpc_pipe_client *cli,
11798 const char *_server /* [in] [unique,charset(UTF16)] */,
11799 struct spoolss_SetPrinterInfoCtr *_info_ctr /* [in] [ref] */,
11800 struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */,
11801 struct sec_desc_buf *_secdesc_ctr /* [in] [ref] */,
11802 struct spoolss_UserLevelCtr *_userlevel_ctr /* [in] [ref] */,
11803 struct policy_handle *_handle /* [out] [ref] */)
11804 {
11805 struct tevent_req *req;
11806 struct rpccli_spoolss_AddPrinterEx_state *state;
11807 struct tevent_req *subreq;
11808
11809 req = tevent_req_create(mem_ctx, &state,
11810 struct rpccli_spoolss_AddPrinterEx_state);
11811 if (req == NULL) {
11812 return NULL;
11813 }
11814 state->out_mem_ctx = NULL;
11815 state->dispatch_recv = cli->dispatch_recv;
11816
11817 /* In parameters */
11818 state->orig.in.server = _server;
11819 state->orig.in.info_ctr = _info_ctr;
11820 state->orig.in.devmode_ctr = _devmode_ctr;
11821 state->orig.in.secdesc_ctr = _secdesc_ctr;
11822 state->orig.in.userlevel_ctr = _userlevel_ctr;
11823
11824 /* Out parameters */
11825 state->orig.out.handle = _handle;
11826
11827 /* Result */
11828 ZERO_STRUCT(state->orig.out.result);
11829
11830 if (DEBUGLEVEL >= 10) {
11831 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterEx, &state->orig);
11832 }
11833
11834 state->out_mem_ctx = talloc_named_const(state, 0,
11835 "rpccli_spoolss_AddPrinterEx_out_memory");
11836 if (tevent_req_nomem(state->out_mem_ctx, req)) {
11837 return tevent_req_post(req, ev);
11838 }
11839
11840 /* make a temporary copy, that we pass to the dispatch function */
11841 state->tmp = state->orig;
11842
11843 subreq = cli->dispatch_send(state, ev, cli,
11844 &ndr_table_spoolss,
11845 NDR_SPOOLSS_ADDPRINTEREX,
11846 &state->tmp);
11847 if (tevent_req_nomem(subreq, req)) {
11848 return tevent_req_post(req, ev);
11849 }
11850 tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterEx_done, req);
11851 return req;
11852 }
11853
11854 static void rpccli_spoolss_AddPrinterEx_done(struct tevent_req *subreq)
11855 {
11856 struct tevent_req *req = tevent_req_callback_data(
11857 subreq, struct tevent_req);
11858 struct rpccli_spoolss_AddPrinterEx_state *state = tevent_req_data(
11859 req, struct rpccli_spoolss_AddPrinterEx_state);
11860 NTSTATUS status;
11861 TALLOC_CTX *mem_ctx;
11862
11863 if (state->out_mem_ctx) {
11864 mem_ctx = state->out_mem_ctx;
11865 } else {
11866 mem_ctx = state;
11867 }
11868
11869 status = state->dispatch_recv(subreq, mem_ctx);
11870 TALLOC_FREE(subreq);
11871 if (!NT_STATUS_IS_OK(status)) {
11872 tevent_req_nterror(req, status);
11873 return;
11874 }
11875
11876 /* Copy out parameters */
11877 *state->orig.out.handle = *state->tmp.out.handle;
11878
11879 /* Copy result */
11880 state->orig.out.result = state->tmp.out.result;
11881
11882 /* Reset temporary structure */
11883 ZERO_STRUCT(state->tmp);
11884
11885 if (DEBUGLEVEL >= 10) {
11886 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterEx, &state->orig);
11887 }
11888
11889 tevent_req_done(req);
11890 }
11891
11892 NTSTATUS rpccli_spoolss_AddPrinterEx_recv(struct tevent_req *req,
11893 TALLOC_CTX *mem_ctx,
11894 WERROR *result)
11895 {
11896 struct rpccli_spoolss_AddPrinterEx_state *state = tevent_req_data(
11897 req, struct rpccli_spoolss_AddPrinterEx_state);
11898 NTSTATUS status;
11899
11900 if (tevent_req_is_nterror(req, &status)) {
11901 tevent_req_received(req);
11902 return status;
11903 }
11904
11905 /* Steal possbile out parameters to the callers context */
11906 talloc_steal(mem_ctx, state->out_mem_ctx);
11907
11908 /* Return result */
11909 *result = state->orig.out.result;
11910
11911 tevent_req_received(req);
11912 return NT_STATUS_OK;
11913 }
11914
11915 NTSTATUS rpccli_spoolss_AddPrinterEx(struct rpc_pipe_client *cli,
11916 TALLOC_CTX *mem_ctx,
11917 const char *server /* [in] [unique,charset(UTF16)] */,
11918 struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */,
11919 struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
11920 struct sec_desc_buf *secdesc_ctr /* [in] [ref] */,
11921 struct spoolss_UserLevelCtr *userlevel_ctr /* [in] [ref] */,
11922 struct policy_handle *handle /* [out] [ref] */,
11923 WERROR *werror)
11924 {
11925 struct spoolss_AddPrinterEx r;
11926 NTSTATUS status;
11927
11928 /* In parameters */
11929 r.in.server = server;
11930 r.in.info_ctr = info_ctr;
11931 r.in.devmode_ctr = devmode_ctr;
11932 r.in.secdesc_ctr = secdesc_ctr;
11933 r.in.userlevel_ctr = userlevel_ctr;
11934
11935 if (DEBUGLEVEL >= 10) {
11936 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterEx, &r);
11937 }
11938
11939 status = cli->dispatch(cli,
11940 mem_ctx,
11941 &ndr_table_spoolss,
11942 NDR_SPOOLSS_ADDPRINTEREX,
11943 &r);
11944
11945 if (!NT_STATUS_IS_OK(status)) {
11946 return status;
11947 }
11948
11949 if (DEBUGLEVEL >= 10) {
11950 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterEx, &r);
11951 }
11952
11953 if (NT_STATUS_IS_ERR(status)) {
11954 return status;
11955 }
11956
11957 /* Return variables */
11958 *handle = *r.out.handle;
11959
11960 /* Return result */
11961 if (werror) {
11962 *werror = r.out.result;
11963 }
11964
11965 return werror_to_ntstatus(r.out.result);
11966 }
11967
11968 struct rpccli_spoolss_47_state {
11969 struct spoolss_47 orig;
11970 struct spoolss_47 tmp;
11971 TALLOC_CTX *out_mem_ctx;
11972 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11973 };
11974
11975 static void rpccli_spoolss_47_done(struct tevent_req *subreq);
11976
11977 struct tevent_req *rpccli_spoolss_47_send(TALLOC_CTX *mem_ctx,
11978 struct tevent_context *ev,
11979 struct rpc_pipe_client *cli)
11980 {
11981 struct tevent_req *req;
11982 struct rpccli_spoolss_47_state *state;
11983 struct tevent_req *subreq;
11984
11985 req = tevent_req_create(mem_ctx, &state,
11986 struct rpccli_spoolss_47_state);
11987 if (req == NULL) {
11988 return NULL;
11989 }
11990 state->out_mem_ctx = NULL;
11991 state->dispatch_recv = cli->dispatch_recv;
11992
11993 /* In parameters */
11994
11995 /* Out parameters */
11996
11997 /* Result */
11998 ZERO_STRUCT(state->orig.out.result);
11999
12000 if (DEBUGLEVEL >= 10) {
12001 NDR_PRINT_IN_DEBUG(spoolss_47, &state->orig);
12002 }
12003
12004 /* make a temporary copy, that we pass to the dispatch function */
12005 state->tmp = state->orig;
12006
12007 subreq = cli->dispatch_send(state, ev, cli,
12008 &ndr_table_spoolss,
12009 NDR_SPOOLSS_47,
12010 &state->tmp);
12011 if (tevent_req_nomem(subreq, req)) {
12012 return tevent_req_post(req, ev);
12013 }
12014 tevent_req_set_callback(subreq, rpccli_spoolss_47_done, req);
12015 return req;
12016 }
12017
12018 static void rpccli_spoolss_47_done(struct tevent_req *subreq)
12019 {
12020 struct tevent_req *req = tevent_req_callback_data(
12021 subreq, struct tevent_req);
12022 struct rpccli_spoolss_47_state *state = tevent_req_data(
12023 req, struct rpccli_spoolss_47_state);
12024 NTSTATUS status;
12025 TALLOC_CTX *mem_ctx;
12026
12027 if (state->out_mem_ctx) {
12028 mem_ctx = state->out_mem_ctx;
12029 } else {
12030 mem_ctx = state;
12031 }
12032
12033 status = state->dispatch_recv(subreq, mem_ctx);
12034 TALLOC_FREE(subreq);
12035 if (!NT_STATUS_IS_OK(status)) {
12036 tevent_req_nterror(req, status);
12037 return;
12038 }
12039
12040 /* Copy out parameters */
12041
12042 /* Copy result */
12043 state->orig.out.result = state->tmp.out.result;
12044
12045 /* Reset temporary structure */
12046 ZERO_STRUCT(state->tmp);
12047
12048 if (DEBUGLEVEL >= 10) {
12049 NDR_PRINT_OUT_DEBUG(spoolss_47, &state->orig);
12050 }
12051
12052 tevent_req_done(req);
12053 }
12054
12055 NTSTATUS rpccli_spoolss_47_recv(struct tevent_req *req,
12056 TALLOC_CTX *mem_ctx,
12057 WERROR *result)
12058 {
12059 struct rpccli_spoolss_47_state *state = tevent_req_data(
12060 req, struct rpccli_spoolss_47_state);
12061 NTSTATUS status;
12062
12063 if (tevent_req_is_nterror(req, &status)) {
12064 tevent_req_received(req);
12065 return status;
12066 }
12067
12068 /* Steal possbile out parameters to the callers context */
12069 talloc_steal(mem_ctx, state->out_mem_ctx);
12070
12071 /* Return result */
12072 *result = state->orig.out.result;
12073
12074 tevent_req_received(req);
12075 return NT_STATUS_OK;
12076 }
12077
12078 NTSTATUS rpccli_spoolss_47(struct rpc_pipe_client *cli,
12079 TALLOC_CTX *mem_ctx,
12080 WERROR *werror)
12081 {
12082 struct spoolss_47 r;
12083 NTSTATUS status;
12084
12085 /* In parameters */
12086
12087 if (DEBUGLEVEL >= 10) {
12088 NDR_PRINT_IN_DEBUG(spoolss_47, &r);
12089 }
12090
12091 status = cli->dispatch(cli,
12092 mem_ctx,
12093 &ndr_table_spoolss,
12094 NDR_SPOOLSS_47,
12095 &r);
12096
12097 if (!NT_STATUS_IS_OK(status)) {
12098 return status;
12099 }
12100
12101 if (DEBUGLEVEL >= 10) {
12102 NDR_PRINT_OUT_DEBUG(spoolss_47, &r);
12103 }
12104
12105 if (NT_STATUS_IS_ERR(status)) {
12106 return status;
12107 }
12108
12109 /* Return variables */
12110
12111 /* Return result */
12112 if (werror) {
12113 *werror = r.out.result;
12114 }
12115
12116 return werror_to_ntstatus(r.out.result);
12117 }
12118
12119 struct rpccli_spoolss_EnumPrinterData_state {
12120 struct spoolss_EnumPrinterData orig;
12121 struct spoolss_EnumPrinterData tmp;
12122 TALLOC_CTX *out_mem_ctx;
12123 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12124 };
12125
12126 static void rpccli_spoolss_EnumPrinterData_done(struct tevent_req *subreq);
12127
12128 struct tevent_req *rpccli_spoolss_EnumPrinterData_send(TALLOC_CTX *mem_ctx,
12129 struct tevent_context *ev,
12130 struct rpc_pipe_client *cli,
12131 struct policy_handle *_handle /* [in] [ref] */,
12132 uint32_t _enum_index /* [in] */,
12133 const char *_value_name /* [out] [charset(UTF16),size_is(value_offered/2)] */,
12134 uint32_t _value_offered /* [in] */,
12135 uint32_t *_value_needed /* [out] [ref] */,
12136 enum winreg_Type *_type /* [out] [ref] */,
12137 uint8_t *_data /* [out] [ref,flag(LIBNDR_PRINT_ARRAY_HEX),size_is(data_offered)] */,
12138 uint32_t _data_offered /* [in] */,
12139 uint32_t *_data_needed /* [out] [ref] */)
12140 {
12141 struct tevent_req *req;
12142 struct rpccli_spoolss_EnumPrinterData_state *state;
12143 struct tevent_req *subreq;
12144
12145 req = tevent_req_create(mem_ctx, &state,
12146 struct rpccli_spoolss_EnumPrinterData_state);
12147 if (req == NULL) {
12148 return NULL;
12149 }
12150 state->out_mem_ctx = NULL;
12151 state->dispatch_recv = cli->dispatch_recv;
12152
12153 /* In parameters */
12154 state->orig.in.handle = _handle;
12155 state->orig.in.enum_index = _enum_index;
12156 state->orig.in.value_offered = _value_offered;
12157 state->orig.in.data_offered = _data_offered;
12158
12159 /* Out parameters */
12160 state->orig.out.value_name = _value_name;
12161 state->orig.out.value_needed = _value_needed;
12162 state->orig.out.type = _type;
12163 state->orig.out.data = _data;
12164 state->orig.out.data_needed = _data_needed;
12165
12166 /* Result */
12167 ZERO_STRUCT(state->orig.out.result);
12168
12169 if (DEBUGLEVEL >= 10) {
12170 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterData, &state->orig);
12171 }
12172
12173 state->out_mem_ctx = talloc_named_const(state, 0,
12174 "rpccli_spoolss_EnumPrinterData_out_memory");
12175 if (tevent_req_nomem(state->out_mem_ctx, req)) {
12176 return tevent_req_post(req, ev);
12177 }
12178
12179 /* make a temporary copy, that we pass to the dispatch function */
12180 state->tmp = state->orig;
12181
12182 subreq = cli->dispatch_send(state, ev, cli,
12183 &ndr_table_spoolss,
12184 NDR_SPOOLSS_ENUMPRINTERDATA,
12185 &state->tmp);
12186 if (tevent_req_nomem(subreq, req)) {
12187 return tevent_req_post(req, ev);
12188 }
12189 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinterData_done, req);
12190 return req;
12191 }
12192
12193 static void rpccli_spoolss_EnumPrinterData_done(struct tevent_req *subreq)
12194 {
12195 struct tevent_req *req = tevent_req_callback_data(
12196 subreq, struct tevent_req);
12197 struct rpccli_spoolss_EnumPrinterData_state *state = tevent_req_data(
12198 req, struct rpccli_spoolss_EnumPrinterData_state);
12199 NTSTATUS status;
12200 TALLOC_CTX *mem_ctx;
12201
12202 if (state->out_mem_ctx) {
12203 mem_ctx = state->out_mem_ctx;
12204 } else {
12205 mem_ctx = state;
12206 }
12207
12208 status = state->dispatch_recv(subreq, mem_ctx);
12209 TALLOC_FREE(subreq);
12210 if (!NT_STATUS_IS_OK(status)) {
12211 tevent_req_nterror(req, status);
12212 return;
12213 }
12214
12215 /* Copy out parameters */
12216 memcpy(CONST_DISCARD(char *, state->orig.out.value_name), state->tmp.out.value_name, state->tmp.in.value_offered / 2 * sizeof(*state->orig.out.value_name));
12217 *state->orig.out.value_needed = *state->tmp.out.value_needed;
12218 *state->orig.out.type = *state->tmp.out.type;
12219 memcpy(state->orig.out.data, state->tmp.out.data, state->tmp.in.data_offered * sizeof(*state->orig.out.data));
12220 *state->orig.out.data_needed = *state->tmp.out.data_needed;
12221
12222 /* Copy result */
12223 state->orig.out.result = state->tmp.out.result;
12224
12225 /* Reset temporary structure */
12226 ZERO_STRUCT(state->tmp);
12227
12228 if (DEBUGLEVEL >= 10) {
12229 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterData, &state->orig);
12230 }
12231
12232 tevent_req_done(req);
12233 }
12234
12235 NTSTATUS rpccli_spoolss_EnumPrinterData_recv(struct tevent_req *req,
12236 TALLOC_CTX *mem_ctx,
12237 WERROR *result)
12238 {
12239 struct rpccli_spoolss_EnumPrinterData_state *state = tevent_req_data(
12240 req, struct rpccli_spoolss_EnumPrinterData_state);
12241 NTSTATUS status;
12242
12243 if (tevent_req_is_nterror(req, &status)) {
12244 tevent_req_received(req);
12245 return status;
12246 }
12247
12248 /* Steal possbile out parameters to the callers context */
12249 talloc_steal(mem_ctx, state->out_mem_ctx);
12250
12251 /* Return result */
12252 *result = state->orig.out.result;
12253
12254 tevent_req_received(req);
12255 return NT_STATUS_OK;
12256 }
12257
12258 NTSTATUS rpccli_spoolss_EnumPrinterData(struct rpc_pipe_client *cli,
12259 TALLOC_CTX *mem_ctx,
12260 struct policy_handle *handle /* [in] [ref] */,
12261 uint32_t enum_index /* [in] */,
12262 const char *value_name /* [out] [charset(UTF16),size_is(value_offered/2)] */,
12263 uint32_t value_offered /* [in] */,
12264 uint32_t *value_needed /* [out] [ref] */,
12265 enum winreg_Type *type /* [out] [ref] */,
12266 uint8_t *data /* [out] [ref,flag(LIBNDR_PRINT_ARRAY_HEX),size_is(data_offered)] */,
12267 uint32_t data_offered /* [in] */,
12268 uint32_t *data_needed /* [out] [ref] */,
12269 WERROR *werror)
12270 {
12271 struct spoolss_EnumPrinterData r;
12272 NTSTATUS status;
12273
12274 /* In parameters */
12275 r.in.handle = handle;
12276 r.in.enum_index = enum_index;
12277 r.in.value_offered = value_offered;
12278 r.in.data_offered = data_offered;
12279
12280 if (DEBUGLEVEL >= 10) {
12281 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterData, &r);
12282 }
12283
12284 status = cli->dispatch(cli,
12285 mem_ctx,
12286 &ndr_table_spoolss,
12287 NDR_SPOOLSS_ENUMPRINTERDATA,
12288 &r);
12289
12290 if (!NT_STATUS_IS_OK(status)) {
12291 return status;
12292 }
12293
12294 if (DEBUGLEVEL >= 10) {
12295 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterData, &r);
12296 }
12297
12298 if (NT_STATUS_IS_ERR(status)) {
12299 return status;
12300 }
12301
12302 /* Return variables */
12303 memcpy(CONST_DISCARD(char *, value_name), r.out.value_name, r.in.value_offered / 2 * sizeof(*value_name));
12304 *value_needed = *r.out.value_needed;
12305 *type = *r.out.type;
12306 memcpy(data, r.out.data, r.in.data_offered * sizeof(*data));
12307 *data_needed = *r.out.data_needed;
12308
12309 /* Return result */
12310 if (werror) {
12311 *werror = r.out.result;
12312 }
12313
12314 return werror_to_ntstatus(r.out.result);
12315 }
12316
12317 struct rpccli_spoolss_DeletePrinterData_state {
12318 struct spoolss_DeletePrinterData orig;
12319 struct spoolss_DeletePrinterData tmp;
12320 TALLOC_CTX *out_mem_ctx;
12321 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12322 };
12323
12324 static void rpccli_spoolss_DeletePrinterData_done(struct tevent_req *subreq);
12325
12326 struct tevent_req *rpccli_spoolss_DeletePrinterData_send(TALLOC_CTX *mem_ctx,
12327 struct tevent_context *ev,
12328 struct rpc_pipe_client *cli,
12329 struct policy_handle *_handle /* [in] [ref] */,
12330 const char *_value_name /* [in] [charset(UTF16)] */)
12331 {
12332 struct tevent_req *req;
12333 struct rpccli_spoolss_DeletePrinterData_state *state;
12334 struct tevent_req *subreq;
12335
12336 req = tevent_req_create(mem_ctx, &state,
12337 struct rpccli_spoolss_DeletePrinterData_state);
12338 if (req == NULL) {
12339 return NULL;
12340 }
12341 state->out_mem_ctx = NULL;
12342 state->dispatch_recv = cli->dispatch_recv;
12343
12344 /* In parameters */
12345 state->orig.in.handle = _handle;
12346 state->orig.in.value_name = _value_name;
12347
12348 /* Out parameters */
12349
12350 /* Result */
12351 ZERO_STRUCT(state->orig.out.result);
12352
12353 if (DEBUGLEVEL >= 10) {
12354 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterData, &state->orig);
12355 }
12356
12357 /* make a temporary copy, that we pass to the dispatch function */
12358 state->tmp = state->orig;
12359
12360 subreq = cli->dispatch_send(state, ev, cli,
12361 &ndr_table_spoolss,
12362 NDR_SPOOLSS_DELETEPRINTERDATA,
12363 &state->tmp);
12364 if (tevent_req_nomem(subreq, req)) {
12365 return tevent_req_post(req, ev);
12366 }
12367 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterData_done, req);
12368 return req;
12369 }
12370
12371 static void rpccli_spoolss_DeletePrinterData_done(struct tevent_req *subreq)
12372 {
12373 struct tevent_req *req = tevent_req_callback_data(
12374 subreq, struct tevent_req);
12375 struct rpccli_spoolss_DeletePrinterData_state *state = tevent_req_data(
12376 req, struct rpccli_spoolss_DeletePrinterData_state);
12377 NTSTATUS status;
12378 TALLOC_CTX *mem_ctx;
12379
12380 if (state->out_mem_ctx) {
12381 mem_ctx = state->out_mem_ctx;
12382 } else {
12383 mem_ctx = state;
12384 }
12385
12386 status = state->dispatch_recv(subreq, mem_ctx);
12387 TALLOC_FREE(subreq);
12388 if (!NT_STATUS_IS_OK(status)) {
12389 tevent_req_nterror(req, status);
12390 return;
12391 }
12392
12393 /* Copy out parameters */
12394
12395 /* Copy result */
12396 state->orig.out.result = state->tmp.out.result;
12397
12398 /* Reset temporary structure */
12399 ZERO_STRUCT(state->tmp);
12400
12401 if (DEBUGLEVEL >= 10) {
12402 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterData, &state->orig);
12403 }
12404
12405 tevent_req_done(req);
12406 }
12407
12408 NTSTATUS rpccli_spoolss_DeletePrinterData_recv(struct tevent_req *req,
12409 TALLOC_CTX *mem_ctx,
12410 WERROR *result)
12411 {
12412 struct rpccli_spoolss_DeletePrinterData_state *state = tevent_req_data(
12413 req, struct rpccli_spoolss_DeletePrinterData_state);
12414 NTSTATUS status;
12415
12416 if (tevent_req_is_nterror(req, &status)) {
12417 tevent_req_received(req);
12418 return status;
12419 }
12420
12421 /* Steal possbile out parameters to the callers context */
12422 talloc_steal(mem_ctx, state->out_mem_ctx);
12423
12424 /* Return result */
12425 *result = state->orig.out.result;
12426
12427 tevent_req_received(req);
12428 return NT_STATUS_OK;
12429 }
12430
12431 NTSTATUS rpccli_spoolss_DeletePrinterData(struct rpc_pipe_client *cli,
12432 TALLOC_CTX *mem_ctx,
12433 struct policy_handle *handle /* [in] [ref] */,
12434 const char *value_name /* [in] [charset(UTF16)] */,
12435 WERROR *werror)
12436 {
12437 struct spoolss_DeletePrinterData r;
12438 NTSTATUS status;
12439
12440 /* In parameters */
12441 r.in.handle = handle;
12442 r.in.value_name = value_name;
12443
12444 if (DEBUGLEVEL >= 10) {
12445 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterData, &r);
12446 }
12447
12448 status = cli->dispatch(cli,
12449 mem_ctx,
12450 &ndr_table_spoolss,
12451 NDR_SPOOLSS_DELETEPRINTERDATA,
12452 &r);
12453
12454 if (!NT_STATUS_IS_OK(status)) {
12455 return status;
12456 }
12457
12458 if (DEBUGLEVEL >= 10) {
12459 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterData, &r);
12460 }
12461
12462 if (NT_STATUS_IS_ERR(status)) {
12463 return status;
12464 }
12465
12466 /* Return variables */
12467
12468 /* Return result */
12469 if (werror) {
12470 *werror = r.out.result;
12471 }
12472
12473 return werror_to_ntstatus(r.out.result);
12474 }
12475
12476 struct rpccli_spoolss_4a_state {
12477 struct spoolss_4a orig;
12478 struct spoolss_4a tmp;
12479 TALLOC_CTX *out_mem_ctx;
12480 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12481 };
12482
12483 static void rpccli_spoolss_4a_done(struct tevent_req *subreq);
12484
12485 struct tevent_req *rpccli_spoolss_4a_send(TALLOC_CTX *mem_ctx,
12486 struct tevent_context *ev,
12487 struct rpc_pipe_client *cli)
12488 {
12489 struct tevent_req *req;
12490 struct rpccli_spoolss_4a_state *state;
12491 struct tevent_req *subreq;
12492
12493 req = tevent_req_create(mem_ctx, &state,
12494 struct rpccli_spoolss_4a_state);
12495 if (req == NULL) {
12496 return NULL;
12497 }
12498 state->out_mem_ctx = NULL;
12499 state->dispatch_recv = cli->dispatch_recv;
12500
12501 /* In parameters */
12502
12503 /* Out parameters */
12504
12505 /* Result */
12506 ZERO_STRUCT(state->orig.out.result);
12507
12508 if (DEBUGLEVEL >= 10) {
12509 NDR_PRINT_IN_DEBUG(spoolss_4a, &state->orig);
12510 }
12511
12512 /* make a temporary copy, that we pass to the dispatch function */
12513 state->tmp = state->orig;
12514
12515 subreq = cli->dispatch_send(state, ev, cli,
12516 &ndr_table_spoolss,
12517 NDR_SPOOLSS_4A,
12518 &state->tmp);
12519 if (tevent_req_nomem(subreq, req)) {
12520 return tevent_req_post(req, ev);
12521 }
12522 tevent_req_set_callback(subreq, rpccli_spoolss_4a_done, req);
12523 return req;
12524 }
12525
12526 static void rpccli_spoolss_4a_done(struct tevent_req *subreq)
12527 {
12528 struct tevent_req *req = tevent_req_callback_data(
12529 subreq, struct tevent_req);
12530 struct rpccli_spoolss_4a_state *state = tevent_req_data(
12531 req, struct rpccli_spoolss_4a_state);
12532 NTSTATUS status;
12533 TALLOC_CTX *mem_ctx;
12534
12535 if (state->out_mem_ctx) {
12536 mem_ctx = state->out_mem_ctx;
12537 } else {
12538 mem_ctx = state;
12539 }
12540
12541 status = state->dispatch_recv(subreq, mem_ctx);
12542 TALLOC_FREE(subreq);
12543 if (!NT_STATUS_IS_OK(status)) {
12544 tevent_req_nterror(req, status);
12545 return;
12546 }
12547
12548 /* Copy out parameters */
12549
12550 /* Copy result */
12551 state->orig.out.result = state->tmp.out.result;
12552
12553 /* Reset temporary structure */
12554 ZERO_STRUCT(state->tmp);
12555
12556 if (DEBUGLEVEL >= 10) {
12557 NDR_PRINT_OUT_DEBUG(spoolss_4a, &state->orig);
12558 }
12559
12560 tevent_req_done(req);
12561 }
12562
12563 NTSTATUS rpccli_spoolss_4a_recv(struct tevent_req *req,
12564 TALLOC_CTX *mem_ctx,
12565 WERROR *result)
12566 {
12567 struct rpccli_spoolss_4a_state *state = tevent_req_data(
12568 req, struct rpccli_spoolss_4a_state);
12569 NTSTATUS status;
12570
12571 if (tevent_req_is_nterror(req, &status)) {
12572 tevent_req_received(req);
12573 return status;
12574 }
12575
12576 /* Steal possbile out parameters to the callers context */
12577 talloc_steal(mem_ctx, state->out_mem_ctx);
12578
12579 /* Return result */
12580 *result = state->orig.out.result;
12581
12582 tevent_req_received(req);
12583 return NT_STATUS_OK;
12584 }
12585
12586 NTSTATUS rpccli_spoolss_4a(struct rpc_pipe_client *cli,
12587 TALLOC_CTX *mem_ctx,
12588 WERROR *werror)
12589 {
12590 struct spoolss_4a r;
12591 NTSTATUS status;
12592
12593 /* In parameters */
12594
12595 if (DEBUGLEVEL >= 10) {
12596 NDR_PRINT_IN_DEBUG(spoolss_4a, &r);
12597 }
12598
12599 status = cli->dispatch(cli,
12600 mem_ctx,
12601 &ndr_table_spoolss,
12602 NDR_SPOOLSS_4A,
12603 &r);
12604
12605 if (!NT_STATUS_IS_OK(status)) {
12606 return status;
12607 }
12608
12609 if (DEBUGLEVEL >= 10) {
12610 NDR_PRINT_OUT_DEBUG(spoolss_4a, &r);
12611 }
12612
12613 if (NT_STATUS_IS_ERR(status)) {
12614 return status;
12615 }
12616
12617 /* Return variables */
12618
12619 /* Return result */
12620 if (werror) {
12621 *werror = r.out.result;
12622 }
12623
12624 return werror_to_ntstatus(r.out.result);
12625 }
12626
12627 struct rpccli_spoolss_4b_state {
12628 struct spoolss_4b orig;
12629 struct spoolss_4b tmp;
12630 TALLOC_CTX *out_mem_ctx;
12631 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12632 };
12633
12634 static void rpccli_spoolss_4b_done(struct tevent_req *subreq);
12635
12636 struct tevent_req *rpccli_spoolss_4b_send(TALLOC_CTX *mem_ctx,
12637 struct tevent_context *ev,
12638 struct rpc_pipe_client *cli)
12639 {
12640 struct tevent_req *req;
12641 struct rpccli_spoolss_4b_state *state;
12642 struct tevent_req *subreq;
12643
12644 req = tevent_req_create(mem_ctx, &state,
12645 struct rpccli_spoolss_4b_state);
12646 if (req == NULL) {
12647 return NULL;
12648 }
12649 state->out_mem_ctx = NULL;
12650 state->dispatch_recv = cli->dispatch_recv;
12651
12652 /* In parameters */
12653
12654 /* Out parameters */
12655
12656 /* Result */
12657 ZERO_STRUCT(state->orig.out.result);
12658
12659 if (DEBUGLEVEL >= 10) {
12660 NDR_PRINT_IN_DEBUG(spoolss_4b, &state->orig);
12661 }
12662
12663 /* make a temporary copy, that we pass to the dispatch function */
12664 state->tmp = state->orig;
12665
12666 subreq = cli->dispatch_send(state, ev, cli,
12667 &ndr_table_spoolss,
12668 NDR_SPOOLSS_4B,
12669 &state->tmp);
12670 if (tevent_req_nomem(subreq, req)) {
12671 return tevent_req_post(req, ev);
12672 }
12673 tevent_req_set_callback(subreq, rpccli_spoolss_4b_done, req);
12674 return req;
12675 }
12676
12677 static void rpccli_spoolss_4b_done(struct tevent_req *subreq)
12678 {
12679 struct tevent_req *req = tevent_req_callback_data(
12680 subreq, struct tevent_req);
12681 struct rpccli_spoolss_4b_state *state = tevent_req_data(
12682 req, struct rpccli_spoolss_4b_state);
12683 NTSTATUS status;
12684 TALLOC_CTX *mem_ctx;
12685
12686 if (state->out_mem_ctx) {
12687 mem_ctx = state->out_mem_ctx;
12688 } else {
12689 mem_ctx = state;
12690 }
12691
12692 status = state->dispatch_recv(subreq, mem_ctx);
12693 TALLOC_FREE(subreq);
12694 if (!NT_STATUS_IS_OK(status)) {
12695 tevent_req_nterror(req, status);
12696 return;
12697 }
12698
12699 /* Copy out parameters */
12700
12701 /* Copy result */
12702 state->orig.out.result = state->tmp.out.result;
12703
12704 /* Reset temporary structure */
12705 ZERO_STRUCT(state->tmp);
12706
12707 if (DEBUGLEVEL >= 10) {
12708 NDR_PRINT_OUT_DEBUG(spoolss_4b, &state->orig);
12709 }
12710
12711 tevent_req_done(req);
12712 }
12713
12714 NTSTATUS rpccli_spoolss_4b_recv(struct tevent_req *req,
12715 TALLOC_CTX *mem_ctx,
12716 WERROR *result)
12717 {
12718 struct rpccli_spoolss_4b_state *state = tevent_req_data(
12719 req, struct rpccli_spoolss_4b_state);
12720 NTSTATUS status;
12721
12722 if (tevent_req_is_nterror(req, &status)) {
12723 tevent_req_received(req);
12724 return status;
12725 }
12726
12727 /* Steal possbile out parameters to the callers context */
12728 talloc_steal(mem_ctx, state->out_mem_ctx);
12729
12730 /* Return result */
12731 *result = state->orig.out.result;
12732
12733 tevent_req_received(req);
12734 return NT_STATUS_OK;
12735 }
12736
12737 NTSTATUS rpccli_spoolss_4b(struct rpc_pipe_client *cli,
12738 TALLOC_CTX *mem_ctx,
12739 WERROR *werror)
12740 {
12741 struct spoolss_4b r;
12742 NTSTATUS status;
12743
12744 /* In parameters */
12745
12746 if (DEBUGLEVEL >= 10) {
12747 NDR_PRINT_IN_DEBUG(spoolss_4b, &r);
12748 }
12749
12750 status = cli->dispatch(cli,
12751 mem_ctx,
12752 &ndr_table_spoolss,
12753 NDR_SPOOLSS_4B,
12754 &r);
12755
12756 if (!NT_STATUS_IS_OK(status)) {
12757 return status;
12758 }
12759
12760 if (DEBUGLEVEL >= 10) {
12761 NDR_PRINT_OUT_DEBUG(spoolss_4b, &r);
12762 }
12763
12764 if (NT_STATUS_IS_ERR(status)) {
12765 return status;
12766 }
12767
12768 /* Return variables */
12769
12770 /* Return result */
12771 if (werror) {
12772 *werror = r.out.result;
12773 }
12774
12775 return werror_to_ntstatus(r.out.result);
12776 }
12777
12778 struct rpccli_spoolss_4c_state {
12779 struct spoolss_4c orig;
12780 struct spoolss_4c tmp;
12781 TALLOC_CTX *out_mem_ctx;
12782 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12783 };
12784
12785 static void rpccli_spoolss_4c_done(struct tevent_req *subreq);
12786
12787 struct tevent_req *rpccli_spoolss_4c_send(TALLOC_CTX *mem_ctx,
12788 struct tevent_context *ev,
12789 struct rpc_pipe_client *cli)
12790 {
12791 struct tevent_req *req;
12792 struct rpccli_spoolss_4c_state *state;
12793 struct tevent_req *subreq;
12794
12795 req = tevent_req_create(mem_ctx, &state,
12796 struct rpccli_spoolss_4c_state);
12797 if (req == NULL) {
12798 return NULL;
12799 }
12800 state->out_mem_ctx = NULL;
12801 state->dispatch_recv = cli->dispatch_recv;
12802
12803 /* In parameters */
12804
12805 /* Out parameters */
12806
12807 /* Result */
12808 ZERO_STRUCT(state->orig.out.result);
12809
12810 if (DEBUGLEVEL >= 10) {
12811 NDR_PRINT_IN_DEBUG(spoolss_4c, &state->orig);
12812 }
12813
12814 /* make a temporary copy, that we pass to the dispatch function */
12815 state->tmp = state->orig;
12816
12817 subreq = cli->dispatch_send(state, ev, cli,
12818 &ndr_table_spoolss,
12819 NDR_SPOOLSS_4C,
12820 &state->tmp);
12821 if (tevent_req_nomem(subreq, req)) {
12822 return tevent_req_post(req, ev);
12823 }
12824 tevent_req_set_callback(subreq, rpccli_spoolss_4c_done, req);
12825 return req;
12826 }
12827
12828 static void rpccli_spoolss_4c_done(struct tevent_req *subreq)
12829 {
12830 struct tevent_req *req = tevent_req_callback_data(
12831 subreq, struct tevent_req);
12832 struct rpccli_spoolss_4c_state *state = tevent_req_data(
12833 req, struct rpccli_spoolss_4c_state);
12834 NTSTATUS status;
12835 TALLOC_CTX *mem_ctx;
12836
12837 if (state->out_mem_ctx) {
12838 mem_ctx = state->out_mem_ctx;
12839 } else {
12840 mem_ctx = state;
12841 }
12842
12843 status = state->dispatch_recv(subreq, mem_ctx);
12844 TALLOC_FREE(subreq);
12845 if (!NT_STATUS_IS_OK(status)) {
12846 tevent_req_nterror(req, status);
12847 return;
12848 }
12849
12850 /* Copy out parameters */
12851
12852 /* Copy result */
12853 state->orig.out.result = state->tmp.out.result;
12854
12855 /* Reset temporary structure */
12856 ZERO_STRUCT(state->tmp);
12857
12858 if (DEBUGLEVEL >= 10) {
12859 NDR_PRINT_OUT_DEBUG(spoolss_4c, &state->orig);
12860 }
12861
12862 tevent_req_done(req);
12863 }
12864
12865 NTSTATUS rpccli_spoolss_4c_recv(struct tevent_req *req,
12866 TALLOC_CTX *mem_ctx,
12867 WERROR *result)
12868 {
12869 struct rpccli_spoolss_4c_state *state = tevent_req_data(
12870 req, struct rpccli_spoolss_4c_state);
12871 NTSTATUS status;
12872
12873 if (tevent_req_is_nterror(req, &status)) {
12874 tevent_req_received(req);
12875 return status;
12876 }
12877
12878 /* Steal possbile out parameters to the callers context */
12879 talloc_steal(mem_ctx, state->out_mem_ctx);
12880
12881 /* Return result */
12882 *result = state->orig.out.result;
12883
12884 tevent_req_received(req);
12885 return NT_STATUS_OK;
12886 }
12887
12888 NTSTATUS rpccli_spoolss_4c(struct rpc_pipe_client *cli,
12889 TALLOC_CTX *mem_ctx,
12890 WERROR *werror)
12891 {
12892 struct spoolss_4c r;
12893 NTSTATUS status;
12894
12895 /* In parameters */
12896
12897 if (DEBUGLEVEL >= 10) {
12898 NDR_PRINT_IN_DEBUG(spoolss_4c, &r);
12899 }
12900
12901 status = cli->dispatch(cli,
12902 mem_ctx,
12903 &ndr_table_spoolss,
12904 NDR_SPOOLSS_4C,
12905 &r);
12906
12907 if (!NT_STATUS_IS_OK(status)) {
12908 return status;
12909 }
12910
12911 if (DEBUGLEVEL >= 10) {
12912 NDR_PRINT_OUT_DEBUG(spoolss_4c, &r);
12913 }
12914
12915 if (NT_STATUS_IS_ERR(status)) {
12916 return status;
12917 }
12918
12919 /* Return variables */
12920
12921 /* Return result */
12922 if (werror) {
12923 *werror = r.out.result;
12924 }
12925
12926 return werror_to_ntstatus(r.out.result);
12927 }
12928
12929 struct rpccli_spoolss_SetPrinterDataEx_state {
12930 struct spoolss_SetPrinterDataEx orig;
12931 struct spoolss_SetPrinterDataEx tmp;
12932 TALLOC_CTX *out_mem_ctx;
12933 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12934 };
12935
12936 static void rpccli_spoolss_SetPrinterDataEx_done(struct tevent_req *subreq);
12937
12938 struct tevent_req *rpccli_spoolss_SetPrinterDataEx_send(TALLOC_CTX *mem_ctx,
12939 struct tevent_context *ev,
12940 struct rpc_pipe_client *cli,
12941 struct policy_handle *_handle /* [in] [ref] */,
12942 const char *_key_name /* [in] [charset(UTF16)] */,
12943 const char *_value_name /* [in] [charset(UTF16)] */,
12944 enum winreg_Type _type /* [in] */,
12945 uint8_t *_buffer /* [in] [ref,size_is(offered)] */,
12946 uint32_t _offered /* [in] */)
12947 {
12948 struct tevent_req *req;
12949 struct rpccli_spoolss_SetPrinterDataEx_state *state;
12950 struct tevent_req *subreq;
12951
12952 req = tevent_req_create(mem_ctx, &state,
12953 struct rpccli_spoolss_SetPrinterDataEx_state);
12954 if (req == NULL) {
12955 return NULL;
12956 }
12957 state->out_mem_ctx = NULL;
12958 state->dispatch_recv = cli->dispatch_recv;
12959
12960 /* In parameters */
12961 state->orig.in.handle = _handle;
12962 state->orig.in.key_name = _key_name;
12963 state->orig.in.value_name = _value_name;
12964 state->orig.in.type = _type;
12965 state->orig.in.buffer = _buffer;
12966 state->orig.in.offered = _offered;
12967
12968 /* Out parameters */
12969
12970 /* Result */
12971 ZERO_STRUCT(state->orig.out.result);
12972
12973 if (DEBUGLEVEL >= 10) {
12974 NDR_PRINT_IN_DEBUG(spoolss_SetPrinterDataEx, &state->orig);
12975 }
12976
12977 /* make a temporary copy, that we pass to the dispatch function */
12978 state->tmp = state->orig;
12979
12980 subreq = cli->dispatch_send(state, ev, cli,
12981 &ndr_table_spoolss,
12982 NDR_SPOOLSS_SETPRINTERDATAEX,
12983 &state->tmp);
12984 if (tevent_req_nomem(subreq, req)) {
12985 return tevent_req_post(req, ev);
12986 }
12987 tevent_req_set_callback(subreq, rpccli_spoolss_SetPrinterDataEx_done, req);
12988 return req;
12989 }
12990
12991 static void rpccli_spoolss_SetPrinterDataEx_done(struct tevent_req *subreq)
12992 {
12993 struct tevent_req *req = tevent_req_callback_data(
12994 subreq, struct tevent_req);
12995 struct rpccli_spoolss_SetPrinterDataEx_state *state = tevent_req_data(
12996 req, struct rpccli_spoolss_SetPrinterDataEx_state);
12997 NTSTATUS status;
12998 TALLOC_CTX *mem_ctx;
12999
13000 if (state->out_mem_ctx) {
13001 mem_ctx = state->out_mem_ctx;
13002 } else {
13003 mem_ctx = state;
13004 }
13005
13006 status = state->dispatch_recv(subreq, mem_ctx);
13007 TALLOC_FREE(subreq);
13008 if (!NT_STATUS_IS_OK(status)) {
13009 tevent_req_nterror(req, status);
13010 return;
13011 }
13012
13013 /* Copy out parameters */
13014
13015 /* Copy result */
13016 state->orig.out.result = state->tmp.out.result;
13017
13018 /* Reset temporary structure */
13019 ZERO_STRUCT(state->tmp);
13020
13021 if (DEBUGLEVEL >= 10) {
13022 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinterDataEx, &state->orig);
13023 }
13024
13025 tevent_req_done(req);
13026 }
13027
13028 NTSTATUS rpccli_spoolss_SetPrinterDataEx_recv(struct tevent_req *req,
13029 TALLOC_CTX *mem_ctx,
13030 WERROR *result)
13031 {
13032 struct rpccli_spoolss_SetPrinterDataEx_state *state = tevent_req_data(
13033 req, struct rpccli_spoolss_SetPrinterDataEx_state);
13034 NTSTATUS status;
13035
13036 if (tevent_req_is_nterror(req, &status)) {
13037 tevent_req_received(req);
13038 return status;
13039 }
13040
13041 /* Steal possbile out parameters to the callers context */
13042 talloc_steal(mem_ctx, state->out_mem_ctx);
13043
13044 /* Return result */
13045 *result = state->orig.out.result;
13046
13047 tevent_req_received(req);
13048 return NT_STATUS_OK;
13049 }
13050
13051 NTSTATUS rpccli_spoolss_SetPrinterDataEx(struct rpc_pipe_client *cli,
13052 TALLOC_CTX *mem_ctx,
13053 struct policy_handle *handle /* [in] [ref] */,
13054 const char *key_name /* [in] [charset(UTF16)] */,
13055 const char *value_name /* [in] [charset(UTF16)] */,
13056 enum winreg_Type type /* [in] */,
13057 uint8_t *buffer /* [in] [ref,size_is(offered)] */,
13058 uint32_t offered /* [in] */,
13059 WERROR *werror)
13060 {
13061 struct spoolss_SetPrinterDataEx r;
13062 NTSTATUS status;
13063
13064 /* In parameters */
13065 r.in.handle = handle;
13066 r.in.key_name = key_name;
13067 r.in.value_name = value_name;
13068 r.in.type = type;
13069 r.in.buffer = buffer;
13070 r.in.offered = offered;
13071
13072 if (DEBUGLEVEL >= 10) {
13073 NDR_PRINT_IN_DEBUG(spoolss_SetPrinterDataEx, &r);
13074 }
13075
13076 status = cli->dispatch(cli,
13077 mem_ctx,
13078 &ndr_table_spoolss,
13079 NDR_SPOOLSS_SETPRINTERDATAEX,
13080 &r);
13081
13082 if (!NT_STATUS_IS_OK(status)) {
13083 return status;
13084 }
13085
13086 if (DEBUGLEVEL >= 10) {
13087 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinterDataEx, &r);
13088 }
13089
13090 if (NT_STATUS_IS_ERR(status)) {
13091 return status;
13092 }
13093
13094 /* Return variables */
13095
13096 /* Return result */
13097 if (werror) {
13098 *werror = r.out.result;
13099 }
13100
13101 return werror_to_ntstatus(r.out.result);
13102 }
13103
13104 struct rpccli_spoolss_GetPrinterDataEx_state {
13105 struct spoolss_GetPrinterDataEx orig;
13106 struct spoolss_GetPrinterDataEx tmp;
13107 TALLOC_CTX *out_mem_ctx;
13108 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13109 };
13110
13111 static void rpccli_spoolss_GetPrinterDataEx_done(struct tevent_req *subreq);
13112
13113 struct tevent_req *rpccli_spoolss_GetPrinterDataEx_send(TALLOC_CTX *mem_ctx,
13114 struct tevent_context *ev,
13115 struct rpc_pipe_client *cli,
13116 struct policy_handle *_handle /* [in] [ref] */,
13117 const char *_key_name /* [in] [charset(UTF16)] */,
13118 const char *_value_name /* [in] [charset(UTF16)] */,
13119 enum winreg_Type *_type /* [out] [ref] */,
13120 uint8_t *_buffer /* [out] [ref,size_is(offered)] */,
13121 uint32_t _offered /* [in] */,
13122 uint32_t *_needed /* [out] [ref] */)
13123 {
13124 struct tevent_req *req;
13125 struct rpccli_spoolss_GetPrinterDataEx_state *state;
13126 struct tevent_req *subreq;
13127
13128 req = tevent_req_create(mem_ctx, &state,
13129 struct rpccli_spoolss_GetPrinterDataEx_state);
13130 if (req == NULL) {
13131 return NULL;
13132 }
13133 state->out_mem_ctx = NULL;
13134 state->dispatch_recv = cli->dispatch_recv;
13135
13136 /* In parameters */
13137 state->orig.in.handle = _handle;
13138 state->orig.in.key_name = _key_name;
13139 state->orig.in.value_name = _value_name;
13140 state->orig.in.offered = _offered;
13141
13142 /* Out parameters */
13143 state->orig.out.type = _type;
13144 state->orig.out.buffer = _buffer;
13145 state->orig.out.needed = _needed;
13146
13147 /* Result */
13148 ZERO_STRUCT(state->orig.out.result);
13149
13150 if (DEBUGLEVEL >= 10) {
13151 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDataEx, &state->orig);
13152 }
13153
13154 state->out_mem_ctx = talloc_named_const(state, 0,
13155 "rpccli_spoolss_GetPrinterDataEx_out_memory");
13156 if (tevent_req_nomem(state->out_mem_ctx, req)) {
13157 return tevent_req_post(req, ev);
13158 }
13159
13160 /* make a temporary copy, that we pass to the dispatch function */
13161 state->tmp = state->orig;
13162
13163 subreq = cli->dispatch_send(state, ev, cli,
13164 &ndr_table_spoolss,
13165 NDR_SPOOLSS_GETPRINTERDATAEX,
13166 &state->tmp);
13167 if (tevent_req_nomem(subreq, req)) {
13168 return tevent_req_post(req, ev);
13169 }
13170 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDataEx_done, req);
13171 return req;
13172 }
13173
13174 static void rpccli_spoolss_GetPrinterDataEx_done(struct tevent_req *subreq)
13175 {
13176 struct tevent_req *req = tevent_req_callback_data(
13177 subreq, struct tevent_req);
13178 struct rpccli_spoolss_GetPrinterDataEx_state *state = tevent_req_data(
13179 req, struct rpccli_spoolss_GetPrinterDataEx_state);
13180 NTSTATUS status;
13181 TALLOC_CTX *mem_ctx;
13182
13183 if (state->out_mem_ctx) {
13184 mem_ctx = state->out_mem_ctx;
13185 } else {
13186 mem_ctx = state;
13187 }
13188
13189 status = state->dispatch_recv(subreq, mem_ctx);
13190 TALLOC_FREE(subreq);
13191 if (!NT_STATUS_IS_OK(status)) {
13192 tevent_req_nterror(req, status);
13193 return;
13194 }
13195
13196 /* Copy out parameters */
13197 *state->orig.out.type = *state->tmp.out.type;
13198 memcpy(state->orig.out.buffer, state->tmp.out.buffer, state->tmp.in.offered * sizeof(*state->orig.out.buffer));
13199 *state->orig.out.needed = *state->tmp.out.needed;
13200
13201 /* Copy result */
13202 state->orig.out.result = state->tmp.out.result;
13203
13204 /* Reset temporary structure */
13205 ZERO_STRUCT(state->tmp);
13206
13207 if (DEBUGLEVEL >= 10) {
13208 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDataEx, &state->orig);
13209 }
13210
13211 tevent_req_done(req);
13212 }
13213
13214 NTSTATUS rpccli_spoolss_GetPrinterDataEx_recv(struct tevent_req *req,
13215 TALLOC_CTX *mem_ctx,
13216 WERROR *result)
13217 {
13218 struct rpccli_spoolss_GetPrinterDataEx_state *state = tevent_req_data(
13219 req, struct rpccli_spoolss_GetPrinterDataEx_state);
13220 NTSTATUS status;
13221
13222 if (tevent_req_is_nterror(req, &status)) {
13223 tevent_req_received(req);
13224 return status;
13225 }
13226
13227 /* Steal possbile out parameters to the callers context */
13228 talloc_steal(mem_ctx, state->out_mem_ctx);
13229
13230 /* Return result */
13231 *result = state->orig.out.result;
13232
13233 tevent_req_received(req);
13234 return NT_STATUS_OK;
13235 }
13236
13237 NTSTATUS rpccli_spoolss_GetPrinterDataEx(struct rpc_pipe_client *cli,
13238 TALLOC_CTX *mem_ctx,
13239 struct policy_handle *handle /* [in] [ref] */,
13240 const char *key_name /* [in] [charset(UTF16)] */,
13241 const char *value_name /* [in] [charset(UTF16)] */,
13242 enum winreg_Type *type /* [out] [ref] */,
13243 uint8_t *buffer /* [out] [ref,size_is(offered)] */,
13244 uint32_t offered /* [in] */,
13245 uint32_t *needed /* [out] [ref] */,
13246 WERROR *werror)
13247 {
13248 struct spoolss_GetPrinterDataEx r;
13249 NTSTATUS status;
13250
13251 /* In parameters */
13252 r.in.handle = handle;
13253 r.in.key_name = key_name;
13254 r.in.value_name = value_name;
13255 r.in.offered = offered;
13256
13257 if (DEBUGLEVEL >= 10) {
13258 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDataEx, &r);
13259 }
13260
13261 status = cli->dispatch(cli,
13262 mem_ctx,
13263 &ndr_table_spoolss,
13264 NDR_SPOOLSS_GETPRINTERDATAEX,
13265 &r);
13266
13267 if (!NT_STATUS_IS_OK(status)) {
13268 return status;
13269 }
13270
13271 if (DEBUGLEVEL >= 10) {
13272 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDataEx, &r);
13273 }
13274
13275 if (NT_STATUS_IS_ERR(status)) {
13276 return status;
13277 }
13278
13279 /* Return variables */
13280 *type = *r.out.type;
13281 memcpy(buffer, r.out.buffer, r.in.offered * sizeof(*buffer));
13282 *needed = *r.out.needed;
13283
13284 /* Return result */
13285 if (werror) {
13286 *werror = r.out.result;
13287 }
13288
13289 return werror_to_ntstatus(r.out.result);
13290 }
13291
13292 struct rpccli_spoolss_EnumPrinterDataEx_state {
13293 struct spoolss_EnumPrinterDataEx orig;
13294 struct spoolss_EnumPrinterDataEx tmp;
13295 TALLOC_CTX *out_mem_ctx;
13296 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13297 };
13298
13299 static void rpccli_spoolss_EnumPrinterDataEx_done(struct tevent_req *subreq);
13300
13301 struct tevent_req *rpccli_spoolss_EnumPrinterDataEx_send(TALLOC_CTX *mem_ctx,
13302 struct tevent_context *ev,
13303 struct rpc_pipe_client *cli,
13304 struct policy_handle *_handle /* [in] [ref] */,
13305 const char *_key_name /* [in] [charset(UTF16)] */,
13306 uint32_t _offered /* [in] */,
13307 uint32_t *_count /* [out] [ref] */,
13308 struct spoolss_PrinterEnumValues **_info /* [out] [ref,size_is(,*count)] */,
13309 uint32_t *_needed /* [out] [ref] */)
13310 {
13311 struct tevent_req *req;
13312 struct rpccli_spoolss_EnumPrinterDataEx_state *state;
13313 struct tevent_req *subreq;
13314
13315 req = tevent_req_create(mem_ctx, &state,
13316 struct rpccli_spoolss_EnumPrinterDataEx_state);
13317 if (req == NULL) {
13318 return NULL;
13319 }
13320 state->out_mem_ctx = NULL;
13321 state->dispatch_recv = cli->dispatch_recv;
13322
13323 /* In parameters */
13324 state->orig.in.handle = _handle;
13325 state->orig.in.key_name = _key_name;
13326 state->orig.in.offered = _offered;
13327
13328 /* Out parameters */
13329 state->orig.out.count = _count;
13330 state->orig.out.info = _info;
13331 state->orig.out.needed = _needed;
13332
13333 /* Result */
13334 ZERO_STRUCT(state->orig.out.result);
13335
13336 if (DEBUGLEVEL >= 10) {
13337 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterDataEx, &state->orig);
13338 }
13339
13340 state->out_mem_ctx = talloc_named_const(state, 0,
13341 "rpccli_spoolss_EnumPrinterDataEx_out_memory");
13342 if (tevent_req_nomem(state->out_mem_ctx, req)) {
13343 return tevent_req_post(req, ev);
13344 }
13345
13346 /* make a temporary copy, that we pass to the dispatch function */
13347 state->tmp = state->orig;
13348
13349 subreq = cli->dispatch_send(state, ev, cli,
13350 &ndr_table_spoolss,
13351 NDR_SPOOLSS_ENUMPRINTERDATAEX,
13352 &state->tmp);
13353 if (tevent_req_nomem(subreq, req)) {
13354 return tevent_req_post(req, ev);
13355 }
13356 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinterDataEx_done, req);
13357 return req;
13358 }
13359
13360 static void rpccli_spoolss_EnumPrinterDataEx_done(struct tevent_req *subreq)
13361 {
13362 struct tevent_req *req = tevent_req_callback_data(
13363 subreq, struct tevent_req);
13364 struct rpccli_spoolss_EnumPrinterDataEx_state *state = tevent_req_data(
13365 req, struct rpccli_spoolss_EnumPrinterDataEx_state);
13366 NTSTATUS status;
13367 TALLOC_CTX *mem_ctx;
13368
13369 if (state->out_mem_ctx) {
13370 mem_ctx = state->out_mem_ctx;
13371 } else {
13372 mem_ctx = state;
13373 }
13374
13375 status = state->dispatch_recv(subreq, mem_ctx);
13376 TALLOC_FREE(subreq);
13377 if (!NT_STATUS_IS_OK(status)) {
13378 tevent_req_nterror(req, status);
13379 return;
13380 }
13381
13382 /* Copy out parameters */
13383 *state->orig.out.count = *state->tmp.out.count;
13384 *state->orig.out.info = *state->tmp.out.info;
13385 *state->orig.out.needed = *state->tmp.out.needed;
13386
13387 /* Copy result */
13388 state->orig.out.result = state->tmp.out.result;
13389
13390 /* Reset temporary structure */
13391 ZERO_STRUCT(state->tmp);
13392
13393 if (DEBUGLEVEL >= 10) {
13394 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterDataEx, &state->orig);
13395 }
13396
13397 tevent_req_done(req);
13398 }
13399
13400 NTSTATUS rpccli_spoolss_EnumPrinterDataEx_recv(struct tevent_req *req,
13401 TALLOC_CTX *mem_ctx,
13402 WERROR *result)
13403 {
13404 struct rpccli_spoolss_EnumPrinterDataEx_state *state = tevent_req_data(
13405 req, struct rpccli_spoolss_EnumPrinterDataEx_state);
13406 NTSTATUS status;
13407
13408 if (tevent_req_is_nterror(req, &status)) {
13409 tevent_req_received(req);
13410 return status;
13411 }
13412
13413 /* Steal possbile out parameters to the callers context */
13414 talloc_steal(mem_ctx, state->out_mem_ctx);
13415
13416 /* Return result */
13417 *result = state->orig.out.result;
13418
13419 tevent_req_received(req);
13420 return NT_STATUS_OK;
13421 }
13422
13423 NTSTATUS rpccli_spoolss_EnumPrinterDataEx(struct rpc_pipe_client *cli,
13424 TALLOC_CTX *mem_ctx,
13425 struct policy_handle *handle /* [in] [ref] */,
13426 const char *key_name /* [in] [charset(UTF16)] */,
13427 uint32_t offered /* [in] */,
13428 uint32_t *count /* [out] [ref] */,
13429 struct spoolss_PrinterEnumValues **info /* [out] [ref,size_is(,*count)] */,
13430 uint32_t *needed /* [out] [ref] */,
13431 WERROR *werror)
13432 {
13433 struct spoolss_EnumPrinterDataEx r;
13434 NTSTATUS status;
13435
13436 /* In parameters */
13437 r.in.handle = handle;
13438 r.in.key_name = key_name;
13439 r.in.offered = offered;
13440
13441 if (DEBUGLEVEL >= 10) {
13442 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterDataEx, &r);
13443 }
13444
13445 status = cli->dispatch(cli,
13446 mem_ctx,
13447 &ndr_table_spoolss,
13448 NDR_SPOOLSS_ENUMPRINTERDATAEX,
13449 &r);
13450
13451 if (!NT_STATUS_IS_OK(status)) {
13452 return status;
13453 }
13454
13455 if (DEBUGLEVEL >= 10) {
13456 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterDataEx, &r);
13457 }
13458
13459 if (NT_STATUS_IS_ERR(status)) {
13460 return status;
13461 }
13462
13463 /* Return variables */
13464 *count = *r.out.count;
13465 *info = *r.out.info;
13466 *needed = *r.out.needed;
13467
13468 /* Return result */
13469 if (werror) {
13470 *werror = r.out.result;
13471 }
13472
13473 return werror_to_ntstatus(r.out.result);
13474 }
13475
13476 struct rpccli_spoolss_EnumPrinterKey_state {
13477 struct spoolss_EnumPrinterKey orig;
13478 struct spoolss_EnumPrinterKey tmp;
13479 TALLOC_CTX *out_mem_ctx;
13480 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13481 };
13482
13483 static void rpccli_spoolss_EnumPrinterKey_done(struct tevent_req *subreq);
13484
13485 struct tevent_req *rpccli_spoolss_EnumPrinterKey_send(TALLOC_CTX *mem_ctx,
13486 struct tevent_context *ev,
13487 struct rpc_pipe_client *cli,
13488 struct policy_handle *_handle /* [in] [ref] */,
13489 const char *_key_name /* [in] [charset(UTF16)] */,
13490 const char ** *_key_buffer /* [out] [subcontext_size(offered),ref,subcontext(0),flag(LIBNDR_FLAG_STR_NULLTERM)] */,
13491 uint32_t _offered /* [in] */,
13492 uint32_t *_needed /* [out] [ref] */)
13493 {
13494 struct tevent_req *req;
13495 struct rpccli_spoolss_EnumPrinterKey_state *state;
13496 struct tevent_req *subreq;
13497
13498 req = tevent_req_create(mem_ctx, &state,
13499 struct rpccli_spoolss_EnumPrinterKey_state);
13500 if (req == NULL) {
13501 return NULL;
13502 }
13503 state->out_mem_ctx = NULL;
13504 state->dispatch_recv = cli->dispatch_recv;
13505
13506 /* In parameters */
13507 state->orig.in.handle = _handle;
13508 state->orig.in.key_name = _key_name;
13509 state->orig.in.offered = _offered;
13510
13511 /* Out parameters */
13512 state->orig.out.key_buffer = _key_buffer;
13513 state->orig.out.needed = _needed;
13514
13515 /* Result */
13516 ZERO_STRUCT(state->orig.out.result);
13517
13518 if (DEBUGLEVEL >= 10) {
13519 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterKey, &state->orig);
13520 }
13521
13522 state->out_mem_ctx = talloc_named_const(state, 0,
13523 "rpccli_spoolss_EnumPrinterKey_out_memory");
13524 if (tevent_req_nomem(state->out_mem_ctx, req)) {
13525 return tevent_req_post(req, ev);
13526 }
13527
13528 /* make a temporary copy, that we pass to the dispatch function */
13529 state->tmp = state->orig;
13530
13531 subreq = cli->dispatch_send(state, ev, cli,
13532 &ndr_table_spoolss,
13533 NDR_SPOOLSS_ENUMPRINTERKEY,
13534 &state->tmp);
13535 if (tevent_req_nomem(subreq, req)) {
13536 return tevent_req_post(req, ev);
13537 }
13538 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinterKey_done, req);
13539 return req;
13540 }
13541
13542 static void rpccli_spoolss_EnumPrinterKey_done(struct tevent_req *subreq)
13543 {
13544 struct tevent_req *req = tevent_req_callback_data(
13545 subreq, struct tevent_req);
13546 struct rpccli_spoolss_EnumPrinterKey_state *state = tevent_req_data(
13547 req, struct rpccli_spoolss_EnumPrinterKey_state);
13548 NTSTATUS status;
13549 TALLOC_CTX *mem_ctx;
13550
13551 if (state->out_mem_ctx) {
13552 mem_ctx = state->out_mem_ctx;
13553 } else {
13554 mem_ctx = state;
13555 }
13556
13557 status = state->dispatch_recv(subreq, mem_ctx);
13558 TALLOC_FREE(subreq);
13559 if (!NT_STATUS_IS_OK(status)) {
13560 tevent_req_nterror(req, status);
13561 return;
13562 }
13563
13564 /* Copy out parameters */
13565 *state->orig.out.key_buffer = *state->tmp.out.key_buffer;
13566 *state->orig.out.needed = *state->tmp.out.needed;
13567
13568 /* Copy result */
13569 state->orig.out.result = state->tmp.out.result;
13570
13571 /* Reset temporary structure */
13572 ZERO_STRUCT(state->tmp);
13573
13574 if (DEBUGLEVEL >= 10) {
13575 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterKey, &state->orig);
13576 }
13577
13578 tevent_req_done(req);
13579 }
13580
13581 NTSTATUS rpccli_spoolss_EnumPrinterKey_recv(struct tevent_req *req,
13582 TALLOC_CTX *mem_ctx,
13583 WERROR *result)
13584 {
13585 struct rpccli_spoolss_EnumPrinterKey_state *state = tevent_req_data(
13586 req, struct rpccli_spoolss_EnumPrinterKey_state);
13587 NTSTATUS status;
13588
13589 if (tevent_req_is_nterror(req, &status)) {
13590 tevent_req_received(req);
13591 return status;
13592 }
13593
13594 /* Steal possbile out parameters to the callers context */
13595 talloc_steal(mem_ctx, state->out_mem_ctx);
13596
13597 /* Return result */
13598 *result = state->orig.out.result;
13599
13600 tevent_req_received(req);
13601 return NT_STATUS_OK;
13602 }
13603
13604 NTSTATUS rpccli_spoolss_EnumPrinterKey(struct rpc_pipe_client *cli,
13605 TALLOC_CTX *mem_ctx,
13606 struct policy_handle *handle /* [in] [ref] */,
13607 const char *key_name /* [in] [charset(UTF16)] */,
13608 const char ** *key_buffer /* [out] [subcontext_size(offered),ref,subcontext(0),flag(LIBNDR_FLAG_STR_NULLTERM)] */,
13609 uint32_t offered /* [in] */,
13610 uint32_t *needed /* [out] [ref] */,
13611 WERROR *werror)
13612 {
13613 struct spoolss_EnumPrinterKey r;
13614 NTSTATUS status;
13615
13616 /* In parameters */
13617 r.in.handle = handle;
13618 r.in.key_name = key_name;
13619 r.in.offered = offered;
13620
13621 if (DEBUGLEVEL >= 10) {
13622 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterKey, &r);
13623 }
13624
13625 status = cli->dispatch(cli,
13626 mem_ctx,
13627 &ndr_table_spoolss,
13628 NDR_SPOOLSS_ENUMPRINTERKEY,
13629 &r);
13630
13631 if (!NT_STATUS_IS_OK(status)) {
13632 return status;
13633 }
13634
13635 if (DEBUGLEVEL >= 10) {
13636 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterKey, &r);
13637 }
13638
13639 if (NT_STATUS_IS_ERR(status)) {
13640 return status;
13641 }
13642
13643 /* Return variables */
13644 *key_buffer = *r.out.key_buffer;
13645 *needed = *r.out.needed;
13646
13647 /* Return result */
13648 if (werror) {
13649 *werror = r.out.result;
13650 }
13651
13652 return werror_to_ntstatus(r.out.result);
13653 }
13654
13655 struct rpccli_spoolss_DeletePrinterDataEx_state {
13656 struct spoolss_DeletePrinterDataEx orig;
13657 struct spoolss_DeletePrinterDataEx tmp;
13658 TALLOC_CTX *out_mem_ctx;
13659 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13660 };
13661
13662 static void rpccli_spoolss_DeletePrinterDataEx_done(struct tevent_req *subreq);
13663
13664 struct tevent_req *rpccli_spoolss_DeletePrinterDataEx_send(TALLOC_CTX *mem_ctx,
13665 struct tevent_context *ev,
13666 struct rpc_pipe_client *cli,
13667 struct policy_handle *_handle /* [in] [ref] */,
13668 const char *_key_name /* [in] [charset(UTF16)] */,
13669 const char *_value_name /* [in] [charset(UTF16)] */)
13670 {
13671 struct tevent_req *req;
13672 struct rpccli_spoolss_DeletePrinterDataEx_state *state;
13673 struct tevent_req *subreq;
13674
13675 req = tevent_req_create(mem_ctx, &state,
13676 struct rpccli_spoolss_DeletePrinterDataEx_state);
13677 if (req == NULL) {
13678 return NULL;
13679 }
13680 state->out_mem_ctx = NULL;
13681 state->dispatch_recv = cli->dispatch_recv;
13682
13683 /* In parameters */
13684 state->orig.in.handle = _handle;
13685 state->orig.in.key_name = _key_name;
13686 state->orig.in.value_name = _value_name;
13687
13688 /* Out parameters */
13689
13690 /* Result */
13691 ZERO_STRUCT(state->orig.out.result);
13692
13693 if (DEBUGLEVEL >= 10) {
13694 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDataEx, &state->orig);
13695 }
13696
13697 /* make a temporary copy, that we pass to the dispatch function */
13698 state->tmp = state->orig;
13699
13700 subreq = cli->dispatch_send(state, ev, cli,
13701 &ndr_table_spoolss,
13702 NDR_SPOOLSS_DELETEPRINTERDATAEX,
13703 &state->tmp);
13704 if (tevent_req_nomem(subreq, req)) {
13705 return tevent_req_post(req, ev);
13706 }
13707 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterDataEx_done, req);
13708 return req;
13709 }
13710
13711 static void rpccli_spoolss_DeletePrinterDataEx_done(struct tevent_req *subreq)
13712 {
13713 struct tevent_req *req = tevent_req_callback_data(
13714 subreq, struct tevent_req);
13715 struct rpccli_spoolss_DeletePrinterDataEx_state *state = tevent_req_data(
13716 req, struct rpccli_spoolss_DeletePrinterDataEx_state);
13717 NTSTATUS status;
13718 TALLOC_CTX *mem_ctx;
13719
13720 if (state->out_mem_ctx) {
13721 mem_ctx = state->out_mem_ctx;
13722 } else {
13723 mem_ctx = state;
13724 }
13725
13726 status = state->dispatch_recv(subreq, mem_ctx);
13727 TALLOC_FREE(subreq);
13728 if (!NT_STATUS_IS_OK(status)) {
13729 tevent_req_nterror(req, status);
13730 return;
13731 }
13732
13733 /* Copy out parameters */
13734
13735 /* Copy result */
13736 state->orig.out.result = state->tmp.out.result;
13737
13738 /* Reset temporary structure */
13739 ZERO_STRUCT(state->tmp);
13740
13741 if (DEBUGLEVEL >= 10) {
13742 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDataEx, &state->orig);
13743 }
13744
13745 tevent_req_done(req);
13746 }
13747
13748 NTSTATUS rpccli_spoolss_DeletePrinterDataEx_recv(struct tevent_req *req,
13749 TALLOC_CTX *mem_ctx,
13750 WERROR *result)
13751 {
13752 struct rpccli_spoolss_DeletePrinterDataEx_state *state = tevent_req_data(
13753 req, struct rpccli_spoolss_DeletePrinterDataEx_state);
13754 NTSTATUS status;
13755
13756 if (tevent_req_is_nterror(req, &status)) {
13757 tevent_req_received(req);
13758 return status;
13759 }
13760
13761 /* Steal possbile out parameters to the callers context */
13762 talloc_steal(mem_ctx, state->out_mem_ctx);
13763
13764 /* Return result */
13765 *result = state->orig.out.result;
13766
13767 tevent_req_received(req);
13768 return NT_STATUS_OK;
13769 }
13770
13771 NTSTATUS rpccli_spoolss_DeletePrinterDataEx(struct rpc_pipe_client *cli,
13772 TALLOC_CTX *mem_ctx,
13773 struct policy_handle *handle /* [in] [ref] */,
13774 const char *key_name /* [in] [charset(UTF16)] */,
13775 const char *value_name /* [in] [charset(UTF16)] */,
13776 WERROR *werror)
13777 {
13778 struct spoolss_DeletePrinterDataEx r;
13779 NTSTATUS status;
13780
13781 /* In parameters */
13782 r.in.handle = handle;
13783 r.in.key_name = key_name;
13784 r.in.value_name = value_name;
13785
13786 if (DEBUGLEVEL >= 10) {
13787 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDataEx, &r);
13788 }
13789
13790 status = cli->dispatch(cli,
13791 mem_ctx,
13792 &ndr_table_spoolss,
13793 NDR_SPOOLSS_DELETEPRINTERDATAEX,
13794 &r);
13795
13796 if (!NT_STATUS_IS_OK(status)) {
13797 return status;
13798 }
13799
13800 if (DEBUGLEVEL >= 10) {
13801 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDataEx, &r);
13802 }
13803
13804 if (NT_STATUS_IS_ERR(status)) {
13805 return status;
13806 }
13807
13808 /* Return variables */
13809
13810 /* Return result */
13811 if (werror) {
13812 *werror = r.out.result;
13813 }
13814
13815 return werror_to_ntstatus(r.out.result);
13816 }
13817
13818 struct rpccli_spoolss_DeletePrinterKey_state {
13819 struct spoolss_DeletePrinterKey orig;
13820 struct spoolss_DeletePrinterKey tmp;
13821 TALLOC_CTX *out_mem_ctx;
13822 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13823 };
13824
13825 static void rpccli_spoolss_DeletePrinterKey_done(struct tevent_req *subreq);
13826
13827 struct tevent_req *rpccli_spoolss_DeletePrinterKey_send(TALLOC_CTX *mem_ctx,
13828 struct tevent_context *ev,
13829 struct rpc_pipe_client *cli,
13830 struct policy_handle *_handle /* [in] [ref] */,
13831 const char *_key_name /* [in] [charset(UTF16)] */)
13832 {
13833 struct tevent_req *req;
13834 struct rpccli_spoolss_DeletePrinterKey_state *state;
13835 struct tevent_req *subreq;
13836
13837 req = tevent_req_create(mem_ctx, &state,
13838 struct rpccli_spoolss_DeletePrinterKey_state);
13839 if (req == NULL) {
13840 return NULL;
13841 }
13842 state->out_mem_ctx = NULL;
13843 state->dispatch_recv = cli->dispatch_recv;
13844
13845 /* In parameters */
13846 state->orig.in.handle = _handle;
13847 state->orig.in.key_name = _key_name;
13848
13849 /* Out parameters */
13850
13851 /* Result */
13852 ZERO_STRUCT(state->orig.out.result);
13853
13854 if (DEBUGLEVEL >= 10) {
13855 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterKey, &state->orig);
13856 }
13857
13858 /* make a temporary copy, that we pass to the dispatch function */
13859 state->tmp = state->orig;
13860
13861 subreq = cli->dispatch_send(state, ev, cli,
13862 &ndr_table_spoolss,
13863 NDR_SPOOLSS_DELETEPRINTERKEY,
13864 &state->tmp);
13865 if (tevent_req_nomem(subreq, req)) {
13866 return tevent_req_post(req, ev);
13867 }
13868 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterKey_done, req);
13869 return req;
13870 }
13871
13872 static void rpccli_spoolss_DeletePrinterKey_done(struct tevent_req *subreq)
13873 {
13874 struct tevent_req *req = tevent_req_callback_data(
13875 subreq, struct tevent_req);
13876 struct rpccli_spoolss_DeletePrinterKey_state *state = tevent_req_data(
13877 req, struct rpccli_spoolss_DeletePrinterKey_state);
13878 NTSTATUS status;
13879 TALLOC_CTX *mem_ctx;
13880
13881 if (state->out_mem_ctx) {
13882 mem_ctx = state->out_mem_ctx;
13883 } else {
13884 mem_ctx = state;
13885 }
13886
13887 status = state->dispatch_recv(subreq, mem_ctx);
13888 TALLOC_FREE(subreq);
13889 if (!NT_STATUS_IS_OK(status)) {
13890 tevent_req_nterror(req, status);
13891 return;
13892 }
13893
13894 /* Copy out parameters */
13895
13896 /* Copy result */
13897 state->orig.out.result = state->tmp.out.result;
13898
13899 /* Reset temporary structure */
13900 ZERO_STRUCT(state->tmp);
13901
13902 if (DEBUGLEVEL >= 10) {
13903 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterKey, &state->orig);
13904 }
13905
13906 tevent_req_done(req);
13907 }
13908
13909 NTSTATUS rpccli_spoolss_DeletePrinterKey_recv(struct tevent_req *req,
13910 TALLOC_CTX *mem_ctx,
13911 WERROR *result)
13912 {
13913 struct rpccli_spoolss_DeletePrinterKey_state *state = tevent_req_data(
13914 req, struct rpccli_spoolss_DeletePrinterKey_state);
13915 NTSTATUS status;
13916
13917 if (tevent_req_is_nterror(req, &status)) {
13918 tevent_req_received(req);
13919 return status;
13920 }
13921
13922 /* Steal possbile out parameters to the callers context */
13923 talloc_steal(mem_ctx, state->out_mem_ctx);
13924
13925 /* Return result */
13926 *result = state->orig.out.result;
13927
13928 tevent_req_received(req);
13929 return NT_STATUS_OK;
13930 }
13931
13932 NTSTATUS rpccli_spoolss_DeletePrinterKey(struct rpc_pipe_client *cli,
13933 TALLOC_CTX *mem_ctx,
13934 struct policy_handle *handle /* [in] [ref] */,
13935 const char *key_name /* [in] [charset(UTF16)] */,
13936 WERROR *werror)
13937 {
13938 struct spoolss_DeletePrinterKey r;
13939 NTSTATUS status;
13940
13941 /* In parameters */
13942 r.in.handle = handle;
13943 r.in.key_name = key_name;
13944
13945 if (DEBUGLEVEL >= 10) {
13946 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterKey, &r);
13947 }
13948
13949 status = cli->dispatch(cli,
13950 mem_ctx,
13951 &ndr_table_spoolss,
13952 NDR_SPOOLSS_DELETEPRINTERKEY,
13953 &r);
13954
13955 if (!NT_STATUS_IS_OK(status)) {
13956 return status;
13957 }
13958
13959 if (DEBUGLEVEL >= 10) {
13960 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterKey, &r);
13961 }
13962
13963 if (NT_STATUS_IS_ERR(status)) {
13964 return status;
13965 }
13966
13967 /* Return variables */
13968
13969 /* Return result */
13970 if (werror) {
13971 *werror = r.out.result;
13972 }
13973
13974 return werror_to_ntstatus(r.out.result);
13975 }
13976
13977 struct rpccli_spoolss_53_state {
13978 struct spoolss_53 orig;
13979 struct spoolss_53 tmp;
13980 TALLOC_CTX *out_mem_ctx;
13981 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13982 };
13983
13984 static void rpccli_spoolss_53_done(struct tevent_req *subreq);
13985
13986 struct tevent_req *rpccli_spoolss_53_send(TALLOC_CTX *mem_ctx,
13987 struct tevent_context *ev,
13988 struct rpc_pipe_client *cli)
13989 {
13990 struct tevent_req *req;
13991 struct rpccli_spoolss_53_state *state;
13992 struct tevent_req *subreq;
13993
13994 req = tevent_req_create(mem_ctx, &state,
13995 struct rpccli_spoolss_53_state);
13996 if (req == NULL) {
13997 return NULL;
13998 }
13999 state->out_mem_ctx = NULL;
14000 state->dispatch_recv = cli->dispatch_recv;
14001
14002 /* In parameters */
14003
14004 /* Out parameters */
14005
14006 /* Result */
14007 ZERO_STRUCT(state->orig.out.result);
14008
14009 if (DEBUGLEVEL >= 10) {
14010 NDR_PRINT_IN_DEBUG(spoolss_53, &state->orig);
14011 }
14012
14013 /* make a temporary copy, that we pass to the dispatch function */
14014 state->tmp = state->orig;
14015
14016 subreq = cli->dispatch_send(state, ev, cli,
14017 &ndr_table_spoolss,
14018 NDR_SPOOLSS_53,
14019 &state->tmp);
14020 if (tevent_req_nomem(subreq, req)) {
14021 return tevent_req_post(req, ev);
14022 }
14023 tevent_req_set_callback(subreq, rpccli_spoolss_53_done, req);
14024 return req;
14025 }
14026
14027 static void rpccli_spoolss_53_done(struct tevent_req *subreq)
14028 {
14029 struct tevent_req *req = tevent_req_callback_data(
14030 subreq, struct tevent_req);
14031 struct rpccli_spoolss_53_state *state = tevent_req_data(
14032 req, struct rpccli_spoolss_53_state);
14033 NTSTATUS status;
14034 TALLOC_CTX *mem_ctx;
14035
14036 if (state->out_mem_ctx) {
14037 mem_ctx = state->out_mem_ctx;
14038 } else {
14039 mem_ctx = state;
14040 }
14041
14042 status = state->dispatch_recv(subreq, mem_ctx);
14043 TALLOC_FREE(subreq);
14044 if (!NT_STATUS_IS_OK(status)) {
14045 tevent_req_nterror(req, status);
14046 return;
14047 }
14048
14049 /* Copy out parameters */
14050
14051 /* Copy result */
14052 state->orig.out.result = state->tmp.out.result;
14053
14054 /* Reset temporary structure */
14055 ZERO_STRUCT(state->tmp);
14056
14057 if (DEBUGLEVEL >= 10) {
14058 NDR_PRINT_OUT_DEBUG(spoolss_53, &state->orig);
14059 }
14060
14061 tevent_req_done(req);
14062 }
14063
14064 NTSTATUS rpccli_spoolss_53_recv(struct tevent_req *req,
14065 TALLOC_CTX *mem_ctx,
14066 WERROR *result)
14067 {
14068 struct rpccli_spoolss_53_state *state = tevent_req_data(
14069 req, struct rpccli_spoolss_53_state);
14070 NTSTATUS status;
14071
14072 if (tevent_req_is_nterror(req, &status)) {
14073 tevent_req_received(req);
14074 return status;
14075 }
14076
14077 /* Steal possbile out parameters to the callers context */
14078 talloc_steal(mem_ctx, state->out_mem_ctx);
14079
14080 /* Return result */
14081 *result = state->orig.out.result;
14082
14083 tevent_req_received(req);
14084 return NT_STATUS_OK;
14085 }
14086
14087 NTSTATUS rpccli_spoolss_53(struct rpc_pipe_client *cli,
14088 TALLOC_CTX *mem_ctx,
14089 WERROR *werror)
14090 {
14091 struct spoolss_53 r;
14092 NTSTATUS status;
14093
14094 /* In parameters */
14095
14096 if (DEBUGLEVEL >= 10) {
14097 NDR_PRINT_IN_DEBUG(spoolss_53, &r);
14098 }
14099
14100 status = cli->dispatch(cli,
14101 mem_ctx,
14102 &ndr_table_spoolss,
14103 NDR_SPOOLSS_53,
14104 &r);
14105
14106 if (!NT_STATUS_IS_OK(status)) {
14107 return status;
14108 }
14109
14110 if (DEBUGLEVEL >= 10) {
14111 NDR_PRINT_OUT_DEBUG(spoolss_53, &r);
14112 }
14113
14114 if (NT_STATUS_IS_ERR(status)) {
14115 return status;
14116 }
14117
14118 /* Return variables */
14119
14120 /* Return result */
14121 if (werror) {
14122 *werror = r.out.result;
14123 }
14124
14125 return werror_to_ntstatus(r.out.result);
14126 }
14127
14128 struct rpccli_spoolss_DeletePrinterDriverEx_state {
14129 struct spoolss_DeletePrinterDriverEx orig;
14130 struct spoolss_DeletePrinterDriverEx tmp;
14131 TALLOC_CTX *out_mem_ctx;
14132 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14133 };
14134
14135 static void rpccli_spoolss_DeletePrinterDriverEx_done(struct tevent_req *subreq);
14136
14137 struct tevent_req *rpccli_spoolss_DeletePrinterDriverEx_send(TALLOC_CTX *mem_ctx,
14138 struct tevent_context *ev,
14139 struct rpc_pipe_client *cli,
14140 const char *_server /* [in] [unique,charset(UTF16)] */,
14141 const char *_architecture /* [in] [charset(UTF16)] */,
14142 const char *_driver /* [in] [charset(UTF16)] */,
14143 uint32_t _delete_flags /* [in] */,
14144 uint32_t _version /* [in] */)
14145 {
14146 struct tevent_req *req;
14147 struct rpccli_spoolss_DeletePrinterDriverEx_state *state;
14148 struct tevent_req *subreq;
14149
14150 req = tevent_req_create(mem_ctx, &state,
14151 struct rpccli_spoolss_DeletePrinterDriverEx_state);
14152 if (req == NULL) {
14153 return NULL;
14154 }
14155 state->out_mem_ctx = NULL;
14156 state->dispatch_recv = cli->dispatch_recv;
14157
14158 /* In parameters */
14159 state->orig.in.server = _server;
14160 state->orig.in.architecture = _architecture;
14161 state->orig.in.driver = _driver;
14162 state->orig.in.delete_flags = _delete_flags;
14163 state->orig.in.version = _version;
14164
14165 /* Out parameters */
14166
14167 /* Result */
14168 ZERO_STRUCT(state->orig.out.result);
14169
14170 if (DEBUGLEVEL >= 10) {
14171 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDriverEx, &state->orig);
14172 }
14173
14174 /* make a temporary copy, that we pass to the dispatch function */
14175 state->tmp = state->orig;
14176
14177 subreq = cli->dispatch_send(state, ev, cli,
14178 &ndr_table_spoolss,
14179 NDR_SPOOLSS_DELETEPRINTERDRIVEREX,
14180 &state->tmp);
14181 if (tevent_req_nomem(subreq, req)) {
14182 return tevent_req_post(req, ev);
14183 }
14184 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterDriverEx_done, req);
14185 return req;
14186 }
14187
14188 static void rpccli_spoolss_DeletePrinterDriverEx_done(struct tevent_req *subreq)
14189 {
14190 struct tevent_req *req = tevent_req_callback_data(
14191 subreq, struct tevent_req);
14192 struct rpccli_spoolss_DeletePrinterDriverEx_state *state = tevent_req_data(
14193 req, struct rpccli_spoolss_DeletePrinterDriverEx_state);
14194 NTSTATUS status;
14195 TALLOC_CTX *mem_ctx;
14196
14197 if (state->out_mem_ctx) {
14198 mem_ctx = state->out_mem_ctx;
14199 } else {
14200 mem_ctx = state;
14201 }
14202
14203 status = state->dispatch_recv(subreq, mem_ctx);
14204 TALLOC_FREE(subreq);
14205 if (!NT_STATUS_IS_OK(status)) {
14206 tevent_req_nterror(req, status);
14207 return;
14208 }
14209
14210 /* Copy out parameters */
14211
14212 /* Copy result */
14213 state->orig.out.result = state->tmp.out.result;
14214
14215 /* Reset temporary structure */
14216 ZERO_STRUCT(state->tmp);
14217
14218 if (DEBUGLEVEL >= 10) {
14219 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDriverEx, &state->orig);
14220 }
14221
14222 tevent_req_done(req);
14223 }
14224
14225 NTSTATUS rpccli_spoolss_DeletePrinterDriverEx_recv(struct tevent_req *req,
14226 TALLOC_CTX *mem_ctx,
14227 WERROR *result)
14228 {
14229 struct rpccli_spoolss_DeletePrinterDriverEx_state *state = tevent_req_data(
14230 req, struct rpccli_spoolss_DeletePrinterDriverEx_state);
14231 NTSTATUS status;
14232
14233 if (tevent_req_is_nterror(req, &status)) {
14234 tevent_req_received(req);
14235 return status;
14236 }
14237
14238 /* Steal possbile out parameters to the callers context */
14239 talloc_steal(mem_ctx, state->out_mem_ctx);
14240
14241 /* Return result */
14242 *result = state->orig.out.result;
14243
14244 tevent_req_received(req);
14245 return NT_STATUS_OK;
14246 }
14247
14248 NTSTATUS rpccli_spoolss_DeletePrinterDriverEx(struct rpc_pipe_client *cli,
14249 TALLOC_CTX *mem_ctx,
14250 const char *server /* [in] [unique,charset(UTF16)] */,
14251 const char *architecture /* [in] [charset(UTF16)] */,
14252 const char *driver /* [in] [charset(UTF16)] */,
14253 uint32_t delete_flags /* [in] */,
14254 uint32_t version /* [in] */,
14255 WERROR *werror)
14256 {
14257 struct spoolss_DeletePrinterDriverEx r;
14258 NTSTATUS status;
14259
14260 /* In parameters */
14261 r.in.server = server;
14262 r.in.architecture = architecture;
14263 r.in.driver = driver;
14264 r.in.delete_flags = delete_flags;
14265 r.in.version = version;
14266
14267 if (DEBUGLEVEL >= 10) {
14268 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDriverEx, &r);
14269 }
14270
14271 status = cli->dispatch(cli,
14272 mem_ctx,
14273 &ndr_table_spoolss,
14274 NDR_SPOOLSS_DELETEPRINTERDRIVEREX,
14275 &r);
14276
14277 if (!NT_STATUS_IS_OK(status)) {
14278 return status;
14279 }
14280
14281 if (DEBUGLEVEL >= 10) {
14282 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDriverEx, &r);
14283 }
14284
14285 if (NT_STATUS_IS_ERR(status)) {
14286 return status;
14287 }
14288
14289 /* Return variables */
14290
14291 /* Return result */
14292 if (werror) {
14293 *werror = r.out.result;
14294 }
14295
14296 return werror_to_ntstatus(r.out.result);
14297 }
14298
14299 struct rpccli_spoolss_55_state {
14300 struct spoolss_55 orig;
14301 struct spoolss_55 tmp;
14302 TALLOC_CTX *out_mem_ctx;
14303 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14304 };
14305
14306 static void rpccli_spoolss_55_done(struct tevent_req *subreq);
14307
14308 struct tevent_req *rpccli_spoolss_55_send(TALLOC_CTX *mem_ctx,
14309 struct tevent_context *ev,
14310 struct rpc_pipe_client *cli)
14311 {
14312 struct tevent_req *req;
14313 struct rpccli_spoolss_55_state *state;
14314 struct tevent_req *subreq;
14315
14316 req = tevent_req_create(mem_ctx, &state,
14317 struct rpccli_spoolss_55_state);
14318 if (req == NULL) {
14319 return NULL;
14320 }
14321 state->out_mem_ctx = NULL;
14322 state->dispatch_recv = cli->dispatch_recv;
14323
14324 /* In parameters */
14325
14326 /* Out parameters */
14327
14328 /* Result */
14329 ZERO_STRUCT(state->orig.out.result);
14330
14331 if (DEBUGLEVEL >= 10) {
14332 NDR_PRINT_IN_DEBUG(spoolss_55, &state->orig);
14333 }
14334
14335 /* make a temporary copy, that we pass to the dispatch function */
14336 state->tmp = state->orig;
14337
14338 subreq = cli->dispatch_send(state, ev, cli,
14339 &ndr_table_spoolss,
14340 NDR_SPOOLSS_55,
14341 &state->tmp);
14342 if (tevent_req_nomem(subreq, req)) {
14343 return tevent_req_post(req, ev);
14344 }
14345 tevent_req_set_callback(subreq, rpccli_spoolss_55_done, req);
14346 return req;
14347 }
14348
14349 static void rpccli_spoolss_55_done(struct tevent_req *subreq)
14350 {
14351 struct tevent_req *req = tevent_req_callback_data(
14352 subreq, struct tevent_req);
14353 struct rpccli_spoolss_55_state *state = tevent_req_data(
14354 req, struct rpccli_spoolss_55_state);
14355 NTSTATUS status;
14356 TALLOC_CTX *mem_ctx;
14357
14358 if (state->out_mem_ctx) {
14359 mem_ctx = state->out_mem_ctx;
14360 } else {
14361 mem_ctx = state;
14362 }
14363
14364 status = state->dispatch_recv(subreq, mem_ctx);
14365 TALLOC_FREE(subreq);
14366 if (!NT_STATUS_IS_OK(status)) {
14367 tevent_req_nterror(req, status);
14368 return;
14369 }
14370
14371 /* Copy out parameters */
14372
14373 /* Copy result */
14374 state->orig.out.result = state->tmp.out.result;
14375
14376 /* Reset temporary structure */
14377 ZERO_STRUCT(state->tmp);
14378
14379 if (DEBUGLEVEL >= 10) {
14380 NDR_PRINT_OUT_DEBUG(spoolss_55, &state->orig);
14381 }
14382
14383 tevent_req_done(req);
14384 }
14385
14386 NTSTATUS rpccli_spoolss_55_recv(struct tevent_req *req,
14387 TALLOC_CTX *mem_ctx,
14388 WERROR *result)
14389 {
14390 struct rpccli_spoolss_55_state *state = tevent_req_data(
14391 req, struct rpccli_spoolss_55_state);
14392 NTSTATUS status;
14393
14394 if (tevent_req_is_nterror(req, &status)) {
14395 tevent_req_received(req);
14396 return status;
14397 }
14398
14399 /* Steal possbile out parameters to the callers context */
14400 talloc_steal(mem_ctx, state->out_mem_ctx);
14401
14402 /* Return result */
14403 *result = state->orig.out.result;
14404
14405 tevent_req_received(req);
14406 return NT_STATUS_OK;
14407 }
14408
14409 NTSTATUS rpccli_spoolss_55(struct rpc_pipe_client *cli,
14410 TALLOC_CTX *mem_ctx,
14411 WERROR *werror)
14412 {
14413 struct spoolss_55 r;
14414 NTSTATUS status;
14415
14416 /* In parameters */
14417
14418 if (DEBUGLEVEL >= 10) {
14419 NDR_PRINT_IN_DEBUG(spoolss_55, &r);
14420 }
14421
14422 status = cli->dispatch(cli,
14423 mem_ctx,
14424 &ndr_table_spoolss,
14425 NDR_SPOOLSS_55,
14426 &r);
14427
14428 if (!NT_STATUS_IS_OK(status)) {
14429 return status;
14430 }
14431
14432 if (DEBUGLEVEL >= 10) {
14433 NDR_PRINT_OUT_DEBUG(spoolss_55, &r);
14434 }
14435
14436 if (NT_STATUS_IS_ERR(status)) {
14437 return status;
14438 }
14439
14440 /* Return variables */
14441
14442 /* Return result */
14443 if (werror) {
14444 *werror = r.out.result;
14445 }
14446
14447 return werror_to_ntstatus(r.out.result);
14448 }
14449
14450 struct rpccli_spoolss_56_state {
14451 struct spoolss_56 orig;
14452 struct spoolss_56 tmp;
14453 TALLOC_CTX *out_mem_ctx;
14454 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14455 };
14456
14457 static void rpccli_spoolss_56_done(struct tevent_req *subreq);
14458
14459 struct tevent_req *rpccli_spoolss_56_send(TALLOC_CTX *mem_ctx,
14460 struct tevent_context *ev,
14461 struct rpc_pipe_client *cli)
14462 {
14463 struct tevent_req *req;
14464 struct rpccli_spoolss_56_state *state;
14465 struct tevent_req *subreq;
14466
14467 req = tevent_req_create(mem_ctx, &state,
14468 struct rpccli_spoolss_56_state);
14469 if (req == NULL) {
14470 return NULL;
14471 }
14472 state->out_mem_ctx = NULL;
14473 state->dispatch_recv = cli->dispatch_recv;
14474
14475 /* In parameters */
14476
14477 /* Out parameters */
14478
14479 /* Result */
14480 ZERO_STRUCT(state->orig.out.result);
14481
14482 if (DEBUGLEVEL >= 10) {
14483 NDR_PRINT_IN_DEBUG(spoolss_56, &state->orig);
14484 }
14485
14486 /* make a temporary copy, that we pass to the dispatch function */
14487 state->tmp = state->orig;
14488
14489 subreq = cli->dispatch_send(state, ev, cli,
14490 &ndr_table_spoolss,
14491 NDR_SPOOLSS_56,
14492 &state->tmp);
14493 if (tevent_req_nomem(subreq, req)) {
14494 return tevent_req_post(req, ev);
14495 }
14496 tevent_req_set_callback(subreq, rpccli_spoolss_56_done, req);
14497 return req;
14498 }
14499
14500 static void rpccli_spoolss_56_done(struct tevent_req *subreq)
14501 {
14502 struct tevent_req *req = tevent_req_callback_data(
14503 subreq, struct tevent_req);
14504 struct rpccli_spoolss_56_state *state = tevent_req_data(
14505 req, struct rpccli_spoolss_56_state);
14506 NTSTATUS status;
14507 TALLOC_CTX *mem_ctx;
14508
14509 if (state->out_mem_ctx) {
14510 mem_ctx = state->out_mem_ctx;
14511 } else {
14512 mem_ctx = state;
14513 }
14514
14515 status = state->dispatch_recv(subreq, mem_ctx);
14516 TALLOC_FREE(subreq);
14517 if (!NT_STATUS_IS_OK(status)) {
14518 tevent_req_nterror(req, status);
14519 return;
14520 }
14521
14522 /* Copy out parameters */
14523
14524 /* Copy result */
14525 state->orig.out.result = state->tmp.out.result;
14526
14527 /* Reset temporary structure */
14528 ZERO_STRUCT(state->tmp);
14529
14530 if (DEBUGLEVEL >= 10) {
14531 NDR_PRINT_OUT_DEBUG(spoolss_56, &state->orig);
14532 }
14533
14534 tevent_req_done(req);
14535 }
14536
14537 NTSTATUS rpccli_spoolss_56_recv(struct tevent_req *req,
14538 TALLOC_CTX *mem_ctx,
14539 WERROR *result)
14540 {
14541 struct rpccli_spoolss_56_state *state = tevent_req_data(
14542 req, struct rpccli_spoolss_56_state);
14543 NTSTATUS status;
14544
14545 if (tevent_req_is_nterror(req, &status)) {
14546 tevent_req_received(req);
14547 return status;
14548 }
14549
14550 /* Steal possbile out parameters to the callers context */
14551 talloc_steal(mem_ctx, state->out_mem_ctx);
14552
14553 /* Return result */
14554 *result = state->orig.out.result;
14555
14556 tevent_req_received(req);
14557 return NT_STATUS_OK;
14558 }
14559
14560 NTSTATUS rpccli_spoolss_56(struct rpc_pipe_client *cli,
14561 TALLOC_CTX *mem_ctx,
14562 WERROR *werror)
14563 {
14564 struct spoolss_56 r;
14565 NTSTATUS status;
14566
14567 /* In parameters */
14568
14569 if (DEBUGLEVEL >= 10) {
14570 NDR_PRINT_IN_DEBUG(spoolss_56, &r);
14571 }
14572
14573 status = cli->dispatch(cli,
14574 mem_ctx,
14575 &ndr_table_spoolss,
14576 NDR_SPOOLSS_56,
14577 &r);
14578
14579 if (!NT_STATUS_IS_OK(status)) {
14580 return status;
14581 }
14582
14583 if (DEBUGLEVEL >= 10) {
14584 NDR_PRINT_OUT_DEBUG(spoolss_56, &r);
14585 }
14586
14587 if (NT_STATUS_IS_ERR(status)) {
14588 return status;
14589 }
14590
14591 /* Return variables */
14592
14593 /* Return result */
14594 if (werror) {
14595 *werror = r.out.result;
14596 }
14597
14598 return werror_to_ntstatus(r.out.result);
14599 }
14600
14601 struct rpccli_spoolss_57_state {
14602 struct spoolss_57 orig;
14603 struct spoolss_57 tmp;
14604 TALLOC_CTX *out_mem_ctx;
14605 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14606 };
14607
14608 static void rpccli_spoolss_57_done(struct tevent_req *subreq);
14609
14610 struct tevent_req *rpccli_spoolss_57_send(TALLOC_CTX *mem_ctx,
14611 struct tevent_context *ev,
14612 struct rpc_pipe_client *cli)
14613 {
14614 struct tevent_req *req;
14615 struct rpccli_spoolss_57_state *state;
14616 struct tevent_req *subreq;
14617
14618 req = tevent_req_create(mem_ctx, &state,
14619 struct rpccli_spoolss_57_state);
14620 if (req == NULL) {
14621 return NULL;
14622 }
14623 state->out_mem_ctx = NULL;
14624 state->dispatch_recv = cli->dispatch_recv;
14625
14626 /* In parameters */
14627
14628 /* Out parameters */
14629
14630 /* Result */
14631 ZERO_STRUCT(state->orig.out.result);
14632
14633 if (DEBUGLEVEL >= 10) {
14634 NDR_PRINT_IN_DEBUG(spoolss_57, &state->orig);
14635 }
14636
14637 /* make a temporary copy, that we pass to the dispatch function */
14638 state->tmp = state->orig;
14639
14640 subreq = cli->dispatch_send(state, ev, cli,
14641 &ndr_table_spoolss,
14642 NDR_SPOOLSS_57,
14643 &state->tmp);
14644 if (tevent_req_nomem(subreq, req)) {
14645 return tevent_req_post(req, ev);
14646 }
14647 tevent_req_set_callback(subreq, rpccli_spoolss_57_done, req);
14648 return req;
14649 }
14650
14651 static void rpccli_spoolss_57_done(struct tevent_req *subreq)
14652 {
14653 struct tevent_req *req = tevent_req_callback_data(
14654 subreq, struct tevent_req);
14655 struct rpccli_spoolss_57_state *state = tevent_req_data(
14656 req, struct rpccli_spoolss_57_state);
14657 NTSTATUS status;
14658 TALLOC_CTX *mem_ctx;
14659
14660 if (state->out_mem_ctx) {
14661 mem_ctx = state->out_mem_ctx;
14662 } else {
14663 mem_ctx = state;
14664 }
14665
14666 status = state->dispatch_recv(subreq, mem_ctx);
14667 TALLOC_FREE(subreq);
14668 if (!NT_STATUS_IS_OK(status)) {
14669 tevent_req_nterror(req, status);
14670 return;
14671 }
14672
14673 /* Copy out parameters */
14674
14675 /* Copy result */
14676 state->orig.out.result = state->tmp.out.result;
14677
14678 /* Reset temporary structure */
14679 ZERO_STRUCT(state->tmp);
14680
14681 if (DEBUGLEVEL >= 10) {
14682 NDR_PRINT_OUT_DEBUG(spoolss_57, &state->orig);
14683 }
14684
14685 tevent_req_done(req);
14686 }
14687
14688 NTSTATUS rpccli_spoolss_57_recv(struct tevent_req *req,
14689 TALLOC_CTX *mem_ctx,
14690 WERROR *result)
14691 {
14692 struct rpccli_spoolss_57_state *state = tevent_req_data(
14693 req, struct rpccli_spoolss_57_state);
14694 NTSTATUS status;
14695
14696 if (tevent_req_is_nterror(req, &status)) {
14697 tevent_req_received(req);
14698 return status;
14699 }
14700
14701 /* Steal possbile out parameters to the callers context */
14702 talloc_steal(mem_ctx, state->out_mem_ctx);
14703
14704 /* Return result */
14705 *result = state->orig.out.result;
14706
14707 tevent_req_received(req);
14708 return NT_STATUS_OK;
14709 }
14710
14711 NTSTATUS rpccli_spoolss_57(struct rpc_pipe_client *cli,
14712 TALLOC_CTX *mem_ctx,
14713 WERROR *werror)
14714 {
14715 struct spoolss_57 r;
14716 NTSTATUS status;
14717
14718 /* In parameters */
14719
14720 if (DEBUGLEVEL >= 10) {
14721 NDR_PRINT_IN_DEBUG(spoolss_57, &r);
14722 }
14723
14724 status = cli->dispatch(cli,
14725 mem_ctx,
14726 &ndr_table_spoolss,
14727 NDR_SPOOLSS_57,
14728 &r);
14729
14730 if (!NT_STATUS_IS_OK(status)) {
14731 return status;
14732 }
14733
14734 if (DEBUGLEVEL >= 10) {
14735 NDR_PRINT_OUT_DEBUG(spoolss_57, &r);
14736 }
14737
14738 if (NT_STATUS_IS_ERR(status)) {
14739 return status;
14740 }
14741
14742 /* Return variables */
14743
14744 /* Return result */
14745 if (werror) {
14746 *werror = r.out.result;
14747 }
14748
14749 return werror_to_ntstatus(r.out.result);
14750 }
14751
14752 struct rpccli_spoolss_XcvData_state {
14753 struct spoolss_XcvData orig;
14754 struct spoolss_XcvData tmp;
14755 TALLOC_CTX *out_mem_ctx;
14756 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14757 };
14758
14759 static void rpccli_spoolss_XcvData_done(struct tevent_req *subreq);
14760
14761 struct tevent_req *rpccli_spoolss_XcvData_send(TALLOC_CTX *mem_ctx,
14762 struct tevent_context *ev,
14763 struct rpc_pipe_client *cli,
14764 struct policy_handle *_handle /* [in] [ref] */,
14765 const char *_function_name /* [in] [charset(UTF16)] */,
14766 DATA_BLOB _in_data /* [in] */,
14767 uint32_t __in_data_length /* [in] [value(r->in.in_data.length)] */,
14768 uint8_t *_out_data /* [out] [ref,size_is(out_data_size)] */,
14769 uint32_t _out_data_size /* [in] */,
14770 uint32_t *_needed /* [out] [ref] */,
14771 uint32_t *_status_code /* [in,out] [ref] */)
14772 {
14773 struct tevent_req *req;
14774 struct rpccli_spoolss_XcvData_state *state;
14775 struct tevent_req *subreq;
14776
14777 req = tevent_req_create(mem_ctx, &state,
14778 struct rpccli_spoolss_XcvData_state);
14779 if (req == NULL) {
14780 return NULL;
14781 }
14782 state->out_mem_ctx = NULL;
14783 state->dispatch_recv = cli->dispatch_recv;
14784
14785 /* In parameters */
14786 state->orig.in.handle = _handle;
14787 state->orig.in.function_name = _function_name;
14788 state->orig.in.in_data = _in_data;
14789 state->orig.in._in_data_length = __in_data_length;
14790 state->orig.in.out_data_size = _out_data_size;
14791 state->orig.in.status_code = _status_code;
14792
14793 /* Out parameters */
14794 state->orig.out.out_data = _out_data;
14795 state->orig.out.needed = _needed;
14796 state->orig.out.status_code = _status_code;
14797
14798 /* Result */
14799 ZERO_STRUCT(state->orig.out.result);
14800
14801 if (DEBUGLEVEL >= 10) {
14802 NDR_PRINT_IN_DEBUG(spoolss_XcvData, &state->orig);
14803 }
14804
14805 state->out_mem_ctx = talloc_named_const(state, 0,
14806 "rpccli_spoolss_XcvData_out_memory");
14807 if (tevent_req_nomem(state->out_mem_ctx, req)) {
14808 return tevent_req_post(req, ev);
14809 }
14810
14811 /* make a temporary copy, that we pass to the dispatch function */
14812 state->tmp = state->orig;
14813
14814 subreq = cli->dispatch_send(state, ev, cli,
14815 &ndr_table_spoolss,
14816 NDR_SPOOLSS_XCVDATA,
14817 &state->tmp);
14818 if (tevent_req_nomem(subreq, req)) {
14819 return tevent_req_post(req, ev);
14820 }
14821 tevent_req_set_callback(subreq, rpccli_spoolss_XcvData_done, req);
14822 return req;
14823 }
14824
14825 static void rpccli_spoolss_XcvData_done(struct tevent_req *subreq)
14826 {
14827 struct tevent_req *req = tevent_req_callback_data(
14828 subreq, struct tevent_req);
14829 struct rpccli_spoolss_XcvData_state *state = tevent_req_data(
14830 req, struct rpccli_spoolss_XcvData_state);
14831 NTSTATUS status;
14832 TALLOC_CTX *mem_ctx;
14833
14834 if (state->out_mem_ctx) {
14835 mem_ctx = state->out_mem_ctx;
14836 } else {
14837 mem_ctx = state;
14838 }
14839
14840 status = state->dispatch_recv(subreq, mem_ctx);
14841 TALLOC_FREE(subreq);
14842 if (!NT_STATUS_IS_OK(status)) {
14843 tevent_req_nterror(req, status);
14844 return;
14845 }
14846
14847 /* Copy out parameters */
14848 memcpy(state->orig.out.out_data, state->tmp.out.out_data, state->tmp.in.out_data_size * sizeof(*state->orig.out.out_data));
14849 *state->orig.out.needed = *state->tmp.out.needed;
14850 *state->orig.out.status_code = *state->tmp.out.status_code;
14851
14852 /* Copy result */
14853 state->orig.out.result = state->tmp.out.result;
14854
14855 /* Reset temporary structure */
14856 ZERO_STRUCT(state->tmp);
14857
14858 if (DEBUGLEVEL >= 10) {
14859 NDR_PRINT_OUT_DEBUG(spoolss_XcvData, &state->orig);
14860 }
14861
14862 tevent_req_done(req);
14863 }
14864
14865 NTSTATUS rpccli_spoolss_XcvData_recv(struct tevent_req *req,
14866 TALLOC_CTX *mem_ctx,
14867 WERROR *result)
14868 {
14869 struct rpccli_spoolss_XcvData_state *state = tevent_req_data(
14870 req, struct rpccli_spoolss_XcvData_state);
14871 NTSTATUS status;
14872
14873 if (tevent_req_is_nterror(req, &status)) {
14874 tevent_req_received(req);
14875 return status;
14876 }
14877
14878 /* Steal possbile out parameters to the callers context */
14879 talloc_steal(mem_ctx, state->out_mem_ctx);
14880
14881 /* Return result */
14882 *result = state->orig.out.result;
14883
14884 tevent_req_received(req);
14885 return NT_STATUS_OK;
14886 }
14887
14888 NTSTATUS rpccli_spoolss_XcvData(struct rpc_pipe_client *cli,
14889 TALLOC_CTX *mem_ctx,
14890 struct policy_handle *handle /* [in] [ref] */,
14891 const char *function_name /* [in] [charset(UTF16)] */,
14892 DATA_BLOB in_data /* [in] */,
14893 uint32_t _in_data_length /* [in] [value(r->in.in_data.length)] */,
14894 uint8_t *out_data /* [out] [ref,size_is(out_data_size)] */,
14895 uint32_t out_data_size /* [in] */,
14896 uint32_t *needed /* [out] [ref] */,
14897 uint32_t *status_code /* [in,out] [ref] */,
14898 WERROR *werror)
14899 {
14900 struct spoolss_XcvData r;
14901 NTSTATUS status;
14902
14903 /* In parameters */
14904 r.in.handle = handle;
14905 r.in.function_name = function_name;
14906 r.in.in_data = in_data;
14907 r.in._in_data_length = _in_data_length;
14908 r.in.out_data_size = out_data_size;
14909 r.in.status_code = status_code;
14910
14911 if (DEBUGLEVEL >= 10) {
14912 NDR_PRINT_IN_DEBUG(spoolss_XcvData, &r);
14913 }
14914
14915 status = cli->dispatch(cli,
14916 mem_ctx,
14917 &ndr_table_spoolss,
14918 NDR_SPOOLSS_XCVDATA,
14919 &r);
14920
14921 if (!NT_STATUS_IS_OK(status)) {
14922 return status;
14923 }
14924
14925 if (DEBUGLEVEL >= 10) {
14926 NDR_PRINT_OUT_DEBUG(spoolss_XcvData, &r);
14927 }
14928
14929 if (NT_STATUS_IS_ERR(status)) {
14930 return status;
14931 }
14932
14933 /* Return variables */
14934 memcpy(out_data, r.out.out_data, r.in.out_data_size * sizeof(*out_data));
14935 *needed = *r.out.needed;
14936 *status_code = *r.out.status_code;
14937
14938 /* Return result */
14939 if (werror) {
14940 *werror = r.out.result;
14941 }
14942
14943 return werror_to_ntstatus(r.out.result);
14944 }
14945
14946 struct rpccli_spoolss_AddPrinterDriverEx_state {
14947 struct spoolss_AddPrinterDriverEx orig;
14948 struct spoolss_AddPrinterDriverEx tmp;
14949 TALLOC_CTX *out_mem_ctx;
14950 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14951 };
14952
14953 static void rpccli_spoolss_AddPrinterDriverEx_done(struct tevent_req *subreq);
14954
14955 struct tevent_req *rpccli_spoolss_AddPrinterDriverEx_send(TALLOC_CTX *mem_ctx,
14956 struct tevent_context *ev,
14957 struct rpc_pipe_client *cli,
14958 const char *_servername /* [in] [unique,charset(UTF16)] */,
14959 struct spoolss_AddDriverInfoCtr *_info_ctr /* [in] [ref] */,
14960 uint32_t _flags /* [in] */)
14961 {
14962 struct tevent_req *req;
14963 struct rpccli_spoolss_AddPrinterDriverEx_state *state;
14964 struct tevent_req *subreq;
14965
14966 req = tevent_req_create(mem_ctx, &state,
14967 struct rpccli_spoolss_AddPrinterDriverEx_state);
14968 if (req == NULL) {
14969 return NULL;
14970 }
14971 state->out_mem_ctx = NULL;
14972 state->dispatch_recv = cli->dispatch_recv;
14973
14974 /* In parameters */
14975 state->orig.in.servername = _servername;
14976 state->orig.in.info_ctr = _info_ctr;
14977 state->orig.in.flags = _flags;
14978
14979 /* Out parameters */
14980
14981 /* Result */
14982 ZERO_STRUCT(state->orig.out.result);
14983
14984 if (DEBUGLEVEL >= 10) {
14985 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterDriverEx, &state->orig);
14986 }
14987
14988 /* make a temporary copy, that we pass to the dispatch function */
14989 state->tmp = state->orig;
14990
14991 subreq = cli->dispatch_send(state, ev, cli,
14992 &ndr_table_spoolss,
14993 NDR_SPOOLSS_ADDPRINTERDRIVEREX,
14994 &state->tmp);
14995 if (tevent_req_nomem(subreq, req)) {
14996 return tevent_req_post(req, ev);
14997 }
14998 tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterDriverEx_done, req);
14999 return req;
15000 }
15001
15002 static void rpccli_spoolss_AddPrinterDriverEx_done(struct tevent_req *subreq)
15003 {
15004 struct tevent_req *req = tevent_req_callback_data(
15005 subreq, struct tevent_req);
15006 struct rpccli_spoolss_AddPrinterDriverEx_state *state = tevent_req_data(
15007 req, struct rpccli_spoolss_AddPrinterDriverEx_state);
15008 NTSTATUS status;
15009 TALLOC_CTX *mem_ctx;
15010
15011 if (state->out_mem_ctx) {
15012 mem_ctx = state->out_mem_ctx;
15013 } else {
15014 mem_ctx = state;
15015 }
15016
15017 status = state->dispatch_recv(subreq, mem_ctx);
15018 TALLOC_FREE(subreq);
15019 if (!NT_STATUS_IS_OK(status)) {
15020 tevent_req_nterror(req, status);
15021 return;
15022 }
15023
15024 /* Copy out parameters */
15025
15026 /* Copy result */
15027 state->orig.out.result = state->tmp.out.result;
15028
15029 /* Reset temporary structure */
15030 ZERO_STRUCT(state->tmp);
15031
15032 if (DEBUGLEVEL >= 10) {
15033 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterDriverEx, &state->orig);
15034 }
15035
15036 tevent_req_done(req);
15037 }
15038
15039 NTSTATUS rpccli_spoolss_AddPrinterDriverEx_recv(struct tevent_req *req,
15040 TALLOC_CTX *mem_ctx,
15041 WERROR *result)
15042 {
15043 struct rpccli_spoolss_AddPrinterDriverEx_state *state = tevent_req_data(
15044 req, struct rpccli_spoolss_AddPrinterDriverEx_state);
15045 NTSTATUS status;
15046
15047 if (tevent_req_is_nterror(req, &status)) {
15048 tevent_req_received(req);
15049 return status;
15050 }
15051
15052 /* Steal possbile out parameters to the callers context */
15053 talloc_steal(mem_ctx, state->out_mem_ctx);
15054
15055 /* Return result */
15056 *result = state->orig.out.result;
15057
15058 tevent_req_received(req);
15059 return NT_STATUS_OK;
15060 }
15061
15062 NTSTATUS rpccli_spoolss_AddPrinterDriverEx(struct rpc_pipe_client *cli,
15063 TALLOC_CTX *mem_ctx,
15064 const char *servername /* [in] [unique,charset(UTF16)] */,
15065 struct spoolss_AddDriverInfoCtr *info_ctr /* [in] [ref] */,
15066 uint32_t flags /* [in] */,
15067 WERROR *werror)
15068 {
15069 struct spoolss_AddPrinterDriverEx r;
15070 NTSTATUS status;
15071
15072 /* In parameters */
15073 r.in.servername = servername;
15074 r.in.info_ctr = info_ctr;
15075 r.in.flags = flags;
15076
15077 if (DEBUGLEVEL >= 10) {
15078 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterDriverEx, &r);
15079 }
15080
15081 status = cli->dispatch(cli,
15082 mem_ctx,
15083 &ndr_table_spoolss,
15084 NDR_SPOOLSS_ADDPRINTERDRIVEREX,
15085 &r);
15086
15087 if (!NT_STATUS_IS_OK(status)) {
15088 return status;
15089 }
15090
15091 if (DEBUGLEVEL >= 10) {
15092 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterDriverEx, &r);
15093 }
15094
15095 if (NT_STATUS_IS_ERR(status)) {
15096 return status;
15097 }
15098
15099 /* Return variables */
15100
15101 /* Return result */
15102 if (werror) {
15103 *werror = r.out.result;
15104 }
15105
15106 return werror_to_ntstatus(r.out.result);
15107 }
15108
15109 struct rpccli_spoolss_5a_state {
15110 struct spoolss_5a orig;
15111 struct spoolss_5a tmp;
15112 TALLOC_CTX *out_mem_ctx;
15113 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15114 };
15115
15116 static void rpccli_spoolss_5a_done(struct tevent_req *subreq);
15117
15118 struct tevent_req *rpccli_spoolss_5a_send(TALLOC_CTX *mem_ctx,
15119 struct tevent_context *ev,
15120 struct rpc_pipe_client *cli)
15121 {
15122 struct tevent_req *req;
15123 struct rpccli_spoolss_5a_state *state;
15124 struct tevent_req *subreq;
15125
15126 req = tevent_req_create(mem_ctx, &state,
15127 struct rpccli_spoolss_5a_state);
15128 if (req == NULL) {
15129 return NULL;
15130 }
15131 state->out_mem_ctx = NULL;
15132 state->dispatch_recv = cli->dispatch_recv;
15133
15134 /* In parameters */
15135
15136 /* Out parameters */
15137
15138 /* Result */
15139 ZERO_STRUCT(state->orig.out.result);
15140
15141 if (DEBUGLEVEL >= 10) {
15142 NDR_PRINT_IN_DEBUG(spoolss_5a, &state->orig);
15143 }
15144
15145 /* make a temporary copy, that we pass to the dispatch function */
15146 state->tmp = state->orig;
15147
15148 subreq = cli->dispatch_send(state, ev, cli,
15149 &ndr_table_spoolss,
15150 NDR_SPOOLSS_5A,
15151 &state->tmp);
15152 if (tevent_req_nomem(subreq, req)) {
15153 return tevent_req_post(req, ev);
15154 }
15155 tevent_req_set_callback(subreq, rpccli_spoolss_5a_done, req);
15156 return req;
15157 }
15158
15159 static void rpccli_spoolss_5a_done(struct tevent_req *subreq)
15160 {
15161 struct tevent_req *req = tevent_req_callback_data(
15162 subreq, struct tevent_req);
15163 struct rpccli_spoolss_5a_state *state = tevent_req_data(
15164 req, struct rpccli_spoolss_5a_state);
15165 NTSTATUS status;
15166 TALLOC_CTX *mem_ctx;
15167
15168 if (state->out_mem_ctx) {
15169 mem_ctx = state->out_mem_ctx;
15170 } else {
15171 mem_ctx = state;
15172 }
15173
15174 status = state->dispatch_recv(subreq, mem_ctx);
15175 TALLOC_FREE(subreq);
15176 if (!NT_STATUS_IS_OK(status)) {
15177 tevent_req_nterror(req, status);
15178 return;
15179 }
15180
15181 /* Copy out parameters */
15182
15183 /* Copy result */
15184 state->orig.out.result = state->tmp.out.result;
15185
15186 /* Reset temporary structure */
15187 ZERO_STRUCT(state->tmp);
15188
15189 if (DEBUGLEVEL >= 10) {
15190 NDR_PRINT_OUT_DEBUG(spoolss_5a, &state->orig);
15191 }
15192
15193 tevent_req_done(req);
15194 }
15195
15196 NTSTATUS rpccli_spoolss_5a_recv(struct tevent_req *req,
15197 TALLOC_CTX *mem_ctx,
15198 WERROR *result)
15199 {
15200 struct rpccli_spoolss_5a_state *state = tevent_req_data(
15201 req, struct rpccli_spoolss_5a_state);
15202 NTSTATUS status;
15203
15204 if (tevent_req_is_nterror(req, &status)) {
15205 tevent_req_received(req);
15206 return status;
15207 }
15208
15209 /* Steal possbile out parameters to the callers context */
15210 talloc_steal(mem_ctx, state->out_mem_ctx);
15211
15212 /* Return result */
15213 *result = state->orig.out.result;
15214
15215 tevent_req_received(req);
15216 return NT_STATUS_OK;
15217 }
15218
15219 NTSTATUS rpccli_spoolss_5a(struct rpc_pipe_client *cli,
15220 TALLOC_CTX *mem_ctx,
15221 WERROR *werror)
15222 {
15223 struct spoolss_5a r;
15224 NTSTATUS status;
15225
15226 /* In parameters */
15227
15228 if (DEBUGLEVEL >= 10) {
15229 NDR_PRINT_IN_DEBUG(spoolss_5a, &r);
15230 }
15231
15232 status = cli->dispatch(cli,
15233 mem_ctx,
15234 &ndr_table_spoolss,
15235 NDR_SPOOLSS_5A,
15236 &r);
15237
15238 if (!NT_STATUS_IS_OK(status)) {
15239 return status;
15240 }
15241
15242 if (DEBUGLEVEL >= 10) {
15243 NDR_PRINT_OUT_DEBUG(spoolss_5a, &r);
15244 }
15245
15246 if (NT_STATUS_IS_ERR(status)) {
15247 return status;
15248 }
15249
15250 /* Return variables */
15251
15252 /* Return result */
15253 if (werror) {
15254 *werror = r.out.result;
15255 }
15256
15257 return werror_to_ntstatus(r.out.result);
15258 }
15259
15260 struct rpccli_spoolss_5b_state {
15261 struct spoolss_5b orig;
15262 struct spoolss_5b tmp;
15263 TALLOC_CTX *out_mem_ctx;
15264 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15265 };
15266
15267 static void rpccli_spoolss_5b_done(struct tevent_req *subreq);
15268
15269 struct tevent_req *rpccli_spoolss_5b_send(TALLOC_CTX *mem_ctx,
15270 struct tevent_context *ev,
15271 struct rpc_pipe_client *cli)
15272 {
15273 struct tevent_req *req;
15274 struct rpccli_spoolss_5b_state *state;
15275 struct tevent_req *subreq;
15276
15277 req = tevent_req_create(mem_ctx, &state,
15278 struct rpccli_spoolss_5b_state);
15279 if (req == NULL) {
15280 return NULL;
15281 }
15282 state->out_mem_ctx = NULL;
15283 state->dispatch_recv = cli->dispatch_recv;
15284
15285 /* In parameters */
15286
15287 /* Out parameters */
15288
15289 /* Result */
15290 ZERO_STRUCT(state->orig.out.result);
15291
15292 if (DEBUGLEVEL >= 10) {
15293 NDR_PRINT_IN_DEBUG(spoolss_5b, &state->orig);
15294 }
15295
15296 /* make a temporary copy, that we pass to the dispatch function */
15297 state->tmp = state->orig;
15298
15299 subreq = cli->dispatch_send(state, ev, cli,
15300 &ndr_table_spoolss,
15301 NDR_SPOOLSS_5B,
15302 &state->tmp);
15303 if (tevent_req_nomem(subreq, req)) {
15304 return tevent_req_post(req, ev);
15305 }
15306 tevent_req_set_callback(subreq, rpccli_spoolss_5b_done, req);
15307 return req;
15308 }
15309
15310 static void rpccli_spoolss_5b_done(struct tevent_req *subreq)
15311 {
15312 struct tevent_req *req = tevent_req_callback_data(
15313 subreq, struct tevent_req);
15314 struct rpccli_spoolss_5b_state *state = tevent_req_data(
15315 req, struct rpccli_spoolss_5b_state);
15316 NTSTATUS status;
15317 TALLOC_CTX *mem_ctx;
15318
15319 if (state->out_mem_ctx) {
15320 mem_ctx = state->out_mem_ctx;
15321 } else {
15322 mem_ctx = state;
15323 }
15324
15325 status = state->dispatch_recv(subreq, mem_ctx);
15326 TALLOC_FREE(subreq);
15327 if (!NT_STATUS_IS_OK(status)) {
15328 tevent_req_nterror(req, status);
15329 return;
15330 }
15331
15332 /* Copy out parameters */
15333
15334 /* Copy result */
15335 state->orig.out.result = state->tmp.out.result;
15336
15337 /* Reset temporary structure */
15338 ZERO_STRUCT(state->tmp);
15339
15340 if (DEBUGLEVEL >= 10) {
15341 NDR_PRINT_OUT_DEBUG(spoolss_5b, &state->orig);
15342 }
15343
15344 tevent_req_done(req);
15345 }
15346
15347 NTSTATUS rpccli_spoolss_5b_recv(struct tevent_req *req,
15348 TALLOC_CTX *mem_ctx,
15349 WERROR *result)
15350 {
15351 struct rpccli_spoolss_5b_state *state = tevent_req_data(
15352 req, struct rpccli_spoolss_5b_state);
15353 NTSTATUS status;
15354
15355 if (tevent_req_is_nterror(req, &status)) {
15356 tevent_req_received(req);
15357 return status;
15358 }
15359
15360 /* Steal possbile out parameters to the callers context */
15361 talloc_steal(mem_ctx, state->out_mem_ctx);
15362
15363 /* Return result */
15364 *result = state->orig.out.result;
15365
15366 tevent_req_received(req);
15367 return NT_STATUS_OK;
15368 }
15369
15370 NTSTATUS rpccli_spoolss_5b(struct rpc_pipe_client *cli,
15371 TALLOC_CTX *mem_ctx,
15372 WERROR *werror)
15373 {
15374 struct spoolss_5b r;
15375 NTSTATUS status;
15376
15377 /* In parameters */
15378
15379 if (DEBUGLEVEL >= 10) {
15380 NDR_PRINT_IN_DEBUG(spoolss_5b, &r);
15381 }
15382
15383 status = cli->dispatch(cli,
15384 mem_ctx,
15385 &ndr_table_spoolss,
15386 NDR_SPOOLSS_5B,
15387 &r);
15388
15389 if (!NT_STATUS_IS_OK(status)) {
15390 return status;
15391 }
15392
15393 if (DEBUGLEVEL >= 10) {
15394 NDR_PRINT_OUT_DEBUG(spoolss_5b, &r);
15395 }
15396
15397 if (NT_STATUS_IS_ERR(status)) {
15398 return status;
15399 }
15400
15401 /* Return variables */
15402
15403 /* Return result */
15404 if (werror) {
15405 *werror = r.out.result;
15406 }
15407
15408 return werror_to_ntstatus(r.out.result);
15409 }
15410
15411 struct rpccli_spoolss_5c_state {
15412 struct spoolss_5c orig;
15413 struct spoolss_5c tmp;
15414 TALLOC_CTX *out_mem_ctx;
15415 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15416 };
15417
15418 static void rpccli_spoolss_5c_done(struct tevent_req *subreq);
15419
15420 struct tevent_req *rpccli_spoolss_5c_send(TALLOC_CTX *mem_ctx,
15421 struct tevent_context *ev,
15422 struct rpc_pipe_client *cli)
15423 {
15424 struct tevent_req *req;
15425 struct rpccli_spoolss_5c_state *state;
15426 struct tevent_req *subreq;
15427
15428 req = tevent_req_create(mem_ctx, &state,
15429 struct rpccli_spoolss_5c_state);
15430 if (req == NULL) {
15431 return NULL;
15432 }
15433 state->out_mem_ctx = NULL;
15434 state->dispatch_recv = cli->dispatch_recv;
15435
15436 /* In parameters */
15437
15438 /* Out parameters */
15439
15440 /* Result */
15441 ZERO_STRUCT(state->orig.out.result);
15442
15443 if (DEBUGLEVEL >= 10) {
15444 NDR_PRINT_IN_DEBUG(spoolss_5c, &state->orig);
15445 }
15446
15447 /* make a temporary copy, that we pass to the dispatch function */
15448 state->tmp = state->orig;
15449
15450 subreq = cli->dispatch_send(state, ev, cli,
15451 &ndr_table_spoolss,
15452 NDR_SPOOLSS_5C,
15453 &state->tmp);
15454 if (tevent_req_nomem(subreq, req)) {
15455 return tevent_req_post(req, ev);
15456 }
15457 tevent_req_set_callback(subreq, rpccli_spoolss_5c_done, req);
15458 return req;
15459 }
15460
15461 static void rpccli_spoolss_5c_done(struct tevent_req *subreq)
15462 {
15463 struct tevent_req *req = tevent_req_callback_data(
15464 subreq, struct tevent_req);
15465 struct rpccli_spoolss_5c_state *state = tevent_req_data(
15466 req, struct rpccli_spoolss_5c_state);
15467 NTSTATUS status;
15468 TALLOC_CTX *mem_ctx;
15469
15470 if (state->out_mem_ctx) {
15471 mem_ctx = state->out_mem_ctx;
15472 } else {
15473 mem_ctx = state;
15474 }
15475
15476 status = state->dispatch_recv(subreq, mem_ctx);
15477 TALLOC_FREE(subreq);
15478 if (!NT_STATUS_IS_OK(status)) {
15479 tevent_req_nterror(req, status);
15480 return;
15481 }
15482
15483 /* Copy out parameters */
15484
15485 /* Copy result */
15486 state->orig.out.result = state->tmp.out.result;
15487
15488 /* Reset temporary structure */
15489 ZERO_STRUCT(state->tmp);
15490
15491 if (DEBUGLEVEL >= 10) {
15492 NDR_PRINT_OUT_DEBUG(spoolss_5c, &state->orig);
15493 }
15494
15495 tevent_req_done(req);
15496 }
15497
15498 NTSTATUS rpccli_spoolss_5c_recv(struct tevent_req *req,
15499 TALLOC_CTX *mem_ctx,
15500 WERROR *result)
15501 {
15502 struct rpccli_spoolss_5c_state *state = tevent_req_data(
15503 req, struct rpccli_spoolss_5c_state);
15504 NTSTATUS status;
15505
15506 if (tevent_req_is_nterror(req, &status)) {
15507 tevent_req_received(req);
15508 return status;
15509 }
15510
15511 /* Steal possbile out parameters to the callers context */
15512 talloc_steal(mem_ctx, state->out_mem_ctx);
15513
15514 /* Return result */
15515 *result = state->orig.out.result;
15516
15517 tevent_req_received(req);
15518 return NT_STATUS_OK;
15519 }
15520
15521 NTSTATUS rpccli_spoolss_5c(struct rpc_pipe_client *cli,
15522 TALLOC_CTX *mem_ctx,
15523 WERROR *werror)
15524 {
15525 struct spoolss_5c r;
15526 NTSTATUS status;
15527
15528 /* In parameters */
15529
15530 if (DEBUGLEVEL >= 10) {
15531 NDR_PRINT_IN_DEBUG(spoolss_5c, &r);
15532 }
15533
15534 status = cli->dispatch(cli,
15535 mem_ctx,
15536 &ndr_table_spoolss,
15537 NDR_SPOOLSS_5C,
15538 &r);
15539
15540 if (!NT_STATUS_IS_OK(status)) {
15541 return status;
15542 }
15543
15544 if (DEBUGLEVEL >= 10) {
15545 NDR_PRINT_OUT_DEBUG(spoolss_5c, &r);
15546 }
15547
15548 if (NT_STATUS_IS_ERR(status)) {
15549 return status;
15550 }
15551
15552 /* Return variables */
15553
15554 /* Return result */
15555 if (werror) {
15556 *werror = r.out.result;
15557 }
15558
15559 return werror_to_ntstatus(r.out.result);
15560 }
15561
15562 struct rpccli_spoolss_5d_state {
15563 struct spoolss_5d orig;
15564 struct spoolss_5d tmp;
15565 TALLOC_CTX *out_mem_ctx;
15566 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15567 };
15568
15569 static void rpccli_spoolss_5d_done(struct tevent_req *subreq);
15570
15571 struct tevent_req *rpccli_spoolss_5d_send(TALLOC_CTX *mem_ctx,
15572 struct tevent_context *ev,
15573 struct rpc_pipe_client *cli)
15574 {
15575 struct tevent_req *req;
15576 struct rpccli_spoolss_5d_state *state;
15577 struct tevent_req *subreq;
15578
15579 req = tevent_req_create(mem_ctx, &state,
15580 struct rpccli_spoolss_5d_state);
15581 if (req == NULL) {
15582 return NULL;
15583 }
15584 state->out_mem_ctx = NULL;
15585 state->dispatch_recv = cli->dispatch_recv;
15586
15587 /* In parameters */
15588
15589 /* Out parameters */
15590
15591 /* Result */
15592 ZERO_STRUCT(state->orig.out.result);
15593
15594 if (DEBUGLEVEL >= 10) {
15595 NDR_PRINT_IN_DEBUG(spoolss_5d, &state->orig);
15596 }
15597
15598 /* make a temporary copy, that we pass to the dispatch function */
15599 state->tmp = state->orig;
15600
15601 subreq = cli->dispatch_send(state, ev, cli,
15602 &ndr_table_spoolss,
15603 NDR_SPOOLSS_5D,
15604 &state->tmp);
15605 if (tevent_req_nomem(subreq, req)) {
15606 return tevent_req_post(req, ev);
15607 }
15608 tevent_req_set_callback(subreq, rpccli_spoolss_5d_done, req);
15609 return req;
15610 }
15611
15612 static void rpccli_spoolss_5d_done(struct tevent_req *subreq)
15613 {
15614 struct tevent_req *req = tevent_req_callback_data(
15615 subreq, struct tevent_req);
15616 struct rpccli_spoolss_5d_state *state = tevent_req_data(
15617 req, struct rpccli_spoolss_5d_state);
15618 NTSTATUS status;
15619 TALLOC_CTX *mem_ctx;
15620
15621 if (state->out_mem_ctx) {
15622 mem_ctx = state->out_mem_ctx;
15623 } else {
15624 mem_ctx = state;
15625 }
15626
15627 status = state->dispatch_recv(subreq, mem_ctx);
15628 TALLOC_FREE(subreq);
15629 if (!NT_STATUS_IS_OK(status)) {
15630 tevent_req_nterror(req, status);
15631 return;
15632 }
15633
15634 /* Copy out parameters */
15635
15636 /* Copy result */
15637 state->orig.out.result = state->tmp.out.result;
15638
15639 /* Reset temporary structure */
15640 ZERO_STRUCT(state->tmp);
15641
15642 if (DEBUGLEVEL >= 10) {
15643 NDR_PRINT_OUT_DEBUG(spoolss_5d, &state->orig);
15644 }
15645
15646 tevent_req_done(req);
15647 }
15648
15649 NTSTATUS rpccli_spoolss_5d_recv(struct tevent_req *req,
15650 TALLOC_CTX *mem_ctx,
15651 WERROR *result)
15652 {
15653 struct rpccli_spoolss_5d_state *state = tevent_req_data(
15654 req, struct rpccli_spoolss_5d_state);
15655 NTSTATUS status;
15656
15657 if (tevent_req_is_nterror(req, &status)) {
15658 tevent_req_received(req);
15659 return status;
15660 }
15661
15662 /* Steal possbile out parameters to the callers context */
15663 talloc_steal(mem_ctx, state->out_mem_ctx);
15664
15665 /* Return result */
15666 *result = state->orig.out.result;
15667
15668 tevent_req_received(req);
15669 return NT_STATUS_OK;
15670 }
15671
15672 NTSTATUS rpccli_spoolss_5d(struct rpc_pipe_client *cli,
15673 TALLOC_CTX *mem_ctx,
15674 WERROR *werror)
15675 {
15676 struct spoolss_5d r;
15677 NTSTATUS status;
15678
15679 /* In parameters */
15680
15681 if (DEBUGLEVEL >= 10) {
15682 NDR_PRINT_IN_DEBUG(spoolss_5d, &r);
15683 }
15684
15685 status = cli->dispatch(cli,
15686 mem_ctx,
15687 &ndr_table_spoolss,
15688 NDR_SPOOLSS_5D,
15689 &r);
15690
15691 if (!NT_STATUS_IS_OK(status)) {
15692 return status;
15693 }
15694
15695 if (DEBUGLEVEL >= 10) {
15696 NDR_PRINT_OUT_DEBUG(spoolss_5d, &r);
15697 }
15698
15699 if (NT_STATUS_IS_ERR(status)) {
15700 return status;
15701 }
15702
15703 /* Return variables */
15704
15705 /* Return result */
15706 if (werror) {
15707 *werror = r.out.result;
15708 }
15709
15710 return werror_to_ntstatus(r.out.result);
15711 }
15712
15713 struct rpccli_spoolss_5e_state {
15714 struct spoolss_5e orig;
15715 struct spoolss_5e tmp;
15716 TALLOC_CTX *out_mem_ctx;
15717 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15718 };
15719
15720 static void rpccli_spoolss_5e_done(struct tevent_req *subreq);
15721
15722 struct tevent_req *rpccli_spoolss_5e_send(TALLOC_CTX *mem_ctx,
15723 struct tevent_context *ev,
15724 struct rpc_pipe_client *cli)
15725 {
15726 struct tevent_req *req;
15727 struct rpccli_spoolss_5e_state *state;
15728 struct tevent_req *subreq;
15729
15730 req = tevent_req_create(mem_ctx, &state,
15731 struct rpccli_spoolss_5e_state);
15732 if (req == NULL) {
15733 return NULL;
15734 }
15735 state->out_mem_ctx = NULL;
15736 state->dispatch_recv = cli->dispatch_recv;
15737
15738 /* In parameters */
15739
15740 /* Out parameters */
15741
15742 /* Result */
15743 ZERO_STRUCT(state->orig.out.result);
15744
15745 if (DEBUGLEVEL >= 10) {
15746 NDR_PRINT_IN_DEBUG(spoolss_5e, &state->orig);
15747 }
15748
15749 /* make a temporary copy, that we pass to the dispatch function */
15750 state->tmp = state->orig;
15751
15752 subreq = cli->dispatch_send(state, ev, cli,
15753 &ndr_table_spoolss,
15754 NDR_SPOOLSS_5E,
15755 &state->tmp);
15756 if (tevent_req_nomem(subreq, req)) {
15757 return tevent_req_post(req, ev);
15758 }
15759 tevent_req_set_callback(subreq, rpccli_spoolss_5e_done, req);
15760 return req;
15761 }
15762
15763 static void rpccli_spoolss_5e_done(struct tevent_req *subreq)
15764 {
15765 struct tevent_req *req = tevent_req_callback_data(
15766 subreq, struct tevent_req);
15767 struct rpccli_spoolss_5e_state *state = tevent_req_data(
15768 req, struct rpccli_spoolss_5e_state);
15769 NTSTATUS status;
15770 TALLOC_CTX *mem_ctx;
15771
15772 if (state->out_mem_ctx) {
15773 mem_ctx = state->out_mem_ctx;
15774 } else {
15775 mem_ctx = state;
15776 }
15777
15778 status = state->dispatch_recv(subreq, mem_ctx);
15779 TALLOC_FREE(subreq);
15780 if (!NT_STATUS_IS_OK(status)) {
15781 tevent_req_nterror(req, status);
15782 return;
15783 }
15784
15785 /* Copy out parameters */
15786
15787 /* Copy result */
15788 state->orig.out.result = state->tmp.out.result;
15789
15790 /* Reset temporary structure */
15791 ZERO_STRUCT(state->tmp);
15792
15793 if (DEBUGLEVEL >= 10) {
15794 NDR_PRINT_OUT_DEBUG(spoolss_5e, &state->orig);
15795 }
15796
15797 tevent_req_done(req);
15798 }
15799
15800 NTSTATUS rpccli_spoolss_5e_recv(struct tevent_req *req,
15801 TALLOC_CTX *mem_ctx,
15802 WERROR *result)
15803 {
15804 struct rpccli_spoolss_5e_state *state = tevent_req_data(
15805 req, struct rpccli_spoolss_5e_state);
15806 NTSTATUS status;
15807
15808 if (tevent_req_is_nterror(req, &status)) {
15809 tevent_req_received(req);
15810 return status;
15811 }
15812
15813 /* Steal possbile out parameters to the callers context */
15814 talloc_steal(mem_ctx, state->out_mem_ctx);
15815
15816 /* Return result */
15817 *result = state->orig.out.result;
15818
15819 tevent_req_received(req);
15820 return NT_STATUS_OK;
15821 }
15822
15823 NTSTATUS rpccli_spoolss_5e(struct rpc_pipe_client *cli,
15824 TALLOC_CTX *mem_ctx,
15825 WERROR *werror)
15826 {
15827 struct spoolss_5e r;
15828 NTSTATUS status;
15829
15830 /* In parameters */
15831
15832 if (DEBUGLEVEL >= 10) {
15833 NDR_PRINT_IN_DEBUG(spoolss_5e, &r);
15834 }
15835
15836 status = cli->dispatch(cli,
15837 mem_ctx,
15838 &ndr_table_spoolss,
15839 NDR_SPOOLSS_5E,
15840 &r);
15841
15842 if (!NT_STATUS_IS_OK(status)) {
15843 return status;
15844 }
15845
15846 if (DEBUGLEVEL >= 10) {
15847 NDR_PRINT_OUT_DEBUG(spoolss_5e, &r);
15848 }
15849
15850 if (NT_STATUS_IS_ERR(status)) {
15851 return status;
15852 }
15853
15854 /* Return variables */
15855
15856 /* Return result */
15857 if (werror) {
15858 *werror = r.out.result;
15859 }
15860
15861 return werror_to_ntstatus(r.out.result);
15862 }
15863
15864 struct rpccli_spoolss_5f_state {
15865 struct spoolss_5f orig;
15866 struct spoolss_5f tmp;
15867 TALLOC_CTX *out_mem_ctx;
15868 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15869 };
15870
15871 static void rpccli_spoolss_5f_done(struct tevent_req *subreq);
15872
15873 struct tevent_req *rpccli_spoolss_5f_send(TALLOC_CTX *mem_ctx,
15874 struct tevent_context *ev,
15875 struct rpc_pipe_client *cli)
15876 {
15877 struct tevent_req *req;
15878 struct rpccli_spoolss_5f_state *state;
15879 struct tevent_req *subreq;
15880
15881 req = tevent_req_create(mem_ctx, &state,
15882 struct rpccli_spoolss_5f_state);
15883 if (req == NULL) {
15884 return NULL;
15885 }
15886 state->out_mem_ctx = NULL;
15887 state->dispatch_recv = cli->dispatch_recv;
15888
15889 /* In parameters */
15890
15891 /* Out parameters */
15892
15893 /* Result */
15894 ZERO_STRUCT(state->orig.out.result);
15895
15896 if (DEBUGLEVEL >= 10) {
15897 NDR_PRINT_IN_DEBUG(spoolss_5f, &state->orig);
15898 }
15899
15900 /* make a temporary copy, that we pass to the dispatch function */
15901 state->tmp = state->orig;
15902
15903 subreq = cli->dispatch_send(state, ev, cli,
15904 &ndr_table_spoolss,
15905 NDR_SPOOLSS_5F,
15906 &state->tmp);
15907 if (tevent_req_nomem(subreq, req)) {
15908 return tevent_req_post(req, ev);
15909 }
15910 tevent_req_set_callback(subreq, rpccli_spoolss_5f_done, req);
15911 return req;
15912 }
15913
15914 static void rpccli_spoolss_5f_done(struct tevent_req *subreq)
15915 {
15916 struct tevent_req *req = tevent_req_callback_data(
15917 subreq, struct tevent_req);
15918 struct rpccli_spoolss_5f_state *state = tevent_req_data(
15919 req, struct rpccli_spoolss_5f_state);
15920 NTSTATUS status;
15921 TALLOC_CTX *mem_ctx;
15922
15923 if (state->out_mem_ctx) {
15924 mem_ctx = state->out_mem_ctx;
15925 } else {
15926 mem_ctx = state;
15927 }
15928
15929 status = state->dispatch_recv(subreq, mem_ctx);
15930 TALLOC_FREE(subreq);
15931 if (!NT_STATUS_IS_OK(status)) {
15932 tevent_req_nterror(req, status);
15933 return;
15934 }
15935
15936 /* Copy out parameters */
15937
15938 /* Copy result */
15939 state->orig.out.result = state->tmp.out.result;
15940
15941 /* Reset temporary structure */
15942 ZERO_STRUCT(state->tmp);
15943
15944 if (DEBUGLEVEL >= 10) {
15945 NDR_PRINT_OUT_DEBUG(spoolss_5f, &state->orig);
15946 }
15947
15948 tevent_req_done(req);
15949 }
15950
15951 NTSTATUS rpccli_spoolss_5f_recv(struct tevent_req *req,
15952 TALLOC_CTX *mem_ctx,
15953 WERROR *result)
15954 {
15955 struct rpccli_spoolss_5f_state *state = tevent_req_data(
15956 req, struct rpccli_spoolss_5f_state);
15957 NTSTATUS status;
15958
15959 if (tevent_req_is_nterror(req, &status)) {
15960 tevent_req_received(req);
15961 return status;
15962 }
15963
15964 /* Steal possbile out parameters to the callers context */
15965 talloc_steal(mem_ctx, state->out_mem_ctx);
15966
15967 /* Return result */
15968 *result = state->orig.out.result;
15969
15970 tevent_req_received(req);
15971 return NT_STATUS_OK;
15972 }
15973
15974 NTSTATUS rpccli_spoolss_5f(struct rpc_pipe_client *cli,
15975 TALLOC_CTX *mem_ctx,
15976 WERROR *werror)
15977 {
15978 struct spoolss_5f r;
15979 NTSTATUS status;
15980
15981 /* In parameters */
15982
15983 if (DEBUGLEVEL >= 10) {
15984 NDR_PRINT_IN_DEBUG(spoolss_5f, &r);
15985 }
15986
15987 status = cli->dispatch(cli,
15988 mem_ctx,
15989 &ndr_table_spoolss,
15990 NDR_SPOOLSS_5F,
15991 &r);
15992
15993 if (!NT_STATUS_IS_OK(status)) {
15994 return status;
15995 }
15996
15997 if (DEBUGLEVEL >= 10) {
15998 NDR_PRINT_OUT_DEBUG(spoolss_5f, &r);
15999 }
16000
16001 if (NT_STATUS_IS_ERR(status)) {
16002 return status;
16003 }
16004
16005 /* Return variables */
16006
16007 /* Return result */
16008 if (werror) {
16009 *werror = r.out.result;
16010 }
16011
16012 return werror_to_ntstatus(r.out.result);
16013 }
16014
16015 struct rpccli_spoolss_60_state {
16016 struct spoolss_60 orig;
16017 struct spoolss_60 tmp;
16018 TALLOC_CTX *out_mem_ctx;
16019 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16020 };
16021
16022 static void rpccli_spoolss_60_done(struct tevent_req *subreq);
16023
16024 struct tevent_req *rpccli_spoolss_60_send(TALLOC_CTX *mem_ctx,
16025 struct tevent_context *ev,
16026 struct rpc_pipe_client *cli)
16027 {
16028 struct tevent_req *req;
16029 struct rpccli_spoolss_60_state *state;
16030 struct tevent_req *subreq;
16031
16032 req = tevent_req_create(mem_ctx, &state,
16033 struct rpccli_spoolss_60_state);
16034 if (req == NULL) {
16035 return NULL;
16036 }
16037 state->out_mem_ctx = NULL;
16038 state->dispatch_recv = cli->dispatch_recv;
16039
16040 /* In parameters */
16041
16042 /* Out parameters */
16043
16044 /* Result */
16045 ZERO_STRUCT(state->orig.out.result);
16046
16047 if (DEBUGLEVEL >= 10) {
16048 NDR_PRINT_IN_DEBUG(spoolss_60, &state->orig);
16049 }
16050
16051 /* make a temporary copy, that we pass to the dispatch function */
16052 state->tmp = state->orig;
16053
16054 subreq = cli->dispatch_send(state, ev, cli,
16055 &ndr_table_spoolss,
16056 NDR_SPOOLSS_60,
16057 &state->tmp);
16058 if (tevent_req_nomem(subreq, req)) {
16059 return tevent_req_post(req, ev);
16060 }
16061 tevent_req_set_callback(subreq, rpccli_spoolss_60_done, req);
16062 return req;
16063 }
16064
16065 static void rpccli_spoolss_60_done(struct tevent_req *subreq)
16066 {
16067 struct tevent_req *req = tevent_req_callback_data(
16068 subreq, struct tevent_req);
16069 struct rpccli_spoolss_60_state *state = tevent_req_data(
16070 req, struct rpccli_spoolss_60_state);
16071 NTSTATUS status;
16072 TALLOC_CTX *mem_ctx;
16073
16074 if (state->out_mem_ctx) {
16075 mem_ctx = state->out_mem_ctx;
16076 } else {
16077 mem_ctx = state;
16078 }
16079
16080 status = state->dispatch_recv(subreq, mem_ctx);
16081 TALLOC_FREE(subreq);
16082 if (!NT_STATUS_IS_OK(status)) {
16083 tevent_req_nterror(req, status);
16084 return;
16085 }
16086
16087 /* Copy out parameters */
16088
16089 /* Copy result */
16090 state->orig.out.result = state->tmp.out.result;
16091
16092 /* Reset temporary structure */
16093 ZERO_STRUCT(state->tmp);
16094
16095 if (DEBUGLEVEL >= 10) {
16096 NDR_PRINT_OUT_DEBUG(spoolss_60, &state->orig);
16097 }
16098
16099 tevent_req_done(req);
16100 }
16101
16102 NTSTATUS rpccli_spoolss_60_recv(struct tevent_req *req,
16103 TALLOC_CTX *mem_ctx,
16104 WERROR *result)
16105 {
16106 struct rpccli_spoolss_60_state *state = tevent_req_data(
16107 req, struct rpccli_spoolss_60_state);
16108 NTSTATUS status;
16109
16110 if (tevent_req_is_nterror(req, &status)) {
16111 tevent_req_received(req);
16112 return status;
16113 }
16114
16115 /* Steal possbile out parameters to the callers context */
16116 talloc_steal(mem_ctx, state->out_mem_ctx);
16117
16118 /* Return result */
16119 *result = state->orig.out.result;
16120
16121 tevent_req_received(req);
16122 return NT_STATUS_OK;
16123 }
16124
16125 NTSTATUS rpccli_spoolss_60(struct rpc_pipe_client *cli,
16126 TALLOC_CTX *mem_ctx,
16127 WERROR *werror)
16128 {
16129 struct spoolss_60 r;
16130 NTSTATUS status;
16131
16132 /* In parameters */
16133
16134 if (DEBUGLEVEL >= 10) {
16135 NDR_PRINT_IN_DEBUG(spoolss_60, &r);
16136 }
16137
16138 status = cli->dispatch(cli,
16139 mem_ctx,
16140 &ndr_table_spoolss,
16141 NDR_SPOOLSS_60,
16142 &r);
16143
16144 if (!NT_STATUS_IS_OK(status)) {
16145 return status;
16146 }
16147
16148 if (DEBUGLEVEL >= 10) {
16149 NDR_PRINT_OUT_DEBUG(spoolss_60, &r);
16150 }
16151
16152 if (NT_STATUS_IS_ERR(status)) {
16153 return status;
16154 }
16155
16156 /* Return variables */
16157
16158 /* Return result */
16159 if (werror) {
16160 *werror = r.out.result;
16161 }
16162
16163 return werror_to_ntstatus(r.out.result);
16164 }
16165
16166 struct rpccli_spoolss_61_state {
16167 struct spoolss_61 orig;
16168 struct spoolss_61 tmp;
16169 TALLOC_CTX *out_mem_ctx;
16170 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16171 };
16172
16173 static void rpccli_spoolss_61_done(struct tevent_req *subreq);
16174
16175 struct tevent_req *rpccli_spoolss_61_send(TALLOC_CTX *mem_ctx,
16176 struct tevent_context *ev,
16177 struct rpc_pipe_client *cli)
16178 {
16179 struct tevent_req *req;
16180 struct rpccli_spoolss_61_state *state;
16181 struct tevent_req *subreq;
16182
16183 req = tevent_req_create(mem_ctx, &state,
16184 struct rpccli_spoolss_61_state);
16185 if (req == NULL) {
16186 return NULL;
16187 }
16188 state->out_mem_ctx = NULL;
16189 state->dispatch_recv = cli->dispatch_recv;
16190
16191 /* In parameters */
16192
16193 /* Out parameters */
16194
16195 /* Result */
16196 ZERO_STRUCT(state->orig.out.result);
16197
16198 if (DEBUGLEVEL >= 10) {
16199 NDR_PRINT_IN_DEBUG(spoolss_61, &state->orig);
16200 }
16201
16202 /* make a temporary copy, that we pass to the dispatch function */
16203 state->tmp = state->orig;
16204
16205 subreq = cli->dispatch_send(state, ev, cli,
16206 &ndr_table_spoolss,
16207 NDR_SPOOLSS_61,
16208 &state->tmp);
16209 if (tevent_req_nomem(subreq, req)) {
16210 return tevent_req_post(req, ev);
16211 }
16212 tevent_req_set_callback(subreq, rpccli_spoolss_61_done, req);
16213 return req;
16214 }
16215
16216 static void rpccli_spoolss_61_done(struct tevent_req *subreq)
16217 {
16218 struct tevent_req *req = tevent_req_callback_data(
16219 subreq, struct tevent_req);
16220 struct rpccli_spoolss_61_state *state = tevent_req_data(
16221 req, struct rpccli_spoolss_61_state);
16222 NTSTATUS status;
16223 TALLOC_CTX *mem_ctx;
16224
16225 if (state->out_mem_ctx) {
16226 mem_ctx = state->out_mem_ctx;
16227 } else {
16228 mem_ctx = state;
16229 }
16230
16231 status = state->dispatch_recv(subreq, mem_ctx);
16232 TALLOC_FREE(subreq);
16233 if (!NT_STATUS_IS_OK(status)) {
16234 tevent_req_nterror(req, status);
16235 return;
16236 }
16237
16238 /* Copy out parameters */
16239
16240 /* Copy result */
16241 state->orig.out.result = state->tmp.out.result;
16242
16243 /* Reset temporary structure */
16244 ZERO_STRUCT(state->tmp);
16245
16246 if (DEBUGLEVEL >= 10) {
16247 NDR_PRINT_OUT_DEBUG(spoolss_61, &state->orig);
16248 }
16249
16250 tevent_req_done(req);
16251 }
16252
16253 NTSTATUS rpccli_spoolss_61_recv(struct tevent_req *req,
16254 TALLOC_CTX *mem_ctx,
16255 WERROR *result)
16256 {
16257 struct rpccli_spoolss_61_state *state = tevent_req_data(
16258 req, struct rpccli_spoolss_61_state);
16259 NTSTATUS status;
16260
16261 if (tevent_req_is_nterror(req, &status)) {
16262 tevent_req_received(req);
16263 return status;
16264 }
16265
16266 /* Steal possbile out parameters to the callers context */
16267 talloc_steal(mem_ctx, state->out_mem_ctx);
16268
16269 /* Return result */
16270 *result = state->orig.out.result;
16271
16272 tevent_req_received(req);
16273 return NT_STATUS_OK;
16274 }
16275
16276 NTSTATUS rpccli_spoolss_61(struct rpc_pipe_client *cli,
16277 TALLOC_CTX *mem_ctx,
16278 WERROR *werror)
16279 {
16280 struct spoolss_61 r;
16281 NTSTATUS status;
16282
16283 /* In parameters */
16284
16285 if (DEBUGLEVEL >= 10) {
16286 NDR_PRINT_IN_DEBUG(spoolss_61, &r);
16287 }
16288
16289 status = cli->dispatch(cli,
16290 mem_ctx,
16291 &ndr_table_spoolss,
16292 NDR_SPOOLSS_61,
16293 &r);
16294
16295 if (!NT_STATUS_IS_OK(status)) {
16296 return status;
16297 }
16298
16299 if (DEBUGLEVEL >= 10) {
16300 NDR_PRINT_OUT_DEBUG(spoolss_61, &r);
16301 }
16302
16303 if (NT_STATUS_IS_ERR(status)) {
16304 return status;
16305 }
16306
16307 /* Return variables */
16308
16309 /* Return result */
16310 if (werror) {
16311 *werror = r.out.result;
16312 }
16313
16314 return werror_to_ntstatus(r.out.result);
16315 }
16316
16317 struct rpccli_spoolss_62_state {
16318 struct spoolss_62 orig;
16319 struct spoolss_62 tmp;
16320 TALLOC_CTX *out_mem_ctx;
16321 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16322 };
16323
16324 static void rpccli_spoolss_62_done(struct tevent_req *subreq);
16325
16326 struct tevent_req *rpccli_spoolss_62_send(TALLOC_CTX *mem_ctx,
16327 struct tevent_context *ev,
16328 struct rpc_pipe_client *cli)
16329 {
16330 struct tevent_req *req;
16331 struct rpccli_spoolss_62_state *state;
16332 struct tevent_req *subreq;
16333
16334 req = tevent_req_create(mem_ctx, &state,
16335 struct rpccli_spoolss_62_state);
16336 if (req == NULL) {
16337 return NULL;
16338 }
16339 state->out_mem_ctx = NULL;
16340 state->dispatch_recv = cli->dispatch_recv;
16341
16342 /* In parameters */
16343
16344 /* Out parameters */
16345
16346 /* Result */
16347 ZERO_STRUCT(state->orig.out.result);
16348
16349 if (DEBUGLEVEL >= 10) {
16350 NDR_PRINT_IN_DEBUG(spoolss_62, &state->orig);
16351 }
16352
16353 /* make a temporary copy, that we pass to the dispatch function */
16354 state->tmp = state->orig;
16355
16356 subreq = cli->dispatch_send(state, ev, cli,
16357 &ndr_table_spoolss,
16358 NDR_SPOOLSS_62,
16359 &state->tmp);
16360 if (tevent_req_nomem(subreq, req)) {
16361 return tevent_req_post(req, ev);
16362 }
16363 tevent_req_set_callback(subreq, rpccli_spoolss_62_done, req);
16364 return req;
16365 }
16366
16367 static void rpccli_spoolss_62_done(struct tevent_req *subreq)
16368 {
16369 struct tevent_req *req = tevent_req_callback_data(
16370 subreq, struct tevent_req);
16371 struct rpccli_spoolss_62_state *state = tevent_req_data(
16372 req, struct rpccli_spoolss_62_state);
16373 NTSTATUS status;
16374 TALLOC_CTX *mem_ctx;
16375
16376 if (state->out_mem_ctx) {
16377 mem_ctx = state->out_mem_ctx;
16378 } else {
16379 mem_ctx = state;
16380 }
16381
16382 status = state->dispatch_recv(subreq, mem_ctx);
16383 TALLOC_FREE(subreq);
16384 if (!NT_STATUS_IS_OK(status)) {
16385 tevent_req_nterror(req, status);
16386 return;
16387 }
16388
16389 /* Copy out parameters */
16390
16391 /* Copy result */
16392 state->orig.out.result = state->tmp.out.result;
16393
16394 /* Reset temporary structure */
16395 ZERO_STRUCT(state->tmp);
16396
16397 if (DEBUGLEVEL >= 10) {
16398 NDR_PRINT_OUT_DEBUG(spoolss_62, &state->orig);
16399 }
16400
16401 tevent_req_done(req);
16402 }
16403
16404 NTSTATUS rpccli_spoolss_62_recv(struct tevent_req *req,
16405 TALLOC_CTX *mem_ctx,
16406 WERROR *result)
16407 {
16408 struct rpccli_spoolss_62_state *state = tevent_req_data(
16409 req, struct rpccli_spoolss_62_state);
16410 NTSTATUS status;
16411
16412 if (tevent_req_is_nterror(req, &status)) {
16413 tevent_req_received(req);
16414 return status;
16415 }
16416
16417 /* Steal possbile out parameters to the callers context */
16418 talloc_steal(mem_ctx, state->out_mem_ctx);
16419
16420 /* Return result */
16421 *result = state->orig.out.result;
16422
16423 tevent_req_received(req);
16424 return NT_STATUS_OK;
16425 }
16426
16427 NTSTATUS rpccli_spoolss_62(struct rpc_pipe_client *cli,
16428 TALLOC_CTX *mem_ctx,
16429 WERROR *werror)
16430 {
16431 struct spoolss_62 r;
16432 NTSTATUS status;
16433
16434 /* In parameters */
16435
16436 if (DEBUGLEVEL >= 10) {
16437 NDR_PRINT_IN_DEBUG(spoolss_62, &r);
16438 }
16439
16440 status = cli->dispatch(cli,
16441 mem_ctx,
16442 &ndr_table_spoolss,
16443 NDR_SPOOLSS_62,
16444 &r);
16445
16446 if (!NT_STATUS_IS_OK(status)) {
16447 return status;
16448 }
16449
16450 if (DEBUGLEVEL >= 10) {
16451 NDR_PRINT_OUT_DEBUG(spoolss_62, &r);
16452 }
16453
16454 if (NT_STATUS_IS_ERR(status)) {
16455 return status;
16456 }
16457
16458 /* Return variables */
16459
16460 /* Return result */
16461 if (werror) {
16462 *werror = r.out.result;
16463 }
16464
16465 return werror_to_ntstatus(r.out.result);
16466 }
16467
16468 struct rpccli_spoolss_63_state {
16469 struct spoolss_63 orig;
16470 struct spoolss_63 tmp;
16471 TALLOC_CTX *out_mem_ctx;
16472 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16473 };
16474
16475 static void rpccli_spoolss_63_done(struct tevent_req *subreq);
16476
16477 struct tevent_req *rpccli_spoolss_63_send(TALLOC_CTX *mem_ctx,
16478 struct tevent_context *ev,
16479 struct rpc_pipe_client *cli)
16480 {
16481 struct tevent_req *req;
16482 struct rpccli_spoolss_63_state *state;
16483 struct tevent_req *subreq;
16484
16485 req = tevent_req_create(mem_ctx, &state,
16486 struct rpccli_spoolss_63_state);
16487 if (req == NULL) {
16488 return NULL;
16489 }
16490 state->out_mem_ctx = NULL;
16491 state->dispatch_recv = cli->dispatch_recv;
16492
16493 /* In parameters */
16494
16495 /* Out parameters */
16496
16497 /* Result */
16498 ZERO_STRUCT(state->orig.out.result);
16499
16500 if (DEBUGLEVEL >= 10) {
16501 NDR_PRINT_IN_DEBUG(spoolss_63, &state->orig);
16502 }
16503
16504 /* make a temporary copy, that we pass to the dispatch function */
16505 state->tmp = state->orig;
16506
16507 subreq = cli->dispatch_send(state, ev, cli,
16508 &ndr_table_spoolss,
16509 NDR_SPOOLSS_63,
16510 &state->tmp);
16511 if (tevent_req_nomem(subreq, req)) {
16512 return tevent_req_post(req, ev);
16513 }
16514 tevent_req_set_callback(subreq, rpccli_spoolss_63_done, req);
16515 return req;
16516 }
16517
16518 static void rpccli_spoolss_63_done(struct tevent_req *subreq)
16519 {
16520 struct tevent_req *req = tevent_req_callback_data(
16521 subreq, struct tevent_req);
16522 struct rpccli_spoolss_63_state *state = tevent_req_data(
16523 req, struct rpccli_spoolss_63_state);
16524 NTSTATUS status;
16525 TALLOC_CTX *mem_ctx;
16526
16527 if (state->out_mem_ctx) {
16528 mem_ctx = state->out_mem_ctx;
16529 } else {
16530 mem_ctx = state;
16531 }
16532
16533 status = state->dispatch_recv(subreq, mem_ctx);
16534 TALLOC_FREE(subreq);
16535 if (!NT_STATUS_IS_OK(status)) {
16536 tevent_req_nterror(req, status);
16537 return;
16538 }
16539
16540 /* Copy out parameters */
16541
16542 /* Copy result */
16543 state->orig.out.result = state->tmp.out.result;
16544
16545 /* Reset temporary structure */
16546 ZERO_STRUCT(state->tmp);
16547
16548 if (DEBUGLEVEL >= 10) {
16549 NDR_PRINT_OUT_DEBUG(spoolss_63, &state->orig);
16550 }
16551
16552 tevent_req_done(req);
16553 }
16554
16555 NTSTATUS rpccli_spoolss_63_recv(struct tevent_req *req,
16556 TALLOC_CTX *mem_ctx,
16557 WERROR *result)
16558 {
16559 struct rpccli_spoolss_63_state *state = tevent_req_data(
16560 req, struct rpccli_spoolss_63_state);
16561 NTSTATUS status;
16562
16563 if (tevent_req_is_nterror(req, &status)) {
16564 tevent_req_received(req);
16565 return status;
16566 }
16567
16568 /* Steal possbile out parameters to the callers context */
16569 talloc_steal(mem_ctx, state->out_mem_ctx);
16570
16571 /* Return result */
16572 *result = state->orig.out.result;
16573
16574 tevent_req_received(req);
16575 return NT_STATUS_OK;
16576 }
16577
16578 NTSTATUS rpccli_spoolss_63(struct rpc_pipe_client *cli,
16579 TALLOC_CTX *mem_ctx,
16580 WERROR *werror)
16581 {
16582 struct spoolss_63 r;
16583 NTSTATUS status;
16584
16585 /* In parameters */
16586
16587 if (DEBUGLEVEL >= 10) {
16588 NDR_PRINT_IN_DEBUG(spoolss_63, &r);
16589 }
16590
16591 status = cli->dispatch(cli,
16592 mem_ctx,
16593 &ndr_table_spoolss,
16594 NDR_SPOOLSS_63,
16595 &r);
16596
16597 if (!NT_STATUS_IS_OK(status)) {
16598 return status;
16599 }
16600
16601 if (DEBUGLEVEL >= 10) {
16602 NDR_PRINT_OUT_DEBUG(spoolss_63, &r);
16603 }
16604
16605 if (NT_STATUS_IS_ERR(status)) {
16606 return status;
16607 }
16608
16609 /* Return variables */
16610
16611 /* Return result */
16612 if (werror) {
16613 *werror = r.out.result;
16614 }
16615
16616 return werror_to_ntstatus(r.out.result);
16617 }
16618
16619 struct rpccli_spoolss_64_state {
16620 struct spoolss_64 orig;
16621 struct spoolss_64 tmp;
16622 TALLOC_CTX *out_mem_ctx;
16623 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16624 };
16625
16626 static void rpccli_spoolss_64_done(struct tevent_req *subreq);
16627
16628 struct tevent_req *rpccli_spoolss_64_send(TALLOC_CTX *mem_ctx,
16629 struct tevent_context *ev,
16630 struct rpc_pipe_client *cli)
16631 {
16632 struct tevent_req *req;
16633 struct rpccli_spoolss_64_state *state;
16634 struct tevent_req *subreq;
16635
16636 req = tevent_req_create(mem_ctx, &state,
16637 struct rpccli_spoolss_64_state);
16638 if (req == NULL) {
16639 return NULL;
16640 }
16641 state->out_mem_ctx = NULL;
16642 state->dispatch_recv = cli->dispatch_recv;
16643
16644 /* In parameters */
16645
16646 /* Out parameters */
16647
16648 /* Result */
16649 ZERO_STRUCT(state->orig.out.result);
16650
16651 if (DEBUGLEVEL >= 10) {
16652 NDR_PRINT_IN_DEBUG(spoolss_64, &state->orig);
16653 }
16654
16655 /* make a temporary copy, that we pass to the dispatch function */
16656 state->tmp = state->orig;
16657
16658 subreq = cli->dispatch_send(state, ev, cli,
16659 &ndr_table_spoolss,
16660 NDR_SPOOLSS_64,
16661 &state->tmp);
16662 if (tevent_req_nomem(subreq, req)) {
16663 return tevent_req_post(req, ev);
16664 }
16665 tevent_req_set_callback(subreq, rpccli_spoolss_64_done, req);
16666 return req;
16667 }
16668
16669 static void rpccli_spoolss_64_done(struct tevent_req *subreq)
16670 {
16671 struct tevent_req *req = tevent_req_callback_data(
16672 subreq, struct tevent_req);
16673 struct rpccli_spoolss_64_state *state = tevent_req_data(
16674 req, struct rpccli_spoolss_64_state);
16675 NTSTATUS status;
16676 TALLOC_CTX *mem_ctx;
16677
16678 if (state->out_mem_ctx) {
16679 mem_ctx = state->out_mem_ctx;
16680 } else {
16681 mem_ctx = state;
16682 }
16683
16684 status = state->dispatch_recv(subreq, mem_ctx);
16685 TALLOC_FREE(subreq);
16686 if (!NT_STATUS_IS_OK(status)) {
16687 tevent_req_nterror(req, status);
16688 return;
16689 }
16690
16691 /* Copy out parameters */
16692
16693 /* Copy result */
16694 state->orig.out.result = state->tmp.out.result;
16695
16696 /* Reset temporary structure */
16697 ZERO_STRUCT(state->tmp);
16698
16699 if (DEBUGLEVEL >= 10) {
16700 NDR_PRINT_OUT_DEBUG(spoolss_64, &state->orig);
16701 }
16702
16703 tevent_req_done(req);
16704 }
16705
16706 NTSTATUS rpccli_spoolss_64_recv(struct tevent_req *req,
16707 TALLOC_CTX *mem_ctx,
16708 WERROR *result)
16709 {
16710 struct rpccli_spoolss_64_state *state = tevent_req_data(
16711 req, struct rpccli_spoolss_64_state);
16712 NTSTATUS status;
16713
16714 if (tevent_req_is_nterror(req, &status)) {
16715 tevent_req_received(req);
16716 return status;
16717 }
16718
16719 /* Steal possbile out parameters to the callers context */
16720 talloc_steal(mem_ctx, state->out_mem_ctx);
16721
16722 /* Return result */
16723 *result = state->orig.out.result;
16724
16725 tevent_req_received(req);
16726 return NT_STATUS_OK;
16727 }
16728
16729 NTSTATUS rpccli_spoolss_64(struct rpc_pipe_client *cli,
16730 TALLOC_CTX *mem_ctx,
16731 WERROR *werror)
16732 {
16733 struct spoolss_64 r;
16734 NTSTATUS status;
16735
16736 /* In parameters */
16737
16738 if (DEBUGLEVEL >= 10) {
16739 NDR_PRINT_IN_DEBUG(spoolss_64, &r);
16740 }
16741
16742 status = cli->dispatch(cli,
16743 mem_ctx,
16744 &ndr_table_spoolss,
16745 NDR_SPOOLSS_64,
16746 &r);
16747
16748 if (!NT_STATUS_IS_OK(status)) {
16749 return status;
16750 }
16751
16752 if (DEBUGLEVEL >= 10) {
16753 NDR_PRINT_OUT_DEBUG(spoolss_64, &r);
16754 }
16755
16756 if (NT_STATUS_IS_ERR(status)) {
16757 return status;
16758 }
16759
16760 /* Return variables */
16761
16762 /* Return result */
16763 if (werror) {
16764 *werror = r.out.result;
16765 }
16766
16767 return werror_to_ntstatus(r.out.result);
16768 }
16769
16770 struct rpccli_spoolss_65_state {
16771 struct spoolss_65 orig;
16772 struct spoolss_65 tmp;
16773 TALLOC_CTX *out_mem_ctx;
16774 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16775 };
16776
16777 static void rpccli_spoolss_65_done(struct tevent_req *subreq);
16778
16779 struct tevent_req *rpccli_spoolss_65_send(TALLOC_CTX *mem_ctx,
16780 struct tevent_context *ev,
16781 struct rpc_pipe_client *cli)
16782 {
16783 struct tevent_req *req;
16784 struct rpccli_spoolss_65_state *state;
16785 struct tevent_req *subreq;
16786
16787 req = tevent_req_create(mem_ctx, &state,
16788 struct rpccli_spoolss_65_state);
16789 if (req == NULL) {
16790 return NULL;
16791 }
16792 state->out_mem_ctx = NULL;
16793 state->dispatch_recv = cli->dispatch_recv;
16794
16795 /* In parameters */
16796
16797 /* Out parameters */
16798
16799 /* Result */
16800 ZERO_STRUCT(state->orig.out.result);
16801
16802 if (DEBUGLEVEL >= 10) {
16803 NDR_PRINT_IN_DEBUG(spoolss_65, &state->orig);
16804 }
16805
16806 /* make a temporary copy, that we pass to the dispatch function */
16807 state->tmp = state->orig;
16808
16809 subreq = cli->dispatch_send(state, ev, cli,
16810 &ndr_table_spoolss,
16811 NDR_SPOOLSS_65,
16812 &state->tmp);
16813 if (tevent_req_nomem(subreq, req)) {
16814 return tevent_req_post(req, ev);
16815 }
16816 tevent_req_set_callback(subreq, rpccli_spoolss_65_done, req);
16817 return req;
16818 }
16819
16820 static void rpccli_spoolss_65_done(struct tevent_req *subreq)
16821 {
16822 struct tevent_req *req = tevent_req_callback_data(
16823 subreq, struct tevent_req);
16824 struct rpccli_spoolss_65_state *state = tevent_req_data(
16825 req, struct rpccli_spoolss_65_state);
16826 NTSTATUS status;
16827 TALLOC_CTX *mem_ctx;
16828
16829 if (state->out_mem_ctx) {
16830 mem_ctx = state->out_mem_ctx;
16831 } else {
16832 mem_ctx = state;
16833 }
16834
16835 status = state->dispatch_recv(subreq, mem_ctx);
16836 TALLOC_FREE(subreq);
16837 if (!NT_STATUS_IS_OK(status)) {
16838 tevent_req_nterror(req, status);
16839 return;
16840 }
16841
16842 /* Copy out parameters */
16843
16844 /* Copy result */
16845 state->orig.out.result = state->tmp.out.result;
16846
16847 /* Reset temporary structure */
16848 ZERO_STRUCT(state->tmp);
16849
16850 if (DEBUGLEVEL >= 10) {
16851 NDR_PRINT_OUT_DEBUG(spoolss_65, &state->orig);
16852 }
16853
16854 tevent_req_done(req);
16855 }
16856
16857 NTSTATUS rpccli_spoolss_65_recv(struct tevent_req *req,
16858 TALLOC_CTX *mem_ctx,
16859 WERROR *result)
16860 {
16861 struct rpccli_spoolss_65_state *state = tevent_req_data(
16862 req, struct rpccli_spoolss_65_state);
16863 NTSTATUS status;
16864
16865 if (tevent_req_is_nterror(req, &status)) {
16866 tevent_req_received(req);
16867 return status;
16868 }
16869
16870 /* Steal possbile out parameters to the callers context */
16871 talloc_steal(mem_ctx, state->out_mem_ctx);
16872
16873 /* Return result */
16874 *result = state->orig.out.result;
16875
16876 tevent_req_received(req);
16877 return NT_STATUS_OK;
16878 }
16879
16880 NTSTATUS rpccli_spoolss_65(struct rpc_pipe_client *cli,
16881 TALLOC_CTX *mem_ctx,
16882 WERROR *werror)
16883 {
16884 struct spoolss_65 r;
16885 NTSTATUS status;
16886
16887 /* In parameters */
16888
16889 if (DEBUGLEVEL >= 10) {
16890 NDR_PRINT_IN_DEBUG(spoolss_65, &r);
16891 }
16892
16893 status = cli->dispatch(cli,
16894 mem_ctx,
16895 &ndr_table_spoolss,
16896 NDR_SPOOLSS_65,
16897 &r);
16898
16899 if (!NT_STATUS_IS_OK(status)) {
16900 return status;
16901 }
16902
16903 if (DEBUGLEVEL >= 10) {
16904 NDR_PRINT_OUT_DEBUG(spoolss_65, &r);
16905 }
16906
16907 if (NT_STATUS_IS_ERR(status)) {
16908 return status;
16909 }
16910
16911 /* Return variables */
16912
16913 /* Return result */
16914 if (werror) {
16915 *werror = r.out.result;
16916 }
16917
16918 return werror_to_ntstatus(r.out.result);
16919 }
16920
16921 struct rpccli_spoolss_GetCorePrinterDrivers_state {
16922 struct spoolss_GetCorePrinterDrivers orig;
16923 struct spoolss_GetCorePrinterDrivers tmp;
16924 TALLOC_CTX *out_mem_ctx;
16925 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16926 };
16927
16928 static void rpccli_spoolss_GetCorePrinterDrivers_done(struct tevent_req *subreq);
16929
16930 struct tevent_req *rpccli_spoolss_GetCorePrinterDrivers_send(TALLOC_CTX *mem_ctx,
16931 struct tevent_context *ev,
16932 struct rpc_pipe_client *cli,
16933 const char *_servername /* [in] [unique,charset(UTF16)] */,
16934 const char *_architecture /* [in] [ref,charset(UTF16)] */,
16935 uint32_t _core_driver_size /* [in] */,
16936 const char *_core_driver_dependencies /* [in] [ref,charset(UTF16),size_is(core_driver_size)] */,
16937 uint32_t _core_printer_driver_count /* [in] */,
16938 struct spoolss_CorePrinterDriver *_core_printer_drivers /* [out] [ref,size_is(core_printer_driver_count)] */)
16939 {
16940 struct tevent_req *req;
16941 struct rpccli_spoolss_GetCorePrinterDrivers_state *state;
16942 struct tevent_req *subreq;
16943
16944 req = tevent_req_create(mem_ctx, &state,
16945 struct rpccli_spoolss_GetCorePrinterDrivers_state);
16946 if (req == NULL) {
16947 return NULL;
16948 }
16949 state->out_mem_ctx = NULL;
16950 state->dispatch_recv = cli->dispatch_recv;
16951
16952 /* In parameters */
16953 state->orig.in.servername = _servername;
16954 state->orig.in.architecture = _architecture;
16955 state->orig.in.core_driver_size = _core_driver_size;
16956 state->orig.in.core_driver_dependencies = _core_driver_dependencies;
16957 state->orig.in.core_printer_driver_count = _core_printer_driver_count;
16958
16959 /* Out parameters */
16960 state->orig.out.core_printer_drivers = _core_printer_drivers;
16961
16962 /* Result */
16963 ZERO_STRUCT(state->orig.out.result);
16964
16965 if (DEBUGLEVEL >= 10) {
16966 NDR_PRINT_IN_DEBUG(spoolss_GetCorePrinterDrivers, &state->orig);
16967 }
16968
16969 state->out_mem_ctx = talloc_named_const(state, 0,
16970 "rpccli_spoolss_GetCorePrinterDrivers_out_memory");
16971 if (tevent_req_nomem(state->out_mem_ctx, req)) {
16972 return tevent_req_post(req, ev);
16973 }
16974
16975 /* make a temporary copy, that we pass to the dispatch function */
16976 state->tmp = state->orig;
16977
16978 subreq = cli->dispatch_send(state, ev, cli,
16979 &ndr_table_spoolss,
16980 NDR_SPOOLSS_GETCOREPRINTERDRIVERS,
16981 &state->tmp);
16982 if (tevent_req_nomem(subreq, req)) {
16983 return tevent_req_post(req, ev);
16984 }
16985 tevent_req_set_callback(subreq, rpccli_spoolss_GetCorePrinterDrivers_done, req);
16986 return req;
16987 }
16988
16989 static void rpccli_spoolss_GetCorePrinterDrivers_done(struct tevent_req *subreq)
16990 {
16991 struct tevent_req *req = tevent_req_callback_data(
16992 subreq, struct tevent_req);
16993 struct rpccli_spoolss_GetCorePrinterDrivers_state *state = tevent_req_data(
16994 req, struct rpccli_spoolss_GetCorePrinterDrivers_state);
16995 NTSTATUS status;
16996 TALLOC_CTX *mem_ctx;
16997
16998 if (state->out_mem_ctx) {
16999 mem_ctx = state->out_mem_ctx;
17000 } else {
17001 mem_ctx = state;
17002 }
17003
17004 status = state->dispatch_recv(subreq, mem_ctx);
17005 TALLOC_FREE(subreq);
17006 if (!NT_STATUS_IS_OK(status)) {
17007 tevent_req_nterror(req, status);
17008 return;
17009 }
17010
17011 /* Copy out parameters */
17012 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));
17013
17014 /* Copy result */
17015 state->orig.out.result = state->tmp.out.result;
17016
17017 /* Reset temporary structure */
17018 ZERO_STRUCT(state->tmp);
17019
17020 if (DEBUGLEVEL >= 10) {
17021 NDR_PRINT_OUT_DEBUG(spoolss_GetCorePrinterDrivers, &state->orig);
17022 }
17023
17024 tevent_req_done(req);
17025 }
17026
17027 NTSTATUS rpccli_spoolss_GetCorePrinterDrivers_recv(struct tevent_req *req,
17028 TALLOC_CTX *mem_ctx,
17029 WERROR *result)
17030 {
17031 struct rpccli_spoolss_GetCorePrinterDrivers_state *state = tevent_req_data(
17032 req, struct rpccli_spoolss_GetCorePrinterDrivers_state);
17033 NTSTATUS status;
17034
17035 if (tevent_req_is_nterror(req, &status)) {
17036 tevent_req_received(req);
17037 return status;
17038 }
17039
17040 /* Steal possbile out parameters to the callers context */
17041 talloc_steal(mem_ctx, state->out_mem_ctx);
17042
17043 /* Return result */
17044 *result = state->orig.out.result;
17045
17046 tevent_req_received(req);
17047 return NT_STATUS_OK;
17048 }
17049
17050 NTSTATUS rpccli_spoolss_GetCorePrinterDrivers(struct rpc_pipe_client *cli,
17051 TALLOC_CTX *mem_ctx,
17052 const char *servername /* [in] [unique,charset(UTF16)] */,
17053 const char *architecture /* [in] [ref,charset(UTF16)] */,
17054 uint32_t core_driver_size /* [in] */,
17055 const char *core_driver_dependencies /* [in] [ref,charset(UTF16),size_is(core_driver_size)] */,
17056 uint32_t core_printer_driver_count /* [in] */,
17057 struct spoolss_CorePrinterDriver *core_printer_drivers /* [out] [ref,size_is(core_printer_driver_count)] */,
17058 WERROR *werror)
17059 {
17060 struct spoolss_GetCorePrinterDrivers r;
17061 NTSTATUS status;
17062
17063 /* In parameters */
17064 r.in.servername = servername;
17065 r.in.architecture = architecture;
17066 r.in.core_driver_size = core_driver_size;
17067 r.in.core_driver_dependencies = core_driver_dependencies;
17068 r.in.core_printer_driver_count = core_printer_driver_count;
17069
17070 if (DEBUGLEVEL >= 10) {
17071 NDR_PRINT_IN_DEBUG(spoolss_GetCorePrinterDrivers, &r);
17072 }
17073
17074 status = cli->dispatch(cli,
17075 mem_ctx,
17076 &ndr_table_spoolss,
17077 NDR_SPOOLSS_GETCOREPRINTERDRIVERS,
17078 &r);
17079
17080 if (!NT_STATUS_IS_OK(status)) {
17081 return status;
17082 }
17083
17084 if (DEBUGLEVEL >= 10) {
17085 NDR_PRINT_OUT_DEBUG(spoolss_GetCorePrinterDrivers, &r);
17086 }
17087
17088 if (NT_STATUS_IS_ERR(status)) {
17089 return status;
17090 }
17091
17092 /* Return variables */
17093 memcpy(core_printer_drivers, r.out.core_printer_drivers, r.in.core_printer_driver_count * sizeof(*core_printer_drivers));
17094
17095 /* Return result */
17096 if (werror) {
17097 *werror = r.out.result;
17098 }
17099
17100 return werror_to_ntstatus(r.out.result);
17101 }
17102
17103 struct rpccli_spoolss_67_state {
17104 struct spoolss_67 orig;
17105 struct spoolss_67 tmp;
17106 TALLOC_CTX *out_mem_ctx;
17107 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
17108 };
17109
17110 static void rpccli_spoolss_67_done(struct tevent_req *subreq);
17111
17112 struct tevent_req *rpccli_spoolss_67_send(TALLOC_CTX *mem_ctx,
17113 struct tevent_context *ev,
17114 struct rpc_pipe_client *cli)
17115 {
17116 struct tevent_req *req;
17117 struct rpccli_spoolss_67_state *state;
17118 struct tevent_req *subreq;
17119
17120 req = tevent_req_create(mem_ctx, &state,
17121 struct rpccli_spoolss_67_state);
17122 if (req == NULL) {
17123 return NULL;
17124 }
17125 state->out_mem_ctx = NULL;
17126 state->dispatch_recv = cli->dispatch_recv;
17127
17128 /* In parameters */
17129
17130 /* Out parameters */
17131
17132 /* Result */
17133 ZERO_STRUCT(state->orig.out.result);
17134
17135 if (DEBUGLEVEL >= 10) {
17136 NDR_PRINT_IN_DEBUG(spoolss_67, &state->orig);
17137 }
17138
17139 /* make a temporary copy, that we pass to the dispatch function */
17140 state->tmp = state->orig;
17141
17142 subreq = cli->dispatch_send(state, ev, cli,
17143 &ndr_table_spoolss,
17144 NDR_SPOOLSS_67,
17145 &state->tmp);
17146 if (tevent_req_nomem(subreq, req)) {
17147 return tevent_req_post(req, ev);
17148 }
17149 tevent_req_set_callback(subreq, rpccli_spoolss_67_done, req);
17150 return req;
17151 }
17152
17153 static void rpccli_spoolss_67_done(struct tevent_req *subreq)
17154 {
17155 struct tevent_req *req = tevent_req_callback_data(
17156 subreq, struct tevent_req);
17157 struct rpccli_spoolss_67_state *state = tevent_req_data(
17158 req, struct rpccli_spoolss_67_state);
17159 NTSTATUS status;
17160 TALLOC_CTX *mem_ctx;
17161
17162 if (state->out_mem_ctx) {
17163 mem_ctx = state->out_mem_ctx;
17164 } else {
17165 mem_ctx = state;
17166 }
17167
17168 status = state->dispatch_recv(subreq, mem_ctx);
17169 TALLOC_FREE(subreq);
17170 if (!NT_STATUS_IS_OK(status)) {
17171 tevent_req_nterror(req, status);
17172 return;
17173 }
17174
17175 /* Copy out parameters */
17176
17177 /* Copy result */
17178 state->orig.out.result = state->tmp.out.result;
17179
17180 /* Reset temporary structure */
17181 ZERO_STRUCT(state->tmp);
17182
17183 if (DEBUGLEVEL >= 10) {
17184 NDR_PRINT_OUT_DEBUG(spoolss_67, &state->orig);
17185 }
17186
17187 tevent_req_done(req);
17188 }
17189
17190 NTSTATUS rpccli_spoolss_67_recv(struct tevent_req *req,
17191 TALLOC_CTX *mem_ctx,
17192 WERROR *result)
17193 {
17194 struct rpccli_spoolss_67_state *state = tevent_req_data(
17195 req, struct rpccli_spoolss_67_state);
17196 NTSTATUS status;
17197
17198 if (tevent_req_is_nterror(req, &status)) {
17199 tevent_req_received(req);
17200 return status;
17201 }
17202
17203 /* Steal possbile out parameters to the callers context */
17204 talloc_steal(mem_ctx, state->out_mem_ctx);
17205
17206 /* Return result */
17207 *result = state->orig.out.result;
17208
17209 tevent_req_received(req);
17210 return NT_STATUS_OK;
17211 }
17212
17213 NTSTATUS rpccli_spoolss_67(struct rpc_pipe_client *cli,
17214 TALLOC_CTX *mem_ctx,
17215 WERROR *werror)
17216 {
17217 struct spoolss_67 r;
17218 NTSTATUS status;
17219
17220 /* In parameters */
17221
17222 if (DEBUGLEVEL >= 10) {
17223 NDR_PRINT_IN_DEBUG(spoolss_67, &r);
17224 }
17225
17226 status = cli->dispatch(cli,
17227 mem_ctx,
17228 &ndr_table_spoolss,
17229 NDR_SPOOLSS_67,
17230 &r);
17231
17232 if (!NT_STATUS_IS_OK(status)) {
17233 return status;
17234 }
17235
17236 if (DEBUGLEVEL >= 10) {
17237 NDR_PRINT_OUT_DEBUG(spoolss_67, &r);
17238 }
17239
17240 if (NT_STATUS_IS_ERR(status)) {
17241 return status;
17242 }
17243
17244 /* Return variables */
17245
17246 /* Return result */
17247 if (werror) {
17248 *werror = r.out.result;
17249 }
17250
17251 return werror_to_ntstatus(r.out.result);
17252 }
17253
17254 struct rpccli_spoolss_GetPrinterDriverPackagePath_state {
17255 struct spoolss_GetPrinterDriverPackagePath orig;
17256 struct spoolss_GetPrinterDriverPackagePath tmp;
17257 TALLOC_CTX *out_mem_ctx;
17258 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
17259 };
17260
17261 static void rpccli_spoolss_GetPrinterDriverPackagePath_done(struct tevent_req *subreq);
17262
17263 struct tevent_req *rpccli_spoolss_GetPrinterDriverPackagePath_send(TALLOC_CTX *mem_ctx,
17264 struct tevent_context *ev,
17265 struct rpc_pipe_client *cli,
17266 const char *_servername /* [in] [unique,charset(UTF16)] */,
17267 const char *_architecture /* [in] [ref,charset(UTF16)] */,
17268 const char *_language /* [in] [unique,charset(UTF16)] */,
17269 const char *_package_id /* [in] [ref,charset(UTF16)] */,
17270 const char *_driver_package_cab /* [in,out] [unique,charset(UTF16),size_is(driver_package_cab_size)] */,
17271 uint32_t _driver_package_cab_size /* [in] */,
17272 uint32_t *_required /* [out] [ref] */)
17273 {
17274 struct tevent_req *req;
17275 struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state;
17276 struct tevent_req *subreq;
17277
17278 req = tevent_req_create(mem_ctx, &state,
17279 struct rpccli_spoolss_GetPrinterDriverPackagePath_state);
17280 if (req == NULL) {
17281 return NULL;
17282 }
17283 state->out_mem_ctx = NULL;
17284 state->dispatch_recv = cli->dispatch_recv;
17285
17286 /* In parameters */
17287 state->orig.in.servername = _servername;
17288 state->orig.in.architecture = _architecture;
17289 state->orig.in.language = _language;
17290 state->orig.in.package_id = _package_id;
17291 state->orig.in.driver_package_cab = _driver_package_cab;
17292 state->orig.in.driver_package_cab_size = _driver_package_cab_size;
17293
17294 /* Out parameters */
17295 state->orig.out.driver_package_cab = _driver_package_cab;
17296 state->orig.out.required = _required;
17297
17298 /* Result */
17299 ZERO_STRUCT(state->orig.out.result);
17300
17301 if (DEBUGLEVEL >= 10) {
17302 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverPackagePath, &state->orig);
17303 }
17304
17305 state->out_mem_ctx = talloc_named_const(state, 0,
17306 "rpccli_spoolss_GetPrinterDriverPackagePath_out_memory");
17307 if (tevent_req_nomem(state->out_mem_ctx, req)) {
17308 return tevent_req_post(req, ev);
17309 }
17310
17311 /* make a temporary copy, that we pass to the dispatch function */
17312 state->tmp = state->orig;
17313
17314 subreq = cli->dispatch_send(state, ev, cli,
17315 &ndr_table_spoolss,
17316 NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH,
17317 &state->tmp);
17318 if (tevent_req_nomem(subreq, req)) {
17319 return tevent_req_post(req, ev);
17320 }
17321 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriverPackagePath_done, req);
17322 return req;
17323 }
17324
17325 static void rpccli_spoolss_GetPrinterDriverPackagePath_done(struct tevent_req *subreq)
17326 {
17327 struct tevent_req *req = tevent_req_callback_data(
17328 subreq, struct tevent_req);
17329 struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state = tevent_req_data(
17330 req, struct rpccli_spoolss_GetPrinterDriverPackagePath_state);
17331 NTSTATUS status;
17332 TALLOC_CTX *mem_ctx;
17333
17334 if (state->out_mem_ctx) {
17335 mem_ctx = state->out_mem_ctx;
17336 } else {
17337 mem_ctx = state;
17338 }
17339
17340 status = state->dispatch_recv(subreq, mem_ctx);
17341 TALLOC_FREE(subreq);
17342 if (!NT_STATUS_IS_OK(status)) {
17343 tevent_req_nterror(req, status);
17344 return;
17345 }
17346
17347 /* Copy out parameters */
17348 if (state->orig.out.driver_package_cab && state->tmp.out.driver_package_cab) {
17349 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));
17350 }
17351 *state->orig.out.required = *state->tmp.out.required;
17352
17353 /* Copy result */
17354 state->orig.out.result = state->tmp.out.result;
17355
17356 /* Reset temporary structure */
17357 ZERO_STRUCT(state->tmp);
17358
17359 if (DEBUGLEVEL >= 10) {
17360 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverPackagePath, &state->orig);
17361 }
17362
17363 tevent_req_done(req);
17364 }
17365
17366 NTSTATUS rpccli_spoolss_GetPrinterDriverPackagePath_recv(struct tevent_req *req,
17367 TALLOC_CTX *mem_ctx,
17368 WERROR *result)
17369 {
17370 struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state = tevent_req_data(
17371 req, struct rpccli_spoolss_GetPrinterDriverPackagePath_state);
17372 NTSTATUS status;
17373
17374 if (tevent_req_is_nterror(req, &status)) {
17375 tevent_req_received(req);
17376 return status;
17377 }
17378
17379 /* Steal possbile out parameters to the callers context */
17380 talloc_steal(mem_ctx, state->out_mem_ctx);
17381
17382 /* Return result */
17383 *result = state->orig.out.result;
17384
17385 tevent_req_received(req);
17386 return NT_STATUS_OK;
17387 }
17388
17389 NTSTATUS rpccli_spoolss_GetPrinterDriverPackagePath(struct rpc_pipe_client *cli,
17390 TALLOC_CTX *mem_ctx,
17391 const char *servername /* [in] [unique,charset(UTF16)] */,
17392 const char *architecture /* [in] [ref,charset(UTF16)] */,
17393 const char *language /* [in] [unique,charset(UTF16)] */,
17394 const char *package_id /* [in] [ref,charset(UTF16)] */,
17395 const char *driver_package_cab /* [in,out] [unique,charset(UTF16),size_is(driver_package_cab_size)] */,
17396 uint32_t driver_package_cab_size /* [in] */,
17397 uint32_t *required /* [out] [ref] */,
17398 WERROR *werror)
17399 {
17400 struct spoolss_GetPrinterDriverPackagePath r;
17401 NTSTATUS status;
17402
17403 /* In parameters */
17404 r.in.servername = servername;
17405 r.in.architecture = architecture;
17406 r.in.language = language;
17407 r.in.package_id = package_id;
17408 r.in.driver_package_cab = driver_package_cab;
17409 r.in.driver_package_cab_size = driver_package_cab_size;
17410
17411 if (DEBUGLEVEL >= 10) {
17412 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverPackagePath, &r);
17413 }
17414
17415 status = cli->dispatch(cli,
17416 mem_ctx,
17417 &ndr_table_spoolss,
17418 NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH,
17419 &r);
17420
17421 if (!NT_STATUS_IS_OK(status)) {
17422 return status;
17423 }
17424
17425 if (DEBUGLEVEL >= 10) {
17426 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverPackagePath, &r);
17427 }
17428
17429 if (NT_STATUS_IS_ERR(status)) {
17430 return status;
17431 }
17432
17433 /* Return variables */
17434 if (driver_package_cab && r.out.driver_package_cab) {
17435 memcpy(CONST_DISCARD(char *, driver_package_cab), r.out.driver_package_cab, r.in.driver_package_cab_size * sizeof(*driver_package_cab));
17436 }
17437 *required = *r.out.required;
17438
17439 /* Return result */
17440 if (werror) {
17441 *werror = r.out.result;
17442 }
17443
17444 return werror_to_ntstatus(r.out.result);
17445 }
17446
17447 struct rpccli_spoolss_69_state {
17448 struct spoolss_69 orig;
17449 struct spoolss_69 tmp;
17450 TALLOC_CTX *out_mem_ctx;
17451 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
17452 };
17453
17454 static void rpccli_spoolss_69_done(struct tevent_req *subreq);
17455
17456 struct tevent_req *rpccli_spoolss_69_send(TALLOC_CTX *mem_ctx,
17457 struct tevent_context *ev,
17458 struct rpc_pipe_client *cli)
17459 {
17460 struct tevent_req *req;
17461 struct rpccli_spoolss_69_state *state;
17462 struct tevent_req *subreq;
17463
17464 req = tevent_req_create(mem_ctx, &state,
17465 struct rpccli_spoolss_69_state);
17466 if (req == NULL) {
17467 return NULL;
17468 }
17469 state->out_mem_ctx = NULL;
17470 state->dispatch_recv = cli->dispatch_recv;
17471
17472 /* In parameters */
17473
17474 /* Out parameters */
17475
17476 /* Result */
17477 ZERO_STRUCT(state->orig.out.result);
17478
17479 if (DEBUGLEVEL >= 10) {
17480 NDR_PRINT_IN_DEBUG(spoolss_69, &state->orig);
17481 }
17482
17483 /* make a temporary copy, that we pass to the dispatch function */
17484 state->tmp = state->orig;
17485
17486 subreq = cli->dispatch_send(state, ev, cli,
17487 &ndr_table_spoolss,
17488 NDR_SPOOLSS_69,
17489 &state->tmp);
17490 if (tevent_req_nomem(subreq, req)) {
17491 return tevent_req_post(req, ev);
17492 }
17493 tevent_req_set_callback(subreq, rpccli_spoolss_69_done, req);
17494 return req;
17495 }
17496
17497 static void rpccli_spoolss_69_done(struct tevent_req *subreq)
17498 {
17499 struct tevent_req *req = tevent_req_callback_data(
17500 subreq, struct tevent_req);
17501 struct rpccli_spoolss_69_state *state = tevent_req_data(
17502 req, struct rpccli_spoolss_69_state);
17503 NTSTATUS status;
17504 TALLOC_CTX *mem_ctx;
17505
17506 if (state->out_mem_ctx) {
17507 mem_ctx = state->out_mem_ctx;
17508 } else {
17509 mem_ctx = state;
17510 }
17511
17512 status = state->dispatch_recv(subreq, mem_ctx);
17513 TALLOC_FREE(subreq);
17514 if (!NT_STATUS_IS_OK(status)) {
17515 tevent_req_nterror(req, status);
17516 return;
17517 }
17518
17519 /* Copy out parameters */
17520
17521 /* Copy result */
17522 state->orig.out.result = state->tmp.out.result;
17523
17524 /* Reset temporary structure */
17525 ZERO_STRUCT(state->tmp);
17526
17527 if (DEBUGLEVEL >= 10) {
17528 NDR_PRINT_OUT_DEBUG(spoolss_69, &state->orig);
17529 }
17530
17531 tevent_req_done(req);
17532 }
17533
17534 NTSTATUS rpccli_spoolss_69_recv(struct tevent_req *req,
17535 TALLOC_CTX *mem_ctx,
17536 WERROR *result)
17537 {
17538 struct rpccli_spoolss_69_state *state = tevent_req_data(
17539 req, struct rpccli_spoolss_69_state);
17540 NTSTATUS status;
17541
17542 if (tevent_req_is_nterror(req, &status)) {
17543 tevent_req_received(req);
17544 return status;
17545 }
17546
17547 /* Steal possbile out parameters to the callers context */
17548 talloc_steal(mem_ctx, state->out_mem_ctx);
17549
17550 /* Return result */
17551 *result = state->orig.out.result;
17552
17553 tevent_req_received(req);
17554 return NT_STATUS_OK;
17555 }
17556
17557 NTSTATUS rpccli_spoolss_69(struct rpc_pipe_client *cli,
17558 TALLOC_CTX *mem_ctx,
17559 WERROR *werror)
17560 {
17561 struct spoolss_69 r;
17562 NTSTATUS status;
17563
17564 /* In parameters */
17565
17566 if (DEBUGLEVEL >= 10) {
17567 NDR_PRINT_IN_DEBUG(spoolss_69, &r);
17568 }
17569
17570 status = cli->dispatch(cli,
17571 mem_ctx,
17572 &ndr_table_spoolss,
17573 NDR_SPOOLSS_69,
17574 &r);
17575
17576 if (!NT_STATUS_IS_OK(status)) {
17577 return status;
17578 }
17579
17580 if (DEBUGLEVEL >= 10) {
17581 NDR_PRINT_OUT_DEBUG(spoolss_69, &r);
17582 }
17583
17584 if (NT_STATUS_IS_ERR(status)) {
17585 return status;
17586 }
17587
17588 /* Return variables */
17589
17590 /* Return result */
17591 if (werror) {
17592 *werror = r.out.result;
17593 }
17594
17595 return werror_to_ntstatus(r.out.result);
17596 }
17597
17598 struct rpccli_spoolss_6a_state {
17599 struct spoolss_6a orig;
17600 struct spoolss_6a tmp;
17601 TALLOC_CTX *out_mem_ctx;
17602 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
17603 };
17604
17605 static void rpccli_spoolss_6a_done(struct tevent_req *subreq);
17606
17607 struct tevent_req *rpccli_spoolss_6a_send(TALLOC_CTX *mem_ctx,
17608 struct tevent_context *ev,
17609 struct rpc_pipe_client *cli)
17610 {
17611 struct tevent_req *req;
17612 struct rpccli_spoolss_6a_state *state;
17613 struct tevent_req *subreq;
17614
17615 req = tevent_req_create(mem_ctx, &state,
17616 struct rpccli_spoolss_6a_state);
17617 if (req == NULL) {
17618 return NULL;
17619 }
17620 state->out_mem_ctx = NULL;
17621 state->dispatch_recv = cli->dispatch_recv;
17622
17623 /* In parameters */
17624
17625 /* Out parameters */
17626
17627 /* Result */
17628 ZERO_STRUCT(state->orig.out.result);
17629
17630 if (DEBUGLEVEL >= 10) {
17631 NDR_PRINT_IN_DEBUG(spoolss_6a, &state->orig);
17632 }
17633
17634 /* make a temporary copy, that we pass to the dispatch function */
17635 state->tmp = state->orig;
17636
17637 subreq = cli->dispatch_send(state, ev, cli,
17638 &ndr_table_spoolss,
17639 NDR_SPOOLSS_6A,
17640 &state->tmp);
17641 if (tevent_req_nomem(subreq, req)) {
17642 return tevent_req_post(req, ev);
17643 }
17644 tevent_req_set_callback(subreq, rpccli_spoolss_6a_done, req);
17645 return req;
17646 }
17647
17648 static void rpccli_spoolss_6a_done(struct tevent_req *subreq)
17649 {
17650 struct tevent_req *req = tevent_req_callback_data(
17651 subreq, struct tevent_req);
17652 struct rpccli_spoolss_6a_state *state = tevent_req_data(
17653 req, struct rpccli_spoolss_6a_state);
17654 NTSTATUS status;
17655 TALLOC_CTX *mem_ctx;
17656
17657 if (state->out_mem_ctx) {
17658 mem_ctx = state->out_mem_ctx;
17659 } else {
17660 mem_ctx = state;
17661 }
17662
17663 status = state->dispatch_recv(subreq, mem_ctx);
17664 TALLOC_FREE(subreq);
17665 if (!NT_STATUS_IS_OK(status)) {
17666 tevent_req_nterror(req, status);
17667 return;
17668 }
17669
17670 /* Copy out parameters */
17671
17672 /* Copy result */
17673 state->orig.out.result = state->tmp.out.result;
17674
17675 /* Reset temporary structure */
17676 ZERO_STRUCT(state->tmp);
17677
17678 if (DEBUGLEVEL >= 10) {
17679 NDR_PRINT_OUT_DEBUG(spoolss_6a, &state->orig);
17680 }
17681
17682 tevent_req_done(req);
17683 }
17684
17685 NTSTATUS rpccli_spoolss_6a_recv(struct tevent_req *req,
17686 TALLOC_CTX *mem_ctx,
17687 WERROR *result)
17688 {
17689 struct rpccli_spoolss_6a_state *state = tevent_req_data(
17690 req, struct rpccli_spoolss_6a_state);
17691 NTSTATUS status;
17692
17693 if (tevent_req_is_nterror(req, &status)) {
17694 tevent_req_received(req);
17695 return status;
17696 }
17697
17698 /* Steal possbile out parameters to the callers context */
17699 talloc_steal(mem_ctx, state->out_mem_ctx);
17700
17701 /* Return result */
17702 *result = state->orig.out.result;
17703
17704 tevent_req_received(req);
17705 return NT_STATUS_OK;
17706 }
17707
17708 NTSTATUS rpccli_spoolss_6a(struct rpc_pipe_client *cli,
17709 TALLOC_CTX *mem_ctx,
17710 WERROR *werror)
17711 {
17712 struct spoolss_6a r;
17713 NTSTATUS status;
17714
17715 /* In parameters */
17716
17717 if (DEBUGLEVEL >= 10) {
17718 NDR_PRINT_IN_DEBUG(spoolss_6a, &r);
17719 }
17720
17721 status = cli->dispatch(cli,
17722 mem_ctx,
17723 &ndr_table_spoolss,
17724 NDR_SPOOLSS_6A,
17725 &r);
17726
17727 if (!NT_STATUS_IS_OK(status)) {
17728 return status;
17729 }
17730
17731 if (DEBUGLEVEL >= 10) {
17732 NDR_PRINT_OUT_DEBUG(spoolss_6a, &r);
17733 }
17734
17735 if (NT_STATUS_IS_ERR(status)) {
17736 return status;
17737 }
17738
17739 /* Return variables */
17740
17741 /* Return result */
17742 if (werror) {
17743 *werror = r.out.result;
17744 }
17745
17746 return werror_to_ntstatus(r.out.result);
17747 }
17748
17749 struct rpccli_spoolss_6b_state {
17750 struct spoolss_6b orig;
17751 struct spoolss_6b tmp;
17752 TALLOC_CTX *out_mem_ctx;
17753 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
17754 };
17755
17756 static void rpccli_spoolss_6b_done(struct tevent_req *subreq);
17757
17758 struct tevent_req *rpccli_spoolss_6b_send(TALLOC_CTX *mem_ctx,
17759 struct tevent_context *ev,
17760 struct rpc_pipe_client *cli)
17761 {
17762 struct tevent_req *req;
17763 struct rpccli_spoolss_6b_state *state;
17764 struct tevent_req *subreq;
17765
17766 req = tevent_req_create(mem_ctx, &state,
17767 struct rpccli_spoolss_6b_state);
17768 if (req == NULL) {
17769 return NULL;
17770 }
17771 state->out_mem_ctx = NULL;
17772 state->dispatch_recv = cli->dispatch_recv;
17773
17774 /* In parameters */
17775
17776 /* Out parameters */
17777
17778 /* Result */
17779 ZERO_STRUCT(state->orig.out.result);
17780
17781 if (DEBUGLEVEL >= 10) {
17782 NDR_PRINT_IN_DEBUG(spoolss_6b, &state->orig);
17783 }
17784
17785 /* make a temporary copy, that we pass to the dispatch function */
17786 state->tmp = state->orig;
17787
17788 subreq = cli->dispatch_send(state, ev, cli,
17789 &ndr_table_spoolss,
17790 NDR_SPOOLSS_6B,
17791 &state->tmp);
17792 if (tevent_req_nomem(subreq, req)) {
17793 return tevent_req_post(req, ev);
17794 }
17795 tevent_req_set_callback(subreq, rpccli_spoolss_6b_done, req);
17796 return req;
17797 }
17798
17799 static void rpccli_spoolss_6b_done(struct tevent_req *subreq)
17800 {
17801 struct tevent_req *req = tevent_req_callback_data(
17802 subreq, struct tevent_req);
17803 struct rpccli_spoolss_6b_state *state = tevent_req_data(
17804 req, struct rpccli_spoolss_6b_state);
17805 NTSTATUS status;
17806 TALLOC_CTX *mem_ctx;
17807
17808 if (state->out_mem_ctx) {
17809 mem_ctx = state->out_mem_ctx;
17810 } else {
17811 mem_ctx = state;
17812 }
17813
17814 status = state->dispatch_recv(subreq, mem_ctx);
17815 TALLOC_FREE(subreq);
17816 if (!NT_STATUS_IS_OK(status)) {
17817 tevent_req_nterror(req, status);
17818 return;
17819 }
17820
17821 /* Copy out parameters */
17822
17823 /* Copy result */
17824 state->orig.out.result = state->tmp.out.result;
17825
17826 /* Reset temporary structure */
17827 ZERO_STRUCT(state->tmp);
17828
17829 if (DEBUGLEVEL >= 10) {
17830 NDR_PRINT_OUT_DEBUG(spoolss_6b, &state->orig);
17831 }
17832
17833 tevent_req_done(req);
17834 }
17835
17836 NTSTATUS rpccli_spoolss_6b_recv(struct tevent_req *req,
17837 TALLOC_CTX *mem_ctx,
17838 WERROR *result)
17839 {
17840 struct rpccli_spoolss_6b_state *state = tevent_req_data(
17841 req, struct rpccli_spoolss_6b_state);
17842 NTSTATUS status;
17843
17844 if (tevent_req_is_nterror(req, &status)) {
17845 tevent_req_received(req);
17846 return status;
17847 }
17848
17849 /* Steal possbile out parameters to the callers context */
17850 talloc_steal(mem_ctx, state->out_mem_ctx);
17851
17852 /* Return result */
17853 *result = state->orig.out.result;
17854
17855 tevent_req_received(req);
17856 return NT_STATUS_OK;
17857 }
17858
17859 NTSTATUS rpccli_spoolss_6b(struct rpc_pipe_client *cli,
17860 TALLOC_CTX *mem_ctx,
17861 WERROR *werror)
17862 {
17863 struct spoolss_6b r;
17864 NTSTATUS status;
17865
17866 /* In parameters */
17867
17868 if (DEBUGLEVEL >= 10) {
17869 NDR_PRINT_IN_DEBUG(spoolss_6b, &r);
17870 }
17871
17872 status = cli->dispatch(cli,
17873 mem_ctx,
17874 &ndr_table_spoolss,
17875 NDR_SPOOLSS_6B,
17876 &r);
17877
17878 if (!NT_STATUS_IS_OK(status)) {
17879 return status;
17880 }
17881
17882 if (DEBUGLEVEL >= 10) {
17883 NDR_PRINT_OUT_DEBUG(spoolss_6b, &r);
17884 }
17885
17886 if (NT_STATUS_IS_ERR(status)) {
17887 return status;
17888 }
17889
17890 /* Return variables */
17891
17892 /* Return result */
17893 if (werror) {
17894 *werror = r.out.result;
17895 }
17896
17897 return werror_to_ntstatus(r.out.result);
17898 }
17899
17900 struct rpccli_spoolss_6c_state {
17901 struct spoolss_6c orig;
17902 struct spoolss_6c tmp;
17903 TALLOC_CTX *out_mem_ctx;
17904 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
17905 };
17906
17907 static void rpccli_spoolss_6c_done(struct tevent_req *subreq);
17908
17909 struct tevent_req *rpccli_spoolss_6c_send(TALLOC_CTX *mem_ctx,
17910 struct tevent_context *ev,
17911 struct rpc_pipe_client *cli)
17912 {
17913 struct tevent_req *req;
17914 struct rpccli_spoolss_6c_state *state;
17915 struct tevent_req *subreq;
17916
17917 req = tevent_req_create(mem_ctx, &state,
17918 struct rpccli_spoolss_6c_state);
17919 if (req == NULL) {
17920 return NULL;
17921 }
17922 state->out_mem_ctx = NULL;
17923 state->dispatch_recv = cli->dispatch_recv;
17924
17925 /* In parameters */
17926
17927 /* Out parameters */
17928
17929 /* Result */
17930 ZERO_STRUCT(state->orig.out.result);
17931
17932 if (DEBUGLEVEL >= 10) {
17933 NDR_PRINT_IN_DEBUG(spoolss_6c, &state->orig);
17934 }
17935
17936 /* make a temporary copy, that we pass to the dispatch function */
17937 state->tmp = state->orig;
17938
17939 subreq = cli->dispatch_send(state, ev, cli,
17940 &ndr_table_spoolss,
17941 NDR_SPOOLSS_6C,
17942 &state->tmp);
17943 if (tevent_req_nomem(subreq, req)) {
17944 return tevent_req_post(req, ev);
17945 }
17946 tevent_req_set_callback(subreq, rpccli_spoolss_6c_done, req);
17947 return req;
17948 }
17949
17950 static void rpccli_spoolss_6c_done(struct tevent_req *subreq)
17951 {
17952 struct tevent_req *req = tevent_req_callback_data(
17953 subreq, struct tevent_req);
17954 struct rpccli_spoolss_6c_state *state = tevent_req_data(
17955 req, struct rpccli_spoolss_6c_state);
17956 NTSTATUS status;
17957 TALLOC_CTX *mem_ctx;
17958
17959 if (state->out_mem_ctx) {
17960 mem_ctx = state->out_mem_ctx;
17961 } else {
17962 mem_ctx = state;
17963 }
17964
17965 status = state->dispatch_recv(subreq, mem_ctx);
17966 TALLOC_FREE(subreq);
17967 if (!NT_STATUS_IS_OK(status)) {
17968 tevent_req_nterror(req, status);
17969 return;
17970 }
17971
17972 /* Copy out parameters */
17973
17974 /* Copy result */
17975 state->orig.out.result = state->tmp.out.result;
17976
17977 /* Reset temporary structure */
17978 ZERO_STRUCT(state->tmp);
17979
17980 if (DEBUGLEVEL >= 10) {
17981 NDR_PRINT_OUT_DEBUG(spoolss_6c, &state->orig);
17982 }
17983
17984 tevent_req_done(req);
17985 }
17986
17987 NTSTATUS rpccli_spoolss_6c_recv(struct tevent_req *req,
17988 TALLOC_CTX *mem_ctx,
17989 WERROR *result)
17990 {
17991 struct rpccli_spoolss_6c_state *state = tevent_req_data(
17992 req, struct rpccli_spoolss_6c_state);
17993 NTSTATUS status;
17994
17995 if (tevent_req_is_nterror(req, &status)) {
17996 tevent_req_received(req);
17997 return status;
17998 }
17999
18000 /* Steal possbile out parameters to the callers context */
18001 talloc_steal(mem_ctx, state->out_mem_ctx);
18002
18003 /* Return result */
18004 *result = state->orig.out.result;
18005
18006 tevent_req_received(req);
18007 return NT_STATUS_OK;
18008 }
18009
18010 NTSTATUS rpccli_spoolss_6c(struct rpc_pipe_client *cli,
18011 TALLOC_CTX *mem_ctx,
18012 WERROR *werror)
18013 {
18014 struct spoolss_6c r;
18015 NTSTATUS status;
18016
18017 /* In parameters */
18018
18019 if (DEBUGLEVEL >= 10) {
18020 NDR_PRINT_IN_DEBUG(spoolss_6c, &r);
18021 }
18022
18023 status = cli->dispatch(cli,
18024 mem_ctx,
18025 &ndr_table_spoolss,
18026 NDR_SPOOLSS_6C,
18027 &r);
18028
18029 if (!NT_STATUS_IS_OK(status)) {
18030 return status;
18031 }
18032
18033 if (DEBUGLEVEL >= 10) {
18034 NDR_PRINT_OUT_DEBUG(spoolss_6c, &r);
18035 }
18036
18037 if (NT_STATUS_IS_ERR(status)) {
18038 return status;
18039 }
18040
18041 /* Return variables */
18042
18043 /* Return result */
18044 if (werror) {
18045 *werror = r.out.result;
18046 }
18047
18048 return werror_to_ntstatus(r.out.result);
18049 }
18050
18051 struct rpccli_spoolss_6d_state {
18052 struct spoolss_6d orig;
18053 struct spoolss_6d tmp;
18054 TALLOC_CTX *out_mem_ctx;
18055 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
18056 };
18057
18058 static void rpccli_spoolss_6d_done(struct tevent_req *subreq);
18059
18060 struct tevent_req *rpccli_spoolss_6d_send(TALLOC_CTX *mem_ctx,
18061 struct tevent_context *ev,
18062 struct rpc_pipe_client *cli)
18063 {
18064 struct tevent_req *req;
18065 struct rpccli_spoolss_6d_state *state;
18066 struct tevent_req *subreq;
18067
18068 req = tevent_req_create(mem_ctx, &state,
18069 struct rpccli_spoolss_6d_state);
18070 if (req == NULL) {
18071 return NULL;
18072 }
18073 state->out_mem_ctx = NULL;
18074 state->dispatch_recv = cli->dispatch_recv;
18075
18076 /* In parameters */
18077
18078 /* Out parameters */
18079
18080 /* Result */
18081 ZERO_STRUCT(state->orig.out.result);
18082
18083 if (DEBUGLEVEL >= 10) {
18084 NDR_PRINT_IN_DEBUG(spoolss_6d, &state->orig);
18085 }
18086
18087 /* make a temporary copy, that we pass to the dispatch function */
18088 state->tmp = state->orig;
18089
18090 subreq = cli->dispatch_send(state, ev, cli,
18091 &ndr_table_spoolss,
18092 NDR_SPOOLSS_6D,
18093 &state->tmp);
18094 if (tevent_req_nomem(subreq, req)) {
18095 return tevent_req_post(req, ev);
18096 }
18097 tevent_req_set_callback(subreq, rpccli_spoolss_6d_done, req);
18098 return req;
18099 }
18100
18101 static void rpccli_spoolss_6d_done(struct tevent_req *subreq)
18102 {
18103 struct tevent_req *req = tevent_req_callback_data(
18104 subreq, struct tevent_req);
18105 struct rpccli_spoolss_6d_state *state = tevent_req_data(
18106 req, struct rpccli_spoolss_6d_state);
18107 NTSTATUS status;
18108 TALLOC_CTX *mem_ctx;
18109
18110 if (state->out_mem_ctx) {
18111 mem_ctx = state->out_mem_ctx;
18112 } else {
18113 mem_ctx = state;
18114 }
18115
18116 status = state->dispatch_recv(subreq, mem_ctx);
18117 TALLOC_FREE(subreq);
18118 if (!NT_STATUS_IS_OK(status)) {
18119 tevent_req_nterror(req, status);
18120 return;
18121 }
18122
18123 /* Copy out parameters */
18124
18125 /* Copy result */
18126 state->orig.out.result = state->tmp.out.result;
18127
18128 /* Reset temporary structure */
18129 ZERO_STRUCT(state->tmp);
18130
18131 if (DEBUGLEVEL >= 10) {
18132 NDR_PRINT_OUT_DEBUG(spoolss_6d, &state->orig);
18133 }
18134
18135 tevent_req_done(req);
18136 }
18137
18138 NTSTATUS rpccli_spoolss_6d_recv(struct tevent_req *req,
18139 TALLOC_CTX *mem_ctx,
18140 WERROR *result)
18141 {
18142 struct rpccli_spoolss_6d_state *state = tevent_req_data(
18143 req, struct rpccli_spoolss_6d_state);
18144 NTSTATUS status;
18145
18146 if (tevent_req_is_nterror(req, &status)) {
18147 tevent_req_received(req);
18148 return status;
18149 }
18150
18151 /* Steal possbile out parameters to the callers context */
18152 talloc_steal(mem_ctx, state->out_mem_ctx);
18153
18154 /* Return result */
18155 *result = state->orig.out.result;
18156
18157 tevent_req_received(req);
18158 return NT_STATUS_OK;
18159 }
18160
18161 NTSTATUS rpccli_spoolss_6d(struct rpc_pipe_client *cli,
18162 TALLOC_CTX *mem_ctx,
18163 WERROR *werror)
18164 {
18165 struct spoolss_6d r;
18166 NTSTATUS status;
18167
18168 /* In parameters */
18169
18170 if (DEBUGLEVEL >= 10) {
18171 NDR_PRINT_IN_DEBUG(spoolss_6d, &r);
18172 }
18173
18174 status = cli->dispatch(cli,
18175 mem_ctx,
18176 &ndr_table_spoolss,
18177 NDR_SPOOLSS_6D,
18178 &r);
18179
18180 if (!NT_STATUS_IS_OK(status)) {
18181 return status;
18182 }
18183
18184 if (DEBUGLEVEL >= 10) {
18185 NDR_PRINT_OUT_DEBUG(spoolss_6d, &r);
18186 }
18187
18188 if (NT_STATUS_IS_ERR(status)) {
18189 return status;
18190 }
18191
18192 /* Return variables */
18193
18194 /* Return result */
18195 if (werror) {
18196 *werror = r.out.result;
18197 }
18198
18199 return werror_to_ntstatus(r.out.result);
18200 }
18201
aatanasov's samba4 branch