?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pidl: fix handling of output arguments in s3 client stubs.
[Samba/bb.git] / librpc / gen_ndr / cli_spoolss.c
blobaba70f2d2daa52242a0dc44b970f4a81de30bd12
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 state->out_mem_ctx = talloc_named_const(state, 0,
58 "rpccli_spoolss_EnumPrinters_out_memory");
59 if (tevent_req_nomem(state->out_mem_ctx, req)) {
60 return tevent_req_post(req, ev);
61 }
62
63 /* make a temporary copy, that we pass to the dispatch function */
64 state->tmp = state->orig;
65
66 subreq = cli->dispatch_send(state, ev, cli,
67 &ndr_table_spoolss,
68 NDR_SPOOLSS_ENUMPRINTERS,
69 &state->tmp);
70 if (tevent_req_nomem(subreq, req)) {
71 return tevent_req_post(req, ev);
72 }
73 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinters_done, req);
74 return req;
75 }
76
77 static void rpccli_spoolss_EnumPrinters_done(struct tevent_req *subreq)
78 {
79 struct tevent_req *req = tevent_req_callback_data(
80 subreq, struct tevent_req);
81 struct rpccli_spoolss_EnumPrinters_state *state = tevent_req_data(
82 req, struct rpccli_spoolss_EnumPrinters_state);
83 NTSTATUS status;
84 TALLOC_CTX *mem_ctx;
85
86 if (state->out_mem_ctx) {
87 mem_ctx = state->out_mem_ctx;
88 } else {
89 mem_ctx = state;
90 }
91
92 status = state->dispatch_recv(subreq, mem_ctx);
93 TALLOC_FREE(subreq);
94 if (!NT_STATUS_IS_OK(status)) {
95 tevent_req_nterror(req, status);
96 return;
97 }
98
99 /* Copy out parameters */
100 *state->orig.out.count = *state->tmp.out.count;
101 *state->orig.out.info = *state->tmp.out.info;
102 *state->orig.out.needed = *state->tmp.out.needed;
103
104 /* Copy result */
105 state->orig.out.result = state->tmp.out.result;
106
107 /* Reset temporary structure */
108 ZERO_STRUCT(state->tmp);
109
110 tevent_req_done(req);
111 }
112
113 NTSTATUS rpccli_spoolss_EnumPrinters_recv(struct tevent_req *req,
114 TALLOC_CTX *mem_ctx,
115 WERROR *result)
116 {
117 struct rpccli_spoolss_EnumPrinters_state *state = tevent_req_data(
118 req, struct rpccli_spoolss_EnumPrinters_state);
119 NTSTATUS status;
120
121 if (tevent_req_is_nterror(req, &status)) {
122 tevent_req_received(req);
123 return status;
124 }
125
126 /* Steal possbile out parameters to the callers context */
127 talloc_steal(mem_ctx, state->out_mem_ctx);
128
129 /* Return result */
130 *result = state->orig.out.result;
131
132 tevent_req_received(req);
133 return NT_STATUS_OK;
134 }
135
136 NTSTATUS rpccli_spoolss_EnumPrinters(struct rpc_pipe_client *cli,
137 TALLOC_CTX *mem_ctx,
138 uint32_t flags /* [in] */,
139 const char *server /* [in] [unique,charset(UTF16)] */,
140 uint32_t level /* [in] */,
141 DATA_BLOB *buffer /* [in] [unique] */,
142 uint32_t offered /* [in] */,
143 uint32_t *count /* [out] [ref] */,
144 union spoolss_PrinterInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
145 uint32_t *needed /* [out] [ref] */,
146 WERROR *werror)
147 {
148 struct spoolss_EnumPrinters r;
149 NTSTATUS status;
150
151 /* In parameters */
152 r.in.flags = flags;
153 r.in.server = server;
154 r.in.level = level;
155 r.in.buffer = buffer;
156 r.in.offered = offered;
157
158 status = cli->dispatch(cli,
159 mem_ctx,
160 &ndr_table_spoolss,
161 NDR_SPOOLSS_ENUMPRINTERS,
162 &r);
163
164 if (!NT_STATUS_IS_OK(status)) {
165 return status;
166 }
167
168 if (NT_STATUS_IS_ERR(status)) {
169 return status;
170 }
171
172 /* Return variables */
173 *count = *r.out.count;
174 *info = *r.out.info;
175 *needed = *r.out.needed;
176
177 /* Return result */
178 if (werror) {
179 *werror = r.out.result;
180 }
181
182 return werror_to_ntstatus(r.out.result);
183 }
184
185 struct rpccli_spoolss_OpenPrinter_state {
186 struct spoolss_OpenPrinter orig;
187 struct spoolss_OpenPrinter tmp;
188 TALLOC_CTX *out_mem_ctx;
189 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
190 };
191
192 static void rpccli_spoolss_OpenPrinter_done(struct tevent_req *subreq);
193
194 struct tevent_req *rpccli_spoolss_OpenPrinter_send(TALLOC_CTX *mem_ctx,
195 struct tevent_context *ev,
196 struct rpc_pipe_client *cli,
197 const char *_printername /* [in] [unique,charset(UTF16)] */,
198 const char *_datatype /* [in] [unique,charset(UTF16)] */,
199 struct spoolss_DevmodeContainer _devmode_ctr /* [in] */,
200 uint32_t _access_mask /* [in] */,
201 struct policy_handle *_handle /* [out] [ref] */)
202 {
203 struct tevent_req *req;
204 struct rpccli_spoolss_OpenPrinter_state *state;
205 struct tevent_req *subreq;
206
207 req = tevent_req_create(mem_ctx, &state,
208 struct rpccli_spoolss_OpenPrinter_state);
209 if (req == NULL) {
210 return NULL;
211 }
212 state->out_mem_ctx = NULL;
213 state->dispatch_recv = cli->dispatch_recv;
214
215 /* In parameters */
216 state->orig.in.printername = _printername;
217 state->orig.in.datatype = _datatype;
218 state->orig.in.devmode_ctr = _devmode_ctr;
219 state->orig.in.access_mask = _access_mask;
220
221 /* Out parameters */
222 state->orig.out.handle = _handle;
223
224 /* Result */
225 ZERO_STRUCT(state->orig.out.result);
226
227 state->out_mem_ctx = talloc_named_const(state, 0,
228 "rpccli_spoolss_OpenPrinter_out_memory");
229 if (tevent_req_nomem(state->out_mem_ctx, req)) {
230 return tevent_req_post(req, ev);
231 }
232
233 /* make a temporary copy, that we pass to the dispatch function */
234 state->tmp = state->orig;
235
236 subreq = cli->dispatch_send(state, ev, cli,
237 &ndr_table_spoolss,
238 NDR_SPOOLSS_OPENPRINTER,
239 &state->tmp);
240 if (tevent_req_nomem(subreq, req)) {
241 return tevent_req_post(req, ev);
242 }
243 tevent_req_set_callback(subreq, rpccli_spoolss_OpenPrinter_done, req);
244 return req;
245 }
246
247 static void rpccli_spoolss_OpenPrinter_done(struct tevent_req *subreq)
248 {
249 struct tevent_req *req = tevent_req_callback_data(
250 subreq, struct tevent_req);
251 struct rpccli_spoolss_OpenPrinter_state *state = tevent_req_data(
252 req, struct rpccli_spoolss_OpenPrinter_state);
253 NTSTATUS status;
254 TALLOC_CTX *mem_ctx;
255
256 if (state->out_mem_ctx) {
257 mem_ctx = state->out_mem_ctx;
258 } else {
259 mem_ctx = state;
260 }
261
262 status = state->dispatch_recv(subreq, mem_ctx);
263 TALLOC_FREE(subreq);
264 if (!NT_STATUS_IS_OK(status)) {
265 tevent_req_nterror(req, status);
266 return;
267 }
268
269 /* Copy out parameters */
270 *state->orig.out.handle = *state->tmp.out.handle;
271
272 /* Copy result */
273 state->orig.out.result = state->tmp.out.result;
274
275 /* Reset temporary structure */
276 ZERO_STRUCT(state->tmp);
277
278 tevent_req_done(req);
279 }
280
281 NTSTATUS rpccli_spoolss_OpenPrinter_recv(struct tevent_req *req,
282 TALLOC_CTX *mem_ctx,
283 WERROR *result)
284 {
285 struct rpccli_spoolss_OpenPrinter_state *state = tevent_req_data(
286 req, struct rpccli_spoolss_OpenPrinter_state);
287 NTSTATUS status;
288
289 if (tevent_req_is_nterror(req, &status)) {
290 tevent_req_received(req);
291 return status;
292 }
293
294 /* Steal possbile out parameters to the callers context */
295 talloc_steal(mem_ctx, state->out_mem_ctx);
296
297 /* Return result */
298 *result = state->orig.out.result;
299
300 tevent_req_received(req);
301 return NT_STATUS_OK;
302 }
303
304 NTSTATUS rpccli_spoolss_OpenPrinter(struct rpc_pipe_client *cli,
305 TALLOC_CTX *mem_ctx,
306 const char *printername /* [in] [unique,charset(UTF16)] */,
307 const char *datatype /* [in] [unique,charset(UTF16)] */,
308 struct spoolss_DevmodeContainer devmode_ctr /* [in] */,
309 uint32_t access_mask /* [in] */,
310 struct policy_handle *handle /* [out] [ref] */,
311 WERROR *werror)
312 {
313 struct spoolss_OpenPrinter r;
314 NTSTATUS status;
315
316 /* In parameters */
317 r.in.printername = printername;
318 r.in.datatype = datatype;
319 r.in.devmode_ctr = devmode_ctr;
320 r.in.access_mask = access_mask;
321
322 status = cli->dispatch(cli,
323 mem_ctx,
324 &ndr_table_spoolss,
325 NDR_SPOOLSS_OPENPRINTER,
326 &r);
327
328 if (!NT_STATUS_IS_OK(status)) {
329 return status;
330 }
331
332 if (NT_STATUS_IS_ERR(status)) {
333 return status;
334 }
335
336 /* Return variables */
337 *handle = *r.out.handle;
338
339 /* Return result */
340 if (werror) {
341 *werror = r.out.result;
342 }
343
344 return werror_to_ntstatus(r.out.result);
345 }
346
347 struct rpccli_spoolss_SetJob_state {
348 struct spoolss_SetJob orig;
349 struct spoolss_SetJob tmp;
350 TALLOC_CTX *out_mem_ctx;
351 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
352 };
353
354 static void rpccli_spoolss_SetJob_done(struct tevent_req *subreq);
355
356 struct tevent_req *rpccli_spoolss_SetJob_send(TALLOC_CTX *mem_ctx,
357 struct tevent_context *ev,
358 struct rpc_pipe_client *cli,
359 struct policy_handle *_handle /* [in] [ref] */,
360 uint32_t _job_id /* [in] */,
361 struct spoolss_JobInfoContainer *_ctr /* [in] [unique] */,
362 enum spoolss_JobControl _command /* [in] */)
363 {
364 struct tevent_req *req;
365 struct rpccli_spoolss_SetJob_state *state;
366 struct tevent_req *subreq;
367
368 req = tevent_req_create(mem_ctx, &state,
369 struct rpccli_spoolss_SetJob_state);
370 if (req == NULL) {
371 return NULL;
372 }
373 state->out_mem_ctx = NULL;
374 state->dispatch_recv = cli->dispatch_recv;
375
376 /* In parameters */
377 state->orig.in.handle = _handle;
378 state->orig.in.job_id = _job_id;
379 state->orig.in.ctr = _ctr;
380 state->orig.in.command = _command;
381
382 /* Out parameters */
383
384 /* Result */
385 ZERO_STRUCT(state->orig.out.result);
386
387 /* make a temporary copy, that we pass to the dispatch function */
388 state->tmp = state->orig;
389
390 subreq = cli->dispatch_send(state, ev, cli,
391 &ndr_table_spoolss,
392 NDR_SPOOLSS_SETJOB,
393 &state->tmp);
394 if (tevent_req_nomem(subreq, req)) {
395 return tevent_req_post(req, ev);
396 }
397 tevent_req_set_callback(subreq, rpccli_spoolss_SetJob_done, req);
398 return req;
399 }
400
401 static void rpccli_spoolss_SetJob_done(struct tevent_req *subreq)
402 {
403 struct tevent_req *req = tevent_req_callback_data(
404 subreq, struct tevent_req);
405 struct rpccli_spoolss_SetJob_state *state = tevent_req_data(
406 req, struct rpccli_spoolss_SetJob_state);
407 NTSTATUS status;
408 TALLOC_CTX *mem_ctx;
409
410 if (state->out_mem_ctx) {
411 mem_ctx = state->out_mem_ctx;
412 } else {
413 mem_ctx = state;
414 }
415
416 status = state->dispatch_recv(subreq, mem_ctx);
417 TALLOC_FREE(subreq);
418 if (!NT_STATUS_IS_OK(status)) {
419 tevent_req_nterror(req, status);
420 return;
421 }
422
423 /* Copy out parameters */
424
425 /* Copy result */
426 state->orig.out.result = state->tmp.out.result;
427
428 /* Reset temporary structure */
429 ZERO_STRUCT(state->tmp);
430
431 tevent_req_done(req);
432 }
433
434 NTSTATUS rpccli_spoolss_SetJob_recv(struct tevent_req *req,
435 TALLOC_CTX *mem_ctx,
436 WERROR *result)
437 {
438 struct rpccli_spoolss_SetJob_state *state = tevent_req_data(
439 req, struct rpccli_spoolss_SetJob_state);
440 NTSTATUS status;
441
442 if (tevent_req_is_nterror(req, &status)) {
443 tevent_req_received(req);
444 return status;
445 }
446
447 /* Steal possbile out parameters to the callers context */
448 talloc_steal(mem_ctx, state->out_mem_ctx);
449
450 /* Return result */
451 *result = state->orig.out.result;
452
453 tevent_req_received(req);
454 return NT_STATUS_OK;
455 }
456
457 NTSTATUS rpccli_spoolss_SetJob(struct rpc_pipe_client *cli,
458 TALLOC_CTX *mem_ctx,
459 struct policy_handle *handle /* [in] [ref] */,
460 uint32_t job_id /* [in] */,
461 struct spoolss_JobInfoContainer *ctr /* [in] [unique] */,
462 enum spoolss_JobControl command /* [in] */,
463 WERROR *werror)
464 {
465 struct spoolss_SetJob r;
466 NTSTATUS status;
467
468 /* In parameters */
469 r.in.handle = handle;
470 r.in.job_id = job_id;
471 r.in.ctr = ctr;
472 r.in.command = command;
473
474 status = cli->dispatch(cli,
475 mem_ctx,
476 &ndr_table_spoolss,
477 NDR_SPOOLSS_SETJOB,
478 &r);
479
480 if (!NT_STATUS_IS_OK(status)) {
481 return status;
482 }
483
484 if (NT_STATUS_IS_ERR(status)) {
485 return status;
486 }
487
488 /* Return variables */
489
490 /* Return result */
491 if (werror) {
492 *werror = r.out.result;
493 }
494
495 return werror_to_ntstatus(r.out.result);
496 }
497
498 struct rpccli_spoolss_GetJob_state {
499 struct spoolss_GetJob orig;
500 struct spoolss_GetJob tmp;
501 TALLOC_CTX *out_mem_ctx;
502 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
503 };
504
505 static void rpccli_spoolss_GetJob_done(struct tevent_req *subreq);
506
507 struct tevent_req *rpccli_spoolss_GetJob_send(TALLOC_CTX *mem_ctx,
508 struct tevent_context *ev,
509 struct rpc_pipe_client *cli,
510 struct policy_handle *_handle /* [in] [ref] */,
511 uint32_t _job_id /* [in] */,
512 uint32_t _level /* [in] */,
513 DATA_BLOB *_buffer /* [in] [unique] */,
514 uint32_t _offered /* [in] */,
515 union spoolss_JobInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
516 uint32_t *_needed /* [out] [ref] */)
517 {
518 struct tevent_req *req;
519 struct rpccli_spoolss_GetJob_state *state;
520 struct tevent_req *subreq;
521
522 req = tevent_req_create(mem_ctx, &state,
523 struct rpccli_spoolss_GetJob_state);
524 if (req == NULL) {
525 return NULL;
526 }
527 state->out_mem_ctx = NULL;
528 state->dispatch_recv = cli->dispatch_recv;
529
530 /* In parameters */
531 state->orig.in.handle = _handle;
532 state->orig.in.job_id = _job_id;
533 state->orig.in.level = _level;
534 state->orig.in.buffer = _buffer;
535 state->orig.in.offered = _offered;
536
537 /* Out parameters */
538 state->orig.out.info = _info;
539 state->orig.out.needed = _needed;
540
541 /* Result */
542 ZERO_STRUCT(state->orig.out.result);
543
544 state->out_mem_ctx = talloc_named_const(state, 0,
545 "rpccli_spoolss_GetJob_out_memory");
546 if (tevent_req_nomem(state->out_mem_ctx, req)) {
547 return tevent_req_post(req, ev);
548 }
549
550 /* make a temporary copy, that we pass to the dispatch function */
551 state->tmp = state->orig;
552
553 subreq = cli->dispatch_send(state, ev, cli,
554 &ndr_table_spoolss,
555 NDR_SPOOLSS_GETJOB,
556 &state->tmp);
557 if (tevent_req_nomem(subreq, req)) {
558 return tevent_req_post(req, ev);
559 }
560 tevent_req_set_callback(subreq, rpccli_spoolss_GetJob_done, req);
561 return req;
562 }
563
564 static void rpccli_spoolss_GetJob_done(struct tevent_req *subreq)
565 {
566 struct tevent_req *req = tevent_req_callback_data(
567 subreq, struct tevent_req);
568 struct rpccli_spoolss_GetJob_state *state = tevent_req_data(
569 req, struct rpccli_spoolss_GetJob_state);
570 NTSTATUS status;
571 TALLOC_CTX *mem_ctx;
572
573 if (state->out_mem_ctx) {
574 mem_ctx = state->out_mem_ctx;
575 } else {
576 mem_ctx = state;
577 }
578
579 status = state->dispatch_recv(subreq, mem_ctx);
580 TALLOC_FREE(subreq);
581 if (!NT_STATUS_IS_OK(status)) {
582 tevent_req_nterror(req, status);
583 return;
584 }
585
586 /* Copy out parameters */
587 if (state->orig.out.info && state->tmp.out.info) {
588 *state->orig.out.info = *state->tmp.out.info;
589 }
590 *state->orig.out.needed = *state->tmp.out.needed;
591
592 /* Copy result */
593 state->orig.out.result = state->tmp.out.result;
594
595 /* Reset temporary structure */
596 ZERO_STRUCT(state->tmp);
597
598 tevent_req_done(req);
599 }
600
601 NTSTATUS rpccli_spoolss_GetJob_recv(struct tevent_req *req,
602 TALLOC_CTX *mem_ctx,
603 WERROR *result)
604 {
605 struct rpccli_spoolss_GetJob_state *state = tevent_req_data(
606 req, struct rpccli_spoolss_GetJob_state);
607 NTSTATUS status;
608
609 if (tevent_req_is_nterror(req, &status)) {
610 tevent_req_received(req);
611 return status;
612 }
613
614 /* Steal possbile out parameters to the callers context */
615 talloc_steal(mem_ctx, state->out_mem_ctx);
616
617 /* Return result */
618 *result = state->orig.out.result;
619
620 tevent_req_received(req);
621 return NT_STATUS_OK;
622 }
623
624 NTSTATUS rpccli_spoolss_GetJob(struct rpc_pipe_client *cli,
625 TALLOC_CTX *mem_ctx,
626 struct policy_handle *handle /* [in] [ref] */,
627 uint32_t job_id /* [in] */,
628 uint32_t level /* [in] */,
629 DATA_BLOB *buffer /* [in] [unique] */,
630 uint32_t offered /* [in] */,
631 union spoolss_JobInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
632 uint32_t *needed /* [out] [ref] */,
633 WERROR *werror)
634 {
635 struct spoolss_GetJob r;
636 NTSTATUS status;
637
638 /* In parameters */
639 r.in.handle = handle;
640 r.in.job_id = job_id;
641 r.in.level = level;
642 r.in.buffer = buffer;
643 r.in.offered = offered;
644
645 status = cli->dispatch(cli,
646 mem_ctx,
647 &ndr_table_spoolss,
648 NDR_SPOOLSS_GETJOB,
649 &r);
650
651 if (!NT_STATUS_IS_OK(status)) {
652 return status;
653 }
654
655 if (NT_STATUS_IS_ERR(status)) {
656 return status;
657 }
658
659 /* Return variables */
660 if (info && r.out.info) {
661 *info = *r.out.info;
662 }
663 *needed = *r.out.needed;
664
665 /* Return result */
666 if (werror) {
667 *werror = r.out.result;
668 }
669
670 return werror_to_ntstatus(r.out.result);
671 }
672
673 struct rpccli_spoolss_EnumJobs_state {
674 struct spoolss_EnumJobs orig;
675 struct spoolss_EnumJobs tmp;
676 TALLOC_CTX *out_mem_ctx;
677 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
678 };
679
680 static void rpccli_spoolss_EnumJobs_done(struct tevent_req *subreq);
681
682 struct tevent_req *rpccli_spoolss_EnumJobs_send(TALLOC_CTX *mem_ctx,
683 struct tevent_context *ev,
684 struct rpc_pipe_client *cli,
685 struct policy_handle *_handle /* [in] [ref] */,
686 uint32_t _firstjob /* [in] */,
687 uint32_t _numjobs /* [in] */,
688 uint32_t _level /* [in] */,
689 DATA_BLOB *_buffer /* [in] [unique] */,
690 uint32_t _offered /* [in] */,
691 uint32_t *_count /* [out] [ref] */,
692 union spoolss_JobInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
693 uint32_t *_needed /* [out] [ref] */)
694 {
695 struct tevent_req *req;
696 struct rpccli_spoolss_EnumJobs_state *state;
697 struct tevent_req *subreq;
698
699 req = tevent_req_create(mem_ctx, &state,
700 struct rpccli_spoolss_EnumJobs_state);
701 if (req == NULL) {
702 return NULL;
703 }
704 state->out_mem_ctx = NULL;
705 state->dispatch_recv = cli->dispatch_recv;
706
707 /* In parameters */
708 state->orig.in.handle = _handle;
709 state->orig.in.firstjob = _firstjob;
710 state->orig.in.numjobs = _numjobs;
711 state->orig.in.level = _level;
712 state->orig.in.buffer = _buffer;
713 state->orig.in.offered = _offered;
714
715 /* Out parameters */
716 state->orig.out.count = _count;
717 state->orig.out.info = _info;
718 state->orig.out.needed = _needed;
719
720 /* Result */
721 ZERO_STRUCT(state->orig.out.result);
722
723 state->out_mem_ctx = talloc_named_const(state, 0,
724 "rpccli_spoolss_EnumJobs_out_memory");
725 if (tevent_req_nomem(state->out_mem_ctx, req)) {
726 return tevent_req_post(req, ev);
727 }
728
729 /* make a temporary copy, that we pass to the dispatch function */
730 state->tmp = state->orig;
731
732 subreq = cli->dispatch_send(state, ev, cli,
733 &ndr_table_spoolss,
734 NDR_SPOOLSS_ENUMJOBS,
735 &state->tmp);
736 if (tevent_req_nomem(subreq, req)) {
737 return tevent_req_post(req, ev);
738 }
739 tevent_req_set_callback(subreq, rpccli_spoolss_EnumJobs_done, req);
740 return req;
741 }
742
743 static void rpccli_spoolss_EnumJobs_done(struct tevent_req *subreq)
744 {
745 struct tevent_req *req = tevent_req_callback_data(
746 subreq, struct tevent_req);
747 struct rpccli_spoolss_EnumJobs_state *state = tevent_req_data(
748 req, struct rpccli_spoolss_EnumJobs_state);
749 NTSTATUS status;
750 TALLOC_CTX *mem_ctx;
751
752 if (state->out_mem_ctx) {
753 mem_ctx = state->out_mem_ctx;
754 } else {
755 mem_ctx = state;
756 }
757
758 status = state->dispatch_recv(subreq, mem_ctx);
759 TALLOC_FREE(subreq);
760 if (!NT_STATUS_IS_OK(status)) {
761 tevent_req_nterror(req, status);
762 return;
763 }
764
765 /* Copy out parameters */
766 *state->orig.out.count = *state->tmp.out.count;
767 *state->orig.out.info = *state->tmp.out.info;
768 *state->orig.out.needed = *state->tmp.out.needed;
769
770 /* Copy result */
771 state->orig.out.result = state->tmp.out.result;
772
773 /* Reset temporary structure */
774 ZERO_STRUCT(state->tmp);
775
776 tevent_req_done(req);
777 }
778
779 NTSTATUS rpccli_spoolss_EnumJobs_recv(struct tevent_req *req,
780 TALLOC_CTX *mem_ctx,
781 WERROR *result)
782 {
783 struct rpccli_spoolss_EnumJobs_state *state = tevent_req_data(
784 req, struct rpccli_spoolss_EnumJobs_state);
785 NTSTATUS status;
786
787 if (tevent_req_is_nterror(req, &status)) {
788 tevent_req_received(req);
789 return status;
790 }
791
792 /* Steal possbile out parameters to the callers context */
793 talloc_steal(mem_ctx, state->out_mem_ctx);
794
795 /* Return result */
796 *result = state->orig.out.result;
797
798 tevent_req_received(req);
799 return NT_STATUS_OK;
800 }
801
802 NTSTATUS rpccli_spoolss_EnumJobs(struct rpc_pipe_client *cli,
803 TALLOC_CTX *mem_ctx,
804 struct policy_handle *handle /* [in] [ref] */,
805 uint32_t firstjob /* [in] */,
806 uint32_t numjobs /* [in] */,
807 uint32_t level /* [in] */,
808 DATA_BLOB *buffer /* [in] [unique] */,
809 uint32_t offered /* [in] */,
810 uint32_t *count /* [out] [ref] */,
811 union spoolss_JobInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
812 uint32_t *needed /* [out] [ref] */,
813 WERROR *werror)
814 {
815 struct spoolss_EnumJobs r;
816 NTSTATUS status;
817
818 /* In parameters */
819 r.in.handle = handle;
820 r.in.firstjob = firstjob;
821 r.in.numjobs = numjobs;
822 r.in.level = level;
823 r.in.buffer = buffer;
824 r.in.offered = offered;
825
826 status = cli->dispatch(cli,
827 mem_ctx,
828 &ndr_table_spoolss,
829 NDR_SPOOLSS_ENUMJOBS,
830 &r);
831
832 if (!NT_STATUS_IS_OK(status)) {
833 return status;
834 }
835
836 if (NT_STATUS_IS_ERR(status)) {
837 return status;
838 }
839
840 /* Return variables */
841 *count = *r.out.count;
842 *info = *r.out.info;
843 *needed = *r.out.needed;
844
845 /* Return result */
846 if (werror) {
847 *werror = r.out.result;
848 }
849
850 return werror_to_ntstatus(r.out.result);
851 }
852
853 struct rpccli_spoolss_AddPrinter_state {
854 struct spoolss_AddPrinter orig;
855 struct spoolss_AddPrinter tmp;
856 TALLOC_CTX *out_mem_ctx;
857 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
858 };
859
860 static void rpccli_spoolss_AddPrinter_done(struct tevent_req *subreq);
861
862 struct tevent_req *rpccli_spoolss_AddPrinter_send(TALLOC_CTX *mem_ctx,
863 struct tevent_context *ev,
864 struct rpc_pipe_client *cli,
865 const char *_server /* [in] [unique,charset(UTF16)] */,
866 struct spoolss_SetPrinterInfoCtr *_info_ctr /* [in] [ref] */,
867 struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */,
868 struct sec_desc_buf *_secdesc_ctr /* [in] [ref] */,
869 struct policy_handle *_handle /* [out] [ref] */)
870 {
871 struct tevent_req *req;
872 struct rpccli_spoolss_AddPrinter_state *state;
873 struct tevent_req *subreq;
874
875 req = tevent_req_create(mem_ctx, &state,
876 struct rpccli_spoolss_AddPrinter_state);
877 if (req == NULL) {
878 return NULL;
879 }
880 state->out_mem_ctx = NULL;
881 state->dispatch_recv = cli->dispatch_recv;
882
883 /* In parameters */
884 state->orig.in.server = _server;
885 state->orig.in.info_ctr = _info_ctr;
886 state->orig.in.devmode_ctr = _devmode_ctr;
887 state->orig.in.secdesc_ctr = _secdesc_ctr;
888
889 /* Out parameters */
890 state->orig.out.handle = _handle;
891
892 /* Result */
893 ZERO_STRUCT(state->orig.out.result);
894
895 state->out_mem_ctx = talloc_named_const(state, 0,
896 "rpccli_spoolss_AddPrinter_out_memory");
897 if (tevent_req_nomem(state->out_mem_ctx, req)) {
898 return tevent_req_post(req, ev);
899 }
900
901 /* make a temporary copy, that we pass to the dispatch function */
902 state->tmp = state->orig;
903
904 subreq = cli->dispatch_send(state, ev, cli,
905 &ndr_table_spoolss,
906 NDR_SPOOLSS_ADDPRINTER,
907 &state->tmp);
908 if (tevent_req_nomem(subreq, req)) {
909 return tevent_req_post(req, ev);
910 }
911 tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinter_done, req);
912 return req;
913 }
914
915 static void rpccli_spoolss_AddPrinter_done(struct tevent_req *subreq)
916 {
917 struct tevent_req *req = tevent_req_callback_data(
918 subreq, struct tevent_req);
919 struct rpccli_spoolss_AddPrinter_state *state = tevent_req_data(
920 req, struct rpccli_spoolss_AddPrinter_state);
921 NTSTATUS status;
922 TALLOC_CTX *mem_ctx;
923
924 if (state->out_mem_ctx) {
925 mem_ctx = state->out_mem_ctx;
926 } else {
927 mem_ctx = state;
928 }
929
930 status = state->dispatch_recv(subreq, mem_ctx);
931 TALLOC_FREE(subreq);
932 if (!NT_STATUS_IS_OK(status)) {
933 tevent_req_nterror(req, status);
934 return;
935 }
936
937 /* Copy out parameters */
938 *state->orig.out.handle = *state->tmp.out.handle;
939
940 /* Copy result */
941 state->orig.out.result = state->tmp.out.result;
942
943 /* Reset temporary structure */
944 ZERO_STRUCT(state->tmp);
945
946 tevent_req_done(req);
947 }
948
949 NTSTATUS rpccli_spoolss_AddPrinter_recv(struct tevent_req *req,
950 TALLOC_CTX *mem_ctx,
951 WERROR *result)
952 {
953 struct rpccli_spoolss_AddPrinter_state *state = tevent_req_data(
954 req, struct rpccli_spoolss_AddPrinter_state);
955 NTSTATUS status;
956
957 if (tevent_req_is_nterror(req, &status)) {
958 tevent_req_received(req);
959 return status;
960 }
961
962 /* Steal possbile out parameters to the callers context */
963 talloc_steal(mem_ctx, state->out_mem_ctx);
964
965 /* Return result */
966 *result = state->orig.out.result;
967
968 tevent_req_received(req);
969 return NT_STATUS_OK;
970 }
971
972 NTSTATUS rpccli_spoolss_AddPrinter(struct rpc_pipe_client *cli,
973 TALLOC_CTX *mem_ctx,
974 const char *server /* [in] [unique,charset(UTF16)] */,
975 struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */,
976 struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
977 struct sec_desc_buf *secdesc_ctr /* [in] [ref] */,
978 struct policy_handle *handle /* [out] [ref] */,
979 WERROR *werror)
980 {
981 struct spoolss_AddPrinter r;
982 NTSTATUS status;
983
984 /* In parameters */
985 r.in.server = server;
986 r.in.info_ctr = info_ctr;
987 r.in.devmode_ctr = devmode_ctr;
988 r.in.secdesc_ctr = secdesc_ctr;
989
990 status = cli->dispatch(cli,
991 mem_ctx,
992 &ndr_table_spoolss,
993 NDR_SPOOLSS_ADDPRINTER,
994 &r);
995
996 if (!NT_STATUS_IS_OK(status)) {
997 return status;
998 }
999
1000 if (NT_STATUS_IS_ERR(status)) {
1001 return status;
1002 }
1003
1004 /* Return variables */
1005 *handle = *r.out.handle;
1006
1007 /* Return result */
1008 if (werror) {
1009 *werror = r.out.result;
1010 }
1011
1012 return werror_to_ntstatus(r.out.result);
1013 }
1014
1015 struct rpccli_spoolss_DeletePrinter_state {
1016 struct spoolss_DeletePrinter orig;
1017 struct spoolss_DeletePrinter tmp;
1018 TALLOC_CTX *out_mem_ctx;
1019 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1020 };
1021
1022 static void rpccli_spoolss_DeletePrinter_done(struct tevent_req *subreq);
1023
1024 struct tevent_req *rpccli_spoolss_DeletePrinter_send(TALLOC_CTX *mem_ctx,
1025 struct tevent_context *ev,
1026 struct rpc_pipe_client *cli,
1027 struct policy_handle *_handle /* [in] [ref] */)
1028 {
1029 struct tevent_req *req;
1030 struct rpccli_spoolss_DeletePrinter_state *state;
1031 struct tevent_req *subreq;
1032
1033 req = tevent_req_create(mem_ctx, &state,
1034 struct rpccli_spoolss_DeletePrinter_state);
1035 if (req == NULL) {
1036 return NULL;
1037 }
1038 state->out_mem_ctx = NULL;
1039 state->dispatch_recv = cli->dispatch_recv;
1040
1041 /* In parameters */
1042 state->orig.in.handle = _handle;
1043
1044 /* Out parameters */
1045
1046 /* Result */
1047 ZERO_STRUCT(state->orig.out.result);
1048
1049 /* make a temporary copy, that we pass to the dispatch function */
1050 state->tmp = state->orig;
1051
1052 subreq = cli->dispatch_send(state, ev, cli,
1053 &ndr_table_spoolss,
1054 NDR_SPOOLSS_DELETEPRINTER,
1055 &state->tmp);
1056 if (tevent_req_nomem(subreq, req)) {
1057 return tevent_req_post(req, ev);
1058 }
1059 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinter_done, req);
1060 return req;
1061 }
1062
1063 static void rpccli_spoolss_DeletePrinter_done(struct tevent_req *subreq)
1064 {
1065 struct tevent_req *req = tevent_req_callback_data(
1066 subreq, struct tevent_req);
1067 struct rpccli_spoolss_DeletePrinter_state *state = tevent_req_data(
1068 req, struct rpccli_spoolss_DeletePrinter_state);
1069 NTSTATUS status;
1070 TALLOC_CTX *mem_ctx;
1071
1072 if (state->out_mem_ctx) {
1073 mem_ctx = state->out_mem_ctx;
1074 } else {
1075 mem_ctx = state;
1076 }
1077
1078 status = state->dispatch_recv(subreq, mem_ctx);
1079 TALLOC_FREE(subreq);
1080 if (!NT_STATUS_IS_OK(status)) {
1081 tevent_req_nterror(req, status);
1082 return;
1083 }
1084
1085 /* Copy out parameters */
1086
1087 /* Copy result */
1088 state->orig.out.result = state->tmp.out.result;
1089
1090 /* Reset temporary structure */
1091 ZERO_STRUCT(state->tmp);
1092
1093 tevent_req_done(req);
1094 }
1095
1096 NTSTATUS rpccli_spoolss_DeletePrinter_recv(struct tevent_req *req,
1097 TALLOC_CTX *mem_ctx,
1098 WERROR *result)
1099 {
1100 struct rpccli_spoolss_DeletePrinter_state *state = tevent_req_data(
1101 req, struct rpccli_spoolss_DeletePrinter_state);
1102 NTSTATUS status;
1103
1104 if (tevent_req_is_nterror(req, &status)) {
1105 tevent_req_received(req);
1106 return status;
1107 }
1108
1109 /* Steal possbile out parameters to the callers context */
1110 talloc_steal(mem_ctx, state->out_mem_ctx);
1111
1112 /* Return result */
1113 *result = state->orig.out.result;
1114
1115 tevent_req_received(req);
1116 return NT_STATUS_OK;
1117 }
1118
1119 NTSTATUS rpccli_spoolss_DeletePrinter(struct rpc_pipe_client *cli,
1120 TALLOC_CTX *mem_ctx,
1121 struct policy_handle *handle /* [in] [ref] */,
1122 WERROR *werror)
1123 {
1124 struct spoolss_DeletePrinter r;
1125 NTSTATUS status;
1126
1127 /* In parameters */
1128 r.in.handle = handle;
1129
1130 status = cli->dispatch(cli,
1131 mem_ctx,
1132 &ndr_table_spoolss,
1133 NDR_SPOOLSS_DELETEPRINTER,
1134 &r);
1135
1136 if (!NT_STATUS_IS_OK(status)) {
1137 return status;
1138 }
1139
1140 if (NT_STATUS_IS_ERR(status)) {
1141 return status;
1142 }
1143
1144 /* Return variables */
1145
1146 /* Return result */
1147 if (werror) {
1148 *werror = r.out.result;
1149 }
1150
1151 return werror_to_ntstatus(r.out.result);
1152 }
1153
1154 struct rpccli_spoolss_SetPrinter_state {
1155 struct spoolss_SetPrinter orig;
1156 struct spoolss_SetPrinter tmp;
1157 TALLOC_CTX *out_mem_ctx;
1158 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1159 };
1160
1161 static void rpccli_spoolss_SetPrinter_done(struct tevent_req *subreq);
1162
1163 struct tevent_req *rpccli_spoolss_SetPrinter_send(TALLOC_CTX *mem_ctx,
1164 struct tevent_context *ev,
1165 struct rpc_pipe_client *cli,
1166 struct policy_handle *_handle /* [in] [ref] */,
1167 struct spoolss_SetPrinterInfoCtr *_info_ctr /* [in] [ref] */,
1168 struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */,
1169 struct sec_desc_buf *_secdesc_ctr /* [in] [ref] */,
1170 enum spoolss_PrinterControl _command /* [in] */)
1171 {
1172 struct tevent_req *req;
1173 struct rpccli_spoolss_SetPrinter_state *state;
1174 struct tevent_req *subreq;
1175
1176 req = tevent_req_create(mem_ctx, &state,
1177 struct rpccli_spoolss_SetPrinter_state);
1178 if (req == NULL) {
1179 return NULL;
1180 }
1181 state->out_mem_ctx = NULL;
1182 state->dispatch_recv = cli->dispatch_recv;
1183
1184 /* In parameters */
1185 state->orig.in.handle = _handle;
1186 state->orig.in.info_ctr = _info_ctr;
1187 state->orig.in.devmode_ctr = _devmode_ctr;
1188 state->orig.in.secdesc_ctr = _secdesc_ctr;
1189 state->orig.in.command = _command;
1190
1191 /* Out parameters */
1192
1193 /* Result */
1194 ZERO_STRUCT(state->orig.out.result);
1195
1196 /* make a temporary copy, that we pass to the dispatch function */
1197 state->tmp = state->orig;
1198
1199 subreq = cli->dispatch_send(state, ev, cli,
1200 &ndr_table_spoolss,
1201 NDR_SPOOLSS_SETPRINTER,
1202 &state->tmp);
1203 if (tevent_req_nomem(subreq, req)) {
1204 return tevent_req_post(req, ev);
1205 }
1206 tevent_req_set_callback(subreq, rpccli_spoolss_SetPrinter_done, req);
1207 return req;
1208 }
1209
1210 static void rpccli_spoolss_SetPrinter_done(struct tevent_req *subreq)
1211 {
1212 struct tevent_req *req = tevent_req_callback_data(
1213 subreq, struct tevent_req);
1214 struct rpccli_spoolss_SetPrinter_state *state = tevent_req_data(
1215 req, struct rpccli_spoolss_SetPrinter_state);
1216 NTSTATUS status;
1217 TALLOC_CTX *mem_ctx;
1218
1219 if (state->out_mem_ctx) {
1220 mem_ctx = state->out_mem_ctx;
1221 } else {
1222 mem_ctx = state;
1223 }
1224
1225 status = state->dispatch_recv(subreq, mem_ctx);
1226 TALLOC_FREE(subreq);
1227 if (!NT_STATUS_IS_OK(status)) {
1228 tevent_req_nterror(req, status);
1229 return;
1230 }
1231
1232 /* Copy out parameters */
1233
1234 /* Copy result */
1235 state->orig.out.result = state->tmp.out.result;
1236
1237 /* Reset temporary structure */
1238 ZERO_STRUCT(state->tmp);
1239
1240 tevent_req_done(req);
1241 }
1242
1243 NTSTATUS rpccli_spoolss_SetPrinter_recv(struct tevent_req *req,
1244 TALLOC_CTX *mem_ctx,
1245 WERROR *result)
1246 {
1247 struct rpccli_spoolss_SetPrinter_state *state = tevent_req_data(
1248 req, struct rpccli_spoolss_SetPrinter_state);
1249 NTSTATUS status;
1250
1251 if (tevent_req_is_nterror(req, &status)) {
1252 tevent_req_received(req);
1253 return status;
1254 }
1255
1256 /* Steal possbile out parameters to the callers context */
1257 talloc_steal(mem_ctx, state->out_mem_ctx);
1258
1259 /* Return result */
1260 *result = state->orig.out.result;
1261
1262 tevent_req_received(req);
1263 return NT_STATUS_OK;
1264 }
1265
1266 NTSTATUS rpccli_spoolss_SetPrinter(struct rpc_pipe_client *cli,
1267 TALLOC_CTX *mem_ctx,
1268 struct policy_handle *handle /* [in] [ref] */,
1269 struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */,
1270 struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
1271 struct sec_desc_buf *secdesc_ctr /* [in] [ref] */,
1272 enum spoolss_PrinterControl command /* [in] */,
1273 WERROR *werror)
1274 {
1275 struct spoolss_SetPrinter r;
1276 NTSTATUS status;
1277
1278 /* In parameters */
1279 r.in.handle = handle;
1280 r.in.info_ctr = info_ctr;
1281 r.in.devmode_ctr = devmode_ctr;
1282 r.in.secdesc_ctr = secdesc_ctr;
1283 r.in.command = command;
1284
1285 status = cli->dispatch(cli,
1286 mem_ctx,
1287 &ndr_table_spoolss,
1288 NDR_SPOOLSS_SETPRINTER,
1289 &r);
1290
1291 if (!NT_STATUS_IS_OK(status)) {
1292 return status;
1293 }
1294
1295 if (NT_STATUS_IS_ERR(status)) {
1296 return status;
1297 }
1298
1299 /* Return variables */
1300
1301 /* Return result */
1302 if (werror) {
1303 *werror = r.out.result;
1304 }
1305
1306 return werror_to_ntstatus(r.out.result);
1307 }
1308
1309 struct rpccli_spoolss_GetPrinter_state {
1310 struct spoolss_GetPrinter orig;
1311 struct spoolss_GetPrinter tmp;
1312 TALLOC_CTX *out_mem_ctx;
1313 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1314 };
1315
1316 static void rpccli_spoolss_GetPrinter_done(struct tevent_req *subreq);
1317
1318 struct tevent_req *rpccli_spoolss_GetPrinter_send(TALLOC_CTX *mem_ctx,
1319 struct tevent_context *ev,
1320 struct rpc_pipe_client *cli,
1321 struct policy_handle *_handle /* [in] [ref] */,
1322 uint32_t _level /* [in] */,
1323 DATA_BLOB *_buffer /* [in] [unique] */,
1324 uint32_t _offered /* [in] */,
1325 union spoolss_PrinterInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1326 uint32_t *_needed /* [out] [ref] */)
1327 {
1328 struct tevent_req *req;
1329 struct rpccli_spoolss_GetPrinter_state *state;
1330 struct tevent_req *subreq;
1331
1332 req = tevent_req_create(mem_ctx, &state,
1333 struct rpccli_spoolss_GetPrinter_state);
1334 if (req == NULL) {
1335 return NULL;
1336 }
1337 state->out_mem_ctx = NULL;
1338 state->dispatch_recv = cli->dispatch_recv;
1339
1340 /* In parameters */
1341 state->orig.in.handle = _handle;
1342 state->orig.in.level = _level;
1343 state->orig.in.buffer = _buffer;
1344 state->orig.in.offered = _offered;
1345
1346 /* Out parameters */
1347 state->orig.out.info = _info;
1348 state->orig.out.needed = _needed;
1349
1350 /* Result */
1351 ZERO_STRUCT(state->orig.out.result);
1352
1353 state->out_mem_ctx = talloc_named_const(state, 0,
1354 "rpccli_spoolss_GetPrinter_out_memory");
1355 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1356 return tevent_req_post(req, ev);
1357 }
1358
1359 /* make a temporary copy, that we pass to the dispatch function */
1360 state->tmp = state->orig;
1361
1362 subreq = cli->dispatch_send(state, ev, cli,
1363 &ndr_table_spoolss,
1364 NDR_SPOOLSS_GETPRINTER,
1365 &state->tmp);
1366 if (tevent_req_nomem(subreq, req)) {
1367 return tevent_req_post(req, ev);
1368 }
1369 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinter_done, req);
1370 return req;
1371 }
1372
1373 static void rpccli_spoolss_GetPrinter_done(struct tevent_req *subreq)
1374 {
1375 struct tevent_req *req = tevent_req_callback_data(
1376 subreq, struct tevent_req);
1377 struct rpccli_spoolss_GetPrinter_state *state = tevent_req_data(
1378 req, struct rpccli_spoolss_GetPrinter_state);
1379 NTSTATUS status;
1380 TALLOC_CTX *mem_ctx;
1381
1382 if (state->out_mem_ctx) {
1383 mem_ctx = state->out_mem_ctx;
1384 } else {
1385 mem_ctx = state;
1386 }
1387
1388 status = state->dispatch_recv(subreq, mem_ctx);
1389 TALLOC_FREE(subreq);
1390 if (!NT_STATUS_IS_OK(status)) {
1391 tevent_req_nterror(req, status);
1392 return;
1393 }
1394
1395 /* Copy out parameters */
1396 if (state->orig.out.info && state->tmp.out.info) {
1397 *state->orig.out.info = *state->tmp.out.info;
1398 }
1399 *state->orig.out.needed = *state->tmp.out.needed;
1400
1401 /* Copy result */
1402 state->orig.out.result = state->tmp.out.result;
1403
1404 /* Reset temporary structure */
1405 ZERO_STRUCT(state->tmp);
1406
1407 tevent_req_done(req);
1408 }
1409
1410 NTSTATUS rpccli_spoolss_GetPrinter_recv(struct tevent_req *req,
1411 TALLOC_CTX *mem_ctx,
1412 WERROR *result)
1413 {
1414 struct rpccli_spoolss_GetPrinter_state *state = tevent_req_data(
1415 req, struct rpccli_spoolss_GetPrinter_state);
1416 NTSTATUS status;
1417
1418 if (tevent_req_is_nterror(req, &status)) {
1419 tevent_req_received(req);
1420 return status;
1421 }
1422
1423 /* Steal possbile out parameters to the callers context */
1424 talloc_steal(mem_ctx, state->out_mem_ctx);
1425
1426 /* Return result */
1427 *result = state->orig.out.result;
1428
1429 tevent_req_received(req);
1430 return NT_STATUS_OK;
1431 }
1432
1433 NTSTATUS rpccli_spoolss_GetPrinter(struct rpc_pipe_client *cli,
1434 TALLOC_CTX *mem_ctx,
1435 struct policy_handle *handle /* [in] [ref] */,
1436 uint32_t level /* [in] */,
1437 DATA_BLOB *buffer /* [in] [unique] */,
1438 uint32_t offered /* [in] */,
1439 union spoolss_PrinterInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1440 uint32_t *needed /* [out] [ref] */,
1441 WERROR *werror)
1442 {
1443 struct spoolss_GetPrinter r;
1444 NTSTATUS status;
1445
1446 /* In parameters */
1447 r.in.handle = handle;
1448 r.in.level = level;
1449 r.in.buffer = buffer;
1450 r.in.offered = offered;
1451
1452 status = cli->dispatch(cli,
1453 mem_ctx,
1454 &ndr_table_spoolss,
1455 NDR_SPOOLSS_GETPRINTER,
1456 &r);
1457
1458 if (!NT_STATUS_IS_OK(status)) {
1459 return status;
1460 }
1461
1462 if (NT_STATUS_IS_ERR(status)) {
1463 return status;
1464 }
1465
1466 /* Return variables */
1467 if (info && r.out.info) {
1468 *info = *r.out.info;
1469 }
1470 *needed = *r.out.needed;
1471
1472 /* Return result */
1473 if (werror) {
1474 *werror = r.out.result;
1475 }
1476
1477 return werror_to_ntstatus(r.out.result);
1478 }
1479
1480 struct rpccli_spoolss_AddPrinterDriver_state {
1481 struct spoolss_AddPrinterDriver orig;
1482 struct spoolss_AddPrinterDriver tmp;
1483 TALLOC_CTX *out_mem_ctx;
1484 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1485 };
1486
1487 static void rpccli_spoolss_AddPrinterDriver_done(struct tevent_req *subreq);
1488
1489 struct tevent_req *rpccli_spoolss_AddPrinterDriver_send(TALLOC_CTX *mem_ctx,
1490 struct tevent_context *ev,
1491 struct rpc_pipe_client *cli,
1492 const char *_servername /* [in] [unique,charset(UTF16)] */,
1493 struct spoolss_AddDriverInfoCtr *_info_ctr /* [in] [ref] */)
1494 {
1495 struct tevent_req *req;
1496 struct rpccli_spoolss_AddPrinterDriver_state *state;
1497 struct tevent_req *subreq;
1498
1499 req = tevent_req_create(mem_ctx, &state,
1500 struct rpccli_spoolss_AddPrinterDriver_state);
1501 if (req == NULL) {
1502 return NULL;
1503 }
1504 state->out_mem_ctx = NULL;
1505 state->dispatch_recv = cli->dispatch_recv;
1506
1507 /* In parameters */
1508 state->orig.in.servername = _servername;
1509 state->orig.in.info_ctr = _info_ctr;
1510
1511 /* Out parameters */
1512
1513 /* Result */
1514 ZERO_STRUCT(state->orig.out.result);
1515
1516 /* make a temporary copy, that we pass to the dispatch function */
1517 state->tmp = state->orig;
1518
1519 subreq = cli->dispatch_send(state, ev, cli,
1520 &ndr_table_spoolss,
1521 NDR_SPOOLSS_ADDPRINTERDRIVER,
1522 &state->tmp);
1523 if (tevent_req_nomem(subreq, req)) {
1524 return tevent_req_post(req, ev);
1525 }
1526 tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterDriver_done, req);
1527 return req;
1528 }
1529
1530 static void rpccli_spoolss_AddPrinterDriver_done(struct tevent_req *subreq)
1531 {
1532 struct tevent_req *req = tevent_req_callback_data(
1533 subreq, struct tevent_req);
1534 struct rpccli_spoolss_AddPrinterDriver_state *state = tevent_req_data(
1535 req, struct rpccli_spoolss_AddPrinterDriver_state);
1536 NTSTATUS status;
1537 TALLOC_CTX *mem_ctx;
1538
1539 if (state->out_mem_ctx) {
1540 mem_ctx = state->out_mem_ctx;
1541 } else {
1542 mem_ctx = state;
1543 }
1544
1545 status = state->dispatch_recv(subreq, mem_ctx);
1546 TALLOC_FREE(subreq);
1547 if (!NT_STATUS_IS_OK(status)) {
1548 tevent_req_nterror(req, status);
1549 return;
1550 }
1551
1552 /* Copy out parameters */
1553
1554 /* Copy result */
1555 state->orig.out.result = state->tmp.out.result;
1556
1557 /* Reset temporary structure */
1558 ZERO_STRUCT(state->tmp);
1559
1560 tevent_req_done(req);
1561 }
1562
1563 NTSTATUS rpccli_spoolss_AddPrinterDriver_recv(struct tevent_req *req,
1564 TALLOC_CTX *mem_ctx,
1565 WERROR *result)
1566 {
1567 struct rpccli_spoolss_AddPrinterDriver_state *state = tevent_req_data(
1568 req, struct rpccli_spoolss_AddPrinterDriver_state);
1569 NTSTATUS status;
1570
1571 if (tevent_req_is_nterror(req, &status)) {
1572 tevent_req_received(req);
1573 return status;
1574 }
1575
1576 /* Steal possbile out parameters to the callers context */
1577 talloc_steal(mem_ctx, state->out_mem_ctx);
1578
1579 /* Return result */
1580 *result = state->orig.out.result;
1581
1582 tevent_req_received(req);
1583 return NT_STATUS_OK;
1584 }
1585
1586 NTSTATUS rpccli_spoolss_AddPrinterDriver(struct rpc_pipe_client *cli,
1587 TALLOC_CTX *mem_ctx,
1588 const char *servername /* [in] [unique,charset(UTF16)] */,
1589 struct spoolss_AddDriverInfoCtr *info_ctr /* [in] [ref] */,
1590 WERROR *werror)
1591 {
1592 struct spoolss_AddPrinterDriver r;
1593 NTSTATUS status;
1594
1595 /* In parameters */
1596 r.in.servername = servername;
1597 r.in.info_ctr = info_ctr;
1598
1599 status = cli->dispatch(cli,
1600 mem_ctx,
1601 &ndr_table_spoolss,
1602 NDR_SPOOLSS_ADDPRINTERDRIVER,
1603 &r);
1604
1605 if (!NT_STATUS_IS_OK(status)) {
1606 return status;
1607 }
1608
1609 if (NT_STATUS_IS_ERR(status)) {
1610 return status;
1611 }
1612
1613 /* Return variables */
1614
1615 /* Return result */
1616 if (werror) {
1617 *werror = r.out.result;
1618 }
1619
1620 return werror_to_ntstatus(r.out.result);
1621 }
1622
1623 struct rpccli_spoolss_EnumPrinterDrivers_state {
1624 struct spoolss_EnumPrinterDrivers orig;
1625 struct spoolss_EnumPrinterDrivers tmp;
1626 TALLOC_CTX *out_mem_ctx;
1627 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1628 };
1629
1630 static void rpccli_spoolss_EnumPrinterDrivers_done(struct tevent_req *subreq);
1631
1632 struct tevent_req *rpccli_spoolss_EnumPrinterDrivers_send(TALLOC_CTX *mem_ctx,
1633 struct tevent_context *ev,
1634 struct rpc_pipe_client *cli,
1635 const char *_server /* [in] [unique,charset(UTF16)] */,
1636 const char *_environment /* [in] [unique,charset(UTF16)] */,
1637 uint32_t _level /* [in] */,
1638 DATA_BLOB *_buffer /* [in] [unique] */,
1639 uint32_t _offered /* [in] */,
1640 uint32_t *_count /* [out] [ref] */,
1641 union spoolss_DriverInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
1642 uint32_t *_needed /* [out] [ref] */)
1643 {
1644 struct tevent_req *req;
1645 struct rpccli_spoolss_EnumPrinterDrivers_state *state;
1646 struct tevent_req *subreq;
1647
1648 req = tevent_req_create(mem_ctx, &state,
1649 struct rpccli_spoolss_EnumPrinterDrivers_state);
1650 if (req == NULL) {
1651 return NULL;
1652 }
1653 state->out_mem_ctx = NULL;
1654 state->dispatch_recv = cli->dispatch_recv;
1655
1656 /* In parameters */
1657 state->orig.in.server = _server;
1658 state->orig.in.environment = _environment;
1659 state->orig.in.level = _level;
1660 state->orig.in.buffer = _buffer;
1661 state->orig.in.offered = _offered;
1662
1663 /* Out parameters */
1664 state->orig.out.count = _count;
1665 state->orig.out.info = _info;
1666 state->orig.out.needed = _needed;
1667
1668 /* Result */
1669 ZERO_STRUCT(state->orig.out.result);
1670
1671 state->out_mem_ctx = talloc_named_const(state, 0,
1672 "rpccli_spoolss_EnumPrinterDrivers_out_memory");
1673 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1674 return tevent_req_post(req, ev);
1675 }
1676
1677 /* make a temporary copy, that we pass to the dispatch function */
1678 state->tmp = state->orig;
1679
1680 subreq = cli->dispatch_send(state, ev, cli,
1681 &ndr_table_spoolss,
1682 NDR_SPOOLSS_ENUMPRINTERDRIVERS,
1683 &state->tmp);
1684 if (tevent_req_nomem(subreq, req)) {
1685 return tevent_req_post(req, ev);
1686 }
1687 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinterDrivers_done, req);
1688 return req;
1689 }
1690
1691 static void rpccli_spoolss_EnumPrinterDrivers_done(struct tevent_req *subreq)
1692 {
1693 struct tevent_req *req = tevent_req_callback_data(
1694 subreq, struct tevent_req);
1695 struct rpccli_spoolss_EnumPrinterDrivers_state *state = tevent_req_data(
1696 req, struct rpccli_spoolss_EnumPrinterDrivers_state);
1697 NTSTATUS status;
1698 TALLOC_CTX *mem_ctx;
1699
1700 if (state->out_mem_ctx) {
1701 mem_ctx = state->out_mem_ctx;
1702 } else {
1703 mem_ctx = state;
1704 }
1705
1706 status = state->dispatch_recv(subreq, mem_ctx);
1707 TALLOC_FREE(subreq);
1708 if (!NT_STATUS_IS_OK(status)) {
1709 tevent_req_nterror(req, status);
1710 return;
1711 }
1712
1713 /* Copy out parameters */
1714 *state->orig.out.count = *state->tmp.out.count;
1715 *state->orig.out.info = *state->tmp.out.info;
1716 *state->orig.out.needed = *state->tmp.out.needed;
1717
1718 /* Copy result */
1719 state->orig.out.result = state->tmp.out.result;
1720
1721 /* Reset temporary structure */
1722 ZERO_STRUCT(state->tmp);
1723
1724 tevent_req_done(req);
1725 }
1726
1727 NTSTATUS rpccli_spoolss_EnumPrinterDrivers_recv(struct tevent_req *req,
1728 TALLOC_CTX *mem_ctx,
1729 WERROR *result)
1730 {
1731 struct rpccli_spoolss_EnumPrinterDrivers_state *state = tevent_req_data(
1732 req, struct rpccli_spoolss_EnumPrinterDrivers_state);
1733 NTSTATUS status;
1734
1735 if (tevent_req_is_nterror(req, &status)) {
1736 tevent_req_received(req);
1737 return status;
1738 }
1739
1740 /* Steal possbile out parameters to the callers context */
1741 talloc_steal(mem_ctx, state->out_mem_ctx);
1742
1743 /* Return result */
1744 *result = state->orig.out.result;
1745
1746 tevent_req_received(req);
1747 return NT_STATUS_OK;
1748 }
1749
1750 NTSTATUS rpccli_spoolss_EnumPrinterDrivers(struct rpc_pipe_client *cli,
1751 TALLOC_CTX *mem_ctx,
1752 const char *server /* [in] [unique,charset(UTF16)] */,
1753 const char *environment /* [in] [unique,charset(UTF16)] */,
1754 uint32_t level /* [in] */,
1755 DATA_BLOB *buffer /* [in] [unique] */,
1756 uint32_t offered /* [in] */,
1757 uint32_t *count /* [out] [ref] */,
1758 union spoolss_DriverInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
1759 uint32_t *needed /* [out] [ref] */,
1760 WERROR *werror)
1761 {
1762 struct spoolss_EnumPrinterDrivers r;
1763 NTSTATUS status;
1764
1765 /* In parameters */
1766 r.in.server = server;
1767 r.in.environment = environment;
1768 r.in.level = level;
1769 r.in.buffer = buffer;
1770 r.in.offered = offered;
1771
1772 status = cli->dispatch(cli,
1773 mem_ctx,
1774 &ndr_table_spoolss,
1775 NDR_SPOOLSS_ENUMPRINTERDRIVERS,
1776 &r);
1777
1778 if (!NT_STATUS_IS_OK(status)) {
1779 return status;
1780 }
1781
1782 if (NT_STATUS_IS_ERR(status)) {
1783 return status;
1784 }
1785
1786 /* Return variables */
1787 *count = *r.out.count;
1788 *info = *r.out.info;
1789 *needed = *r.out.needed;
1790
1791 /* Return result */
1792 if (werror) {
1793 *werror = r.out.result;
1794 }
1795
1796 return werror_to_ntstatus(r.out.result);
1797 }
1798
1799 struct rpccli_spoolss_GetPrinterDriver_state {
1800 struct spoolss_GetPrinterDriver orig;
1801 struct spoolss_GetPrinterDriver tmp;
1802 TALLOC_CTX *out_mem_ctx;
1803 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1804 };
1805
1806 static void rpccli_spoolss_GetPrinterDriver_done(struct tevent_req *subreq);
1807
1808 struct tevent_req *rpccli_spoolss_GetPrinterDriver_send(TALLOC_CTX *mem_ctx,
1809 struct tevent_context *ev,
1810 struct rpc_pipe_client *cli,
1811 struct policy_handle *_handle /* [in] [ref] */,
1812 const char *_architecture /* [in] [unique,charset(UTF16)] */,
1813 uint32_t _level /* [in] */,
1814 DATA_BLOB *_buffer /* [in] [unique] */,
1815 uint32_t _offered /* [in] */,
1816 union spoolss_DriverInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1817 uint32_t *_needed /* [out] [ref] */)
1818 {
1819 struct tevent_req *req;
1820 struct rpccli_spoolss_GetPrinterDriver_state *state;
1821 struct tevent_req *subreq;
1822
1823 req = tevent_req_create(mem_ctx, &state,
1824 struct rpccli_spoolss_GetPrinterDriver_state);
1825 if (req == NULL) {
1826 return NULL;
1827 }
1828 state->out_mem_ctx = NULL;
1829 state->dispatch_recv = cli->dispatch_recv;
1830
1831 /* In parameters */
1832 state->orig.in.handle = _handle;
1833 state->orig.in.architecture = _architecture;
1834 state->orig.in.level = _level;
1835 state->orig.in.buffer = _buffer;
1836 state->orig.in.offered = _offered;
1837
1838 /* Out parameters */
1839 state->orig.out.info = _info;
1840 state->orig.out.needed = _needed;
1841
1842 /* Result */
1843 ZERO_STRUCT(state->orig.out.result);
1844
1845 state->out_mem_ctx = talloc_named_const(state, 0,
1846 "rpccli_spoolss_GetPrinterDriver_out_memory");
1847 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1848 return tevent_req_post(req, ev);
1849 }
1850
1851 /* make a temporary copy, that we pass to the dispatch function */
1852 state->tmp = state->orig;
1853
1854 subreq = cli->dispatch_send(state, ev, cli,
1855 &ndr_table_spoolss,
1856 NDR_SPOOLSS_GETPRINTERDRIVER,
1857 &state->tmp);
1858 if (tevent_req_nomem(subreq, req)) {
1859 return tevent_req_post(req, ev);
1860 }
1861 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriver_done, req);
1862 return req;
1863 }
1864
1865 static void rpccli_spoolss_GetPrinterDriver_done(struct tevent_req *subreq)
1866 {
1867 struct tevent_req *req = tevent_req_callback_data(
1868 subreq, struct tevent_req);
1869 struct rpccli_spoolss_GetPrinterDriver_state *state = tevent_req_data(
1870 req, struct rpccli_spoolss_GetPrinterDriver_state);
1871 NTSTATUS status;
1872 TALLOC_CTX *mem_ctx;
1873
1874 if (state->out_mem_ctx) {
1875 mem_ctx = state->out_mem_ctx;
1876 } else {
1877 mem_ctx = state;
1878 }
1879
1880 status = state->dispatch_recv(subreq, mem_ctx);
1881 TALLOC_FREE(subreq);
1882 if (!NT_STATUS_IS_OK(status)) {
1883 tevent_req_nterror(req, status);
1884 return;
1885 }
1886
1887 /* Copy out parameters */
1888 if (state->orig.out.info && state->tmp.out.info) {
1889 *state->orig.out.info = *state->tmp.out.info;
1890 }
1891 *state->orig.out.needed = *state->tmp.out.needed;
1892
1893 /* Copy result */
1894 state->orig.out.result = state->tmp.out.result;
1895
1896 /* Reset temporary structure */
1897 ZERO_STRUCT(state->tmp);
1898
1899 tevent_req_done(req);
1900 }
1901
1902 NTSTATUS rpccli_spoolss_GetPrinterDriver_recv(struct tevent_req *req,
1903 TALLOC_CTX *mem_ctx,
1904 WERROR *result)
1905 {
1906 struct rpccli_spoolss_GetPrinterDriver_state *state = tevent_req_data(
1907 req, struct rpccli_spoolss_GetPrinterDriver_state);
1908 NTSTATUS status;
1909
1910 if (tevent_req_is_nterror(req, &status)) {
1911 tevent_req_received(req);
1912 return status;
1913 }
1914
1915 /* Steal possbile out parameters to the callers context */
1916 talloc_steal(mem_ctx, state->out_mem_ctx);
1917
1918 /* Return result */
1919 *result = state->orig.out.result;
1920
1921 tevent_req_received(req);
1922 return NT_STATUS_OK;
1923 }
1924
1925 NTSTATUS rpccli_spoolss_GetPrinterDriver(struct rpc_pipe_client *cli,
1926 TALLOC_CTX *mem_ctx,
1927 struct policy_handle *handle /* [in] [ref] */,
1928 const char *architecture /* [in] [unique,charset(UTF16)] */,
1929 uint32_t level /* [in] */,
1930 DATA_BLOB *buffer /* [in] [unique] */,
1931 uint32_t offered /* [in] */,
1932 union spoolss_DriverInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1933 uint32_t *needed /* [out] [ref] */,
1934 WERROR *werror)
1935 {
1936 struct spoolss_GetPrinterDriver r;
1937 NTSTATUS status;
1938
1939 /* In parameters */
1940 r.in.handle = handle;
1941 r.in.architecture = architecture;
1942 r.in.level = level;
1943 r.in.buffer = buffer;
1944 r.in.offered = offered;
1945
1946 status = cli->dispatch(cli,
1947 mem_ctx,
1948 &ndr_table_spoolss,
1949 NDR_SPOOLSS_GETPRINTERDRIVER,
1950 &r);
1951
1952 if (!NT_STATUS_IS_OK(status)) {
1953 return status;
1954 }
1955
1956 if (NT_STATUS_IS_ERR(status)) {
1957 return status;
1958 }
1959
1960 /* Return variables */
1961 if (info && r.out.info) {
1962 *info = *r.out.info;
1963 }
1964 *needed = *r.out.needed;
1965
1966 /* Return result */
1967 if (werror) {
1968 *werror = r.out.result;
1969 }
1970
1971 return werror_to_ntstatus(r.out.result);
1972 }
1973
1974 struct rpccli_spoolss_GetPrinterDriverDirectory_state {
1975 struct spoolss_GetPrinterDriverDirectory orig;
1976 struct spoolss_GetPrinterDriverDirectory tmp;
1977 TALLOC_CTX *out_mem_ctx;
1978 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1979 };
1980
1981 static void rpccli_spoolss_GetPrinterDriverDirectory_done(struct tevent_req *subreq);
1982
1983 struct tevent_req *rpccli_spoolss_GetPrinterDriverDirectory_send(TALLOC_CTX *mem_ctx,
1984 struct tevent_context *ev,
1985 struct rpc_pipe_client *cli,
1986 const char *_server /* [in] [unique,charset(UTF16)] */,
1987 const char *_environment /* [in] [unique,charset(UTF16)] */,
1988 uint32_t _level /* [in] */,
1989 DATA_BLOB *_buffer /* [in] [unique] */,
1990 uint32_t _offered /* [in] */,
1991 union spoolss_DriverDirectoryInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1992 uint32_t *_needed /* [out] [ref] */)
1993 {
1994 struct tevent_req *req;
1995 struct rpccli_spoolss_GetPrinterDriverDirectory_state *state;
1996 struct tevent_req *subreq;
1997
1998 req = tevent_req_create(mem_ctx, &state,
1999 struct rpccli_spoolss_GetPrinterDriverDirectory_state);
2000 if (req == NULL) {
2001 return NULL;
2002 }
2003 state->out_mem_ctx = NULL;
2004 state->dispatch_recv = cli->dispatch_recv;
2005
2006 /* In parameters */
2007 state->orig.in.server = _server;
2008 state->orig.in.environment = _environment;
2009 state->orig.in.level = _level;
2010 state->orig.in.buffer = _buffer;
2011 state->orig.in.offered = _offered;
2012
2013 /* Out parameters */
2014 state->orig.out.info = _info;
2015 state->orig.out.needed = _needed;
2016
2017 /* Result */
2018 ZERO_STRUCT(state->orig.out.result);
2019
2020 state->out_mem_ctx = talloc_named_const(state, 0,
2021 "rpccli_spoolss_GetPrinterDriverDirectory_out_memory");
2022 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2023 return tevent_req_post(req, ev);
2024 }
2025
2026 /* make a temporary copy, that we pass to the dispatch function */
2027 state->tmp = state->orig;
2028
2029 subreq = cli->dispatch_send(state, ev, cli,
2030 &ndr_table_spoolss,
2031 NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY,
2032 &state->tmp);
2033 if (tevent_req_nomem(subreq, req)) {
2034 return tevent_req_post(req, ev);
2035 }
2036 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriverDirectory_done, req);
2037 return req;
2038 }
2039
2040 static void rpccli_spoolss_GetPrinterDriverDirectory_done(struct tevent_req *subreq)
2041 {
2042 struct tevent_req *req = tevent_req_callback_data(
2043 subreq, struct tevent_req);
2044 struct rpccli_spoolss_GetPrinterDriverDirectory_state *state = tevent_req_data(
2045 req, struct rpccli_spoolss_GetPrinterDriverDirectory_state);
2046 NTSTATUS status;
2047 TALLOC_CTX *mem_ctx;
2048
2049 if (state->out_mem_ctx) {
2050 mem_ctx = state->out_mem_ctx;
2051 } else {
2052 mem_ctx = state;
2053 }
2054
2055 status = state->dispatch_recv(subreq, mem_ctx);
2056 TALLOC_FREE(subreq);
2057 if (!NT_STATUS_IS_OK(status)) {
2058 tevent_req_nterror(req, status);
2059 return;
2060 }
2061
2062 /* Copy out parameters */
2063 if (state->orig.out.info && state->tmp.out.info) {
2064 *state->orig.out.info = *state->tmp.out.info;
2065 }
2066 *state->orig.out.needed = *state->tmp.out.needed;
2067
2068 /* Copy result */
2069 state->orig.out.result = state->tmp.out.result;
2070
2071 /* Reset temporary structure */
2072 ZERO_STRUCT(state->tmp);
2073
2074 tevent_req_done(req);
2075 }
2076
2077 NTSTATUS rpccli_spoolss_GetPrinterDriverDirectory_recv(struct tevent_req *req,
2078 TALLOC_CTX *mem_ctx,
2079 WERROR *result)
2080 {
2081 struct rpccli_spoolss_GetPrinterDriverDirectory_state *state = tevent_req_data(
2082 req, struct rpccli_spoolss_GetPrinterDriverDirectory_state);
2083 NTSTATUS status;
2084
2085 if (tevent_req_is_nterror(req, &status)) {
2086 tevent_req_received(req);
2087 return status;
2088 }
2089
2090 /* Steal possbile out parameters to the callers context */
2091 talloc_steal(mem_ctx, state->out_mem_ctx);
2092
2093 /* Return result */
2094 *result = state->orig.out.result;
2095
2096 tevent_req_received(req);
2097 return NT_STATUS_OK;
2098 }
2099
2100 NTSTATUS rpccli_spoolss_GetPrinterDriverDirectory(struct rpc_pipe_client *cli,
2101 TALLOC_CTX *mem_ctx,
2102 const char *server /* [in] [unique,charset(UTF16)] */,
2103 const char *environment /* [in] [unique,charset(UTF16)] */,
2104 uint32_t level /* [in] */,
2105 DATA_BLOB *buffer /* [in] [unique] */,
2106 uint32_t offered /* [in] */,
2107 union spoolss_DriverDirectoryInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
2108 uint32_t *needed /* [out] [ref] */,
2109 WERROR *werror)
2110 {
2111 struct spoolss_GetPrinterDriverDirectory r;
2112 NTSTATUS status;
2113
2114 /* In parameters */
2115 r.in.server = server;
2116 r.in.environment = environment;
2117 r.in.level = level;
2118 r.in.buffer = buffer;
2119 r.in.offered = offered;
2120
2121 status = cli->dispatch(cli,
2122 mem_ctx,
2123 &ndr_table_spoolss,
2124 NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY,
2125 &r);
2126
2127 if (!NT_STATUS_IS_OK(status)) {
2128 return status;
2129 }
2130
2131 if (NT_STATUS_IS_ERR(status)) {
2132 return status;
2133 }
2134
2135 /* Return variables */
2136 if (info && r.out.info) {
2137 *info = *r.out.info;
2138 }
2139 *needed = *r.out.needed;
2140
2141 /* Return result */
2142 if (werror) {
2143 *werror = r.out.result;
2144 }
2145
2146 return werror_to_ntstatus(r.out.result);
2147 }
2148
2149 struct rpccli_spoolss_DeletePrinterDriver_state {
2150 struct spoolss_DeletePrinterDriver orig;
2151 struct spoolss_DeletePrinterDriver tmp;
2152 TALLOC_CTX *out_mem_ctx;
2153 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2154 };
2155
2156 static void rpccli_spoolss_DeletePrinterDriver_done(struct tevent_req *subreq);
2157
2158 struct tevent_req *rpccli_spoolss_DeletePrinterDriver_send(TALLOC_CTX *mem_ctx,
2159 struct tevent_context *ev,
2160 struct rpc_pipe_client *cli,
2161 const char *_server /* [in] [unique,charset(UTF16)] */,
2162 const char *_architecture /* [in] [charset(UTF16)] */,
2163 const char *_driver /* [in] [charset(UTF16)] */)
2164 {
2165 struct tevent_req *req;
2166 struct rpccli_spoolss_DeletePrinterDriver_state *state;
2167 struct tevent_req *subreq;
2168
2169 req = tevent_req_create(mem_ctx, &state,
2170 struct rpccli_spoolss_DeletePrinterDriver_state);
2171 if (req == NULL) {
2172 return NULL;
2173 }
2174 state->out_mem_ctx = NULL;
2175 state->dispatch_recv = cli->dispatch_recv;
2176
2177 /* In parameters */
2178 state->orig.in.server = _server;
2179 state->orig.in.architecture = _architecture;
2180 state->orig.in.driver = _driver;
2181
2182 /* Out parameters */
2183
2184 /* Result */
2185 ZERO_STRUCT(state->orig.out.result);
2186
2187 /* make a temporary copy, that we pass to the dispatch function */
2188 state->tmp = state->orig;
2189
2190 subreq = cli->dispatch_send(state, ev, cli,
2191 &ndr_table_spoolss,
2192 NDR_SPOOLSS_DELETEPRINTERDRIVER,
2193 &state->tmp);
2194 if (tevent_req_nomem(subreq, req)) {
2195 return tevent_req_post(req, ev);
2196 }
2197 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterDriver_done, req);
2198 return req;
2199 }
2200
2201 static void rpccli_spoolss_DeletePrinterDriver_done(struct tevent_req *subreq)
2202 {
2203 struct tevent_req *req = tevent_req_callback_data(
2204 subreq, struct tevent_req);
2205 struct rpccli_spoolss_DeletePrinterDriver_state *state = tevent_req_data(
2206 req, struct rpccli_spoolss_DeletePrinterDriver_state);
2207 NTSTATUS status;
2208 TALLOC_CTX *mem_ctx;
2209
2210 if (state->out_mem_ctx) {
2211 mem_ctx = state->out_mem_ctx;
2212 } else {
2213 mem_ctx = state;
2214 }
2215
2216 status = state->dispatch_recv(subreq, mem_ctx);
2217 TALLOC_FREE(subreq);
2218 if (!NT_STATUS_IS_OK(status)) {
2219 tevent_req_nterror(req, status);
2220 return;
2221 }
2222
2223 /* Copy out parameters */
2224
2225 /* Copy result */
2226 state->orig.out.result = state->tmp.out.result;
2227
2228 /* Reset temporary structure */
2229 ZERO_STRUCT(state->tmp);
2230
2231 tevent_req_done(req);
2232 }
2233
2234 NTSTATUS rpccli_spoolss_DeletePrinterDriver_recv(struct tevent_req *req,
2235 TALLOC_CTX *mem_ctx,
2236 WERROR *result)
2237 {
2238 struct rpccli_spoolss_DeletePrinterDriver_state *state = tevent_req_data(
2239 req, struct rpccli_spoolss_DeletePrinterDriver_state);
2240 NTSTATUS status;
2241
2242 if (tevent_req_is_nterror(req, &status)) {
2243 tevent_req_received(req);
2244 return status;
2245 }
2246
2247 /* Steal possbile out parameters to the callers context */
2248 talloc_steal(mem_ctx, state->out_mem_ctx);
2249
2250 /* Return result */
2251 *result = state->orig.out.result;
2252
2253 tevent_req_received(req);
2254 return NT_STATUS_OK;
2255 }
2256
2257 NTSTATUS rpccli_spoolss_DeletePrinterDriver(struct rpc_pipe_client *cli,
2258 TALLOC_CTX *mem_ctx,
2259 const char *server /* [in] [unique,charset(UTF16)] */,
2260 const char *architecture /* [in] [charset(UTF16)] */,
2261 const char *driver /* [in] [charset(UTF16)] */,
2262 WERROR *werror)
2263 {
2264 struct spoolss_DeletePrinterDriver r;
2265 NTSTATUS status;
2266
2267 /* In parameters */
2268 r.in.server = server;
2269 r.in.architecture = architecture;
2270 r.in.driver = driver;
2271
2272 status = cli->dispatch(cli,
2273 mem_ctx,
2274 &ndr_table_spoolss,
2275 NDR_SPOOLSS_DELETEPRINTERDRIVER,
2276 &r);
2277
2278 if (!NT_STATUS_IS_OK(status)) {
2279 return status;
2280 }
2281
2282 if (NT_STATUS_IS_ERR(status)) {
2283 return status;
2284 }
2285
2286 /* Return variables */
2287
2288 /* Return result */
2289 if (werror) {
2290 *werror = r.out.result;
2291 }
2292
2293 return werror_to_ntstatus(r.out.result);
2294 }
2295
2296 struct rpccli_spoolss_AddPrintProcessor_state {
2297 struct spoolss_AddPrintProcessor orig;
2298 struct spoolss_AddPrintProcessor tmp;
2299 TALLOC_CTX *out_mem_ctx;
2300 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2301 };
2302
2303 static void rpccli_spoolss_AddPrintProcessor_done(struct tevent_req *subreq);
2304
2305 struct tevent_req *rpccli_spoolss_AddPrintProcessor_send(TALLOC_CTX *mem_ctx,
2306 struct tevent_context *ev,
2307 struct rpc_pipe_client *cli,
2308 const char *_server /* [in] [unique,charset(UTF16)] */,
2309 const char *_architecture /* [in] [charset(UTF16)] */,
2310 const char *_path_name /* [in] [charset(UTF16)] */,
2311 const char *_print_processor_name /* [in] [charset(UTF16)] */)
2312 {
2313 struct tevent_req *req;
2314 struct rpccli_spoolss_AddPrintProcessor_state *state;
2315 struct tevent_req *subreq;
2316
2317 req = tevent_req_create(mem_ctx, &state,
2318 struct rpccli_spoolss_AddPrintProcessor_state);
2319 if (req == NULL) {
2320 return NULL;
2321 }
2322 state->out_mem_ctx = NULL;
2323 state->dispatch_recv = cli->dispatch_recv;
2324
2325 /* In parameters */
2326 state->orig.in.server = _server;
2327 state->orig.in.architecture = _architecture;
2328 state->orig.in.path_name = _path_name;
2329 state->orig.in.print_processor_name = _print_processor_name;
2330
2331 /* Out parameters */
2332
2333 /* Result */
2334 ZERO_STRUCT(state->orig.out.result);
2335
2336 /* make a temporary copy, that we pass to the dispatch function */
2337 state->tmp = state->orig;
2338
2339 subreq = cli->dispatch_send(state, ev, cli,
2340 &ndr_table_spoolss,
2341 NDR_SPOOLSS_ADDPRINTPROCESSOR,
2342 &state->tmp);
2343 if (tevent_req_nomem(subreq, req)) {
2344 return tevent_req_post(req, ev);
2345 }
2346 tevent_req_set_callback(subreq, rpccli_spoolss_AddPrintProcessor_done, req);
2347 return req;
2348 }
2349
2350 static void rpccli_spoolss_AddPrintProcessor_done(struct tevent_req *subreq)
2351 {
2352 struct tevent_req *req = tevent_req_callback_data(
2353 subreq, struct tevent_req);
2354 struct rpccli_spoolss_AddPrintProcessor_state *state = tevent_req_data(
2355 req, struct rpccli_spoolss_AddPrintProcessor_state);
2356 NTSTATUS status;
2357 TALLOC_CTX *mem_ctx;
2358
2359 if (state->out_mem_ctx) {
2360 mem_ctx = state->out_mem_ctx;
2361 } else {
2362 mem_ctx = state;
2363 }
2364
2365 status = state->dispatch_recv(subreq, mem_ctx);
2366 TALLOC_FREE(subreq);
2367 if (!NT_STATUS_IS_OK(status)) {
2368 tevent_req_nterror(req, status);
2369 return;
2370 }
2371
2372 /* Copy out parameters */
2373
2374 /* Copy result */
2375 state->orig.out.result = state->tmp.out.result;
2376
2377 /* Reset temporary structure */
2378 ZERO_STRUCT(state->tmp);
2379
2380 tevent_req_done(req);
2381 }
2382
2383 NTSTATUS rpccli_spoolss_AddPrintProcessor_recv(struct tevent_req *req,
2384 TALLOC_CTX *mem_ctx,
2385 WERROR *result)
2386 {
2387 struct rpccli_spoolss_AddPrintProcessor_state *state = tevent_req_data(
2388 req, struct rpccli_spoolss_AddPrintProcessor_state);
2389 NTSTATUS status;
2390
2391 if (tevent_req_is_nterror(req, &status)) {
2392 tevent_req_received(req);
2393 return status;
2394 }
2395
2396 /* Steal possbile out parameters to the callers context */
2397 talloc_steal(mem_ctx, state->out_mem_ctx);
2398
2399 /* Return result */
2400 *result = state->orig.out.result;
2401
2402 tevent_req_received(req);
2403 return NT_STATUS_OK;
2404 }
2405
2406 NTSTATUS rpccli_spoolss_AddPrintProcessor(struct rpc_pipe_client *cli,
2407 TALLOC_CTX *mem_ctx,
2408 const char *server /* [in] [unique,charset(UTF16)] */,
2409 const char *architecture /* [in] [charset(UTF16)] */,
2410 const char *path_name /* [in] [charset(UTF16)] */,
2411 const char *print_processor_name /* [in] [charset(UTF16)] */,
2412 WERROR *werror)
2413 {
2414 struct spoolss_AddPrintProcessor r;
2415 NTSTATUS status;
2416
2417 /* In parameters */
2418 r.in.server = server;
2419 r.in.architecture = architecture;
2420 r.in.path_name = path_name;
2421 r.in.print_processor_name = print_processor_name;
2422
2423 status = cli->dispatch(cli,
2424 mem_ctx,
2425 &ndr_table_spoolss,
2426 NDR_SPOOLSS_ADDPRINTPROCESSOR,
2427 &r);
2428
2429 if (!NT_STATUS_IS_OK(status)) {
2430 return status;
2431 }
2432
2433 if (NT_STATUS_IS_ERR(status)) {
2434 return status;
2435 }
2436
2437 /* Return variables */
2438
2439 /* Return result */
2440 if (werror) {
2441 *werror = r.out.result;
2442 }
2443
2444 return werror_to_ntstatus(r.out.result);
2445 }
2446
2447 struct rpccli_spoolss_EnumPrintProcessors_state {
2448 struct spoolss_EnumPrintProcessors orig;
2449 struct spoolss_EnumPrintProcessors tmp;
2450 TALLOC_CTX *out_mem_ctx;
2451 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2452 };
2453
2454 static void rpccli_spoolss_EnumPrintProcessors_done(struct tevent_req *subreq);
2455
2456 struct tevent_req *rpccli_spoolss_EnumPrintProcessors_send(TALLOC_CTX *mem_ctx,
2457 struct tevent_context *ev,
2458 struct rpc_pipe_client *cli,
2459 const char *_servername /* [in] [unique,charset(UTF16)] */,
2460 const char *_environment /* [in] [unique,charset(UTF16)] */,
2461 uint32_t _level /* [in] */,
2462 DATA_BLOB *_buffer /* [in] [unique] */,
2463 uint32_t _offered /* [in] */,
2464 uint32_t *_count /* [out] [ref] */,
2465 union spoolss_PrintProcessorInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
2466 uint32_t *_needed /* [out] [ref] */)
2467 {
2468 struct tevent_req *req;
2469 struct rpccli_spoolss_EnumPrintProcessors_state *state;
2470 struct tevent_req *subreq;
2471
2472 req = tevent_req_create(mem_ctx, &state,
2473 struct rpccli_spoolss_EnumPrintProcessors_state);
2474 if (req == NULL) {
2475 return NULL;
2476 }
2477 state->out_mem_ctx = NULL;
2478 state->dispatch_recv = cli->dispatch_recv;
2479
2480 /* In parameters */
2481 state->orig.in.servername = _servername;
2482 state->orig.in.environment = _environment;
2483 state->orig.in.level = _level;
2484 state->orig.in.buffer = _buffer;
2485 state->orig.in.offered = _offered;
2486
2487 /* Out parameters */
2488 state->orig.out.count = _count;
2489 state->orig.out.info = _info;
2490 state->orig.out.needed = _needed;
2491
2492 /* Result */
2493 ZERO_STRUCT(state->orig.out.result);
2494
2495 state->out_mem_ctx = talloc_named_const(state, 0,
2496 "rpccli_spoolss_EnumPrintProcessors_out_memory");
2497 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2498 return tevent_req_post(req, ev);
2499 }
2500
2501 /* make a temporary copy, that we pass to the dispatch function */
2502 state->tmp = state->orig;
2503
2504 subreq = cli->dispatch_send(state, ev, cli,
2505 &ndr_table_spoolss,
2506 NDR_SPOOLSS_ENUMPRINTPROCESSORS,
2507 &state->tmp);
2508 if (tevent_req_nomem(subreq, req)) {
2509 return tevent_req_post(req, ev);
2510 }
2511 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrintProcessors_done, req);
2512 return req;
2513 }
2514
2515 static void rpccli_spoolss_EnumPrintProcessors_done(struct tevent_req *subreq)
2516 {
2517 struct tevent_req *req = tevent_req_callback_data(
2518 subreq, struct tevent_req);
2519 struct rpccli_spoolss_EnumPrintProcessors_state *state = tevent_req_data(
2520 req, struct rpccli_spoolss_EnumPrintProcessors_state);
2521 NTSTATUS status;
2522 TALLOC_CTX *mem_ctx;
2523
2524 if (state->out_mem_ctx) {
2525 mem_ctx = state->out_mem_ctx;
2526 } else {
2527 mem_ctx = state;
2528 }
2529
2530 status = state->dispatch_recv(subreq, mem_ctx);
2531 TALLOC_FREE(subreq);
2532 if (!NT_STATUS_IS_OK(status)) {
2533 tevent_req_nterror(req, status);
2534 return;
2535 }
2536
2537 /* Copy out parameters */
2538 *state->orig.out.count = *state->tmp.out.count;
2539 *state->orig.out.info = *state->tmp.out.info;
2540 *state->orig.out.needed = *state->tmp.out.needed;
2541
2542 /* Copy result */
2543 state->orig.out.result = state->tmp.out.result;
2544
2545 /* Reset temporary structure */
2546 ZERO_STRUCT(state->tmp);
2547
2548 tevent_req_done(req);
2549 }
2550
2551 NTSTATUS rpccli_spoolss_EnumPrintProcessors_recv(struct tevent_req *req,
2552 TALLOC_CTX *mem_ctx,
2553 WERROR *result)
2554 {
2555 struct rpccli_spoolss_EnumPrintProcessors_state *state = tevent_req_data(
2556 req, struct rpccli_spoolss_EnumPrintProcessors_state);
2557 NTSTATUS status;
2558
2559 if (tevent_req_is_nterror(req, &status)) {
2560 tevent_req_received(req);
2561 return status;
2562 }
2563
2564 /* Steal possbile out parameters to the callers context */
2565 talloc_steal(mem_ctx, state->out_mem_ctx);
2566
2567 /* Return result */
2568 *result = state->orig.out.result;
2569
2570 tevent_req_received(req);
2571 return NT_STATUS_OK;
2572 }
2573
2574 NTSTATUS rpccli_spoolss_EnumPrintProcessors(struct rpc_pipe_client *cli,
2575 TALLOC_CTX *mem_ctx,
2576 const char *servername /* [in] [unique,charset(UTF16)] */,
2577 const char *environment /* [in] [unique,charset(UTF16)] */,
2578 uint32_t level /* [in] */,
2579 DATA_BLOB *buffer /* [in] [unique] */,
2580 uint32_t offered /* [in] */,
2581 uint32_t *count /* [out] [ref] */,
2582 union spoolss_PrintProcessorInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
2583 uint32_t *needed /* [out] [ref] */,
2584 WERROR *werror)
2585 {
2586 struct spoolss_EnumPrintProcessors r;
2587 NTSTATUS status;
2588
2589 /* In parameters */
2590 r.in.servername = servername;
2591 r.in.environment = environment;
2592 r.in.level = level;
2593 r.in.buffer = buffer;
2594 r.in.offered = offered;
2595
2596 status = cli->dispatch(cli,
2597 mem_ctx,
2598 &ndr_table_spoolss,
2599 NDR_SPOOLSS_ENUMPRINTPROCESSORS,
2600 &r);
2601
2602 if (!NT_STATUS_IS_OK(status)) {
2603 return status;
2604 }
2605
2606 if (NT_STATUS_IS_ERR(status)) {
2607 return status;
2608 }
2609
2610 /* Return variables */
2611 *count = *r.out.count;
2612 *info = *r.out.info;
2613 *needed = *r.out.needed;
2614
2615 /* Return result */
2616 if (werror) {
2617 *werror = r.out.result;
2618 }
2619
2620 return werror_to_ntstatus(r.out.result);
2621 }
2622
2623 struct rpccli_spoolss_GetPrintProcessorDirectory_state {
2624 struct spoolss_GetPrintProcessorDirectory orig;
2625 struct spoolss_GetPrintProcessorDirectory tmp;
2626 TALLOC_CTX *out_mem_ctx;
2627 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2628 };
2629
2630 static void rpccli_spoolss_GetPrintProcessorDirectory_done(struct tevent_req *subreq);
2631
2632 struct tevent_req *rpccli_spoolss_GetPrintProcessorDirectory_send(TALLOC_CTX *mem_ctx,
2633 struct tevent_context *ev,
2634 struct rpc_pipe_client *cli,
2635 const char *_server /* [in] [unique,charset(UTF16)] */,
2636 const char *_environment /* [in] [unique,charset(UTF16)] */,
2637 uint32_t _level /* [in] */,
2638 DATA_BLOB *_buffer /* [in] [unique] */,
2639 uint32_t _offered /* [in] */,
2640 union spoolss_PrintProcessorDirectoryInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
2641 uint32_t *_needed /* [out] [ref] */)
2642 {
2643 struct tevent_req *req;
2644 struct rpccli_spoolss_GetPrintProcessorDirectory_state *state;
2645 struct tevent_req *subreq;
2646
2647 req = tevent_req_create(mem_ctx, &state,
2648 struct rpccli_spoolss_GetPrintProcessorDirectory_state);
2649 if (req == NULL) {
2650 return NULL;
2651 }
2652 state->out_mem_ctx = NULL;
2653 state->dispatch_recv = cli->dispatch_recv;
2654
2655 /* In parameters */
2656 state->orig.in.server = _server;
2657 state->orig.in.environment = _environment;
2658 state->orig.in.level = _level;
2659 state->orig.in.buffer = _buffer;
2660 state->orig.in.offered = _offered;
2661
2662 /* Out parameters */
2663 state->orig.out.info = _info;
2664 state->orig.out.needed = _needed;
2665
2666 /* Result */
2667 ZERO_STRUCT(state->orig.out.result);
2668
2669 state->out_mem_ctx = talloc_named_const(state, 0,
2670 "rpccli_spoolss_GetPrintProcessorDirectory_out_memory");
2671 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2672 return tevent_req_post(req, ev);
2673 }
2674
2675 /* make a temporary copy, that we pass to the dispatch function */
2676 state->tmp = state->orig;
2677
2678 subreq = cli->dispatch_send(state, ev, cli,
2679 &ndr_table_spoolss,
2680 NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY,
2681 &state->tmp);
2682 if (tevent_req_nomem(subreq, req)) {
2683 return tevent_req_post(req, ev);
2684 }
2685 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrintProcessorDirectory_done, req);
2686 return req;
2687 }
2688
2689 static void rpccli_spoolss_GetPrintProcessorDirectory_done(struct tevent_req *subreq)
2690 {
2691 struct tevent_req *req = tevent_req_callback_data(
2692 subreq, struct tevent_req);
2693 struct rpccli_spoolss_GetPrintProcessorDirectory_state *state = tevent_req_data(
2694 req, struct rpccli_spoolss_GetPrintProcessorDirectory_state);
2695 NTSTATUS status;
2696 TALLOC_CTX *mem_ctx;
2697
2698 if (state->out_mem_ctx) {
2699 mem_ctx = state->out_mem_ctx;
2700 } else {
2701 mem_ctx = state;
2702 }
2703
2704 status = state->dispatch_recv(subreq, mem_ctx);
2705 TALLOC_FREE(subreq);
2706 if (!NT_STATUS_IS_OK(status)) {
2707 tevent_req_nterror(req, status);
2708 return;
2709 }
2710
2711 /* Copy out parameters */
2712 if (state->orig.out.info && state->tmp.out.info) {
2713 *state->orig.out.info = *state->tmp.out.info;
2714 }
2715 *state->orig.out.needed = *state->tmp.out.needed;
2716
2717 /* Copy result */
2718 state->orig.out.result = state->tmp.out.result;
2719
2720 /* Reset temporary structure */
2721 ZERO_STRUCT(state->tmp);
2722
2723 tevent_req_done(req);
2724 }
2725
2726 NTSTATUS rpccli_spoolss_GetPrintProcessorDirectory_recv(struct tevent_req *req,
2727 TALLOC_CTX *mem_ctx,
2728 WERROR *result)
2729 {
2730 struct rpccli_spoolss_GetPrintProcessorDirectory_state *state = tevent_req_data(
2731 req, struct rpccli_spoolss_GetPrintProcessorDirectory_state);
2732 NTSTATUS status;
2733
2734 if (tevent_req_is_nterror(req, &status)) {
2735 tevent_req_received(req);
2736 return status;
2737 }
2738
2739 /* Steal possbile out parameters to the callers context */
2740 talloc_steal(mem_ctx, state->out_mem_ctx);
2741
2742 /* Return result */
2743 *result = state->orig.out.result;
2744
2745 tevent_req_received(req);
2746 return NT_STATUS_OK;
2747 }
2748
2749 NTSTATUS rpccli_spoolss_GetPrintProcessorDirectory(struct rpc_pipe_client *cli,
2750 TALLOC_CTX *mem_ctx,
2751 const char *server /* [in] [unique,charset(UTF16)] */,
2752 const char *environment /* [in] [unique,charset(UTF16)] */,
2753 uint32_t level /* [in] */,
2754 DATA_BLOB *buffer /* [in] [unique] */,
2755 uint32_t offered /* [in] */,
2756 union spoolss_PrintProcessorDirectoryInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
2757 uint32_t *needed /* [out] [ref] */,
2758 WERROR *werror)
2759 {
2760 struct spoolss_GetPrintProcessorDirectory r;
2761 NTSTATUS status;
2762
2763 /* In parameters */
2764 r.in.server = server;
2765 r.in.environment = environment;
2766 r.in.level = level;
2767 r.in.buffer = buffer;
2768 r.in.offered = offered;
2769
2770 status = cli->dispatch(cli,
2771 mem_ctx,
2772 &ndr_table_spoolss,
2773 NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY,
2774 &r);
2775
2776 if (!NT_STATUS_IS_OK(status)) {
2777 return status;
2778 }
2779
2780 if (NT_STATUS_IS_ERR(status)) {
2781 return status;
2782 }
2783
2784 /* Return variables */
2785 if (info && r.out.info) {
2786 *info = *r.out.info;
2787 }
2788 *needed = *r.out.needed;
2789
2790 /* Return result */
2791 if (werror) {
2792 *werror = r.out.result;
2793 }
2794
2795 return werror_to_ntstatus(r.out.result);
2796 }
2797
2798 struct rpccli_spoolss_StartDocPrinter_state {
2799 struct spoolss_StartDocPrinter orig;
2800 struct spoolss_StartDocPrinter tmp;
2801 TALLOC_CTX *out_mem_ctx;
2802 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2803 };
2804
2805 static void rpccli_spoolss_StartDocPrinter_done(struct tevent_req *subreq);
2806
2807 struct tevent_req *rpccli_spoolss_StartDocPrinter_send(TALLOC_CTX *mem_ctx,
2808 struct tevent_context *ev,
2809 struct rpc_pipe_client *cli,
2810 struct policy_handle *_handle /* [in] [ref] */,
2811 uint32_t _level /* [in] */,
2812 union spoolss_DocumentInfo _info /* [in] [switch_is(level)] */,
2813 uint32_t *_job_id /* [out] [ref] */)
2814 {
2815 struct tevent_req *req;
2816 struct rpccli_spoolss_StartDocPrinter_state *state;
2817 struct tevent_req *subreq;
2818
2819 req = tevent_req_create(mem_ctx, &state,
2820 struct rpccli_spoolss_StartDocPrinter_state);
2821 if (req == NULL) {
2822 return NULL;
2823 }
2824 state->out_mem_ctx = NULL;
2825 state->dispatch_recv = cli->dispatch_recv;
2826
2827 /* In parameters */
2828 state->orig.in.handle = _handle;
2829 state->orig.in.level = _level;
2830 state->orig.in.info = _info;
2831
2832 /* Out parameters */
2833 state->orig.out.job_id = _job_id;
2834
2835 /* Result */
2836 ZERO_STRUCT(state->orig.out.result);
2837
2838 state->out_mem_ctx = talloc_named_const(state, 0,
2839 "rpccli_spoolss_StartDocPrinter_out_memory");
2840 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2841 return tevent_req_post(req, ev);
2842 }
2843
2844 /* make a temporary copy, that we pass to the dispatch function */
2845 state->tmp = state->orig;
2846
2847 subreq = cli->dispatch_send(state, ev, cli,
2848 &ndr_table_spoolss,
2849 NDR_SPOOLSS_STARTDOCPRINTER,
2850 &state->tmp);
2851 if (tevent_req_nomem(subreq, req)) {
2852 return tevent_req_post(req, ev);
2853 }
2854 tevent_req_set_callback(subreq, rpccli_spoolss_StartDocPrinter_done, req);
2855 return req;
2856 }
2857
2858 static void rpccli_spoolss_StartDocPrinter_done(struct tevent_req *subreq)
2859 {
2860 struct tevent_req *req = tevent_req_callback_data(
2861 subreq, struct tevent_req);
2862 struct rpccli_spoolss_StartDocPrinter_state *state = tevent_req_data(
2863 req, struct rpccli_spoolss_StartDocPrinter_state);
2864 NTSTATUS status;
2865 TALLOC_CTX *mem_ctx;
2866
2867 if (state->out_mem_ctx) {
2868 mem_ctx = state->out_mem_ctx;
2869 } else {
2870 mem_ctx = state;
2871 }
2872
2873 status = state->dispatch_recv(subreq, mem_ctx);
2874 TALLOC_FREE(subreq);
2875 if (!NT_STATUS_IS_OK(status)) {
2876 tevent_req_nterror(req, status);
2877 return;
2878 }
2879
2880 /* Copy out parameters */
2881 *state->orig.out.job_id = *state->tmp.out.job_id;
2882
2883 /* Copy result */
2884 state->orig.out.result = state->tmp.out.result;
2885
2886 /* Reset temporary structure */
2887 ZERO_STRUCT(state->tmp);
2888
2889 tevent_req_done(req);
2890 }
2891
2892 NTSTATUS rpccli_spoolss_StartDocPrinter_recv(struct tevent_req *req,
2893 TALLOC_CTX *mem_ctx,
2894 WERROR *result)
2895 {
2896 struct rpccli_spoolss_StartDocPrinter_state *state = tevent_req_data(
2897 req, struct rpccli_spoolss_StartDocPrinter_state);
2898 NTSTATUS status;
2899
2900 if (tevent_req_is_nterror(req, &status)) {
2901 tevent_req_received(req);
2902 return status;
2903 }
2904
2905 /* Steal possbile out parameters to the callers context */
2906 talloc_steal(mem_ctx, state->out_mem_ctx);
2907
2908 /* Return result */
2909 *result = state->orig.out.result;
2910
2911 tevent_req_received(req);
2912 return NT_STATUS_OK;
2913 }
2914
2915 NTSTATUS rpccli_spoolss_StartDocPrinter(struct rpc_pipe_client *cli,
2916 TALLOC_CTX *mem_ctx,
2917 struct policy_handle *handle /* [in] [ref] */,
2918 uint32_t level /* [in] */,
2919 union spoolss_DocumentInfo info /* [in] [switch_is(level)] */,
2920 uint32_t *job_id /* [out] [ref] */,
2921 WERROR *werror)
2922 {
2923 struct spoolss_StartDocPrinter r;
2924 NTSTATUS status;
2925
2926 /* In parameters */
2927 r.in.handle = handle;
2928 r.in.level = level;
2929 r.in.info = info;
2930
2931 status = cli->dispatch(cli,
2932 mem_ctx,
2933 &ndr_table_spoolss,
2934 NDR_SPOOLSS_STARTDOCPRINTER,
2935 &r);
2936
2937 if (!NT_STATUS_IS_OK(status)) {
2938 return status;
2939 }
2940
2941 if (NT_STATUS_IS_ERR(status)) {
2942 return status;
2943 }
2944
2945 /* Return variables */
2946 *job_id = *r.out.job_id;
2947
2948 /* Return result */
2949 if (werror) {
2950 *werror = r.out.result;
2951 }
2952
2953 return werror_to_ntstatus(r.out.result);
2954 }
2955
2956 struct rpccli_spoolss_StartPagePrinter_state {
2957 struct spoolss_StartPagePrinter orig;
2958 struct spoolss_StartPagePrinter tmp;
2959 TALLOC_CTX *out_mem_ctx;
2960 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2961 };
2962
2963 static void rpccli_spoolss_StartPagePrinter_done(struct tevent_req *subreq);
2964
2965 struct tevent_req *rpccli_spoolss_StartPagePrinter_send(TALLOC_CTX *mem_ctx,
2966 struct tevent_context *ev,
2967 struct rpc_pipe_client *cli,
2968 struct policy_handle *_handle /* [in] [ref] */)
2969 {
2970 struct tevent_req *req;
2971 struct rpccli_spoolss_StartPagePrinter_state *state;
2972 struct tevent_req *subreq;
2973
2974 req = tevent_req_create(mem_ctx, &state,
2975 struct rpccli_spoolss_StartPagePrinter_state);
2976 if (req == NULL) {
2977 return NULL;
2978 }
2979 state->out_mem_ctx = NULL;
2980 state->dispatch_recv = cli->dispatch_recv;
2981
2982 /* In parameters */
2983 state->orig.in.handle = _handle;
2984
2985 /* Out parameters */
2986
2987 /* Result */
2988 ZERO_STRUCT(state->orig.out.result);
2989
2990 /* make a temporary copy, that we pass to the dispatch function */
2991 state->tmp = state->orig;
2992
2993 subreq = cli->dispatch_send(state, ev, cli,
2994 &ndr_table_spoolss,
2995 NDR_SPOOLSS_STARTPAGEPRINTER,
2996 &state->tmp);
2997 if (tevent_req_nomem(subreq, req)) {
2998 return tevent_req_post(req, ev);
2999 }
3000 tevent_req_set_callback(subreq, rpccli_spoolss_StartPagePrinter_done, req);
3001 return req;
3002 }
3003
3004 static void rpccli_spoolss_StartPagePrinter_done(struct tevent_req *subreq)
3005 {
3006 struct tevent_req *req = tevent_req_callback_data(
3007 subreq, struct tevent_req);
3008 struct rpccli_spoolss_StartPagePrinter_state *state = tevent_req_data(
3009 req, struct rpccli_spoolss_StartPagePrinter_state);
3010 NTSTATUS status;
3011 TALLOC_CTX *mem_ctx;
3012
3013 if (state->out_mem_ctx) {
3014 mem_ctx = state->out_mem_ctx;
3015 } else {
3016 mem_ctx = state;
3017 }
3018
3019 status = state->dispatch_recv(subreq, mem_ctx);
3020 TALLOC_FREE(subreq);
3021 if (!NT_STATUS_IS_OK(status)) {
3022 tevent_req_nterror(req, status);
3023 return;
3024 }
3025
3026 /* Copy out parameters */
3027
3028 /* Copy result */
3029 state->orig.out.result = state->tmp.out.result;
3030
3031 /* Reset temporary structure */
3032 ZERO_STRUCT(state->tmp);
3033
3034 tevent_req_done(req);
3035 }
3036
3037 NTSTATUS rpccli_spoolss_StartPagePrinter_recv(struct tevent_req *req,
3038 TALLOC_CTX *mem_ctx,
3039 WERROR *result)
3040 {
3041 struct rpccli_spoolss_StartPagePrinter_state *state = tevent_req_data(
3042 req, struct rpccli_spoolss_StartPagePrinter_state);
3043 NTSTATUS status;
3044
3045 if (tevent_req_is_nterror(req, &status)) {
3046 tevent_req_received(req);
3047 return status;
3048 }
3049
3050 /* Steal possbile out parameters to the callers context */
3051 talloc_steal(mem_ctx, state->out_mem_ctx);
3052
3053 /* Return result */
3054 *result = state->orig.out.result;
3055
3056 tevent_req_received(req);
3057 return NT_STATUS_OK;
3058 }
3059
3060 NTSTATUS rpccli_spoolss_StartPagePrinter(struct rpc_pipe_client *cli,
3061 TALLOC_CTX *mem_ctx,
3062 struct policy_handle *handle /* [in] [ref] */,
3063 WERROR *werror)
3064 {
3065 struct spoolss_StartPagePrinter r;
3066 NTSTATUS status;
3067
3068 /* In parameters */
3069 r.in.handle = handle;
3070
3071 status = cli->dispatch(cli,
3072 mem_ctx,
3073 &ndr_table_spoolss,
3074 NDR_SPOOLSS_STARTPAGEPRINTER,
3075 &r);
3076
3077 if (!NT_STATUS_IS_OK(status)) {
3078 return status;
3079 }
3080
3081 if (NT_STATUS_IS_ERR(status)) {
3082 return status;
3083 }
3084
3085 /* Return variables */
3086
3087 /* Return result */
3088 if (werror) {
3089 *werror = r.out.result;
3090 }
3091
3092 return werror_to_ntstatus(r.out.result);
3093 }
3094
3095 struct rpccli_spoolss_WritePrinter_state {
3096 struct spoolss_WritePrinter orig;
3097 struct spoolss_WritePrinter tmp;
3098 TALLOC_CTX *out_mem_ctx;
3099 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3100 };
3101
3102 static void rpccli_spoolss_WritePrinter_done(struct tevent_req *subreq);
3103
3104 struct tevent_req *rpccli_spoolss_WritePrinter_send(TALLOC_CTX *mem_ctx,
3105 struct tevent_context *ev,
3106 struct rpc_pipe_client *cli,
3107 struct policy_handle *_handle /* [in] [ref] */,
3108 DATA_BLOB _data /* [in] */,
3109 uint32_t __data_size /* [in] [value(r->in.data.length)] */,
3110 uint32_t *_num_written /* [out] [ref] */)
3111 {
3112 struct tevent_req *req;
3113 struct rpccli_spoolss_WritePrinter_state *state;
3114 struct tevent_req *subreq;
3115
3116 req = tevent_req_create(mem_ctx, &state,
3117 struct rpccli_spoolss_WritePrinter_state);
3118 if (req == NULL) {
3119 return NULL;
3120 }
3121 state->out_mem_ctx = NULL;
3122 state->dispatch_recv = cli->dispatch_recv;
3123
3124 /* In parameters */
3125 state->orig.in.handle = _handle;
3126 state->orig.in.data = _data;
3127 state->orig.in._data_size = __data_size;
3128
3129 /* Out parameters */
3130 state->orig.out.num_written = _num_written;
3131
3132 /* Result */
3133 ZERO_STRUCT(state->orig.out.result);
3134
3135 state->out_mem_ctx = talloc_named_const(state, 0,
3136 "rpccli_spoolss_WritePrinter_out_memory");
3137 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3138 return tevent_req_post(req, ev);
3139 }
3140
3141 /* make a temporary copy, that we pass to the dispatch function */
3142 state->tmp = state->orig;
3143
3144 subreq = cli->dispatch_send(state, ev, cli,
3145 &ndr_table_spoolss,
3146 NDR_SPOOLSS_WRITEPRINTER,
3147 &state->tmp);
3148 if (tevent_req_nomem(subreq, req)) {
3149 return tevent_req_post(req, ev);
3150 }
3151 tevent_req_set_callback(subreq, rpccli_spoolss_WritePrinter_done, req);
3152 return req;
3153 }
3154
3155 static void rpccli_spoolss_WritePrinter_done(struct tevent_req *subreq)
3156 {
3157 struct tevent_req *req = tevent_req_callback_data(
3158 subreq, struct tevent_req);
3159 struct rpccli_spoolss_WritePrinter_state *state = tevent_req_data(
3160 req, struct rpccli_spoolss_WritePrinter_state);
3161 NTSTATUS status;
3162 TALLOC_CTX *mem_ctx;
3163
3164 if (state->out_mem_ctx) {
3165 mem_ctx = state->out_mem_ctx;
3166 } else {
3167 mem_ctx = state;
3168 }
3169
3170 status = state->dispatch_recv(subreq, mem_ctx);
3171 TALLOC_FREE(subreq);
3172 if (!NT_STATUS_IS_OK(status)) {
3173 tevent_req_nterror(req, status);
3174 return;
3175 }
3176
3177 /* Copy out parameters */
3178 *state->orig.out.num_written = *state->tmp.out.num_written;
3179
3180 /* Copy result */
3181 state->orig.out.result = state->tmp.out.result;
3182
3183 /* Reset temporary structure */
3184 ZERO_STRUCT(state->tmp);
3185
3186 tevent_req_done(req);
3187 }
3188
3189 NTSTATUS rpccli_spoolss_WritePrinter_recv(struct tevent_req *req,
3190 TALLOC_CTX *mem_ctx,
3191 WERROR *result)
3192 {
3193 struct rpccli_spoolss_WritePrinter_state *state = tevent_req_data(
3194 req, struct rpccli_spoolss_WritePrinter_state);
3195 NTSTATUS status;
3196
3197 if (tevent_req_is_nterror(req, &status)) {
3198 tevent_req_received(req);
3199 return status;
3200 }
3201
3202 /* Steal possbile out parameters to the callers context */
3203 talloc_steal(mem_ctx, state->out_mem_ctx);
3204
3205 /* Return result */
3206 *result = state->orig.out.result;
3207
3208 tevent_req_received(req);
3209 return NT_STATUS_OK;
3210 }
3211
3212 NTSTATUS rpccli_spoolss_WritePrinter(struct rpc_pipe_client *cli,
3213 TALLOC_CTX *mem_ctx,
3214 struct policy_handle *handle /* [in] [ref] */,
3215 DATA_BLOB data /* [in] */,
3216 uint32_t _data_size /* [in] [value(r->in.data.length)] */,
3217 uint32_t *num_written /* [out] [ref] */,
3218 WERROR *werror)
3219 {
3220 struct spoolss_WritePrinter r;
3221 NTSTATUS status;
3222
3223 /* In parameters */
3224 r.in.handle = handle;
3225 r.in.data = data;
3226 r.in._data_size = _data_size;
3227
3228 status = cli->dispatch(cli,
3229 mem_ctx,
3230 &ndr_table_spoolss,
3231 NDR_SPOOLSS_WRITEPRINTER,
3232 &r);
3233
3234 if (!NT_STATUS_IS_OK(status)) {
3235 return status;
3236 }
3237
3238 if (NT_STATUS_IS_ERR(status)) {
3239 return status;
3240 }
3241
3242 /* Return variables */
3243 *num_written = *r.out.num_written;
3244
3245 /* Return result */
3246 if (werror) {
3247 *werror = r.out.result;
3248 }
3249
3250 return werror_to_ntstatus(r.out.result);
3251 }
3252
3253 struct rpccli_spoolss_EndPagePrinter_state {
3254 struct spoolss_EndPagePrinter orig;
3255 struct spoolss_EndPagePrinter tmp;
3256 TALLOC_CTX *out_mem_ctx;
3257 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3258 };
3259
3260 static void rpccli_spoolss_EndPagePrinter_done(struct tevent_req *subreq);
3261
3262 struct tevent_req *rpccli_spoolss_EndPagePrinter_send(TALLOC_CTX *mem_ctx,
3263 struct tevent_context *ev,
3264 struct rpc_pipe_client *cli,
3265 struct policy_handle *_handle /* [in] [ref] */)
3266 {
3267 struct tevent_req *req;
3268 struct rpccli_spoolss_EndPagePrinter_state *state;
3269 struct tevent_req *subreq;
3270
3271 req = tevent_req_create(mem_ctx, &state,
3272 struct rpccli_spoolss_EndPagePrinter_state);
3273 if (req == NULL) {
3274 return NULL;
3275 }
3276 state->out_mem_ctx = NULL;
3277 state->dispatch_recv = cli->dispatch_recv;
3278
3279 /* In parameters */
3280 state->orig.in.handle = _handle;
3281
3282 /* Out parameters */
3283
3284 /* Result */
3285 ZERO_STRUCT(state->orig.out.result);
3286
3287 /* make a temporary copy, that we pass to the dispatch function */
3288 state->tmp = state->orig;
3289
3290 subreq = cli->dispatch_send(state, ev, cli,
3291 &ndr_table_spoolss,
3292 NDR_SPOOLSS_ENDPAGEPRINTER,
3293 &state->tmp);
3294 if (tevent_req_nomem(subreq, req)) {
3295 return tevent_req_post(req, ev);
3296 }
3297 tevent_req_set_callback(subreq, rpccli_spoolss_EndPagePrinter_done, req);
3298 return req;
3299 }
3300
3301 static void rpccli_spoolss_EndPagePrinter_done(struct tevent_req *subreq)
3302 {
3303 struct tevent_req *req = tevent_req_callback_data(
3304 subreq, struct tevent_req);
3305 struct rpccli_spoolss_EndPagePrinter_state *state = tevent_req_data(
3306 req, struct rpccli_spoolss_EndPagePrinter_state);
3307 NTSTATUS status;
3308 TALLOC_CTX *mem_ctx;
3309
3310 if (state->out_mem_ctx) {
3311 mem_ctx = state->out_mem_ctx;
3312 } else {
3313 mem_ctx = state;
3314 }
3315
3316 status = state->dispatch_recv(subreq, mem_ctx);
3317 TALLOC_FREE(subreq);
3318 if (!NT_STATUS_IS_OK(status)) {
3319 tevent_req_nterror(req, status);
3320 return;
3321 }
3322
3323 /* Copy out parameters */
3324
3325 /* Copy result */
3326 state->orig.out.result = state->tmp.out.result;
3327
3328 /* Reset temporary structure */
3329 ZERO_STRUCT(state->tmp);
3330
3331 tevent_req_done(req);
3332 }
3333
3334 NTSTATUS rpccli_spoolss_EndPagePrinter_recv(struct tevent_req *req,
3335 TALLOC_CTX *mem_ctx,
3336 WERROR *result)
3337 {
3338 struct rpccli_spoolss_EndPagePrinter_state *state = tevent_req_data(
3339 req, struct rpccli_spoolss_EndPagePrinter_state);
3340 NTSTATUS status;
3341
3342 if (tevent_req_is_nterror(req, &status)) {
3343 tevent_req_received(req);
3344 return status;
3345 }
3346
3347 /* Steal possbile out parameters to the callers context */
3348 talloc_steal(mem_ctx, state->out_mem_ctx);
3349
3350 /* Return result */
3351 *result = state->orig.out.result;
3352
3353 tevent_req_received(req);
3354 return NT_STATUS_OK;
3355 }
3356
3357 NTSTATUS rpccli_spoolss_EndPagePrinter(struct rpc_pipe_client *cli,
3358 TALLOC_CTX *mem_ctx,
3359 struct policy_handle *handle /* [in] [ref] */,
3360 WERROR *werror)
3361 {
3362 struct spoolss_EndPagePrinter r;
3363 NTSTATUS status;
3364
3365 /* In parameters */
3366 r.in.handle = handle;
3367
3368 status = cli->dispatch(cli,
3369 mem_ctx,
3370 &ndr_table_spoolss,
3371 NDR_SPOOLSS_ENDPAGEPRINTER,
3372 &r);
3373
3374 if (!NT_STATUS_IS_OK(status)) {
3375 return status;
3376 }
3377
3378 if (NT_STATUS_IS_ERR(status)) {
3379 return status;
3380 }
3381
3382 /* Return variables */
3383
3384 /* Return result */
3385 if (werror) {
3386 *werror = r.out.result;
3387 }
3388
3389 return werror_to_ntstatus(r.out.result);
3390 }
3391
3392 struct rpccli_spoolss_AbortPrinter_state {
3393 struct spoolss_AbortPrinter orig;
3394 struct spoolss_AbortPrinter tmp;
3395 TALLOC_CTX *out_mem_ctx;
3396 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3397 };
3398
3399 static void rpccli_spoolss_AbortPrinter_done(struct tevent_req *subreq);
3400
3401 struct tevent_req *rpccli_spoolss_AbortPrinter_send(TALLOC_CTX *mem_ctx,
3402 struct tevent_context *ev,
3403 struct rpc_pipe_client *cli,
3404 struct policy_handle *_handle /* [in] [ref] */)
3405 {
3406 struct tevent_req *req;
3407 struct rpccli_spoolss_AbortPrinter_state *state;
3408 struct tevent_req *subreq;
3409
3410 req = tevent_req_create(mem_ctx, &state,
3411 struct rpccli_spoolss_AbortPrinter_state);
3412 if (req == NULL) {
3413 return NULL;
3414 }
3415 state->out_mem_ctx = NULL;
3416 state->dispatch_recv = cli->dispatch_recv;
3417
3418 /* In parameters */
3419 state->orig.in.handle = _handle;
3420
3421 /* Out parameters */
3422
3423 /* Result */
3424 ZERO_STRUCT(state->orig.out.result);
3425
3426 /* make a temporary copy, that we pass to the dispatch function */
3427 state->tmp = state->orig;
3428
3429 subreq = cli->dispatch_send(state, ev, cli,
3430 &ndr_table_spoolss,
3431 NDR_SPOOLSS_ABORTPRINTER,
3432 &state->tmp);
3433 if (tevent_req_nomem(subreq, req)) {
3434 return tevent_req_post(req, ev);
3435 }
3436 tevent_req_set_callback(subreq, rpccli_spoolss_AbortPrinter_done, req);
3437 return req;
3438 }
3439
3440 static void rpccli_spoolss_AbortPrinter_done(struct tevent_req *subreq)
3441 {
3442 struct tevent_req *req = tevent_req_callback_data(
3443 subreq, struct tevent_req);
3444 struct rpccli_spoolss_AbortPrinter_state *state = tevent_req_data(
3445 req, struct rpccli_spoolss_AbortPrinter_state);
3446 NTSTATUS status;
3447 TALLOC_CTX *mem_ctx;
3448
3449 if (state->out_mem_ctx) {
3450 mem_ctx = state->out_mem_ctx;
3451 } else {
3452 mem_ctx = state;
3453 }
3454
3455 status = state->dispatch_recv(subreq, mem_ctx);
3456 TALLOC_FREE(subreq);
3457 if (!NT_STATUS_IS_OK(status)) {
3458 tevent_req_nterror(req, status);
3459 return;
3460 }
3461
3462 /* Copy out parameters */
3463
3464 /* Copy result */
3465 state->orig.out.result = state->tmp.out.result;
3466
3467 /* Reset temporary structure */
3468 ZERO_STRUCT(state->tmp);
3469
3470 tevent_req_done(req);
3471 }
3472
3473 NTSTATUS rpccli_spoolss_AbortPrinter_recv(struct tevent_req *req,
3474 TALLOC_CTX *mem_ctx,
3475 WERROR *result)
3476 {
3477 struct rpccli_spoolss_AbortPrinter_state *state = tevent_req_data(
3478 req, struct rpccli_spoolss_AbortPrinter_state);
3479 NTSTATUS status;
3480
3481 if (tevent_req_is_nterror(req, &status)) {
3482 tevent_req_received(req);
3483 return status;
3484 }
3485
3486 /* Steal possbile out parameters to the callers context */
3487 talloc_steal(mem_ctx, state->out_mem_ctx);
3488
3489 /* Return result */
3490 *result = state->orig.out.result;
3491
3492 tevent_req_received(req);
3493 return NT_STATUS_OK;
3494 }
3495
3496 NTSTATUS rpccli_spoolss_AbortPrinter(struct rpc_pipe_client *cli,
3497 TALLOC_CTX *mem_ctx,
3498 struct policy_handle *handle /* [in] [ref] */,
3499 WERROR *werror)
3500 {
3501 struct spoolss_AbortPrinter r;
3502 NTSTATUS status;
3503
3504 /* In parameters */
3505 r.in.handle = handle;
3506
3507 status = cli->dispatch(cli,
3508 mem_ctx,
3509 &ndr_table_spoolss,
3510 NDR_SPOOLSS_ABORTPRINTER,
3511 &r);
3512
3513 if (!NT_STATUS_IS_OK(status)) {
3514 return status;
3515 }
3516
3517 if (NT_STATUS_IS_ERR(status)) {
3518 return status;
3519 }
3520
3521 /* Return variables */
3522
3523 /* Return result */
3524 if (werror) {
3525 *werror = r.out.result;
3526 }
3527
3528 return werror_to_ntstatus(r.out.result);
3529 }
3530
3531 struct rpccli_spoolss_ReadPrinter_state {
3532 struct spoolss_ReadPrinter orig;
3533 struct spoolss_ReadPrinter tmp;
3534 TALLOC_CTX *out_mem_ctx;
3535 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3536 };
3537
3538 static void rpccli_spoolss_ReadPrinter_done(struct tevent_req *subreq);
3539
3540 struct tevent_req *rpccli_spoolss_ReadPrinter_send(TALLOC_CTX *mem_ctx,
3541 struct tevent_context *ev,
3542 struct rpc_pipe_client *cli,
3543 struct policy_handle *_handle /* [in] [ref] */,
3544 uint8_t *_data /* [out] [ref,size_is(data_size)] */,
3545 uint32_t _data_size /* [in] */,
3546 uint32_t *__data_size /* [out] [ref] */)
3547 {
3548 struct tevent_req *req;
3549 struct rpccli_spoolss_ReadPrinter_state *state;
3550 struct tevent_req *subreq;
3551
3552 req = tevent_req_create(mem_ctx, &state,
3553 struct rpccli_spoolss_ReadPrinter_state);
3554 if (req == NULL) {
3555 return NULL;
3556 }
3557 state->out_mem_ctx = NULL;
3558 state->dispatch_recv = cli->dispatch_recv;
3559
3560 /* In parameters */
3561 state->orig.in.handle = _handle;
3562 state->orig.in.data_size = _data_size;
3563
3564 /* Out parameters */
3565 state->orig.out.data = _data;
3566 state->orig.out._data_size = __data_size;
3567
3568 /* Result */
3569 ZERO_STRUCT(state->orig.out.result);
3570
3571 state->out_mem_ctx = talloc_named_const(state, 0,
3572 "rpccli_spoolss_ReadPrinter_out_memory");
3573 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3574 return tevent_req_post(req, ev);
3575 }
3576
3577 /* make a temporary copy, that we pass to the dispatch function */
3578 state->tmp = state->orig;
3579
3580 subreq = cli->dispatch_send(state, ev, cli,
3581 &ndr_table_spoolss,
3582 NDR_SPOOLSS_READPRINTER,
3583 &state->tmp);
3584 if (tevent_req_nomem(subreq, req)) {
3585 return tevent_req_post(req, ev);
3586 }
3587 tevent_req_set_callback(subreq, rpccli_spoolss_ReadPrinter_done, req);
3588 return req;
3589 }
3590
3591 static void rpccli_spoolss_ReadPrinter_done(struct tevent_req *subreq)
3592 {
3593 struct tevent_req *req = tevent_req_callback_data(
3594 subreq, struct tevent_req);
3595 struct rpccli_spoolss_ReadPrinter_state *state = tevent_req_data(
3596 req, struct rpccli_spoolss_ReadPrinter_state);
3597 NTSTATUS status;
3598 TALLOC_CTX *mem_ctx;
3599
3600 if (state->out_mem_ctx) {
3601 mem_ctx = state->out_mem_ctx;
3602 } else {
3603 mem_ctx = state;
3604 }
3605
3606 status = state->dispatch_recv(subreq, mem_ctx);
3607 TALLOC_FREE(subreq);
3608 if (!NT_STATUS_IS_OK(status)) {
3609 tevent_req_nterror(req, status);
3610 return;
3611 }
3612
3613 /* Copy out parameters */
3614 memcpy(state->orig.out.data, state->tmp.out.data, (state->tmp.in.data_size) * sizeof(*state->orig.out.data));
3615 *state->orig.out._data_size = *state->tmp.out._data_size;
3616
3617 /* Copy result */
3618 state->orig.out.result = state->tmp.out.result;
3619
3620 /* Reset temporary structure */
3621 ZERO_STRUCT(state->tmp);
3622
3623 tevent_req_done(req);
3624 }
3625
3626 NTSTATUS rpccli_spoolss_ReadPrinter_recv(struct tevent_req *req,
3627 TALLOC_CTX *mem_ctx,
3628 WERROR *result)
3629 {
3630 struct rpccli_spoolss_ReadPrinter_state *state = tevent_req_data(
3631 req, struct rpccli_spoolss_ReadPrinter_state);
3632 NTSTATUS status;
3633
3634 if (tevent_req_is_nterror(req, &status)) {
3635 tevent_req_received(req);
3636 return status;
3637 }
3638
3639 /* Steal possbile out parameters to the callers context */
3640 talloc_steal(mem_ctx, state->out_mem_ctx);
3641
3642 /* Return result */
3643 *result = state->orig.out.result;
3644
3645 tevent_req_received(req);
3646 return NT_STATUS_OK;
3647 }
3648
3649 NTSTATUS rpccli_spoolss_ReadPrinter(struct rpc_pipe_client *cli,
3650 TALLOC_CTX *mem_ctx,
3651 struct policy_handle *handle /* [in] [ref] */,
3652 uint8_t *data /* [out] [ref,size_is(data_size)] */,
3653 uint32_t data_size /* [in] */,
3654 uint32_t *_data_size /* [out] [ref] */,
3655 WERROR *werror)
3656 {
3657 struct spoolss_ReadPrinter r;
3658 NTSTATUS status;
3659
3660 /* In parameters */
3661 r.in.handle = handle;
3662 r.in.data_size = data_size;
3663
3664 status = cli->dispatch(cli,
3665 mem_ctx,
3666 &ndr_table_spoolss,
3667 NDR_SPOOLSS_READPRINTER,
3668 &r);
3669
3670 if (!NT_STATUS_IS_OK(status)) {
3671 return status;
3672 }
3673
3674 if (NT_STATUS_IS_ERR(status)) {
3675 return status;
3676 }
3677
3678 /* Return variables */
3679 memcpy(data, r.out.data, (r.in.data_size) * sizeof(*data));
3680 *_data_size = *r.out._data_size;
3681
3682 /* Return result */
3683 if (werror) {
3684 *werror = r.out.result;
3685 }
3686
3687 return werror_to_ntstatus(r.out.result);
3688 }
3689
3690 struct rpccli_spoolss_EndDocPrinter_state {
3691 struct spoolss_EndDocPrinter orig;
3692 struct spoolss_EndDocPrinter tmp;
3693 TALLOC_CTX *out_mem_ctx;
3694 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3695 };
3696
3697 static void rpccli_spoolss_EndDocPrinter_done(struct tevent_req *subreq);
3698
3699 struct tevent_req *rpccli_spoolss_EndDocPrinter_send(TALLOC_CTX *mem_ctx,
3700 struct tevent_context *ev,
3701 struct rpc_pipe_client *cli,
3702 struct policy_handle *_handle /* [in] [ref] */)
3703 {
3704 struct tevent_req *req;
3705 struct rpccli_spoolss_EndDocPrinter_state *state;
3706 struct tevent_req *subreq;
3707
3708 req = tevent_req_create(mem_ctx, &state,
3709 struct rpccli_spoolss_EndDocPrinter_state);
3710 if (req == NULL) {
3711 return NULL;
3712 }
3713 state->out_mem_ctx = NULL;
3714 state->dispatch_recv = cli->dispatch_recv;
3715
3716 /* In parameters */
3717 state->orig.in.handle = _handle;
3718
3719 /* Out parameters */
3720
3721 /* Result */
3722 ZERO_STRUCT(state->orig.out.result);
3723
3724 /* make a temporary copy, that we pass to the dispatch function */
3725 state->tmp = state->orig;
3726
3727 subreq = cli->dispatch_send(state, ev, cli,
3728 &ndr_table_spoolss,
3729 NDR_SPOOLSS_ENDDOCPRINTER,
3730 &state->tmp);
3731 if (tevent_req_nomem(subreq, req)) {
3732 return tevent_req_post(req, ev);
3733 }
3734 tevent_req_set_callback(subreq, rpccli_spoolss_EndDocPrinter_done, req);
3735 return req;
3736 }
3737
3738 static void rpccli_spoolss_EndDocPrinter_done(struct tevent_req *subreq)
3739 {
3740 struct tevent_req *req = tevent_req_callback_data(
3741 subreq, struct tevent_req);
3742 struct rpccli_spoolss_EndDocPrinter_state *state = tevent_req_data(
3743 req, struct rpccli_spoolss_EndDocPrinter_state);
3744 NTSTATUS status;
3745 TALLOC_CTX *mem_ctx;
3746
3747 if (state->out_mem_ctx) {
3748 mem_ctx = state->out_mem_ctx;
3749 } else {
3750 mem_ctx = state;
3751 }
3752
3753 status = state->dispatch_recv(subreq, mem_ctx);
3754 TALLOC_FREE(subreq);
3755 if (!NT_STATUS_IS_OK(status)) {
3756 tevent_req_nterror(req, status);
3757 return;
3758 }
3759
3760 /* Copy out parameters */
3761
3762 /* Copy result */
3763 state->orig.out.result = state->tmp.out.result;
3764
3765 /* Reset temporary structure */
3766 ZERO_STRUCT(state->tmp);
3767
3768 tevent_req_done(req);
3769 }
3770
3771 NTSTATUS rpccli_spoolss_EndDocPrinter_recv(struct tevent_req *req,
3772 TALLOC_CTX *mem_ctx,
3773 WERROR *result)
3774 {
3775 struct rpccli_spoolss_EndDocPrinter_state *state = tevent_req_data(
3776 req, struct rpccli_spoolss_EndDocPrinter_state);
3777 NTSTATUS status;
3778
3779 if (tevent_req_is_nterror(req, &status)) {
3780 tevent_req_received(req);
3781 return status;
3782 }
3783
3784 /* Steal possbile out parameters to the callers context */
3785 talloc_steal(mem_ctx, state->out_mem_ctx);
3786
3787 /* Return result */
3788 *result = state->orig.out.result;
3789
3790 tevent_req_received(req);
3791 return NT_STATUS_OK;
3792 }
3793
3794 NTSTATUS rpccli_spoolss_EndDocPrinter(struct rpc_pipe_client *cli,
3795 TALLOC_CTX *mem_ctx,
3796 struct policy_handle *handle /* [in] [ref] */,
3797 WERROR *werror)
3798 {
3799 struct spoolss_EndDocPrinter r;
3800 NTSTATUS status;
3801
3802 /* In parameters */
3803 r.in.handle = handle;
3804
3805 status = cli->dispatch(cli,
3806 mem_ctx,
3807 &ndr_table_spoolss,
3808 NDR_SPOOLSS_ENDDOCPRINTER,
3809 &r);
3810
3811 if (!NT_STATUS_IS_OK(status)) {
3812 return status;
3813 }
3814
3815 if (NT_STATUS_IS_ERR(status)) {
3816 return status;
3817 }
3818
3819 /* Return variables */
3820
3821 /* Return result */
3822 if (werror) {
3823 *werror = r.out.result;
3824 }
3825
3826 return werror_to_ntstatus(r.out.result);
3827 }
3828
3829 struct rpccli_spoolss_AddJob_state {
3830 struct spoolss_AddJob orig;
3831 struct spoolss_AddJob tmp;
3832 TALLOC_CTX *out_mem_ctx;
3833 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3834 };
3835
3836 static void rpccli_spoolss_AddJob_done(struct tevent_req *subreq);
3837
3838 struct tevent_req *rpccli_spoolss_AddJob_send(TALLOC_CTX *mem_ctx,
3839 struct tevent_context *ev,
3840 struct rpc_pipe_client *cli,
3841 struct policy_handle *_handle /* [in] [ref] */,
3842 uint32_t _level /* [in] */,
3843 uint8_t *_buffer /* [in,out] [unique,size_is(offered)] */,
3844 uint32_t _offered /* [in] */,
3845 uint32_t *_needed /* [out] [ref] */)
3846 {
3847 struct tevent_req *req;
3848 struct rpccli_spoolss_AddJob_state *state;
3849 struct tevent_req *subreq;
3850
3851 req = tevent_req_create(mem_ctx, &state,
3852 struct rpccli_spoolss_AddJob_state);
3853 if (req == NULL) {
3854 return NULL;
3855 }
3856 state->out_mem_ctx = NULL;
3857 state->dispatch_recv = cli->dispatch_recv;
3858
3859 /* In parameters */
3860 state->orig.in.handle = _handle;
3861 state->orig.in.level = _level;
3862 state->orig.in.buffer = _buffer;
3863 state->orig.in.offered = _offered;
3864
3865 /* Out parameters */
3866 state->orig.out.buffer = _buffer;
3867 state->orig.out.needed = _needed;
3868
3869 /* Result */
3870 ZERO_STRUCT(state->orig.out.result);
3871
3872 state->out_mem_ctx = talloc_named_const(state, 0,
3873 "rpccli_spoolss_AddJob_out_memory");
3874 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3875 return tevent_req_post(req, ev);
3876 }
3877
3878 /* make a temporary copy, that we pass to the dispatch function */
3879 state->tmp = state->orig;
3880
3881 subreq = cli->dispatch_send(state, ev, cli,
3882 &ndr_table_spoolss,
3883 NDR_SPOOLSS_ADDJOB,
3884 &state->tmp);
3885 if (tevent_req_nomem(subreq, req)) {
3886 return tevent_req_post(req, ev);
3887 }
3888 tevent_req_set_callback(subreq, rpccli_spoolss_AddJob_done, req);
3889 return req;
3890 }
3891
3892 static void rpccli_spoolss_AddJob_done(struct tevent_req *subreq)
3893 {
3894 struct tevent_req *req = tevent_req_callback_data(
3895 subreq, struct tevent_req);
3896 struct rpccli_spoolss_AddJob_state *state = tevent_req_data(
3897 req, struct rpccli_spoolss_AddJob_state);
3898 NTSTATUS status;
3899 TALLOC_CTX *mem_ctx;
3900
3901 if (state->out_mem_ctx) {
3902 mem_ctx = state->out_mem_ctx;
3903 } else {
3904 mem_ctx = state;
3905 }
3906
3907 status = state->dispatch_recv(subreq, mem_ctx);
3908 TALLOC_FREE(subreq);
3909 if (!NT_STATUS_IS_OK(status)) {
3910 tevent_req_nterror(req, status);
3911 return;
3912 }
3913
3914 /* Copy out parameters */
3915 if (state->orig.out.buffer && state->tmp.out.buffer) {
3916 memcpy(state->orig.out.buffer, state->tmp.out.buffer, (state->tmp.in.offered) * sizeof(*state->orig.out.buffer));
3917 }
3918 *state->orig.out.needed = *state->tmp.out.needed;
3919
3920 /* Copy result */
3921 state->orig.out.result = state->tmp.out.result;
3922
3923 /* Reset temporary structure */
3924 ZERO_STRUCT(state->tmp);
3925
3926 tevent_req_done(req);
3927 }
3928
3929 NTSTATUS rpccli_spoolss_AddJob_recv(struct tevent_req *req,
3930 TALLOC_CTX *mem_ctx,
3931 WERROR *result)
3932 {
3933 struct rpccli_spoolss_AddJob_state *state = tevent_req_data(
3934 req, struct rpccli_spoolss_AddJob_state);
3935 NTSTATUS status;
3936
3937 if (tevent_req_is_nterror(req, &status)) {
3938 tevent_req_received(req);
3939 return status;
3940 }
3941
3942 /* Steal possbile out parameters to the callers context */
3943 talloc_steal(mem_ctx, state->out_mem_ctx);
3944
3945 /* Return result */
3946 *result = state->orig.out.result;
3947
3948 tevent_req_received(req);
3949 return NT_STATUS_OK;
3950 }
3951
3952 NTSTATUS rpccli_spoolss_AddJob(struct rpc_pipe_client *cli,
3953 TALLOC_CTX *mem_ctx,
3954 struct policy_handle *handle /* [in] [ref] */,
3955 uint32_t level /* [in] */,
3956 uint8_t *buffer /* [in,out] [unique,size_is(offered)] */,
3957 uint32_t offered /* [in] */,
3958 uint32_t *needed /* [out] [ref] */,
3959 WERROR *werror)
3960 {
3961 struct spoolss_AddJob r;
3962 NTSTATUS status;
3963
3964 /* In parameters */
3965 r.in.handle = handle;
3966 r.in.level = level;
3967 r.in.buffer = buffer;
3968 r.in.offered = offered;
3969
3970 status = cli->dispatch(cli,
3971 mem_ctx,
3972 &ndr_table_spoolss,
3973 NDR_SPOOLSS_ADDJOB,
3974 &r);
3975
3976 if (!NT_STATUS_IS_OK(status)) {
3977 return status;
3978 }
3979
3980 if (NT_STATUS_IS_ERR(status)) {
3981 return status;
3982 }
3983
3984 /* Return variables */
3985 if (buffer && r.out.buffer) {
3986 memcpy(buffer, r.out.buffer, (r.in.offered) * sizeof(*buffer));
3987 }
3988 *needed = *r.out.needed;
3989
3990 /* Return result */
3991 if (werror) {
3992 *werror = r.out.result;
3993 }
3994
3995 return werror_to_ntstatus(r.out.result);
3996 }
3997
3998 struct rpccli_spoolss_ScheduleJob_state {
3999 struct spoolss_ScheduleJob orig;
4000 struct spoolss_ScheduleJob tmp;
4001 TALLOC_CTX *out_mem_ctx;
4002 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4003 };
4004
4005 static void rpccli_spoolss_ScheduleJob_done(struct tevent_req *subreq);
4006
4007 struct tevent_req *rpccli_spoolss_ScheduleJob_send(TALLOC_CTX *mem_ctx,
4008 struct tevent_context *ev,
4009 struct rpc_pipe_client *cli,
4010 struct policy_handle *_handle /* [in] [ref] */,
4011 uint32_t _jobid /* [in] */)
4012 {
4013 struct tevent_req *req;
4014 struct rpccli_spoolss_ScheduleJob_state *state;
4015 struct tevent_req *subreq;
4016
4017 req = tevent_req_create(mem_ctx, &state,
4018 struct rpccli_spoolss_ScheduleJob_state);
4019 if (req == NULL) {
4020 return NULL;
4021 }
4022 state->out_mem_ctx = NULL;
4023 state->dispatch_recv = cli->dispatch_recv;
4024
4025 /* In parameters */
4026 state->orig.in.handle = _handle;
4027 state->orig.in.jobid = _jobid;
4028
4029 /* Out parameters */
4030
4031 /* Result */
4032 ZERO_STRUCT(state->orig.out.result);
4033
4034 /* make a temporary copy, that we pass to the dispatch function */
4035 state->tmp = state->orig;
4036
4037 subreq = cli->dispatch_send(state, ev, cli,
4038 &ndr_table_spoolss,
4039 NDR_SPOOLSS_SCHEDULEJOB,
4040 &state->tmp);
4041 if (tevent_req_nomem(subreq, req)) {
4042 return tevent_req_post(req, ev);
4043 }
4044 tevent_req_set_callback(subreq, rpccli_spoolss_ScheduleJob_done, req);
4045 return req;
4046 }
4047
4048 static void rpccli_spoolss_ScheduleJob_done(struct tevent_req *subreq)
4049 {
4050 struct tevent_req *req = tevent_req_callback_data(
4051 subreq, struct tevent_req);
4052 struct rpccli_spoolss_ScheduleJob_state *state = tevent_req_data(
4053 req, struct rpccli_spoolss_ScheduleJob_state);
4054 NTSTATUS status;
4055 TALLOC_CTX *mem_ctx;
4056
4057 if (state->out_mem_ctx) {
4058 mem_ctx = state->out_mem_ctx;
4059 } else {
4060 mem_ctx = state;
4061 }
4062
4063 status = state->dispatch_recv(subreq, mem_ctx);
4064 TALLOC_FREE(subreq);
4065 if (!NT_STATUS_IS_OK(status)) {
4066 tevent_req_nterror(req, status);
4067 return;
4068 }
4069
4070 /* Copy out parameters */
4071
4072 /* Copy result */
4073 state->orig.out.result = state->tmp.out.result;
4074
4075 /* Reset temporary structure */
4076 ZERO_STRUCT(state->tmp);
4077
4078 tevent_req_done(req);
4079 }
4080
4081 NTSTATUS rpccli_spoolss_ScheduleJob_recv(struct tevent_req *req,
4082 TALLOC_CTX *mem_ctx,
4083 WERROR *result)
4084 {
4085 struct rpccli_spoolss_ScheduleJob_state *state = tevent_req_data(
4086 req, struct rpccli_spoolss_ScheduleJob_state);
4087 NTSTATUS status;
4088
4089 if (tevent_req_is_nterror(req, &status)) {
4090 tevent_req_received(req);
4091 return status;
4092 }
4093
4094 /* Steal possbile out parameters to the callers context */
4095 talloc_steal(mem_ctx, state->out_mem_ctx);
4096
4097 /* Return result */
4098 *result = state->orig.out.result;
4099
4100 tevent_req_received(req);
4101 return NT_STATUS_OK;
4102 }
4103
4104 NTSTATUS rpccli_spoolss_ScheduleJob(struct rpc_pipe_client *cli,
4105 TALLOC_CTX *mem_ctx,
4106 struct policy_handle *handle /* [in] [ref] */,
4107 uint32_t jobid /* [in] */,
4108 WERROR *werror)
4109 {
4110 struct spoolss_ScheduleJob r;
4111 NTSTATUS status;
4112
4113 /* In parameters */
4114 r.in.handle = handle;
4115 r.in.jobid = jobid;
4116
4117 status = cli->dispatch(cli,
4118 mem_ctx,
4119 &ndr_table_spoolss,
4120 NDR_SPOOLSS_SCHEDULEJOB,
4121 &r);
4122
4123 if (!NT_STATUS_IS_OK(status)) {
4124 return status;
4125 }
4126
4127 if (NT_STATUS_IS_ERR(status)) {
4128 return status;
4129 }
4130
4131 /* Return variables */
4132
4133 /* Return result */
4134 if (werror) {
4135 *werror = r.out.result;
4136 }
4137
4138 return werror_to_ntstatus(r.out.result);
4139 }
4140
4141 struct rpccli_spoolss_GetPrinterData_state {
4142 struct spoolss_GetPrinterData orig;
4143 struct spoolss_GetPrinterData tmp;
4144 TALLOC_CTX *out_mem_ctx;
4145 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4146 };
4147
4148 static void rpccli_spoolss_GetPrinterData_done(struct tevent_req *subreq);
4149
4150 struct tevent_req *rpccli_spoolss_GetPrinterData_send(TALLOC_CTX *mem_ctx,
4151 struct tevent_context *ev,
4152 struct rpc_pipe_client *cli,
4153 struct policy_handle *_handle /* [in] [ref] */,
4154 const char *_value_name /* [in] [charset(UTF16)] */,
4155 uint32_t _offered /* [in] */,
4156 enum winreg_Type *_type /* [out] [ref] */,
4157 union spoolss_PrinterData *_data /* [out] [subcontext_size(offered),ref,subcontext(4),switch_is(*type)] */,
4158 uint32_t *_needed /* [out] [ref] */)
4159 {
4160 struct tevent_req *req;
4161 struct rpccli_spoolss_GetPrinterData_state *state;
4162 struct tevent_req *subreq;
4163
4164 req = tevent_req_create(mem_ctx, &state,
4165 struct rpccli_spoolss_GetPrinterData_state);
4166 if (req == NULL) {
4167 return NULL;
4168 }
4169 state->out_mem_ctx = NULL;
4170 state->dispatch_recv = cli->dispatch_recv;
4171
4172 /* In parameters */
4173 state->orig.in.handle = _handle;
4174 state->orig.in.value_name = _value_name;
4175 state->orig.in.offered = _offered;
4176
4177 /* Out parameters */
4178 state->orig.out.type = _type;
4179 state->orig.out.data = _data;
4180 state->orig.out.needed = _needed;
4181
4182 /* Result */
4183 ZERO_STRUCT(state->orig.out.result);
4184
4185 state->out_mem_ctx = talloc_named_const(state, 0,
4186 "rpccli_spoolss_GetPrinterData_out_memory");
4187 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4188 return tevent_req_post(req, ev);
4189 }
4190
4191 /* make a temporary copy, that we pass to the dispatch function */
4192 state->tmp = state->orig;
4193
4194 subreq = cli->dispatch_send(state, ev, cli,
4195 &ndr_table_spoolss,
4196 NDR_SPOOLSS_GETPRINTERDATA,
4197 &state->tmp);
4198 if (tevent_req_nomem(subreq, req)) {
4199 return tevent_req_post(req, ev);
4200 }
4201 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterData_done, req);
4202 return req;
4203 }
4204
4205 static void rpccli_spoolss_GetPrinterData_done(struct tevent_req *subreq)
4206 {
4207 struct tevent_req *req = tevent_req_callback_data(
4208 subreq, struct tevent_req);
4209 struct rpccli_spoolss_GetPrinterData_state *state = tevent_req_data(
4210 req, struct rpccli_spoolss_GetPrinterData_state);
4211 NTSTATUS status;
4212 TALLOC_CTX *mem_ctx;
4213
4214 if (state->out_mem_ctx) {
4215 mem_ctx = state->out_mem_ctx;
4216 } else {
4217 mem_ctx = state;
4218 }
4219
4220 status = state->dispatch_recv(subreq, mem_ctx);
4221 TALLOC_FREE(subreq);
4222 if (!NT_STATUS_IS_OK(status)) {
4223 tevent_req_nterror(req, status);
4224 return;
4225 }
4226
4227 /* Copy out parameters */
4228 *state->orig.out.type = *state->tmp.out.type;
4229 *state->orig.out.data = *state->tmp.out.data;
4230 *state->orig.out.needed = *state->tmp.out.needed;
4231
4232 /* Copy result */
4233 state->orig.out.result = state->tmp.out.result;
4234
4235 /* Reset temporary structure */
4236 ZERO_STRUCT(state->tmp);
4237
4238 tevent_req_done(req);
4239 }
4240
4241 NTSTATUS rpccli_spoolss_GetPrinterData_recv(struct tevent_req *req,
4242 TALLOC_CTX *mem_ctx,
4243 WERROR *result)
4244 {
4245 struct rpccli_spoolss_GetPrinterData_state *state = tevent_req_data(
4246 req, struct rpccli_spoolss_GetPrinterData_state);
4247 NTSTATUS status;
4248
4249 if (tevent_req_is_nterror(req, &status)) {
4250 tevent_req_received(req);
4251 return status;
4252 }
4253
4254 /* Steal possbile out parameters to the callers context */
4255 talloc_steal(mem_ctx, state->out_mem_ctx);
4256
4257 /* Return result */
4258 *result = state->orig.out.result;
4259
4260 tevent_req_received(req);
4261 return NT_STATUS_OK;
4262 }
4263
4264 NTSTATUS rpccli_spoolss_GetPrinterData(struct rpc_pipe_client *cli,
4265 TALLOC_CTX *mem_ctx,
4266 struct policy_handle *handle /* [in] [ref] */,
4267 const char *value_name /* [in] [charset(UTF16)] */,
4268 uint32_t offered /* [in] */,
4269 enum winreg_Type *type /* [out] [ref] */,
4270 union spoolss_PrinterData *data /* [out] [subcontext_size(offered),ref,subcontext(4),switch_is(*type)] */,
4271 uint32_t *needed /* [out] [ref] */,
4272 WERROR *werror)
4273 {
4274 struct spoolss_GetPrinterData r;
4275 NTSTATUS status;
4276
4277 /* In parameters */
4278 r.in.handle = handle;
4279 r.in.value_name = value_name;
4280 r.in.offered = offered;
4281
4282 status = cli->dispatch(cli,
4283 mem_ctx,
4284 &ndr_table_spoolss,
4285 NDR_SPOOLSS_GETPRINTERDATA,
4286 &r);
4287
4288 if (!NT_STATUS_IS_OK(status)) {
4289 return status;
4290 }
4291
4292 if (NT_STATUS_IS_ERR(status)) {
4293 return status;
4294 }
4295
4296 /* Return variables */
4297 *type = *r.out.type;
4298 *data = *r.out.data;
4299 *needed = *r.out.needed;
4300
4301 /* Return result */
4302 if (werror) {
4303 *werror = r.out.result;
4304 }
4305
4306 return werror_to_ntstatus(r.out.result);
4307 }
4308
4309 struct rpccli_spoolss_SetPrinterData_state {
4310 struct spoolss_SetPrinterData orig;
4311 struct spoolss_SetPrinterData tmp;
4312 TALLOC_CTX *out_mem_ctx;
4313 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4314 };
4315
4316 static void rpccli_spoolss_SetPrinterData_done(struct tevent_req *subreq);
4317
4318 struct tevent_req *rpccli_spoolss_SetPrinterData_send(TALLOC_CTX *mem_ctx,
4319 struct tevent_context *ev,
4320 struct rpc_pipe_client *cli,
4321 struct policy_handle *_handle /* [in] [ref] */,
4322 const char *_value_name /* [in] [charset(UTF16)] */,
4323 enum winreg_Type _type /* [in] */,
4324 union spoolss_PrinterData _data /* [in] [subcontext(4),switch_is(type)] */,
4325 uint32_t __offered /* [in] [value(ndr_size_spoolss_PrinterData(&data,type,ndr->iconv_convenience,flags))] */)
4326 {
4327 struct tevent_req *req;
4328 struct rpccli_spoolss_SetPrinterData_state *state;
4329 struct tevent_req *subreq;
4330
4331 req = tevent_req_create(mem_ctx, &state,
4332 struct rpccli_spoolss_SetPrinterData_state);
4333 if (req == NULL) {
4334 return NULL;
4335 }
4336 state->out_mem_ctx = NULL;
4337 state->dispatch_recv = cli->dispatch_recv;
4338
4339 /* In parameters */
4340 state->orig.in.handle = _handle;
4341 state->orig.in.value_name = _value_name;
4342 state->orig.in.type = _type;
4343 state->orig.in.data = _data;
4344 state->orig.in._offered = __offered;
4345
4346 /* Out parameters */
4347
4348 /* Result */
4349 ZERO_STRUCT(state->orig.out.result);
4350
4351 /* make a temporary copy, that we pass to the dispatch function */
4352 state->tmp = state->orig;
4353
4354 subreq = cli->dispatch_send(state, ev, cli,
4355 &ndr_table_spoolss,
4356 NDR_SPOOLSS_SETPRINTERDATA,
4357 &state->tmp);
4358 if (tevent_req_nomem(subreq, req)) {
4359 return tevent_req_post(req, ev);
4360 }
4361 tevent_req_set_callback(subreq, rpccli_spoolss_SetPrinterData_done, req);
4362 return req;
4363 }
4364
4365 static void rpccli_spoolss_SetPrinterData_done(struct tevent_req *subreq)
4366 {
4367 struct tevent_req *req = tevent_req_callback_data(
4368 subreq, struct tevent_req);
4369 struct rpccli_spoolss_SetPrinterData_state *state = tevent_req_data(
4370 req, struct rpccli_spoolss_SetPrinterData_state);
4371 NTSTATUS status;
4372 TALLOC_CTX *mem_ctx;
4373
4374 if (state->out_mem_ctx) {
4375 mem_ctx = state->out_mem_ctx;
4376 } else {
4377 mem_ctx = state;
4378 }
4379
4380 status = state->dispatch_recv(subreq, mem_ctx);
4381 TALLOC_FREE(subreq);
4382 if (!NT_STATUS_IS_OK(status)) {
4383 tevent_req_nterror(req, status);
4384 return;
4385 }
4386
4387 /* Copy out parameters */
4388
4389 /* Copy result */
4390 state->orig.out.result = state->tmp.out.result;
4391
4392 /* Reset temporary structure */
4393 ZERO_STRUCT(state->tmp);
4394
4395 tevent_req_done(req);
4396 }
4397
4398 NTSTATUS rpccli_spoolss_SetPrinterData_recv(struct tevent_req *req,
4399 TALLOC_CTX *mem_ctx,
4400 WERROR *result)
4401 {
4402 struct rpccli_spoolss_SetPrinterData_state *state = tevent_req_data(
4403 req, struct rpccli_spoolss_SetPrinterData_state);
4404 NTSTATUS status;
4405
4406 if (tevent_req_is_nterror(req, &status)) {
4407 tevent_req_received(req);
4408 return status;
4409 }
4410
4411 /* Steal possbile out parameters to the callers context */
4412 talloc_steal(mem_ctx, state->out_mem_ctx);
4413
4414 /* Return result */
4415 *result = state->orig.out.result;
4416
4417 tevent_req_received(req);
4418 return NT_STATUS_OK;
4419 }
4420
4421 NTSTATUS rpccli_spoolss_SetPrinterData(struct rpc_pipe_client *cli,
4422 TALLOC_CTX *mem_ctx,
4423 struct policy_handle *handle /* [in] [ref] */,
4424 const char *value_name /* [in] [charset(UTF16)] */,
4425 enum winreg_Type type /* [in] */,
4426 union spoolss_PrinterData data /* [in] [subcontext(4),switch_is(type)] */,
4427 uint32_t _offered /* [in] [value(ndr_size_spoolss_PrinterData(&data,type,ndr->iconv_convenience,flags))] */,
4428 WERROR *werror)
4429 {
4430 struct spoolss_SetPrinterData r;
4431 NTSTATUS status;
4432
4433 /* In parameters */
4434 r.in.handle = handle;
4435 r.in.value_name = value_name;
4436 r.in.type = type;
4437 r.in.data = data;
4438 r.in._offered = _offered;
4439
4440 status = cli->dispatch(cli,
4441 mem_ctx,
4442 &ndr_table_spoolss,
4443 NDR_SPOOLSS_SETPRINTERDATA,
4444 &r);
4445
4446 if (!NT_STATUS_IS_OK(status)) {
4447 return status;
4448 }
4449
4450 if (NT_STATUS_IS_ERR(status)) {
4451 return status;
4452 }
4453
4454 /* Return variables */
4455
4456 /* Return result */
4457 if (werror) {
4458 *werror = r.out.result;
4459 }
4460
4461 return werror_to_ntstatus(r.out.result);
4462 }
4463
4464 struct rpccli_spoolss_WaitForPrinterChange_state {
4465 struct spoolss_WaitForPrinterChange orig;
4466 struct spoolss_WaitForPrinterChange tmp;
4467 TALLOC_CTX *out_mem_ctx;
4468 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4469 };
4470
4471 static void rpccli_spoolss_WaitForPrinterChange_done(struct tevent_req *subreq);
4472
4473 struct tevent_req *rpccli_spoolss_WaitForPrinterChange_send(TALLOC_CTX *mem_ctx,
4474 struct tevent_context *ev,
4475 struct rpc_pipe_client *cli)
4476 {
4477 struct tevent_req *req;
4478 struct rpccli_spoolss_WaitForPrinterChange_state *state;
4479 struct tevent_req *subreq;
4480
4481 req = tevent_req_create(mem_ctx, &state,
4482 struct rpccli_spoolss_WaitForPrinterChange_state);
4483 if (req == NULL) {
4484 return NULL;
4485 }
4486 state->out_mem_ctx = NULL;
4487 state->dispatch_recv = cli->dispatch_recv;
4488
4489 /* In parameters */
4490
4491 /* Out parameters */
4492
4493 /* Result */
4494 ZERO_STRUCT(state->orig.out.result);
4495
4496 /* make a temporary copy, that we pass to the dispatch function */
4497 state->tmp = state->orig;
4498
4499 subreq = cli->dispatch_send(state, ev, cli,
4500 &ndr_table_spoolss,
4501 NDR_SPOOLSS_WAITFORPRINTERCHANGE,
4502 &state->tmp);
4503 if (tevent_req_nomem(subreq, req)) {
4504 return tevent_req_post(req, ev);
4505 }
4506 tevent_req_set_callback(subreq, rpccli_spoolss_WaitForPrinterChange_done, req);
4507 return req;
4508 }
4509
4510 static void rpccli_spoolss_WaitForPrinterChange_done(struct tevent_req *subreq)
4511 {
4512 struct tevent_req *req = tevent_req_callback_data(
4513 subreq, struct tevent_req);
4514 struct rpccli_spoolss_WaitForPrinterChange_state *state = tevent_req_data(
4515 req, struct rpccli_spoolss_WaitForPrinterChange_state);
4516 NTSTATUS status;
4517 TALLOC_CTX *mem_ctx;
4518
4519 if (state->out_mem_ctx) {
4520 mem_ctx = state->out_mem_ctx;
4521 } else {
4522 mem_ctx = state;
4523 }
4524
4525 status = state->dispatch_recv(subreq, mem_ctx);
4526 TALLOC_FREE(subreq);
4527 if (!NT_STATUS_IS_OK(status)) {
4528 tevent_req_nterror(req, status);
4529 return;
4530 }
4531
4532 /* Copy out parameters */
4533
4534 /* Copy result */
4535 state->orig.out.result = state->tmp.out.result;
4536
4537 /* Reset temporary structure */
4538 ZERO_STRUCT(state->tmp);
4539
4540 tevent_req_done(req);
4541 }
4542
4543 NTSTATUS rpccli_spoolss_WaitForPrinterChange_recv(struct tevent_req *req,
4544 TALLOC_CTX *mem_ctx,
4545 WERROR *result)
4546 {
4547 struct rpccli_spoolss_WaitForPrinterChange_state *state = tevent_req_data(
4548 req, struct rpccli_spoolss_WaitForPrinterChange_state);
4549 NTSTATUS status;
4550
4551 if (tevent_req_is_nterror(req, &status)) {
4552 tevent_req_received(req);
4553 return status;
4554 }
4555
4556 /* Steal possbile out parameters to the callers context */
4557 talloc_steal(mem_ctx, state->out_mem_ctx);
4558
4559 /* Return result */
4560 *result = state->orig.out.result;
4561
4562 tevent_req_received(req);
4563 return NT_STATUS_OK;
4564 }
4565
4566 NTSTATUS rpccli_spoolss_WaitForPrinterChange(struct rpc_pipe_client *cli,
4567 TALLOC_CTX *mem_ctx,
4568 WERROR *werror)
4569 {
4570 struct spoolss_WaitForPrinterChange r;
4571 NTSTATUS status;
4572
4573 /* In parameters */
4574
4575 status = cli->dispatch(cli,
4576 mem_ctx,
4577 &ndr_table_spoolss,
4578 NDR_SPOOLSS_WAITFORPRINTERCHANGE,
4579 &r);
4580
4581 if (!NT_STATUS_IS_OK(status)) {
4582 return status;
4583 }
4584
4585 if (NT_STATUS_IS_ERR(status)) {
4586 return status;
4587 }
4588
4589 /* Return variables */
4590
4591 /* Return result */
4592 if (werror) {
4593 *werror = r.out.result;
4594 }
4595
4596 return werror_to_ntstatus(r.out.result);
4597 }
4598
4599 struct rpccli_spoolss_ClosePrinter_state {
4600 struct spoolss_ClosePrinter orig;
4601 struct spoolss_ClosePrinter tmp;
4602 TALLOC_CTX *out_mem_ctx;
4603 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4604 };
4605
4606 static void rpccli_spoolss_ClosePrinter_done(struct tevent_req *subreq);
4607
4608 struct tevent_req *rpccli_spoolss_ClosePrinter_send(TALLOC_CTX *mem_ctx,
4609 struct tevent_context *ev,
4610 struct rpc_pipe_client *cli,
4611 struct policy_handle *_handle /* [in,out] [ref] */)
4612 {
4613 struct tevent_req *req;
4614 struct rpccli_spoolss_ClosePrinter_state *state;
4615 struct tevent_req *subreq;
4616
4617 req = tevent_req_create(mem_ctx, &state,
4618 struct rpccli_spoolss_ClosePrinter_state);
4619 if (req == NULL) {
4620 return NULL;
4621 }
4622 state->out_mem_ctx = NULL;
4623 state->dispatch_recv = cli->dispatch_recv;
4624
4625 /* In parameters */
4626 state->orig.in.handle = _handle;
4627
4628 /* Out parameters */
4629 state->orig.out.handle = _handle;
4630
4631 /* Result */
4632 ZERO_STRUCT(state->orig.out.result);
4633
4634 state->out_mem_ctx = talloc_named_const(state, 0,
4635 "rpccli_spoolss_ClosePrinter_out_memory");
4636 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4637 return tevent_req_post(req, ev);
4638 }
4639
4640 /* make a temporary copy, that we pass to the dispatch function */
4641 state->tmp = state->orig;
4642
4643 subreq = cli->dispatch_send(state, ev, cli,
4644 &ndr_table_spoolss,
4645 NDR_SPOOLSS_CLOSEPRINTER,
4646 &state->tmp);
4647 if (tevent_req_nomem(subreq, req)) {
4648 return tevent_req_post(req, ev);
4649 }
4650 tevent_req_set_callback(subreq, rpccli_spoolss_ClosePrinter_done, req);
4651 return req;
4652 }
4653
4654 static void rpccli_spoolss_ClosePrinter_done(struct tevent_req *subreq)
4655 {
4656 struct tevent_req *req = tevent_req_callback_data(
4657 subreq, struct tevent_req);
4658 struct rpccli_spoolss_ClosePrinter_state *state = tevent_req_data(
4659 req, struct rpccli_spoolss_ClosePrinter_state);
4660 NTSTATUS status;
4661 TALLOC_CTX *mem_ctx;
4662
4663 if (state->out_mem_ctx) {
4664 mem_ctx = state->out_mem_ctx;
4665 } else {
4666 mem_ctx = state;
4667 }
4668
4669 status = state->dispatch_recv(subreq, mem_ctx);
4670 TALLOC_FREE(subreq);
4671 if (!NT_STATUS_IS_OK(status)) {
4672 tevent_req_nterror(req, status);
4673 return;
4674 }
4675
4676 /* Copy out parameters */
4677 *state->orig.out.handle = *state->tmp.out.handle;
4678
4679 /* Copy result */
4680 state->orig.out.result = state->tmp.out.result;
4681
4682 /* Reset temporary structure */
4683 ZERO_STRUCT(state->tmp);
4684
4685 tevent_req_done(req);
4686 }
4687
4688 NTSTATUS rpccli_spoolss_ClosePrinter_recv(struct tevent_req *req,
4689 TALLOC_CTX *mem_ctx,
4690 WERROR *result)
4691 {
4692 struct rpccli_spoolss_ClosePrinter_state *state = tevent_req_data(
4693 req, struct rpccli_spoolss_ClosePrinter_state);
4694 NTSTATUS status;
4695
4696 if (tevent_req_is_nterror(req, &status)) {
4697 tevent_req_received(req);
4698 return status;
4699 }
4700
4701 /* Steal possbile out parameters to the callers context */
4702 talloc_steal(mem_ctx, state->out_mem_ctx);
4703
4704 /* Return result */
4705 *result = state->orig.out.result;
4706
4707 tevent_req_received(req);
4708 return NT_STATUS_OK;
4709 }
4710
4711 NTSTATUS rpccli_spoolss_ClosePrinter(struct rpc_pipe_client *cli,
4712 TALLOC_CTX *mem_ctx,
4713 struct policy_handle *handle /* [in,out] [ref] */,
4714 WERROR *werror)
4715 {
4716 struct spoolss_ClosePrinter r;
4717 NTSTATUS status;
4718
4719 /* In parameters */
4720 r.in.handle = handle;
4721
4722 status = cli->dispatch(cli,
4723 mem_ctx,
4724 &ndr_table_spoolss,
4725 NDR_SPOOLSS_CLOSEPRINTER,
4726 &r);
4727
4728 if (!NT_STATUS_IS_OK(status)) {
4729 return status;
4730 }
4731
4732 if (NT_STATUS_IS_ERR(status)) {
4733 return status;
4734 }
4735
4736 /* Return variables */
4737 *handle = *r.out.handle;
4738
4739 /* Return result */
4740 if (werror) {
4741 *werror = r.out.result;
4742 }
4743
4744 return werror_to_ntstatus(r.out.result);
4745 }
4746
4747 struct rpccli_spoolss_AddForm_state {
4748 struct spoolss_AddForm orig;
4749 struct spoolss_AddForm tmp;
4750 TALLOC_CTX *out_mem_ctx;
4751 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4752 };
4753
4754 static void rpccli_spoolss_AddForm_done(struct tevent_req *subreq);
4755
4756 struct tevent_req *rpccli_spoolss_AddForm_send(TALLOC_CTX *mem_ctx,
4757 struct tevent_context *ev,
4758 struct rpc_pipe_client *cli,
4759 struct policy_handle *_handle /* [in] [ref] */,
4760 uint32_t _level /* [in] */,
4761 union spoolss_AddFormInfo _info /* [in] [switch_is(level)] */)
4762 {
4763 struct tevent_req *req;
4764 struct rpccli_spoolss_AddForm_state *state;
4765 struct tevent_req *subreq;
4766
4767 req = tevent_req_create(mem_ctx, &state,
4768 struct rpccli_spoolss_AddForm_state);
4769 if (req == NULL) {
4770 return NULL;
4771 }
4772 state->out_mem_ctx = NULL;
4773 state->dispatch_recv = cli->dispatch_recv;
4774
4775 /* In parameters */
4776 state->orig.in.handle = _handle;
4777 state->orig.in.level = _level;
4778 state->orig.in.info = _info;
4779
4780 /* Out parameters */
4781
4782 /* Result */
4783 ZERO_STRUCT(state->orig.out.result);
4784
4785 /* make a temporary copy, that we pass to the dispatch function */
4786 state->tmp = state->orig;
4787
4788 subreq = cli->dispatch_send(state, ev, cli,
4789 &ndr_table_spoolss,
4790 NDR_SPOOLSS_ADDFORM,
4791 &state->tmp);
4792 if (tevent_req_nomem(subreq, req)) {
4793 return tevent_req_post(req, ev);
4794 }
4795 tevent_req_set_callback(subreq, rpccli_spoolss_AddForm_done, req);
4796 return req;
4797 }
4798
4799 static void rpccli_spoolss_AddForm_done(struct tevent_req *subreq)
4800 {
4801 struct tevent_req *req = tevent_req_callback_data(
4802 subreq, struct tevent_req);
4803 struct rpccli_spoolss_AddForm_state *state = tevent_req_data(
4804 req, struct rpccli_spoolss_AddForm_state);
4805 NTSTATUS status;
4806 TALLOC_CTX *mem_ctx;
4807
4808 if (state->out_mem_ctx) {
4809 mem_ctx = state->out_mem_ctx;
4810 } else {
4811 mem_ctx = state;
4812 }
4813
4814 status = state->dispatch_recv(subreq, mem_ctx);
4815 TALLOC_FREE(subreq);
4816 if (!NT_STATUS_IS_OK(status)) {
4817 tevent_req_nterror(req, status);
4818 return;
4819 }
4820
4821 /* Copy out parameters */
4822
4823 /* Copy result */
4824 state->orig.out.result = state->tmp.out.result;
4825
4826 /* Reset temporary structure */
4827 ZERO_STRUCT(state->tmp);
4828
4829 tevent_req_done(req);
4830 }
4831
4832 NTSTATUS rpccli_spoolss_AddForm_recv(struct tevent_req *req,
4833 TALLOC_CTX *mem_ctx,
4834 WERROR *result)
4835 {
4836 struct rpccli_spoolss_AddForm_state *state = tevent_req_data(
4837 req, struct rpccli_spoolss_AddForm_state);
4838 NTSTATUS status;
4839
4840 if (tevent_req_is_nterror(req, &status)) {
4841 tevent_req_received(req);
4842 return status;
4843 }
4844
4845 /* Steal possbile out parameters to the callers context */
4846 talloc_steal(mem_ctx, state->out_mem_ctx);
4847
4848 /* Return result */
4849 *result = state->orig.out.result;
4850
4851 tevent_req_received(req);
4852 return NT_STATUS_OK;
4853 }
4854
4855 NTSTATUS rpccli_spoolss_AddForm(struct rpc_pipe_client *cli,
4856 TALLOC_CTX *mem_ctx,
4857 struct policy_handle *handle /* [in] [ref] */,
4858 uint32_t level /* [in] */,
4859 union spoolss_AddFormInfo info /* [in] [switch_is(level)] */,
4860 WERROR *werror)
4861 {
4862 struct spoolss_AddForm r;
4863 NTSTATUS status;
4864
4865 /* In parameters */
4866 r.in.handle = handle;
4867 r.in.level = level;
4868 r.in.info = info;
4869
4870 status = cli->dispatch(cli,
4871 mem_ctx,
4872 &ndr_table_spoolss,
4873 NDR_SPOOLSS_ADDFORM,
4874 &r);
4875
4876 if (!NT_STATUS_IS_OK(status)) {
4877 return status;
4878 }
4879
4880 if (NT_STATUS_IS_ERR(status)) {
4881 return status;
4882 }
4883
4884 /* Return variables */
4885
4886 /* Return result */
4887 if (werror) {
4888 *werror = r.out.result;
4889 }
4890
4891 return werror_to_ntstatus(r.out.result);
4892 }
4893
4894 struct rpccli_spoolss_DeleteForm_state {
4895 struct spoolss_DeleteForm orig;
4896 struct spoolss_DeleteForm tmp;
4897 TALLOC_CTX *out_mem_ctx;
4898 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4899 };
4900
4901 static void rpccli_spoolss_DeleteForm_done(struct tevent_req *subreq);
4902
4903 struct tevent_req *rpccli_spoolss_DeleteForm_send(TALLOC_CTX *mem_ctx,
4904 struct tevent_context *ev,
4905 struct rpc_pipe_client *cli,
4906 struct policy_handle *_handle /* [in] [ref] */,
4907 const char *_form_name /* [in] [charset(UTF16)] */)
4908 {
4909 struct tevent_req *req;
4910 struct rpccli_spoolss_DeleteForm_state *state;
4911 struct tevent_req *subreq;
4912
4913 req = tevent_req_create(mem_ctx, &state,
4914 struct rpccli_spoolss_DeleteForm_state);
4915 if (req == NULL) {
4916 return NULL;
4917 }
4918 state->out_mem_ctx = NULL;
4919 state->dispatch_recv = cli->dispatch_recv;
4920
4921 /* In parameters */
4922 state->orig.in.handle = _handle;
4923 state->orig.in.form_name = _form_name;
4924
4925 /* Out parameters */
4926
4927 /* Result */
4928 ZERO_STRUCT(state->orig.out.result);
4929
4930 /* make a temporary copy, that we pass to the dispatch function */
4931 state->tmp = state->orig;
4932
4933 subreq = cli->dispatch_send(state, ev, cli,
4934 &ndr_table_spoolss,
4935 NDR_SPOOLSS_DELETEFORM,
4936 &state->tmp);
4937 if (tevent_req_nomem(subreq, req)) {
4938 return tevent_req_post(req, ev);
4939 }
4940 tevent_req_set_callback(subreq, rpccli_spoolss_DeleteForm_done, req);
4941 return req;
4942 }
4943
4944 static void rpccli_spoolss_DeleteForm_done(struct tevent_req *subreq)
4945 {
4946 struct tevent_req *req = tevent_req_callback_data(
4947 subreq, struct tevent_req);
4948 struct rpccli_spoolss_DeleteForm_state *state = tevent_req_data(
4949 req, struct rpccli_spoolss_DeleteForm_state);
4950 NTSTATUS status;
4951 TALLOC_CTX *mem_ctx;
4952
4953 if (state->out_mem_ctx) {
4954 mem_ctx = state->out_mem_ctx;
4955 } else {
4956 mem_ctx = state;
4957 }
4958
4959 status = state->dispatch_recv(subreq, mem_ctx);
4960 TALLOC_FREE(subreq);
4961 if (!NT_STATUS_IS_OK(status)) {
4962 tevent_req_nterror(req, status);
4963 return;
4964 }
4965
4966 /* Copy out parameters */
4967
4968 /* Copy result */
4969 state->orig.out.result = state->tmp.out.result;
4970
4971 /* Reset temporary structure */
4972 ZERO_STRUCT(state->tmp);
4973
4974 tevent_req_done(req);
4975 }
4976
4977 NTSTATUS rpccli_spoolss_DeleteForm_recv(struct tevent_req *req,
4978 TALLOC_CTX *mem_ctx,
4979 WERROR *result)
4980 {
4981 struct rpccli_spoolss_DeleteForm_state *state = tevent_req_data(
4982 req, struct rpccli_spoolss_DeleteForm_state);
4983 NTSTATUS status;
4984
4985 if (tevent_req_is_nterror(req, &status)) {
4986 tevent_req_received(req);
4987 return status;
4988 }
4989
4990 /* Steal possbile out parameters to the callers context */
4991 talloc_steal(mem_ctx, state->out_mem_ctx);
4992
4993 /* Return result */
4994 *result = state->orig.out.result;
4995
4996 tevent_req_received(req);
4997 return NT_STATUS_OK;
4998 }
4999
5000 NTSTATUS rpccli_spoolss_DeleteForm(struct rpc_pipe_client *cli,
5001 TALLOC_CTX *mem_ctx,
5002 struct policy_handle *handle /* [in] [ref] */,
5003 const char *form_name /* [in] [charset(UTF16)] */,
5004 WERROR *werror)
5005 {
5006 struct spoolss_DeleteForm r;
5007 NTSTATUS status;
5008
5009 /* In parameters */
5010 r.in.handle = handle;
5011 r.in.form_name = form_name;
5012
5013 status = cli->dispatch(cli,
5014 mem_ctx,
5015 &ndr_table_spoolss,
5016 NDR_SPOOLSS_DELETEFORM,
5017 &r);
5018
5019 if (!NT_STATUS_IS_OK(status)) {
5020 return status;
5021 }
5022
5023 if (NT_STATUS_IS_ERR(status)) {
5024 return status;
5025 }
5026
5027 /* Return variables */
5028
5029 /* Return result */
5030 if (werror) {
5031 *werror = r.out.result;
5032 }
5033
5034 return werror_to_ntstatus(r.out.result);
5035 }
5036
5037 struct rpccli_spoolss_GetForm_state {
5038 struct spoolss_GetForm orig;
5039 struct spoolss_GetForm tmp;
5040 TALLOC_CTX *out_mem_ctx;
5041 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5042 };
5043
5044 static void rpccli_spoolss_GetForm_done(struct tevent_req *subreq);
5045
5046 struct tevent_req *rpccli_spoolss_GetForm_send(TALLOC_CTX *mem_ctx,
5047 struct tevent_context *ev,
5048 struct rpc_pipe_client *cli,
5049 struct policy_handle *_handle /* [in] [ref] */,
5050 const char *_form_name /* [in] [charset(UTF16)] */,
5051 uint32_t _level /* [in] */,
5052 DATA_BLOB *_buffer /* [in] [unique] */,
5053 uint32_t _offered /* [in] */,
5054 union spoolss_FormInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
5055 uint32_t *_needed /* [out] [ref] */)
5056 {
5057 struct tevent_req *req;
5058 struct rpccli_spoolss_GetForm_state *state;
5059 struct tevent_req *subreq;
5060
5061 req = tevent_req_create(mem_ctx, &state,
5062 struct rpccli_spoolss_GetForm_state);
5063 if (req == NULL) {
5064 return NULL;
5065 }
5066 state->out_mem_ctx = NULL;
5067 state->dispatch_recv = cli->dispatch_recv;
5068
5069 /* In parameters */
5070 state->orig.in.handle = _handle;
5071 state->orig.in.form_name = _form_name;
5072 state->orig.in.level = _level;
5073 state->orig.in.buffer = _buffer;
5074 state->orig.in.offered = _offered;
5075
5076 /* Out parameters */
5077 state->orig.out.info = _info;
5078 state->orig.out.needed = _needed;
5079
5080 /* Result */
5081 ZERO_STRUCT(state->orig.out.result);
5082
5083 state->out_mem_ctx = talloc_named_const(state, 0,
5084 "rpccli_spoolss_GetForm_out_memory");
5085 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5086 return tevent_req_post(req, ev);
5087 }
5088
5089 /* make a temporary copy, that we pass to the dispatch function */
5090 state->tmp = state->orig;
5091
5092 subreq = cli->dispatch_send(state, ev, cli,
5093 &ndr_table_spoolss,
5094 NDR_SPOOLSS_GETFORM,
5095 &state->tmp);
5096 if (tevent_req_nomem(subreq, req)) {
5097 return tevent_req_post(req, ev);
5098 }
5099 tevent_req_set_callback(subreq, rpccli_spoolss_GetForm_done, req);
5100 return req;
5101 }
5102
5103 static void rpccli_spoolss_GetForm_done(struct tevent_req *subreq)
5104 {
5105 struct tevent_req *req = tevent_req_callback_data(
5106 subreq, struct tevent_req);
5107 struct rpccli_spoolss_GetForm_state *state = tevent_req_data(
5108 req, struct rpccli_spoolss_GetForm_state);
5109 NTSTATUS status;
5110 TALLOC_CTX *mem_ctx;
5111
5112 if (state->out_mem_ctx) {
5113 mem_ctx = state->out_mem_ctx;
5114 } else {
5115 mem_ctx = state;
5116 }
5117
5118 status = state->dispatch_recv(subreq, mem_ctx);
5119 TALLOC_FREE(subreq);
5120 if (!NT_STATUS_IS_OK(status)) {
5121 tevent_req_nterror(req, status);
5122 return;
5123 }
5124
5125 /* Copy out parameters */
5126 if (state->orig.out.info && state->tmp.out.info) {
5127 *state->orig.out.info = *state->tmp.out.info;
5128 }
5129 *state->orig.out.needed = *state->tmp.out.needed;
5130
5131 /* Copy result */
5132 state->orig.out.result = state->tmp.out.result;
5133
5134 /* Reset temporary structure */
5135 ZERO_STRUCT(state->tmp);
5136
5137 tevent_req_done(req);
5138 }
5139
5140 NTSTATUS rpccli_spoolss_GetForm_recv(struct tevent_req *req,
5141 TALLOC_CTX *mem_ctx,
5142 WERROR *result)
5143 {
5144 struct rpccli_spoolss_GetForm_state *state = tevent_req_data(
5145 req, struct rpccli_spoolss_GetForm_state);
5146 NTSTATUS status;
5147
5148 if (tevent_req_is_nterror(req, &status)) {
5149 tevent_req_received(req);
5150 return status;
5151 }
5152
5153 /* Steal possbile out parameters to the callers context */
5154 talloc_steal(mem_ctx, state->out_mem_ctx);
5155
5156 /* Return result */
5157 *result = state->orig.out.result;
5158
5159 tevent_req_received(req);
5160 return NT_STATUS_OK;
5161 }
5162
5163 NTSTATUS rpccli_spoolss_GetForm(struct rpc_pipe_client *cli,
5164 TALLOC_CTX *mem_ctx,
5165 struct policy_handle *handle /* [in] [ref] */,
5166 const char *form_name /* [in] [charset(UTF16)] */,
5167 uint32_t level /* [in] */,
5168 DATA_BLOB *buffer /* [in] [unique] */,
5169 uint32_t offered /* [in] */,
5170 union spoolss_FormInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
5171 uint32_t *needed /* [out] [ref] */,
5172 WERROR *werror)
5173 {
5174 struct spoolss_GetForm r;
5175 NTSTATUS status;
5176
5177 /* In parameters */
5178 r.in.handle = handle;
5179 r.in.form_name = form_name;
5180 r.in.level = level;
5181 r.in.buffer = buffer;
5182 r.in.offered = offered;
5183
5184 status = cli->dispatch(cli,
5185 mem_ctx,
5186 &ndr_table_spoolss,
5187 NDR_SPOOLSS_GETFORM,
5188 &r);
5189
5190 if (!NT_STATUS_IS_OK(status)) {
5191 return status;
5192 }
5193
5194 if (NT_STATUS_IS_ERR(status)) {
5195 return status;
5196 }
5197
5198 /* Return variables */
5199 if (info && r.out.info) {
5200 *info = *r.out.info;
5201 }
5202 *needed = *r.out.needed;
5203
5204 /* Return result */
5205 if (werror) {
5206 *werror = r.out.result;
5207 }
5208
5209 return werror_to_ntstatus(r.out.result);
5210 }
5211
5212 struct rpccli_spoolss_SetForm_state {
5213 struct spoolss_SetForm orig;
5214 struct spoolss_SetForm tmp;
5215 TALLOC_CTX *out_mem_ctx;
5216 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5217 };
5218
5219 static void rpccli_spoolss_SetForm_done(struct tevent_req *subreq);
5220
5221 struct tevent_req *rpccli_spoolss_SetForm_send(TALLOC_CTX *mem_ctx,
5222 struct tevent_context *ev,
5223 struct rpc_pipe_client *cli,
5224 struct policy_handle *_handle /* [in] [ref] */,
5225 const char *_form_name /* [in] [charset(UTF16)] */,
5226 uint32_t _level /* [in] */,
5227 union spoolss_AddFormInfo _info /* [in] [switch_is(level)] */)
5228 {
5229 struct tevent_req *req;
5230 struct rpccli_spoolss_SetForm_state *state;
5231 struct tevent_req *subreq;
5232
5233 req = tevent_req_create(mem_ctx, &state,
5234 struct rpccli_spoolss_SetForm_state);
5235 if (req == NULL) {
5236 return NULL;
5237 }
5238 state->out_mem_ctx = NULL;
5239 state->dispatch_recv = cli->dispatch_recv;
5240
5241 /* In parameters */
5242 state->orig.in.handle = _handle;
5243 state->orig.in.form_name = _form_name;
5244 state->orig.in.level = _level;
5245 state->orig.in.info = _info;
5246
5247 /* Out parameters */
5248
5249 /* Result */
5250 ZERO_STRUCT(state->orig.out.result);
5251
5252 /* make a temporary copy, that we pass to the dispatch function */
5253 state->tmp = state->orig;
5254
5255 subreq = cli->dispatch_send(state, ev, cli,
5256 &ndr_table_spoolss,
5257 NDR_SPOOLSS_SETFORM,
5258 &state->tmp);
5259 if (tevent_req_nomem(subreq, req)) {
5260 return tevent_req_post(req, ev);
5261 }
5262 tevent_req_set_callback(subreq, rpccli_spoolss_SetForm_done, req);
5263 return req;
5264 }
5265
5266 static void rpccli_spoolss_SetForm_done(struct tevent_req *subreq)
5267 {
5268 struct tevent_req *req = tevent_req_callback_data(
5269 subreq, struct tevent_req);
5270 struct rpccli_spoolss_SetForm_state *state = tevent_req_data(
5271 req, struct rpccli_spoolss_SetForm_state);
5272 NTSTATUS status;
5273 TALLOC_CTX *mem_ctx;
5274
5275 if (state->out_mem_ctx) {
5276 mem_ctx = state->out_mem_ctx;
5277 } else {
5278 mem_ctx = state;
5279 }
5280
5281 status = state->dispatch_recv(subreq, mem_ctx);
5282 TALLOC_FREE(subreq);
5283 if (!NT_STATUS_IS_OK(status)) {
5284 tevent_req_nterror(req, status);
5285 return;
5286 }
5287
5288 /* Copy out parameters */
5289
5290 /* Copy result */
5291 state->orig.out.result = state->tmp.out.result;
5292
5293 /* Reset temporary structure */
5294 ZERO_STRUCT(state->tmp);
5295
5296 tevent_req_done(req);
5297 }
5298
5299 NTSTATUS rpccli_spoolss_SetForm_recv(struct tevent_req *req,
5300 TALLOC_CTX *mem_ctx,
5301 WERROR *result)
5302 {
5303 struct rpccli_spoolss_SetForm_state *state = tevent_req_data(
5304 req, struct rpccli_spoolss_SetForm_state);
5305 NTSTATUS status;
5306
5307 if (tevent_req_is_nterror(req, &status)) {
5308 tevent_req_received(req);
5309 return status;
5310 }
5311
5312 /* Steal possbile out parameters to the callers context */
5313 talloc_steal(mem_ctx, state->out_mem_ctx);
5314
5315 /* Return result */
5316 *result = state->orig.out.result;
5317
5318 tevent_req_received(req);
5319 return NT_STATUS_OK;
5320 }
5321
5322 NTSTATUS rpccli_spoolss_SetForm(struct rpc_pipe_client *cli,
5323 TALLOC_CTX *mem_ctx,
5324 struct policy_handle *handle /* [in] [ref] */,
5325 const char *form_name /* [in] [charset(UTF16)] */,
5326 uint32_t level /* [in] */,
5327 union spoolss_AddFormInfo info /* [in] [switch_is(level)] */,
5328 WERROR *werror)
5329 {
5330 struct spoolss_SetForm r;
5331 NTSTATUS status;
5332
5333 /* In parameters */
5334 r.in.handle = handle;
5335 r.in.form_name = form_name;
5336 r.in.level = level;
5337 r.in.info = info;
5338
5339 status = cli->dispatch(cli,
5340 mem_ctx,
5341 &ndr_table_spoolss,
5342 NDR_SPOOLSS_SETFORM,
5343 &r);
5344
5345 if (!NT_STATUS_IS_OK(status)) {
5346 return status;
5347 }
5348
5349 if (NT_STATUS_IS_ERR(status)) {
5350 return status;
5351 }
5352
5353 /* Return variables */
5354
5355 /* Return result */
5356 if (werror) {
5357 *werror = r.out.result;
5358 }
5359
5360 return werror_to_ntstatus(r.out.result);
5361 }
5362
5363 struct rpccli_spoolss_EnumForms_state {
5364 struct spoolss_EnumForms orig;
5365 struct spoolss_EnumForms tmp;
5366 TALLOC_CTX *out_mem_ctx;
5367 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5368 };
5369
5370 static void rpccli_spoolss_EnumForms_done(struct tevent_req *subreq);
5371
5372 struct tevent_req *rpccli_spoolss_EnumForms_send(TALLOC_CTX *mem_ctx,
5373 struct tevent_context *ev,
5374 struct rpc_pipe_client *cli,
5375 struct policy_handle *_handle /* [in] [ref] */,
5376 uint32_t _level /* [in] */,
5377 DATA_BLOB *_buffer /* [in] [unique] */,
5378 uint32_t _offered /* [in] */,
5379 uint32_t *_count /* [out] [ref] */,
5380 union spoolss_FormInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5381 uint32_t *_needed /* [out] [ref] */)
5382 {
5383 struct tevent_req *req;
5384 struct rpccli_spoolss_EnumForms_state *state;
5385 struct tevent_req *subreq;
5386
5387 req = tevent_req_create(mem_ctx, &state,
5388 struct rpccli_spoolss_EnumForms_state);
5389 if (req == NULL) {
5390 return NULL;
5391 }
5392 state->out_mem_ctx = NULL;
5393 state->dispatch_recv = cli->dispatch_recv;
5394
5395 /* In parameters */
5396 state->orig.in.handle = _handle;
5397 state->orig.in.level = _level;
5398 state->orig.in.buffer = _buffer;
5399 state->orig.in.offered = _offered;
5400
5401 /* Out parameters */
5402 state->orig.out.count = _count;
5403 state->orig.out.info = _info;
5404 state->orig.out.needed = _needed;
5405
5406 /* Result */
5407 ZERO_STRUCT(state->orig.out.result);
5408
5409 state->out_mem_ctx = talloc_named_const(state, 0,
5410 "rpccli_spoolss_EnumForms_out_memory");
5411 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5412 return tevent_req_post(req, ev);
5413 }
5414
5415 /* make a temporary copy, that we pass to the dispatch function */
5416 state->tmp = state->orig;
5417
5418 subreq = cli->dispatch_send(state, ev, cli,
5419 &ndr_table_spoolss,
5420 NDR_SPOOLSS_ENUMFORMS,
5421 &state->tmp);
5422 if (tevent_req_nomem(subreq, req)) {
5423 return tevent_req_post(req, ev);
5424 }
5425 tevent_req_set_callback(subreq, rpccli_spoolss_EnumForms_done, req);
5426 return req;
5427 }
5428
5429 static void rpccli_spoolss_EnumForms_done(struct tevent_req *subreq)
5430 {
5431 struct tevent_req *req = tevent_req_callback_data(
5432 subreq, struct tevent_req);
5433 struct rpccli_spoolss_EnumForms_state *state = tevent_req_data(
5434 req, struct rpccli_spoolss_EnumForms_state);
5435 NTSTATUS status;
5436 TALLOC_CTX *mem_ctx;
5437
5438 if (state->out_mem_ctx) {
5439 mem_ctx = state->out_mem_ctx;
5440 } else {
5441 mem_ctx = state;
5442 }
5443
5444 status = state->dispatch_recv(subreq, mem_ctx);
5445 TALLOC_FREE(subreq);
5446 if (!NT_STATUS_IS_OK(status)) {
5447 tevent_req_nterror(req, status);
5448 return;
5449 }
5450
5451 /* Copy out parameters */
5452 *state->orig.out.count = *state->tmp.out.count;
5453 *state->orig.out.info = *state->tmp.out.info;
5454 *state->orig.out.needed = *state->tmp.out.needed;
5455
5456 /* Copy result */
5457 state->orig.out.result = state->tmp.out.result;
5458
5459 /* Reset temporary structure */
5460 ZERO_STRUCT(state->tmp);
5461
5462 tevent_req_done(req);
5463 }
5464
5465 NTSTATUS rpccli_spoolss_EnumForms_recv(struct tevent_req *req,
5466 TALLOC_CTX *mem_ctx,
5467 WERROR *result)
5468 {
5469 struct rpccli_spoolss_EnumForms_state *state = tevent_req_data(
5470 req, struct rpccli_spoolss_EnumForms_state);
5471 NTSTATUS status;
5472
5473 if (tevent_req_is_nterror(req, &status)) {
5474 tevent_req_received(req);
5475 return status;
5476 }
5477
5478 /* Steal possbile out parameters to the callers context */
5479 talloc_steal(mem_ctx, state->out_mem_ctx);
5480
5481 /* Return result */
5482 *result = state->orig.out.result;
5483
5484 tevent_req_received(req);
5485 return NT_STATUS_OK;
5486 }
5487
5488 NTSTATUS rpccli_spoolss_EnumForms(struct rpc_pipe_client *cli,
5489 TALLOC_CTX *mem_ctx,
5490 struct policy_handle *handle /* [in] [ref] */,
5491 uint32_t level /* [in] */,
5492 DATA_BLOB *buffer /* [in] [unique] */,
5493 uint32_t offered /* [in] */,
5494 uint32_t *count /* [out] [ref] */,
5495 union spoolss_FormInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5496 uint32_t *needed /* [out] [ref] */,
5497 WERROR *werror)
5498 {
5499 struct spoolss_EnumForms r;
5500 NTSTATUS status;
5501
5502 /* In parameters */
5503 r.in.handle = handle;
5504 r.in.level = level;
5505 r.in.buffer = buffer;
5506 r.in.offered = offered;
5507
5508 status = cli->dispatch(cli,
5509 mem_ctx,
5510 &ndr_table_spoolss,
5511 NDR_SPOOLSS_ENUMFORMS,
5512 &r);
5513
5514 if (!NT_STATUS_IS_OK(status)) {
5515 return status;
5516 }
5517
5518 if (NT_STATUS_IS_ERR(status)) {
5519 return status;
5520 }
5521
5522 /* Return variables */
5523 *count = *r.out.count;
5524 *info = *r.out.info;
5525 *needed = *r.out.needed;
5526
5527 /* Return result */
5528 if (werror) {
5529 *werror = r.out.result;
5530 }
5531
5532 return werror_to_ntstatus(r.out.result);
5533 }
5534
5535 struct rpccli_spoolss_EnumPorts_state {
5536 struct spoolss_EnumPorts orig;
5537 struct spoolss_EnumPorts tmp;
5538 TALLOC_CTX *out_mem_ctx;
5539 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5540 };
5541
5542 static void rpccli_spoolss_EnumPorts_done(struct tevent_req *subreq);
5543
5544 struct tevent_req *rpccli_spoolss_EnumPorts_send(TALLOC_CTX *mem_ctx,
5545 struct tevent_context *ev,
5546 struct rpc_pipe_client *cli,
5547 const char *_servername /* [in] [unique,charset(UTF16)] */,
5548 uint32_t _level /* [in] */,
5549 DATA_BLOB *_buffer /* [in] [unique] */,
5550 uint32_t _offered /* [in] */,
5551 uint32_t *_count /* [out] [ref] */,
5552 union spoolss_PortInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5553 uint32_t *_needed /* [out] [ref] */)
5554 {
5555 struct tevent_req *req;
5556 struct rpccli_spoolss_EnumPorts_state *state;
5557 struct tevent_req *subreq;
5558
5559 req = tevent_req_create(mem_ctx, &state,
5560 struct rpccli_spoolss_EnumPorts_state);
5561 if (req == NULL) {
5562 return NULL;
5563 }
5564 state->out_mem_ctx = NULL;
5565 state->dispatch_recv = cli->dispatch_recv;
5566
5567 /* In parameters */
5568 state->orig.in.servername = _servername;
5569 state->orig.in.level = _level;
5570 state->orig.in.buffer = _buffer;
5571 state->orig.in.offered = _offered;
5572
5573 /* Out parameters */
5574 state->orig.out.count = _count;
5575 state->orig.out.info = _info;
5576 state->orig.out.needed = _needed;
5577
5578 /* Result */
5579 ZERO_STRUCT(state->orig.out.result);
5580
5581 state->out_mem_ctx = talloc_named_const(state, 0,
5582 "rpccli_spoolss_EnumPorts_out_memory");
5583 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5584 return tevent_req_post(req, ev);
5585 }
5586
5587 /* make a temporary copy, that we pass to the dispatch function */
5588 state->tmp = state->orig;
5589
5590 subreq = cli->dispatch_send(state, ev, cli,
5591 &ndr_table_spoolss,
5592 NDR_SPOOLSS_ENUMPORTS,
5593 &state->tmp);
5594 if (tevent_req_nomem(subreq, req)) {
5595 return tevent_req_post(req, ev);
5596 }
5597 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPorts_done, req);
5598 return req;
5599 }
5600
5601 static void rpccli_spoolss_EnumPorts_done(struct tevent_req *subreq)
5602 {
5603 struct tevent_req *req = tevent_req_callback_data(
5604 subreq, struct tevent_req);
5605 struct rpccli_spoolss_EnumPorts_state *state = tevent_req_data(
5606 req, struct rpccli_spoolss_EnumPorts_state);
5607 NTSTATUS status;
5608 TALLOC_CTX *mem_ctx;
5609
5610 if (state->out_mem_ctx) {
5611 mem_ctx = state->out_mem_ctx;
5612 } else {
5613 mem_ctx = state;
5614 }
5615
5616 status = state->dispatch_recv(subreq, mem_ctx);
5617 TALLOC_FREE(subreq);
5618 if (!NT_STATUS_IS_OK(status)) {
5619 tevent_req_nterror(req, status);
5620 return;
5621 }
5622
5623 /* Copy out parameters */
5624 *state->orig.out.count = *state->tmp.out.count;
5625 *state->orig.out.info = *state->tmp.out.info;
5626 *state->orig.out.needed = *state->tmp.out.needed;
5627
5628 /* Copy result */
5629 state->orig.out.result = state->tmp.out.result;
5630
5631 /* Reset temporary structure */
5632 ZERO_STRUCT(state->tmp);
5633
5634 tevent_req_done(req);
5635 }
5636
5637 NTSTATUS rpccli_spoolss_EnumPorts_recv(struct tevent_req *req,
5638 TALLOC_CTX *mem_ctx,
5639 WERROR *result)
5640 {
5641 struct rpccli_spoolss_EnumPorts_state *state = tevent_req_data(
5642 req, struct rpccli_spoolss_EnumPorts_state);
5643 NTSTATUS status;
5644
5645 if (tevent_req_is_nterror(req, &status)) {
5646 tevent_req_received(req);
5647 return status;
5648 }
5649
5650 /* Steal possbile out parameters to the callers context */
5651 talloc_steal(mem_ctx, state->out_mem_ctx);
5652
5653 /* Return result */
5654 *result = state->orig.out.result;
5655
5656 tevent_req_received(req);
5657 return NT_STATUS_OK;
5658 }
5659
5660 NTSTATUS rpccli_spoolss_EnumPorts(struct rpc_pipe_client *cli,
5661 TALLOC_CTX *mem_ctx,
5662 const char *servername /* [in] [unique,charset(UTF16)] */,
5663 uint32_t level /* [in] */,
5664 DATA_BLOB *buffer /* [in] [unique] */,
5665 uint32_t offered /* [in] */,
5666 uint32_t *count /* [out] [ref] */,
5667 union spoolss_PortInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5668 uint32_t *needed /* [out] [ref] */,
5669 WERROR *werror)
5670 {
5671 struct spoolss_EnumPorts r;
5672 NTSTATUS status;
5673
5674 /* In parameters */
5675 r.in.servername = servername;
5676 r.in.level = level;
5677 r.in.buffer = buffer;
5678 r.in.offered = offered;
5679
5680 status = cli->dispatch(cli,
5681 mem_ctx,
5682 &ndr_table_spoolss,
5683 NDR_SPOOLSS_ENUMPORTS,
5684 &r);
5685
5686 if (!NT_STATUS_IS_OK(status)) {
5687 return status;
5688 }
5689
5690 if (NT_STATUS_IS_ERR(status)) {
5691 return status;
5692 }
5693
5694 /* Return variables */
5695 *count = *r.out.count;
5696 *info = *r.out.info;
5697 *needed = *r.out.needed;
5698
5699 /* Return result */
5700 if (werror) {
5701 *werror = r.out.result;
5702 }
5703
5704 return werror_to_ntstatus(r.out.result);
5705 }
5706
5707 struct rpccli_spoolss_EnumMonitors_state {
5708 struct spoolss_EnumMonitors orig;
5709 struct spoolss_EnumMonitors tmp;
5710 TALLOC_CTX *out_mem_ctx;
5711 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5712 };
5713
5714 static void rpccli_spoolss_EnumMonitors_done(struct tevent_req *subreq);
5715
5716 struct tevent_req *rpccli_spoolss_EnumMonitors_send(TALLOC_CTX *mem_ctx,
5717 struct tevent_context *ev,
5718 struct rpc_pipe_client *cli,
5719 const char *_servername /* [in] [unique,charset(UTF16)] */,
5720 uint32_t _level /* [in] */,
5721 DATA_BLOB *_buffer /* [in] [unique] */,
5722 uint32_t _offered /* [in] */,
5723 uint32_t *_count /* [out] [ref] */,
5724 union spoolss_MonitorInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5725 uint32_t *_needed /* [out] [ref] */)
5726 {
5727 struct tevent_req *req;
5728 struct rpccli_spoolss_EnumMonitors_state *state;
5729 struct tevent_req *subreq;
5730
5731 req = tevent_req_create(mem_ctx, &state,
5732 struct rpccli_spoolss_EnumMonitors_state);
5733 if (req == NULL) {
5734 return NULL;
5735 }
5736 state->out_mem_ctx = NULL;
5737 state->dispatch_recv = cli->dispatch_recv;
5738
5739 /* In parameters */
5740 state->orig.in.servername = _servername;
5741 state->orig.in.level = _level;
5742 state->orig.in.buffer = _buffer;
5743 state->orig.in.offered = _offered;
5744
5745 /* Out parameters */
5746 state->orig.out.count = _count;
5747 state->orig.out.info = _info;
5748 state->orig.out.needed = _needed;
5749
5750 /* Result */
5751 ZERO_STRUCT(state->orig.out.result);
5752
5753 state->out_mem_ctx = talloc_named_const(state, 0,
5754 "rpccli_spoolss_EnumMonitors_out_memory");
5755 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5756 return tevent_req_post(req, ev);
5757 }
5758
5759 /* make a temporary copy, that we pass to the dispatch function */
5760 state->tmp = state->orig;
5761
5762 subreq = cli->dispatch_send(state, ev, cli,
5763 &ndr_table_spoolss,
5764 NDR_SPOOLSS_ENUMMONITORS,
5765 &state->tmp);
5766 if (tevent_req_nomem(subreq, req)) {
5767 return tevent_req_post(req, ev);
5768 }
5769 tevent_req_set_callback(subreq, rpccli_spoolss_EnumMonitors_done, req);
5770 return req;
5771 }
5772
5773 static void rpccli_spoolss_EnumMonitors_done(struct tevent_req *subreq)
5774 {
5775 struct tevent_req *req = tevent_req_callback_data(
5776 subreq, struct tevent_req);
5777 struct rpccli_spoolss_EnumMonitors_state *state = tevent_req_data(
5778 req, struct rpccli_spoolss_EnumMonitors_state);
5779 NTSTATUS status;
5780 TALLOC_CTX *mem_ctx;
5781
5782 if (state->out_mem_ctx) {
5783 mem_ctx = state->out_mem_ctx;
5784 } else {
5785 mem_ctx = state;
5786 }
5787
5788 status = state->dispatch_recv(subreq, mem_ctx);
5789 TALLOC_FREE(subreq);
5790 if (!NT_STATUS_IS_OK(status)) {
5791 tevent_req_nterror(req, status);
5792 return;
5793 }
5794
5795 /* Copy out parameters */
5796 *state->orig.out.count = *state->tmp.out.count;
5797 *state->orig.out.info = *state->tmp.out.info;
5798 *state->orig.out.needed = *state->tmp.out.needed;
5799
5800 /* Copy result */
5801 state->orig.out.result = state->tmp.out.result;
5802
5803 /* Reset temporary structure */
5804 ZERO_STRUCT(state->tmp);
5805
5806 tevent_req_done(req);
5807 }
5808
5809 NTSTATUS rpccli_spoolss_EnumMonitors_recv(struct tevent_req *req,
5810 TALLOC_CTX *mem_ctx,
5811 WERROR *result)
5812 {
5813 struct rpccli_spoolss_EnumMonitors_state *state = tevent_req_data(
5814 req, struct rpccli_spoolss_EnumMonitors_state);
5815 NTSTATUS status;
5816
5817 if (tevent_req_is_nterror(req, &status)) {
5818 tevent_req_received(req);
5819 return status;
5820 }
5821
5822 /* Steal possbile out parameters to the callers context */
5823 talloc_steal(mem_ctx, state->out_mem_ctx);
5824
5825 /* Return result */
5826 *result = state->orig.out.result;
5827
5828 tevent_req_received(req);
5829 return NT_STATUS_OK;
5830 }
5831
5832 NTSTATUS rpccli_spoolss_EnumMonitors(struct rpc_pipe_client *cli,
5833 TALLOC_CTX *mem_ctx,
5834 const char *servername /* [in] [unique,charset(UTF16)] */,
5835 uint32_t level /* [in] */,
5836 DATA_BLOB *buffer /* [in] [unique] */,
5837 uint32_t offered /* [in] */,
5838 uint32_t *count /* [out] [ref] */,
5839 union spoolss_MonitorInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5840 uint32_t *needed /* [out] [ref] */,
5841 WERROR *werror)
5842 {
5843 struct spoolss_EnumMonitors r;
5844 NTSTATUS status;
5845
5846 /* In parameters */
5847 r.in.servername = servername;
5848 r.in.level = level;
5849 r.in.buffer = buffer;
5850 r.in.offered = offered;
5851
5852 status = cli->dispatch(cli,
5853 mem_ctx,
5854 &ndr_table_spoolss,
5855 NDR_SPOOLSS_ENUMMONITORS,
5856 &r);
5857
5858 if (!NT_STATUS_IS_OK(status)) {
5859 return status;
5860 }
5861
5862 if (NT_STATUS_IS_ERR(status)) {
5863 return status;
5864 }
5865
5866 /* Return variables */
5867 *count = *r.out.count;
5868 *info = *r.out.info;
5869 *needed = *r.out.needed;
5870
5871 /* Return result */
5872 if (werror) {
5873 *werror = r.out.result;
5874 }
5875
5876 return werror_to_ntstatus(r.out.result);
5877 }
5878
5879 struct rpccli_spoolss_AddPort_state {
5880 struct spoolss_AddPort orig;
5881 struct spoolss_AddPort tmp;
5882 TALLOC_CTX *out_mem_ctx;
5883 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5884 };
5885
5886 static void rpccli_spoolss_AddPort_done(struct tevent_req *subreq);
5887
5888 struct tevent_req *rpccli_spoolss_AddPort_send(TALLOC_CTX *mem_ctx,
5889 struct tevent_context *ev,
5890 struct rpc_pipe_client *cli,
5891 const char *_server_name /* [in] [unique,charset(UTF16)] */,
5892 uint32_t _unknown /* [in] */,
5893 const char *_monitor_name /* [in] [charset(UTF16)] */)
5894 {
5895 struct tevent_req *req;
5896 struct rpccli_spoolss_AddPort_state *state;
5897 struct tevent_req *subreq;
5898
5899 req = tevent_req_create(mem_ctx, &state,
5900 struct rpccli_spoolss_AddPort_state);
5901 if (req == NULL) {
5902 return NULL;
5903 }
5904 state->out_mem_ctx = NULL;
5905 state->dispatch_recv = cli->dispatch_recv;
5906
5907 /* In parameters */
5908 state->orig.in.server_name = _server_name;
5909 state->orig.in.unknown = _unknown;
5910 state->orig.in.monitor_name = _monitor_name;
5911
5912 /* Out parameters */
5913
5914 /* Result */
5915 ZERO_STRUCT(state->orig.out.result);
5916
5917 /* make a temporary copy, that we pass to the dispatch function */
5918 state->tmp = state->orig;
5919
5920 subreq = cli->dispatch_send(state, ev, cli,
5921 &ndr_table_spoolss,
5922 NDR_SPOOLSS_ADDPORT,
5923 &state->tmp);
5924 if (tevent_req_nomem(subreq, req)) {
5925 return tevent_req_post(req, ev);
5926 }
5927 tevent_req_set_callback(subreq, rpccli_spoolss_AddPort_done, req);
5928 return req;
5929 }
5930
5931 static void rpccli_spoolss_AddPort_done(struct tevent_req *subreq)
5932 {
5933 struct tevent_req *req = tevent_req_callback_data(
5934 subreq, struct tevent_req);
5935 struct rpccli_spoolss_AddPort_state *state = tevent_req_data(
5936 req, struct rpccli_spoolss_AddPort_state);
5937 NTSTATUS status;
5938 TALLOC_CTX *mem_ctx;
5939
5940 if (state->out_mem_ctx) {
5941 mem_ctx = state->out_mem_ctx;
5942 } else {
5943 mem_ctx = state;
5944 }
5945
5946 status = state->dispatch_recv(subreq, mem_ctx);
5947 TALLOC_FREE(subreq);
5948 if (!NT_STATUS_IS_OK(status)) {
5949 tevent_req_nterror(req, status);
5950 return;
5951 }
5952
5953 /* Copy out parameters */
5954
5955 /* Copy result */
5956 state->orig.out.result = state->tmp.out.result;
5957
5958 /* Reset temporary structure */
5959 ZERO_STRUCT(state->tmp);
5960
5961 tevent_req_done(req);
5962 }
5963
5964 NTSTATUS rpccli_spoolss_AddPort_recv(struct tevent_req *req,
5965 TALLOC_CTX *mem_ctx,
5966 WERROR *result)
5967 {
5968 struct rpccli_spoolss_AddPort_state *state = tevent_req_data(
5969 req, struct rpccli_spoolss_AddPort_state);
5970 NTSTATUS status;
5971
5972 if (tevent_req_is_nterror(req, &status)) {
5973 tevent_req_received(req);
5974 return status;
5975 }
5976
5977 /* Steal possbile out parameters to the callers context */
5978 talloc_steal(mem_ctx, state->out_mem_ctx);
5979
5980 /* Return result */
5981 *result = state->orig.out.result;
5982
5983 tevent_req_received(req);
5984 return NT_STATUS_OK;
5985 }
5986
5987 NTSTATUS rpccli_spoolss_AddPort(struct rpc_pipe_client *cli,
5988 TALLOC_CTX *mem_ctx,
5989 const char *server_name /* [in] [unique,charset(UTF16)] */,
5990 uint32_t unknown /* [in] */,
5991 const char *monitor_name /* [in] [charset(UTF16)] */,
5992 WERROR *werror)
5993 {
5994 struct spoolss_AddPort r;
5995 NTSTATUS status;
5996
5997 /* In parameters */
5998 r.in.server_name = server_name;
5999 r.in.unknown = unknown;
6000 r.in.monitor_name = monitor_name;
6001
6002 status = cli->dispatch(cli,
6003 mem_ctx,
6004 &ndr_table_spoolss,
6005 NDR_SPOOLSS_ADDPORT,
6006 &r);
6007
6008 if (!NT_STATUS_IS_OK(status)) {
6009 return status;
6010 }
6011
6012 if (NT_STATUS_IS_ERR(status)) {
6013 return status;
6014 }
6015
6016 /* Return variables */
6017
6018 /* Return result */
6019 if (werror) {
6020 *werror = r.out.result;
6021 }
6022
6023 return werror_to_ntstatus(r.out.result);
6024 }
6025
6026 struct rpccli_spoolss_ConfigurePort_state {
6027 struct spoolss_ConfigurePort orig;
6028 struct spoolss_ConfigurePort tmp;
6029 TALLOC_CTX *out_mem_ctx;
6030 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6031 };
6032
6033 static void rpccli_spoolss_ConfigurePort_done(struct tevent_req *subreq);
6034
6035 struct tevent_req *rpccli_spoolss_ConfigurePort_send(TALLOC_CTX *mem_ctx,
6036 struct tevent_context *ev,
6037 struct rpc_pipe_client *cli)
6038 {
6039 struct tevent_req *req;
6040 struct rpccli_spoolss_ConfigurePort_state *state;
6041 struct tevent_req *subreq;
6042
6043 req = tevent_req_create(mem_ctx, &state,
6044 struct rpccli_spoolss_ConfigurePort_state);
6045 if (req == NULL) {
6046 return NULL;
6047 }
6048 state->out_mem_ctx = NULL;
6049 state->dispatch_recv = cli->dispatch_recv;
6050
6051 /* In parameters */
6052
6053 /* Out parameters */
6054
6055 /* Result */
6056 ZERO_STRUCT(state->orig.out.result);
6057
6058 /* make a temporary copy, that we pass to the dispatch function */
6059 state->tmp = state->orig;
6060
6061 subreq = cli->dispatch_send(state, ev, cli,
6062 &ndr_table_spoolss,
6063 NDR_SPOOLSS_CONFIGUREPORT,
6064 &state->tmp);
6065 if (tevent_req_nomem(subreq, req)) {
6066 return tevent_req_post(req, ev);
6067 }
6068 tevent_req_set_callback(subreq, rpccli_spoolss_ConfigurePort_done, req);
6069 return req;
6070 }
6071
6072 static void rpccli_spoolss_ConfigurePort_done(struct tevent_req *subreq)
6073 {
6074 struct tevent_req *req = tevent_req_callback_data(
6075 subreq, struct tevent_req);
6076 struct rpccli_spoolss_ConfigurePort_state *state = tevent_req_data(
6077 req, struct rpccli_spoolss_ConfigurePort_state);
6078 NTSTATUS status;
6079 TALLOC_CTX *mem_ctx;
6080
6081 if (state->out_mem_ctx) {
6082 mem_ctx = state->out_mem_ctx;
6083 } else {
6084 mem_ctx = state;
6085 }
6086
6087 status = state->dispatch_recv(subreq, mem_ctx);
6088 TALLOC_FREE(subreq);
6089 if (!NT_STATUS_IS_OK(status)) {
6090 tevent_req_nterror(req, status);
6091 return;
6092 }
6093
6094 /* Copy out parameters */
6095
6096 /* Copy result */
6097 state->orig.out.result = state->tmp.out.result;
6098
6099 /* Reset temporary structure */
6100 ZERO_STRUCT(state->tmp);
6101
6102 tevent_req_done(req);
6103 }
6104
6105 NTSTATUS rpccli_spoolss_ConfigurePort_recv(struct tevent_req *req,
6106 TALLOC_CTX *mem_ctx,
6107 WERROR *result)
6108 {
6109 struct rpccli_spoolss_ConfigurePort_state *state = tevent_req_data(
6110 req, struct rpccli_spoolss_ConfigurePort_state);
6111 NTSTATUS status;
6112
6113 if (tevent_req_is_nterror(req, &status)) {
6114 tevent_req_received(req);
6115 return status;
6116 }
6117
6118 /* Steal possbile out parameters to the callers context */
6119 talloc_steal(mem_ctx, state->out_mem_ctx);
6120
6121 /* Return result */
6122 *result = state->orig.out.result;
6123
6124 tevent_req_received(req);
6125 return NT_STATUS_OK;
6126 }
6127
6128 NTSTATUS rpccli_spoolss_ConfigurePort(struct rpc_pipe_client *cli,
6129 TALLOC_CTX *mem_ctx,
6130 WERROR *werror)
6131 {
6132 struct spoolss_ConfigurePort r;
6133 NTSTATUS status;
6134
6135 /* In parameters */
6136
6137 status = cli->dispatch(cli,
6138 mem_ctx,
6139 &ndr_table_spoolss,
6140 NDR_SPOOLSS_CONFIGUREPORT,
6141 &r);
6142
6143 if (!NT_STATUS_IS_OK(status)) {
6144 return status;
6145 }
6146
6147 if (NT_STATUS_IS_ERR(status)) {
6148 return status;
6149 }
6150
6151 /* Return variables */
6152
6153 /* Return result */
6154 if (werror) {
6155 *werror = r.out.result;
6156 }
6157
6158 return werror_to_ntstatus(r.out.result);
6159 }
6160
6161 struct rpccli_spoolss_DeletePort_state {
6162 struct spoolss_DeletePort orig;
6163 struct spoolss_DeletePort tmp;
6164 TALLOC_CTX *out_mem_ctx;
6165 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6166 };
6167
6168 static void rpccli_spoolss_DeletePort_done(struct tevent_req *subreq);
6169
6170 struct tevent_req *rpccli_spoolss_DeletePort_send(TALLOC_CTX *mem_ctx,
6171 struct tevent_context *ev,
6172 struct rpc_pipe_client *cli)
6173 {
6174 struct tevent_req *req;
6175 struct rpccli_spoolss_DeletePort_state *state;
6176 struct tevent_req *subreq;
6177
6178 req = tevent_req_create(mem_ctx, &state,
6179 struct rpccli_spoolss_DeletePort_state);
6180 if (req == NULL) {
6181 return NULL;
6182 }
6183 state->out_mem_ctx = NULL;
6184 state->dispatch_recv = cli->dispatch_recv;
6185
6186 /* In parameters */
6187
6188 /* Out parameters */
6189
6190 /* Result */
6191 ZERO_STRUCT(state->orig.out.result);
6192
6193 /* make a temporary copy, that we pass to the dispatch function */
6194 state->tmp = state->orig;
6195
6196 subreq = cli->dispatch_send(state, ev, cli,
6197 &ndr_table_spoolss,
6198 NDR_SPOOLSS_DELETEPORT,
6199 &state->tmp);
6200 if (tevent_req_nomem(subreq, req)) {
6201 return tevent_req_post(req, ev);
6202 }
6203 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePort_done, req);
6204 return req;
6205 }
6206
6207 static void rpccli_spoolss_DeletePort_done(struct tevent_req *subreq)
6208 {
6209 struct tevent_req *req = tevent_req_callback_data(
6210 subreq, struct tevent_req);
6211 struct rpccli_spoolss_DeletePort_state *state = tevent_req_data(
6212 req, struct rpccli_spoolss_DeletePort_state);
6213 NTSTATUS status;
6214 TALLOC_CTX *mem_ctx;
6215
6216 if (state->out_mem_ctx) {
6217 mem_ctx = state->out_mem_ctx;
6218 } else {
6219 mem_ctx = state;
6220 }
6221
6222 status = state->dispatch_recv(subreq, mem_ctx);
6223 TALLOC_FREE(subreq);
6224 if (!NT_STATUS_IS_OK(status)) {
6225 tevent_req_nterror(req, status);
6226 return;
6227 }
6228
6229 /* Copy out parameters */
6230
6231 /* Copy result */
6232 state->orig.out.result = state->tmp.out.result;
6233
6234 /* Reset temporary structure */
6235 ZERO_STRUCT(state->tmp);
6236
6237 tevent_req_done(req);
6238 }
6239
6240 NTSTATUS rpccli_spoolss_DeletePort_recv(struct tevent_req *req,
6241 TALLOC_CTX *mem_ctx,
6242 WERROR *result)
6243 {
6244 struct rpccli_spoolss_DeletePort_state *state = tevent_req_data(
6245 req, struct rpccli_spoolss_DeletePort_state);
6246 NTSTATUS status;
6247
6248 if (tevent_req_is_nterror(req, &status)) {
6249 tevent_req_received(req);
6250 return status;
6251 }
6252
6253 /* Steal possbile out parameters to the callers context */
6254 talloc_steal(mem_ctx, state->out_mem_ctx);
6255
6256 /* Return result */
6257 *result = state->orig.out.result;
6258
6259 tevent_req_received(req);
6260 return NT_STATUS_OK;
6261 }
6262
6263 NTSTATUS rpccli_spoolss_DeletePort(struct rpc_pipe_client *cli,
6264 TALLOC_CTX *mem_ctx,
6265 WERROR *werror)
6266 {
6267 struct spoolss_DeletePort r;
6268 NTSTATUS status;
6269
6270 /* In parameters */
6271
6272 status = cli->dispatch(cli,
6273 mem_ctx,
6274 &ndr_table_spoolss,
6275 NDR_SPOOLSS_DELETEPORT,
6276 &r);
6277
6278 if (!NT_STATUS_IS_OK(status)) {
6279 return status;
6280 }
6281
6282 if (NT_STATUS_IS_ERR(status)) {
6283 return status;
6284 }
6285
6286 /* Return variables */
6287
6288 /* Return result */
6289 if (werror) {
6290 *werror = r.out.result;
6291 }
6292
6293 return werror_to_ntstatus(r.out.result);
6294 }
6295
6296 struct rpccli_spoolss_CreatePrinterIC_state {
6297 struct spoolss_CreatePrinterIC orig;
6298 struct spoolss_CreatePrinterIC tmp;
6299 TALLOC_CTX *out_mem_ctx;
6300 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6301 };
6302
6303 static void rpccli_spoolss_CreatePrinterIC_done(struct tevent_req *subreq);
6304
6305 struct tevent_req *rpccli_spoolss_CreatePrinterIC_send(TALLOC_CTX *mem_ctx,
6306 struct tevent_context *ev,
6307 struct rpc_pipe_client *cli,
6308 struct policy_handle *_handle /* [in] [ref] */,
6309 struct policy_handle *_gdi_handle /* [out] [ref] */,
6310 struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */)
6311 {
6312 struct tevent_req *req;
6313 struct rpccli_spoolss_CreatePrinterIC_state *state;
6314 struct tevent_req *subreq;
6315
6316 req = tevent_req_create(mem_ctx, &state,
6317 struct rpccli_spoolss_CreatePrinterIC_state);
6318 if (req == NULL) {
6319 return NULL;
6320 }
6321 state->out_mem_ctx = NULL;
6322 state->dispatch_recv = cli->dispatch_recv;
6323
6324 /* In parameters */
6325 state->orig.in.handle = _handle;
6326 state->orig.in.devmode_ctr = _devmode_ctr;
6327
6328 /* Out parameters */
6329 state->orig.out.gdi_handle = _gdi_handle;
6330
6331 /* Result */
6332 ZERO_STRUCT(state->orig.out.result);
6333
6334 state->out_mem_ctx = talloc_named_const(state, 0,
6335 "rpccli_spoolss_CreatePrinterIC_out_memory");
6336 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6337 return tevent_req_post(req, ev);
6338 }
6339
6340 /* make a temporary copy, that we pass to the dispatch function */
6341 state->tmp = state->orig;
6342
6343 subreq = cli->dispatch_send(state, ev, cli,
6344 &ndr_table_spoolss,
6345 NDR_SPOOLSS_CREATEPRINTERIC,
6346 &state->tmp);
6347 if (tevent_req_nomem(subreq, req)) {
6348 return tevent_req_post(req, ev);
6349 }
6350 tevent_req_set_callback(subreq, rpccli_spoolss_CreatePrinterIC_done, req);
6351 return req;
6352 }
6353
6354 static void rpccli_spoolss_CreatePrinterIC_done(struct tevent_req *subreq)
6355 {
6356 struct tevent_req *req = tevent_req_callback_data(
6357 subreq, struct tevent_req);
6358 struct rpccli_spoolss_CreatePrinterIC_state *state = tevent_req_data(
6359 req, struct rpccli_spoolss_CreatePrinterIC_state);
6360 NTSTATUS status;
6361 TALLOC_CTX *mem_ctx;
6362
6363 if (state->out_mem_ctx) {
6364 mem_ctx = state->out_mem_ctx;
6365 } else {
6366 mem_ctx = state;
6367 }
6368
6369 status = state->dispatch_recv(subreq, mem_ctx);
6370 TALLOC_FREE(subreq);
6371 if (!NT_STATUS_IS_OK(status)) {
6372 tevent_req_nterror(req, status);
6373 return;
6374 }
6375
6376 /* Copy out parameters */
6377 *state->orig.out.gdi_handle = *state->tmp.out.gdi_handle;
6378
6379 /* Copy result */
6380 state->orig.out.result = state->tmp.out.result;
6381
6382 /* Reset temporary structure */
6383 ZERO_STRUCT(state->tmp);
6384
6385 tevent_req_done(req);
6386 }
6387
6388 NTSTATUS rpccli_spoolss_CreatePrinterIC_recv(struct tevent_req *req,
6389 TALLOC_CTX *mem_ctx,
6390 WERROR *result)
6391 {
6392 struct rpccli_spoolss_CreatePrinterIC_state *state = tevent_req_data(
6393 req, struct rpccli_spoolss_CreatePrinterIC_state);
6394 NTSTATUS status;
6395
6396 if (tevent_req_is_nterror(req, &status)) {
6397 tevent_req_received(req);
6398 return status;
6399 }
6400
6401 /* Steal possbile out parameters to the callers context */
6402 talloc_steal(mem_ctx, state->out_mem_ctx);
6403
6404 /* Return result */
6405 *result = state->orig.out.result;
6406
6407 tevent_req_received(req);
6408 return NT_STATUS_OK;
6409 }
6410
6411 NTSTATUS rpccli_spoolss_CreatePrinterIC(struct rpc_pipe_client *cli,
6412 TALLOC_CTX *mem_ctx,
6413 struct policy_handle *handle /* [in] [ref] */,
6414 struct policy_handle *gdi_handle /* [out] [ref] */,
6415 struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
6416 WERROR *werror)
6417 {
6418 struct spoolss_CreatePrinterIC r;
6419 NTSTATUS status;
6420
6421 /* In parameters */
6422 r.in.handle = handle;
6423 r.in.devmode_ctr = devmode_ctr;
6424
6425 status = cli->dispatch(cli,
6426 mem_ctx,
6427 &ndr_table_spoolss,
6428 NDR_SPOOLSS_CREATEPRINTERIC,
6429 &r);
6430
6431 if (!NT_STATUS_IS_OK(status)) {
6432 return status;
6433 }
6434
6435 if (NT_STATUS_IS_ERR(status)) {
6436 return status;
6437 }
6438
6439 /* Return variables */
6440 *gdi_handle = *r.out.gdi_handle;
6441
6442 /* Return result */
6443 if (werror) {
6444 *werror = r.out.result;
6445 }
6446
6447 return werror_to_ntstatus(r.out.result);
6448 }
6449
6450 struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state {
6451 struct spoolss_PlayGDIScriptOnPrinterIC orig;
6452 struct spoolss_PlayGDIScriptOnPrinterIC tmp;
6453 TALLOC_CTX *out_mem_ctx;
6454 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6455 };
6456
6457 static void rpccli_spoolss_PlayGDIScriptOnPrinterIC_done(struct tevent_req *subreq);
6458
6459 struct tevent_req *rpccli_spoolss_PlayGDIScriptOnPrinterIC_send(TALLOC_CTX *mem_ctx,
6460 struct tevent_context *ev,
6461 struct rpc_pipe_client *cli)
6462 {
6463 struct tevent_req *req;
6464 struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state *state;
6465 struct tevent_req *subreq;
6466
6467 req = tevent_req_create(mem_ctx, &state,
6468 struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state);
6469 if (req == NULL) {
6470 return NULL;
6471 }
6472 state->out_mem_ctx = NULL;
6473 state->dispatch_recv = cli->dispatch_recv;
6474
6475 /* In parameters */
6476
6477 /* Out parameters */
6478
6479 /* Result */
6480 ZERO_STRUCT(state->orig.out.result);
6481
6482 /* make a temporary copy, that we pass to the dispatch function */
6483 state->tmp = state->orig;
6484
6485 subreq = cli->dispatch_send(state, ev, cli,
6486 &ndr_table_spoolss,
6487 NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC,
6488 &state->tmp);
6489 if (tevent_req_nomem(subreq, req)) {
6490 return tevent_req_post(req, ev);
6491 }
6492 tevent_req_set_callback(subreq, rpccli_spoolss_PlayGDIScriptOnPrinterIC_done, req);
6493 return req;
6494 }
6495
6496 static void rpccli_spoolss_PlayGDIScriptOnPrinterIC_done(struct tevent_req *subreq)
6497 {
6498 struct tevent_req *req = tevent_req_callback_data(
6499 subreq, struct tevent_req);
6500 struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state *state = tevent_req_data(
6501 req, struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state);
6502 NTSTATUS status;
6503 TALLOC_CTX *mem_ctx;
6504
6505 if (state->out_mem_ctx) {
6506 mem_ctx = state->out_mem_ctx;
6507 } else {
6508 mem_ctx = state;
6509 }
6510
6511 status = state->dispatch_recv(subreq, mem_ctx);
6512 TALLOC_FREE(subreq);
6513 if (!NT_STATUS_IS_OK(status)) {
6514 tevent_req_nterror(req, status);
6515 return;
6516 }
6517
6518 /* Copy out parameters */
6519
6520 /* Copy result */
6521 state->orig.out.result = state->tmp.out.result;
6522
6523 /* Reset temporary structure */
6524 ZERO_STRUCT(state->tmp);
6525
6526 tevent_req_done(req);
6527 }
6528
6529 NTSTATUS rpccli_spoolss_PlayGDIScriptOnPrinterIC_recv(struct tevent_req *req,
6530 TALLOC_CTX *mem_ctx,
6531 WERROR *result)
6532 {
6533 struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state *state = tevent_req_data(
6534 req, struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state);
6535 NTSTATUS status;
6536
6537 if (tevent_req_is_nterror(req, &status)) {
6538 tevent_req_received(req);
6539 return status;
6540 }
6541
6542 /* Steal possbile out parameters to the callers context */
6543 talloc_steal(mem_ctx, state->out_mem_ctx);
6544
6545 /* Return result */
6546 *result = state->orig.out.result;
6547
6548 tevent_req_received(req);
6549 return NT_STATUS_OK;
6550 }
6551
6552 NTSTATUS rpccli_spoolss_PlayGDIScriptOnPrinterIC(struct rpc_pipe_client *cli,
6553 TALLOC_CTX *mem_ctx,
6554 WERROR *werror)
6555 {
6556 struct spoolss_PlayGDIScriptOnPrinterIC r;
6557 NTSTATUS status;
6558
6559 /* In parameters */
6560
6561 status = cli->dispatch(cli,
6562 mem_ctx,
6563 &ndr_table_spoolss,
6564 NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC,
6565 &r);
6566
6567 if (!NT_STATUS_IS_OK(status)) {
6568 return status;
6569 }
6570
6571 if (NT_STATUS_IS_ERR(status)) {
6572 return status;
6573 }
6574
6575 /* Return variables */
6576
6577 /* Return result */
6578 if (werror) {
6579 *werror = r.out.result;
6580 }
6581
6582 return werror_to_ntstatus(r.out.result);
6583 }
6584
6585 struct rpccli_spoolss_DeletePrinterIC_state {
6586 struct spoolss_DeletePrinterIC orig;
6587 struct spoolss_DeletePrinterIC tmp;
6588 TALLOC_CTX *out_mem_ctx;
6589 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6590 };
6591
6592 static void rpccli_spoolss_DeletePrinterIC_done(struct tevent_req *subreq);
6593
6594 struct tevent_req *rpccli_spoolss_DeletePrinterIC_send(TALLOC_CTX *mem_ctx,
6595 struct tevent_context *ev,
6596 struct rpc_pipe_client *cli,
6597 struct policy_handle *_gdi_handle /* [in,out] [ref] */)
6598 {
6599 struct tevent_req *req;
6600 struct rpccli_spoolss_DeletePrinterIC_state *state;
6601 struct tevent_req *subreq;
6602
6603 req = tevent_req_create(mem_ctx, &state,
6604 struct rpccli_spoolss_DeletePrinterIC_state);
6605 if (req == NULL) {
6606 return NULL;
6607 }
6608 state->out_mem_ctx = NULL;
6609 state->dispatch_recv = cli->dispatch_recv;
6610
6611 /* In parameters */
6612 state->orig.in.gdi_handle = _gdi_handle;
6613
6614 /* Out parameters */
6615 state->orig.out.gdi_handle = _gdi_handle;
6616
6617 /* Result */
6618 ZERO_STRUCT(state->orig.out.result);
6619
6620 state->out_mem_ctx = talloc_named_const(state, 0,
6621 "rpccli_spoolss_DeletePrinterIC_out_memory");
6622 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6623 return tevent_req_post(req, ev);
6624 }
6625
6626 /* make a temporary copy, that we pass to the dispatch function */
6627 state->tmp = state->orig;
6628
6629 subreq = cli->dispatch_send(state, ev, cli,
6630 &ndr_table_spoolss,
6631 NDR_SPOOLSS_DELETEPRINTERIC,
6632 &state->tmp);
6633 if (tevent_req_nomem(subreq, req)) {
6634 return tevent_req_post(req, ev);
6635 }
6636 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterIC_done, req);
6637 return req;
6638 }
6639
6640 static void rpccli_spoolss_DeletePrinterIC_done(struct tevent_req *subreq)
6641 {
6642 struct tevent_req *req = tevent_req_callback_data(
6643 subreq, struct tevent_req);
6644 struct rpccli_spoolss_DeletePrinterIC_state *state = tevent_req_data(
6645 req, struct rpccli_spoolss_DeletePrinterIC_state);
6646 NTSTATUS status;
6647 TALLOC_CTX *mem_ctx;
6648
6649 if (state->out_mem_ctx) {
6650 mem_ctx = state->out_mem_ctx;
6651 } else {
6652 mem_ctx = state;
6653 }
6654
6655 status = state->dispatch_recv(subreq, mem_ctx);
6656 TALLOC_FREE(subreq);
6657 if (!NT_STATUS_IS_OK(status)) {
6658 tevent_req_nterror(req, status);
6659 return;
6660 }
6661
6662 /* Copy out parameters */
6663 *state->orig.out.gdi_handle = *state->tmp.out.gdi_handle;
6664
6665 /* Copy result */
6666 state->orig.out.result = state->tmp.out.result;
6667
6668 /* Reset temporary structure */
6669 ZERO_STRUCT(state->tmp);
6670
6671 tevent_req_done(req);
6672 }
6673
6674 NTSTATUS rpccli_spoolss_DeletePrinterIC_recv(struct tevent_req *req,
6675 TALLOC_CTX *mem_ctx,
6676 WERROR *result)
6677 {
6678 struct rpccli_spoolss_DeletePrinterIC_state *state = tevent_req_data(
6679 req, struct rpccli_spoolss_DeletePrinterIC_state);
6680 NTSTATUS status;
6681
6682 if (tevent_req_is_nterror(req, &status)) {
6683 tevent_req_received(req);
6684 return status;
6685 }
6686
6687 /* Steal possbile out parameters to the callers context */
6688 talloc_steal(mem_ctx, state->out_mem_ctx);
6689
6690 /* Return result */
6691 *result = state->orig.out.result;
6692
6693 tevent_req_received(req);
6694 return NT_STATUS_OK;
6695 }
6696
6697 NTSTATUS rpccli_spoolss_DeletePrinterIC(struct rpc_pipe_client *cli,
6698 TALLOC_CTX *mem_ctx,
6699 struct policy_handle *gdi_handle /* [in,out] [ref] */,
6700 WERROR *werror)
6701 {
6702 struct spoolss_DeletePrinterIC r;
6703 NTSTATUS status;
6704
6705 /* In parameters */
6706 r.in.gdi_handle = gdi_handle;
6707
6708 status = cli->dispatch(cli,
6709 mem_ctx,
6710 &ndr_table_spoolss,
6711 NDR_SPOOLSS_DELETEPRINTERIC,
6712 &r);
6713
6714 if (!NT_STATUS_IS_OK(status)) {
6715 return status;
6716 }
6717
6718 if (NT_STATUS_IS_ERR(status)) {
6719 return status;
6720 }
6721
6722 /* Return variables */
6723 *gdi_handle = *r.out.gdi_handle;
6724
6725 /* Return result */
6726 if (werror) {
6727 *werror = r.out.result;
6728 }
6729
6730 return werror_to_ntstatus(r.out.result);
6731 }
6732
6733 struct rpccli_spoolss_AddPrinterConnection_state {
6734 struct spoolss_AddPrinterConnection orig;
6735 struct spoolss_AddPrinterConnection tmp;
6736 TALLOC_CTX *out_mem_ctx;
6737 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6738 };
6739
6740 static void rpccli_spoolss_AddPrinterConnection_done(struct tevent_req *subreq);
6741
6742 struct tevent_req *rpccli_spoolss_AddPrinterConnection_send(TALLOC_CTX *mem_ctx,
6743 struct tevent_context *ev,
6744 struct rpc_pipe_client *cli)
6745 {
6746 struct tevent_req *req;
6747 struct rpccli_spoolss_AddPrinterConnection_state *state;
6748 struct tevent_req *subreq;
6749
6750 req = tevent_req_create(mem_ctx, &state,
6751 struct rpccli_spoolss_AddPrinterConnection_state);
6752 if (req == NULL) {
6753 return NULL;
6754 }
6755 state->out_mem_ctx = NULL;
6756 state->dispatch_recv = cli->dispatch_recv;
6757
6758 /* In parameters */
6759
6760 /* Out parameters */
6761
6762 /* Result */
6763 ZERO_STRUCT(state->orig.out.result);
6764
6765 /* make a temporary copy, that we pass to the dispatch function */
6766 state->tmp = state->orig;
6767
6768 subreq = cli->dispatch_send(state, ev, cli,
6769 &ndr_table_spoolss,
6770 NDR_SPOOLSS_ADDPRINTERCONNECTION,
6771 &state->tmp);
6772 if (tevent_req_nomem(subreq, req)) {
6773 return tevent_req_post(req, ev);
6774 }
6775 tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterConnection_done, req);
6776 return req;
6777 }
6778
6779 static void rpccli_spoolss_AddPrinterConnection_done(struct tevent_req *subreq)
6780 {
6781 struct tevent_req *req = tevent_req_callback_data(
6782 subreq, struct tevent_req);
6783 struct rpccli_spoolss_AddPrinterConnection_state *state = tevent_req_data(
6784 req, struct rpccli_spoolss_AddPrinterConnection_state);
6785 NTSTATUS status;
6786 TALLOC_CTX *mem_ctx;
6787
6788 if (state->out_mem_ctx) {
6789 mem_ctx = state->out_mem_ctx;
6790 } else {
6791 mem_ctx = state;
6792 }
6793
6794 status = state->dispatch_recv(subreq, mem_ctx);
6795 TALLOC_FREE(subreq);
6796 if (!NT_STATUS_IS_OK(status)) {
6797 tevent_req_nterror(req, status);
6798 return;
6799 }
6800
6801 /* Copy out parameters */
6802
6803 /* Copy result */
6804 state->orig.out.result = state->tmp.out.result;
6805
6806 /* Reset temporary structure */
6807 ZERO_STRUCT(state->tmp);
6808
6809 tevent_req_done(req);
6810 }
6811
6812 NTSTATUS rpccli_spoolss_AddPrinterConnection_recv(struct tevent_req *req,
6813 TALLOC_CTX *mem_ctx,
6814 WERROR *result)
6815 {
6816 struct rpccli_spoolss_AddPrinterConnection_state *state = tevent_req_data(
6817 req, struct rpccli_spoolss_AddPrinterConnection_state);
6818 NTSTATUS status;
6819
6820 if (tevent_req_is_nterror(req, &status)) {
6821 tevent_req_received(req);
6822 return status;
6823 }
6824
6825 /* Steal possbile out parameters to the callers context */
6826 talloc_steal(mem_ctx, state->out_mem_ctx);
6827
6828 /* Return result */
6829 *result = state->orig.out.result;
6830
6831 tevent_req_received(req);
6832 return NT_STATUS_OK;
6833 }
6834
6835 NTSTATUS rpccli_spoolss_AddPrinterConnection(struct rpc_pipe_client *cli,
6836 TALLOC_CTX *mem_ctx,
6837 WERROR *werror)
6838 {
6839 struct spoolss_AddPrinterConnection r;
6840 NTSTATUS status;
6841
6842 /* In parameters */
6843
6844 status = cli->dispatch(cli,
6845 mem_ctx,
6846 &ndr_table_spoolss,
6847 NDR_SPOOLSS_ADDPRINTERCONNECTION,
6848 &r);
6849
6850 if (!NT_STATUS_IS_OK(status)) {
6851 return status;
6852 }
6853
6854 if (NT_STATUS_IS_ERR(status)) {
6855 return status;
6856 }
6857
6858 /* Return variables */
6859
6860 /* Return result */
6861 if (werror) {
6862 *werror = r.out.result;
6863 }
6864
6865 return werror_to_ntstatus(r.out.result);
6866 }
6867
6868 struct rpccli_spoolss_DeletePrinterConnection_state {
6869 struct spoolss_DeletePrinterConnection orig;
6870 struct spoolss_DeletePrinterConnection tmp;
6871 TALLOC_CTX *out_mem_ctx;
6872 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6873 };
6874
6875 static void rpccli_spoolss_DeletePrinterConnection_done(struct tevent_req *subreq);
6876
6877 struct tevent_req *rpccli_spoolss_DeletePrinterConnection_send(TALLOC_CTX *mem_ctx,
6878 struct tevent_context *ev,
6879 struct rpc_pipe_client *cli)
6880 {
6881 struct tevent_req *req;
6882 struct rpccli_spoolss_DeletePrinterConnection_state *state;
6883 struct tevent_req *subreq;
6884
6885 req = tevent_req_create(mem_ctx, &state,
6886 struct rpccli_spoolss_DeletePrinterConnection_state);
6887 if (req == NULL) {
6888 return NULL;
6889 }
6890 state->out_mem_ctx = NULL;
6891 state->dispatch_recv = cli->dispatch_recv;
6892
6893 /* In parameters */
6894
6895 /* Out parameters */
6896
6897 /* Result */
6898 ZERO_STRUCT(state->orig.out.result);
6899
6900 /* make a temporary copy, that we pass to the dispatch function */
6901 state->tmp = state->orig;
6902
6903 subreq = cli->dispatch_send(state, ev, cli,
6904 &ndr_table_spoolss,
6905 NDR_SPOOLSS_DELETEPRINTERCONNECTION,
6906 &state->tmp);
6907 if (tevent_req_nomem(subreq, req)) {
6908 return tevent_req_post(req, ev);
6909 }
6910 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterConnection_done, req);
6911 return req;
6912 }
6913
6914 static void rpccli_spoolss_DeletePrinterConnection_done(struct tevent_req *subreq)
6915 {
6916 struct tevent_req *req = tevent_req_callback_data(
6917 subreq, struct tevent_req);
6918 struct rpccli_spoolss_DeletePrinterConnection_state *state = tevent_req_data(
6919 req, struct rpccli_spoolss_DeletePrinterConnection_state);
6920 NTSTATUS status;
6921 TALLOC_CTX *mem_ctx;
6922
6923 if (state->out_mem_ctx) {
6924 mem_ctx = state->out_mem_ctx;
6925 } else {
6926 mem_ctx = state;
6927 }
6928
6929 status = state->dispatch_recv(subreq, mem_ctx);
6930 TALLOC_FREE(subreq);
6931 if (!NT_STATUS_IS_OK(status)) {
6932 tevent_req_nterror(req, status);
6933 return;
6934 }
6935
6936 /* Copy out parameters */
6937
6938 /* Copy result */
6939 state->orig.out.result = state->tmp.out.result;
6940
6941 /* Reset temporary structure */
6942 ZERO_STRUCT(state->tmp);
6943
6944 tevent_req_done(req);
6945 }
6946
6947 NTSTATUS rpccli_spoolss_DeletePrinterConnection_recv(struct tevent_req *req,
6948 TALLOC_CTX *mem_ctx,
6949 WERROR *result)
6950 {
6951 struct rpccli_spoolss_DeletePrinterConnection_state *state = tevent_req_data(
6952 req, struct rpccli_spoolss_DeletePrinterConnection_state);
6953 NTSTATUS status;
6954
6955 if (tevent_req_is_nterror(req, &status)) {
6956 tevent_req_received(req);
6957 return status;
6958 }
6959
6960 /* Steal possbile out parameters to the callers context */
6961 talloc_steal(mem_ctx, state->out_mem_ctx);
6962
6963 /* Return result */
6964 *result = state->orig.out.result;
6965
6966 tevent_req_received(req);
6967 return NT_STATUS_OK;
6968 }
6969
6970 NTSTATUS rpccli_spoolss_DeletePrinterConnection(struct rpc_pipe_client *cli,
6971 TALLOC_CTX *mem_ctx,
6972 WERROR *werror)
6973 {
6974 struct spoolss_DeletePrinterConnection r;
6975 NTSTATUS status;
6976
6977 /* In parameters */
6978
6979 status = cli->dispatch(cli,
6980 mem_ctx,
6981 &ndr_table_spoolss,
6982 NDR_SPOOLSS_DELETEPRINTERCONNECTION,
6983 &r);
6984
6985 if (!NT_STATUS_IS_OK(status)) {
6986 return status;
6987 }
6988
6989 if (NT_STATUS_IS_ERR(status)) {
6990 return status;
6991 }
6992
6993 /* Return variables */
6994
6995 /* Return result */
6996 if (werror) {
6997 *werror = r.out.result;
6998 }
6999
7000 return werror_to_ntstatus(r.out.result);
7001 }
7002
7003 struct rpccli_spoolss_PrinterMessageBox_state {
7004 struct spoolss_PrinterMessageBox orig;
7005 struct spoolss_PrinterMessageBox tmp;
7006 TALLOC_CTX *out_mem_ctx;
7007 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7008 };
7009
7010 static void rpccli_spoolss_PrinterMessageBox_done(struct tevent_req *subreq);
7011
7012 struct tevent_req *rpccli_spoolss_PrinterMessageBox_send(TALLOC_CTX *mem_ctx,
7013 struct tevent_context *ev,
7014 struct rpc_pipe_client *cli)
7015 {
7016 struct tevent_req *req;
7017 struct rpccli_spoolss_PrinterMessageBox_state *state;
7018 struct tevent_req *subreq;
7019
7020 req = tevent_req_create(mem_ctx, &state,
7021 struct rpccli_spoolss_PrinterMessageBox_state);
7022 if (req == NULL) {
7023 return NULL;
7024 }
7025 state->out_mem_ctx = NULL;
7026 state->dispatch_recv = cli->dispatch_recv;
7027
7028 /* In parameters */
7029
7030 /* Out parameters */
7031
7032 /* Result */
7033 ZERO_STRUCT(state->orig.out.result);
7034
7035 /* make a temporary copy, that we pass to the dispatch function */
7036 state->tmp = state->orig;
7037
7038 subreq = cli->dispatch_send(state, ev, cli,
7039 &ndr_table_spoolss,
7040 NDR_SPOOLSS_PRINTERMESSAGEBOX,
7041 &state->tmp);
7042 if (tevent_req_nomem(subreq, req)) {
7043 return tevent_req_post(req, ev);
7044 }
7045 tevent_req_set_callback(subreq, rpccli_spoolss_PrinterMessageBox_done, req);
7046 return req;
7047 }
7048
7049 static void rpccli_spoolss_PrinterMessageBox_done(struct tevent_req *subreq)
7050 {
7051 struct tevent_req *req = tevent_req_callback_data(
7052 subreq, struct tevent_req);
7053 struct rpccli_spoolss_PrinterMessageBox_state *state = tevent_req_data(
7054 req, struct rpccli_spoolss_PrinterMessageBox_state);
7055 NTSTATUS status;
7056 TALLOC_CTX *mem_ctx;
7057
7058 if (state->out_mem_ctx) {
7059 mem_ctx = state->out_mem_ctx;
7060 } else {
7061 mem_ctx = state;
7062 }
7063
7064 status = state->dispatch_recv(subreq, mem_ctx);
7065 TALLOC_FREE(subreq);
7066 if (!NT_STATUS_IS_OK(status)) {
7067 tevent_req_nterror(req, status);
7068 return;
7069 }
7070
7071 /* Copy out parameters */
7072
7073 /* Copy result */
7074 state->orig.out.result = state->tmp.out.result;
7075
7076 /* Reset temporary structure */
7077 ZERO_STRUCT(state->tmp);
7078
7079 tevent_req_done(req);
7080 }
7081
7082 NTSTATUS rpccli_spoolss_PrinterMessageBox_recv(struct tevent_req *req,
7083 TALLOC_CTX *mem_ctx,
7084 WERROR *result)
7085 {
7086 struct rpccli_spoolss_PrinterMessageBox_state *state = tevent_req_data(
7087 req, struct rpccli_spoolss_PrinterMessageBox_state);
7088 NTSTATUS status;
7089
7090 if (tevent_req_is_nterror(req, &status)) {
7091 tevent_req_received(req);
7092 return status;
7093 }
7094
7095 /* Steal possbile out parameters to the callers context */
7096 talloc_steal(mem_ctx, state->out_mem_ctx);
7097
7098 /* Return result */
7099 *result = state->orig.out.result;
7100
7101 tevent_req_received(req);
7102 return NT_STATUS_OK;
7103 }
7104
7105 NTSTATUS rpccli_spoolss_PrinterMessageBox(struct rpc_pipe_client *cli,
7106 TALLOC_CTX *mem_ctx,
7107 WERROR *werror)
7108 {
7109 struct spoolss_PrinterMessageBox r;
7110 NTSTATUS status;
7111
7112 /* In parameters */
7113
7114 status = cli->dispatch(cli,
7115 mem_ctx,
7116 &ndr_table_spoolss,
7117 NDR_SPOOLSS_PRINTERMESSAGEBOX,
7118 &r);
7119
7120 if (!NT_STATUS_IS_OK(status)) {
7121 return status;
7122 }
7123
7124 if (NT_STATUS_IS_ERR(status)) {
7125 return status;
7126 }
7127
7128 /* Return variables */
7129
7130 /* Return result */
7131 if (werror) {
7132 *werror = r.out.result;
7133 }
7134
7135 return werror_to_ntstatus(r.out.result);
7136 }
7137
7138 struct rpccli_spoolss_AddMonitor_state {
7139 struct spoolss_AddMonitor orig;
7140 struct spoolss_AddMonitor tmp;
7141 TALLOC_CTX *out_mem_ctx;
7142 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7143 };
7144
7145 static void rpccli_spoolss_AddMonitor_done(struct tevent_req *subreq);
7146
7147 struct tevent_req *rpccli_spoolss_AddMonitor_send(TALLOC_CTX *mem_ctx,
7148 struct tevent_context *ev,
7149 struct rpc_pipe_client *cli)
7150 {
7151 struct tevent_req *req;
7152 struct rpccli_spoolss_AddMonitor_state *state;
7153 struct tevent_req *subreq;
7154
7155 req = tevent_req_create(mem_ctx, &state,
7156 struct rpccli_spoolss_AddMonitor_state);
7157 if (req == NULL) {
7158 return NULL;
7159 }
7160 state->out_mem_ctx = NULL;
7161 state->dispatch_recv = cli->dispatch_recv;
7162
7163 /* In parameters */
7164
7165 /* Out parameters */
7166
7167 /* Result */
7168 ZERO_STRUCT(state->orig.out.result);
7169
7170 /* make a temporary copy, that we pass to the dispatch function */
7171 state->tmp = state->orig;
7172
7173 subreq = cli->dispatch_send(state, ev, cli,
7174 &ndr_table_spoolss,
7175 NDR_SPOOLSS_ADDMONITOR,
7176 &state->tmp);
7177 if (tevent_req_nomem(subreq, req)) {
7178 return tevent_req_post(req, ev);
7179 }
7180 tevent_req_set_callback(subreq, rpccli_spoolss_AddMonitor_done, req);
7181 return req;
7182 }
7183
7184 static void rpccli_spoolss_AddMonitor_done(struct tevent_req *subreq)
7185 {
7186 struct tevent_req *req = tevent_req_callback_data(
7187 subreq, struct tevent_req);
7188 struct rpccli_spoolss_AddMonitor_state *state = tevent_req_data(
7189 req, struct rpccli_spoolss_AddMonitor_state);
7190 NTSTATUS status;
7191 TALLOC_CTX *mem_ctx;
7192
7193 if (state->out_mem_ctx) {
7194 mem_ctx = state->out_mem_ctx;
7195 } else {
7196 mem_ctx = state;
7197 }
7198
7199 status = state->dispatch_recv(subreq, mem_ctx);
7200 TALLOC_FREE(subreq);
7201 if (!NT_STATUS_IS_OK(status)) {
7202 tevent_req_nterror(req, status);
7203 return;
7204 }
7205
7206 /* Copy out parameters */
7207
7208 /* Copy result */
7209 state->orig.out.result = state->tmp.out.result;
7210
7211 /* Reset temporary structure */
7212 ZERO_STRUCT(state->tmp);
7213
7214 tevent_req_done(req);
7215 }
7216
7217 NTSTATUS rpccli_spoolss_AddMonitor_recv(struct tevent_req *req,
7218 TALLOC_CTX *mem_ctx,
7219 WERROR *result)
7220 {
7221 struct rpccli_spoolss_AddMonitor_state *state = tevent_req_data(
7222 req, struct rpccli_spoolss_AddMonitor_state);
7223 NTSTATUS status;
7224
7225 if (tevent_req_is_nterror(req, &status)) {
7226 tevent_req_received(req);
7227 return status;
7228 }
7229
7230 /* Steal possbile out parameters to the callers context */
7231 talloc_steal(mem_ctx, state->out_mem_ctx);
7232
7233 /* Return result */
7234 *result = state->orig.out.result;
7235
7236 tevent_req_received(req);
7237 return NT_STATUS_OK;
7238 }
7239
7240 NTSTATUS rpccli_spoolss_AddMonitor(struct rpc_pipe_client *cli,
7241 TALLOC_CTX *mem_ctx,
7242 WERROR *werror)
7243 {
7244 struct spoolss_AddMonitor r;
7245 NTSTATUS status;
7246
7247 /* In parameters */
7248
7249 status = cli->dispatch(cli,
7250 mem_ctx,
7251 &ndr_table_spoolss,
7252 NDR_SPOOLSS_ADDMONITOR,
7253 &r);
7254
7255 if (!NT_STATUS_IS_OK(status)) {
7256 return status;
7257 }
7258
7259 if (NT_STATUS_IS_ERR(status)) {
7260 return status;
7261 }
7262
7263 /* Return variables */
7264
7265 /* Return result */
7266 if (werror) {
7267 *werror = r.out.result;
7268 }
7269
7270 return werror_to_ntstatus(r.out.result);
7271 }
7272
7273 struct rpccli_spoolss_DeleteMonitor_state {
7274 struct spoolss_DeleteMonitor orig;
7275 struct spoolss_DeleteMonitor tmp;
7276 TALLOC_CTX *out_mem_ctx;
7277 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7278 };
7279
7280 static void rpccli_spoolss_DeleteMonitor_done(struct tevent_req *subreq);
7281
7282 struct tevent_req *rpccli_spoolss_DeleteMonitor_send(TALLOC_CTX *mem_ctx,
7283 struct tevent_context *ev,
7284 struct rpc_pipe_client *cli)
7285 {
7286 struct tevent_req *req;
7287 struct rpccli_spoolss_DeleteMonitor_state *state;
7288 struct tevent_req *subreq;
7289
7290 req = tevent_req_create(mem_ctx, &state,
7291 struct rpccli_spoolss_DeleteMonitor_state);
7292 if (req == NULL) {
7293 return NULL;
7294 }
7295 state->out_mem_ctx = NULL;
7296 state->dispatch_recv = cli->dispatch_recv;
7297
7298 /* In parameters */
7299
7300 /* Out parameters */
7301
7302 /* Result */
7303 ZERO_STRUCT(state->orig.out.result);
7304
7305 /* make a temporary copy, that we pass to the dispatch function */
7306 state->tmp = state->orig;
7307
7308 subreq = cli->dispatch_send(state, ev, cli,
7309 &ndr_table_spoolss,
7310 NDR_SPOOLSS_DELETEMONITOR,
7311 &state->tmp);
7312 if (tevent_req_nomem(subreq, req)) {
7313 return tevent_req_post(req, ev);
7314 }
7315 tevent_req_set_callback(subreq, rpccli_spoolss_DeleteMonitor_done, req);
7316 return req;
7317 }
7318
7319 static void rpccli_spoolss_DeleteMonitor_done(struct tevent_req *subreq)
7320 {
7321 struct tevent_req *req = tevent_req_callback_data(
7322 subreq, struct tevent_req);
7323 struct rpccli_spoolss_DeleteMonitor_state *state = tevent_req_data(
7324 req, struct rpccli_spoolss_DeleteMonitor_state);
7325 NTSTATUS status;
7326 TALLOC_CTX *mem_ctx;
7327
7328 if (state->out_mem_ctx) {
7329 mem_ctx = state->out_mem_ctx;
7330 } else {
7331 mem_ctx = state;
7332 }
7333
7334 status = state->dispatch_recv(subreq, mem_ctx);
7335 TALLOC_FREE(subreq);
7336 if (!NT_STATUS_IS_OK(status)) {
7337 tevent_req_nterror(req, status);
7338 return;
7339 }
7340
7341 /* Copy out parameters */
7342
7343 /* Copy result */
7344 state->orig.out.result = state->tmp.out.result;
7345
7346 /* Reset temporary structure */
7347 ZERO_STRUCT(state->tmp);
7348
7349 tevent_req_done(req);
7350 }
7351
7352 NTSTATUS rpccli_spoolss_DeleteMonitor_recv(struct tevent_req *req,
7353 TALLOC_CTX *mem_ctx,
7354 WERROR *result)
7355 {
7356 struct rpccli_spoolss_DeleteMonitor_state *state = tevent_req_data(
7357 req, struct rpccli_spoolss_DeleteMonitor_state);
7358 NTSTATUS status;
7359
7360 if (tevent_req_is_nterror(req, &status)) {
7361 tevent_req_received(req);
7362 return status;
7363 }
7364
7365 /* Steal possbile out parameters to the callers context */
7366 talloc_steal(mem_ctx, state->out_mem_ctx);
7367
7368 /* Return result */
7369 *result = state->orig.out.result;
7370
7371 tevent_req_received(req);
7372 return NT_STATUS_OK;
7373 }
7374
7375 NTSTATUS rpccli_spoolss_DeleteMonitor(struct rpc_pipe_client *cli,
7376 TALLOC_CTX *mem_ctx,
7377 WERROR *werror)
7378 {
7379 struct spoolss_DeleteMonitor r;
7380 NTSTATUS status;
7381
7382 /* In parameters */
7383
7384 status = cli->dispatch(cli,
7385 mem_ctx,
7386 &ndr_table_spoolss,
7387 NDR_SPOOLSS_DELETEMONITOR,
7388 &r);
7389
7390 if (!NT_STATUS_IS_OK(status)) {
7391 return status;
7392 }
7393
7394 if (NT_STATUS_IS_ERR(status)) {
7395 return status;
7396 }
7397
7398 /* Return variables */
7399
7400 /* Return result */
7401 if (werror) {
7402 *werror = r.out.result;
7403 }
7404
7405 return werror_to_ntstatus(r.out.result);
7406 }
7407
7408 struct rpccli_spoolss_DeletePrintProcessor_state {
7409 struct spoolss_DeletePrintProcessor orig;
7410 struct spoolss_DeletePrintProcessor tmp;
7411 TALLOC_CTX *out_mem_ctx;
7412 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7413 };
7414
7415 static void rpccli_spoolss_DeletePrintProcessor_done(struct tevent_req *subreq);
7416
7417 struct tevent_req *rpccli_spoolss_DeletePrintProcessor_send(TALLOC_CTX *mem_ctx,
7418 struct tevent_context *ev,
7419 struct rpc_pipe_client *cli)
7420 {
7421 struct tevent_req *req;
7422 struct rpccli_spoolss_DeletePrintProcessor_state *state;
7423 struct tevent_req *subreq;
7424
7425 req = tevent_req_create(mem_ctx, &state,
7426 struct rpccli_spoolss_DeletePrintProcessor_state);
7427 if (req == NULL) {
7428 return NULL;
7429 }
7430 state->out_mem_ctx = NULL;
7431 state->dispatch_recv = cli->dispatch_recv;
7432
7433 /* In parameters */
7434
7435 /* Out parameters */
7436
7437 /* Result */
7438 ZERO_STRUCT(state->orig.out.result);
7439
7440 /* make a temporary copy, that we pass to the dispatch function */
7441 state->tmp = state->orig;
7442
7443 subreq = cli->dispatch_send(state, ev, cli,
7444 &ndr_table_spoolss,
7445 NDR_SPOOLSS_DELETEPRINTPROCESSOR,
7446 &state->tmp);
7447 if (tevent_req_nomem(subreq, req)) {
7448 return tevent_req_post(req, ev);
7449 }
7450 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrintProcessor_done, req);
7451 return req;
7452 }
7453
7454 static void rpccli_spoolss_DeletePrintProcessor_done(struct tevent_req *subreq)
7455 {
7456 struct tevent_req *req = tevent_req_callback_data(
7457 subreq, struct tevent_req);
7458 struct rpccli_spoolss_DeletePrintProcessor_state *state = tevent_req_data(
7459 req, struct rpccli_spoolss_DeletePrintProcessor_state);
7460 NTSTATUS status;
7461 TALLOC_CTX *mem_ctx;
7462
7463 if (state->out_mem_ctx) {
7464 mem_ctx = state->out_mem_ctx;
7465 } else {
7466 mem_ctx = state;
7467 }
7468
7469 status = state->dispatch_recv(subreq, mem_ctx);
7470 TALLOC_FREE(subreq);
7471 if (!NT_STATUS_IS_OK(status)) {
7472 tevent_req_nterror(req, status);
7473 return;
7474 }
7475
7476 /* Copy out parameters */
7477
7478 /* Copy result */
7479 state->orig.out.result = state->tmp.out.result;
7480
7481 /* Reset temporary structure */
7482 ZERO_STRUCT(state->tmp);
7483
7484 tevent_req_done(req);
7485 }
7486
7487 NTSTATUS rpccli_spoolss_DeletePrintProcessor_recv(struct tevent_req *req,
7488 TALLOC_CTX *mem_ctx,
7489 WERROR *result)
7490 {
7491 struct rpccli_spoolss_DeletePrintProcessor_state *state = tevent_req_data(
7492 req, struct rpccli_spoolss_DeletePrintProcessor_state);
7493 NTSTATUS status;
7494
7495 if (tevent_req_is_nterror(req, &status)) {
7496 tevent_req_received(req);
7497 return status;
7498 }
7499
7500 /* Steal possbile out parameters to the callers context */
7501 talloc_steal(mem_ctx, state->out_mem_ctx);
7502
7503 /* Return result */
7504 *result = state->orig.out.result;
7505
7506 tevent_req_received(req);
7507 return NT_STATUS_OK;
7508 }
7509
7510 NTSTATUS rpccli_spoolss_DeletePrintProcessor(struct rpc_pipe_client *cli,
7511 TALLOC_CTX *mem_ctx,
7512 WERROR *werror)
7513 {
7514 struct spoolss_DeletePrintProcessor r;
7515 NTSTATUS status;
7516
7517 /* In parameters */
7518
7519 status = cli->dispatch(cli,
7520 mem_ctx,
7521 &ndr_table_spoolss,
7522 NDR_SPOOLSS_DELETEPRINTPROCESSOR,
7523 &r);
7524
7525 if (!NT_STATUS_IS_OK(status)) {
7526 return status;
7527 }
7528
7529 if (NT_STATUS_IS_ERR(status)) {
7530 return status;
7531 }
7532
7533 /* Return variables */
7534
7535 /* Return result */
7536 if (werror) {
7537 *werror = r.out.result;
7538 }
7539
7540 return werror_to_ntstatus(r.out.result);
7541 }
7542
7543 struct rpccli_spoolss_AddPrintProvidor_state {
7544 struct spoolss_AddPrintProvidor orig;
7545 struct spoolss_AddPrintProvidor tmp;
7546 TALLOC_CTX *out_mem_ctx;
7547 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7548 };
7549
7550 static void rpccli_spoolss_AddPrintProvidor_done(struct tevent_req *subreq);
7551
7552 struct tevent_req *rpccli_spoolss_AddPrintProvidor_send(TALLOC_CTX *mem_ctx,
7553 struct tevent_context *ev,
7554 struct rpc_pipe_client *cli)
7555 {
7556 struct tevent_req *req;
7557 struct rpccli_spoolss_AddPrintProvidor_state *state;
7558 struct tevent_req *subreq;
7559
7560 req = tevent_req_create(mem_ctx, &state,
7561 struct rpccli_spoolss_AddPrintProvidor_state);
7562 if (req == NULL) {
7563 return NULL;
7564 }
7565 state->out_mem_ctx = NULL;
7566 state->dispatch_recv = cli->dispatch_recv;
7567
7568 /* In parameters */
7569
7570 /* Out parameters */
7571
7572 /* Result */
7573 ZERO_STRUCT(state->orig.out.result);
7574
7575 /* make a temporary copy, that we pass to the dispatch function */
7576 state->tmp = state->orig;
7577
7578 subreq = cli->dispatch_send(state, ev, cli,
7579 &ndr_table_spoolss,
7580 NDR_SPOOLSS_ADDPRINTPROVIDOR,
7581 &state->tmp);
7582 if (tevent_req_nomem(subreq, req)) {
7583 return tevent_req_post(req, ev);
7584 }
7585 tevent_req_set_callback(subreq, rpccli_spoolss_AddPrintProvidor_done, req);
7586 return req;
7587 }
7588
7589 static void rpccli_spoolss_AddPrintProvidor_done(struct tevent_req *subreq)
7590 {
7591 struct tevent_req *req = tevent_req_callback_data(
7592 subreq, struct tevent_req);
7593 struct rpccli_spoolss_AddPrintProvidor_state *state = tevent_req_data(
7594 req, struct rpccli_spoolss_AddPrintProvidor_state);
7595 NTSTATUS status;
7596 TALLOC_CTX *mem_ctx;
7597
7598 if (state->out_mem_ctx) {
7599 mem_ctx = state->out_mem_ctx;
7600 } else {
7601 mem_ctx = state;
7602 }
7603
7604 status = state->dispatch_recv(subreq, mem_ctx);
7605 TALLOC_FREE(subreq);
7606 if (!NT_STATUS_IS_OK(status)) {
7607 tevent_req_nterror(req, status);
7608 return;
7609 }
7610
7611 /* Copy out parameters */
7612
7613 /* Copy result */
7614 state->orig.out.result = state->tmp.out.result;
7615
7616 /* Reset temporary structure */
7617 ZERO_STRUCT(state->tmp);
7618
7619 tevent_req_done(req);
7620 }
7621
7622 NTSTATUS rpccli_spoolss_AddPrintProvidor_recv(struct tevent_req *req,
7623 TALLOC_CTX *mem_ctx,
7624 WERROR *result)
7625 {
7626 struct rpccli_spoolss_AddPrintProvidor_state *state = tevent_req_data(
7627 req, struct rpccli_spoolss_AddPrintProvidor_state);
7628 NTSTATUS status;
7629
7630 if (tevent_req_is_nterror(req, &status)) {
7631 tevent_req_received(req);
7632 return status;
7633 }
7634
7635 /* Steal possbile out parameters to the callers context */
7636 talloc_steal(mem_ctx, state->out_mem_ctx);
7637
7638 /* Return result */
7639 *result = state->orig.out.result;
7640
7641 tevent_req_received(req);
7642 return NT_STATUS_OK;
7643 }
7644
7645 NTSTATUS rpccli_spoolss_AddPrintProvidor(struct rpc_pipe_client *cli,
7646 TALLOC_CTX *mem_ctx,
7647 WERROR *werror)
7648 {
7649 struct spoolss_AddPrintProvidor r;
7650 NTSTATUS status;
7651
7652 /* In parameters */
7653
7654 status = cli->dispatch(cli,
7655 mem_ctx,
7656 &ndr_table_spoolss,
7657 NDR_SPOOLSS_ADDPRINTPROVIDOR,
7658 &r);
7659
7660 if (!NT_STATUS_IS_OK(status)) {
7661 return status;
7662 }
7663
7664 if (NT_STATUS_IS_ERR(status)) {
7665 return status;
7666 }
7667
7668 /* Return variables */
7669
7670 /* Return result */
7671 if (werror) {
7672 *werror = r.out.result;
7673 }
7674
7675 return werror_to_ntstatus(r.out.result);
7676 }
7677
7678 struct rpccli_spoolss_DeletePrintProvidor_state {
7679 struct spoolss_DeletePrintProvidor orig;
7680 struct spoolss_DeletePrintProvidor tmp;
7681 TALLOC_CTX *out_mem_ctx;
7682 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7683 };
7684
7685 static void rpccli_spoolss_DeletePrintProvidor_done(struct tevent_req *subreq);
7686
7687 struct tevent_req *rpccli_spoolss_DeletePrintProvidor_send(TALLOC_CTX *mem_ctx,
7688 struct tevent_context *ev,
7689 struct rpc_pipe_client *cli)
7690 {
7691 struct tevent_req *req;
7692 struct rpccli_spoolss_DeletePrintProvidor_state *state;
7693 struct tevent_req *subreq;
7694
7695 req = tevent_req_create(mem_ctx, &state,
7696 struct rpccli_spoolss_DeletePrintProvidor_state);
7697 if (req == NULL) {
7698 return NULL;
7699 }
7700 state->out_mem_ctx = NULL;
7701 state->dispatch_recv = cli->dispatch_recv;
7702
7703 /* In parameters */
7704
7705 /* Out parameters */
7706
7707 /* Result */
7708 ZERO_STRUCT(state->orig.out.result);
7709
7710 /* make a temporary copy, that we pass to the dispatch function */
7711 state->tmp = state->orig;
7712
7713 subreq = cli->dispatch_send(state, ev, cli,
7714 &ndr_table_spoolss,
7715 NDR_SPOOLSS_DELETEPRINTPROVIDOR,
7716 &state->tmp);
7717 if (tevent_req_nomem(subreq, req)) {
7718 return tevent_req_post(req, ev);
7719 }
7720 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrintProvidor_done, req);
7721 return req;
7722 }
7723
7724 static void rpccli_spoolss_DeletePrintProvidor_done(struct tevent_req *subreq)
7725 {
7726 struct tevent_req *req = tevent_req_callback_data(
7727 subreq, struct tevent_req);
7728 struct rpccli_spoolss_DeletePrintProvidor_state *state = tevent_req_data(
7729 req, struct rpccli_spoolss_DeletePrintProvidor_state);
7730 NTSTATUS status;
7731 TALLOC_CTX *mem_ctx;
7732
7733 if (state->out_mem_ctx) {
7734 mem_ctx = state->out_mem_ctx;
7735 } else {
7736 mem_ctx = state;
7737 }
7738
7739 status = state->dispatch_recv(subreq, mem_ctx);
7740 TALLOC_FREE(subreq);
7741 if (!NT_STATUS_IS_OK(status)) {
7742 tevent_req_nterror(req, status);
7743 return;
7744 }
7745
7746 /* Copy out parameters */
7747
7748 /* Copy result */
7749 state->orig.out.result = state->tmp.out.result;
7750
7751 /* Reset temporary structure */
7752 ZERO_STRUCT(state->tmp);
7753
7754 tevent_req_done(req);
7755 }
7756
7757 NTSTATUS rpccli_spoolss_DeletePrintProvidor_recv(struct tevent_req *req,
7758 TALLOC_CTX *mem_ctx,
7759 WERROR *result)
7760 {
7761 struct rpccli_spoolss_DeletePrintProvidor_state *state = tevent_req_data(
7762 req, struct rpccli_spoolss_DeletePrintProvidor_state);
7763 NTSTATUS status;
7764
7765 if (tevent_req_is_nterror(req, &status)) {
7766 tevent_req_received(req);
7767 return status;
7768 }
7769
7770 /* Steal possbile out parameters to the callers context */
7771 talloc_steal(mem_ctx, state->out_mem_ctx);
7772
7773 /* Return result */
7774 *result = state->orig.out.result;
7775
7776 tevent_req_received(req);
7777 return NT_STATUS_OK;
7778 }
7779
7780 NTSTATUS rpccli_spoolss_DeletePrintProvidor(struct rpc_pipe_client *cli,
7781 TALLOC_CTX *mem_ctx,
7782 WERROR *werror)
7783 {
7784 struct spoolss_DeletePrintProvidor r;
7785 NTSTATUS status;
7786
7787 /* In parameters */
7788
7789 status = cli->dispatch(cli,
7790 mem_ctx,
7791 &ndr_table_spoolss,
7792 NDR_SPOOLSS_DELETEPRINTPROVIDOR,
7793 &r);
7794
7795 if (!NT_STATUS_IS_OK(status)) {
7796 return status;
7797 }
7798
7799 if (NT_STATUS_IS_ERR(status)) {
7800 return status;
7801 }
7802
7803 /* Return variables */
7804
7805 /* Return result */
7806 if (werror) {
7807 *werror = r.out.result;
7808 }
7809
7810 return werror_to_ntstatus(r.out.result);
7811 }
7812
7813 struct rpccli_spoolss_EnumPrintProcDataTypes_state {
7814 struct spoolss_EnumPrintProcDataTypes orig;
7815 struct spoolss_EnumPrintProcDataTypes tmp;
7816 TALLOC_CTX *out_mem_ctx;
7817 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7818 };
7819
7820 static void rpccli_spoolss_EnumPrintProcDataTypes_done(struct tevent_req *subreq);
7821
7822 struct tevent_req *rpccli_spoolss_EnumPrintProcDataTypes_send(TALLOC_CTX *mem_ctx,
7823 struct tevent_context *ev,
7824 struct rpc_pipe_client *cli,
7825 const char *_servername /* [in] [unique,charset(UTF16)] */,
7826 const char *_print_processor_name /* [in] [unique,charset(UTF16)] */,
7827 uint32_t _level /* [in] */,
7828 DATA_BLOB *_buffer /* [in] [unique] */,
7829 uint32_t _offered /* [in] */,
7830 uint32_t *_count /* [out] [ref] */,
7831 union spoolss_PrintProcDataTypesInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
7832 uint32_t *_needed /* [out] [ref] */)
7833 {
7834 struct tevent_req *req;
7835 struct rpccli_spoolss_EnumPrintProcDataTypes_state *state;
7836 struct tevent_req *subreq;
7837
7838 req = tevent_req_create(mem_ctx, &state,
7839 struct rpccli_spoolss_EnumPrintProcDataTypes_state);
7840 if (req == NULL) {
7841 return NULL;
7842 }
7843 state->out_mem_ctx = NULL;
7844 state->dispatch_recv = cli->dispatch_recv;
7845
7846 /* In parameters */
7847 state->orig.in.servername = _servername;
7848 state->orig.in.print_processor_name = _print_processor_name;
7849 state->orig.in.level = _level;
7850 state->orig.in.buffer = _buffer;
7851 state->orig.in.offered = _offered;
7852
7853 /* Out parameters */
7854 state->orig.out.count = _count;
7855 state->orig.out.info = _info;
7856 state->orig.out.needed = _needed;
7857
7858 /* Result */
7859 ZERO_STRUCT(state->orig.out.result);
7860
7861 state->out_mem_ctx = talloc_named_const(state, 0,
7862 "rpccli_spoolss_EnumPrintProcDataTypes_out_memory");
7863 if (tevent_req_nomem(state->out_mem_ctx, req)) {
7864 return tevent_req_post(req, ev);
7865 }
7866
7867 /* make a temporary copy, that we pass to the dispatch function */
7868 state->tmp = state->orig;
7869
7870 subreq = cli->dispatch_send(state, ev, cli,
7871 &ndr_table_spoolss,
7872 NDR_SPOOLSS_ENUMPRINTPROCDATATYPES,
7873 &state->tmp);
7874 if (tevent_req_nomem(subreq, req)) {
7875 return tevent_req_post(req, ev);
7876 }
7877 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrintProcDataTypes_done, req);
7878 return req;
7879 }
7880
7881 static void rpccli_spoolss_EnumPrintProcDataTypes_done(struct tevent_req *subreq)
7882 {
7883 struct tevent_req *req = tevent_req_callback_data(
7884 subreq, struct tevent_req);
7885 struct rpccli_spoolss_EnumPrintProcDataTypes_state *state = tevent_req_data(
7886 req, struct rpccli_spoolss_EnumPrintProcDataTypes_state);
7887 NTSTATUS status;
7888 TALLOC_CTX *mem_ctx;
7889
7890 if (state->out_mem_ctx) {
7891 mem_ctx = state->out_mem_ctx;
7892 } else {
7893 mem_ctx = state;
7894 }
7895
7896 status = state->dispatch_recv(subreq, mem_ctx);
7897 TALLOC_FREE(subreq);
7898 if (!NT_STATUS_IS_OK(status)) {
7899 tevent_req_nterror(req, status);
7900 return;
7901 }
7902
7903 /* Copy out parameters */
7904 *state->orig.out.count = *state->tmp.out.count;
7905 *state->orig.out.info = *state->tmp.out.info;
7906 *state->orig.out.needed = *state->tmp.out.needed;
7907
7908 /* Copy result */
7909 state->orig.out.result = state->tmp.out.result;
7910
7911 /* Reset temporary structure */
7912 ZERO_STRUCT(state->tmp);
7913
7914 tevent_req_done(req);
7915 }
7916
7917 NTSTATUS rpccli_spoolss_EnumPrintProcDataTypes_recv(struct tevent_req *req,
7918 TALLOC_CTX *mem_ctx,
7919 WERROR *result)
7920 {
7921 struct rpccli_spoolss_EnumPrintProcDataTypes_state *state = tevent_req_data(
7922 req, struct rpccli_spoolss_EnumPrintProcDataTypes_state);
7923 NTSTATUS status;
7924
7925 if (tevent_req_is_nterror(req, &status)) {
7926 tevent_req_received(req);
7927 return status;
7928 }
7929
7930 /* Steal possbile out parameters to the callers context */
7931 talloc_steal(mem_ctx, state->out_mem_ctx);
7932
7933 /* Return result */
7934 *result = state->orig.out.result;
7935
7936 tevent_req_received(req);
7937 return NT_STATUS_OK;
7938 }
7939
7940 NTSTATUS rpccli_spoolss_EnumPrintProcDataTypes(struct rpc_pipe_client *cli,
7941 TALLOC_CTX *mem_ctx,
7942 const char *servername /* [in] [unique,charset(UTF16)] */,
7943 const char *print_processor_name /* [in] [unique,charset(UTF16)] */,
7944 uint32_t level /* [in] */,
7945 DATA_BLOB *buffer /* [in] [unique] */,
7946 uint32_t offered /* [in] */,
7947 uint32_t *count /* [out] [ref] */,
7948 union spoolss_PrintProcDataTypesInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
7949 uint32_t *needed /* [out] [ref] */,
7950 WERROR *werror)
7951 {
7952 struct spoolss_EnumPrintProcDataTypes r;
7953 NTSTATUS status;
7954
7955 /* In parameters */
7956 r.in.servername = servername;
7957 r.in.print_processor_name = print_processor_name;
7958 r.in.level = level;
7959 r.in.buffer = buffer;
7960 r.in.offered = offered;
7961
7962 status = cli->dispatch(cli,
7963 mem_ctx,
7964 &ndr_table_spoolss,
7965 NDR_SPOOLSS_ENUMPRINTPROCDATATYPES,
7966 &r);
7967
7968 if (!NT_STATUS_IS_OK(status)) {
7969 return status;
7970 }
7971
7972 if (NT_STATUS_IS_ERR(status)) {
7973 return status;
7974 }
7975
7976 /* Return variables */
7977 *count = *r.out.count;
7978 *info = *r.out.info;
7979 *needed = *r.out.needed;
7980
7981 /* Return result */
7982 if (werror) {
7983 *werror = r.out.result;
7984 }
7985
7986 return werror_to_ntstatus(r.out.result);
7987 }
7988
7989 struct rpccli_spoolss_ResetPrinter_state {
7990 struct spoolss_ResetPrinter orig;
7991 struct spoolss_ResetPrinter tmp;
7992 TALLOC_CTX *out_mem_ctx;
7993 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7994 };
7995
7996 static void rpccli_spoolss_ResetPrinter_done(struct tevent_req *subreq);
7997
7998 struct tevent_req *rpccli_spoolss_ResetPrinter_send(TALLOC_CTX *mem_ctx,
7999 struct tevent_context *ev,
8000 struct rpc_pipe_client *cli,
8001 struct policy_handle *_handle /* [in] [ref] */,
8002 const char *_data_type /* [in] [unique,charset(UTF16)] */,
8003 struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */)
8004 {
8005 struct tevent_req *req;
8006 struct rpccli_spoolss_ResetPrinter_state *state;
8007 struct tevent_req *subreq;
8008
8009 req = tevent_req_create(mem_ctx, &state,
8010 struct rpccli_spoolss_ResetPrinter_state);
8011 if (req == NULL) {
8012 return NULL;
8013 }
8014 state->out_mem_ctx = NULL;
8015 state->dispatch_recv = cli->dispatch_recv;
8016
8017 /* In parameters */
8018 state->orig.in.handle = _handle;
8019 state->orig.in.data_type = _data_type;
8020 state->orig.in.devmode_ctr = _devmode_ctr;
8021
8022 /* Out parameters */
8023
8024 /* Result */
8025 ZERO_STRUCT(state->orig.out.result);
8026
8027 /* make a temporary copy, that we pass to the dispatch function */
8028 state->tmp = state->orig;
8029
8030 subreq = cli->dispatch_send(state, ev, cli,
8031 &ndr_table_spoolss,
8032 NDR_SPOOLSS_RESETPRINTER,
8033 &state->tmp);
8034 if (tevent_req_nomem(subreq, req)) {
8035 return tevent_req_post(req, ev);
8036 }
8037 tevent_req_set_callback(subreq, rpccli_spoolss_ResetPrinter_done, req);
8038 return req;
8039 }
8040
8041 static void rpccli_spoolss_ResetPrinter_done(struct tevent_req *subreq)
8042 {
8043 struct tevent_req *req = tevent_req_callback_data(
8044 subreq, struct tevent_req);
8045 struct rpccli_spoolss_ResetPrinter_state *state = tevent_req_data(
8046 req, struct rpccli_spoolss_ResetPrinter_state);
8047 NTSTATUS status;
8048 TALLOC_CTX *mem_ctx;
8049
8050 if (state->out_mem_ctx) {
8051 mem_ctx = state->out_mem_ctx;
8052 } else {
8053 mem_ctx = state;
8054 }
8055
8056 status = state->dispatch_recv(subreq, mem_ctx);
8057 TALLOC_FREE(subreq);
8058 if (!NT_STATUS_IS_OK(status)) {
8059 tevent_req_nterror(req, status);
8060 return;
8061 }
8062
8063 /* Copy out parameters */
8064
8065 /* Copy result */
8066 state->orig.out.result = state->tmp.out.result;
8067
8068 /* Reset temporary structure */
8069 ZERO_STRUCT(state->tmp);
8070
8071 tevent_req_done(req);
8072 }
8073
8074 NTSTATUS rpccli_spoolss_ResetPrinter_recv(struct tevent_req *req,
8075 TALLOC_CTX *mem_ctx,
8076 WERROR *result)
8077 {
8078 struct rpccli_spoolss_ResetPrinter_state *state = tevent_req_data(
8079 req, struct rpccli_spoolss_ResetPrinter_state);
8080 NTSTATUS status;
8081
8082 if (tevent_req_is_nterror(req, &status)) {
8083 tevent_req_received(req);
8084 return status;
8085 }
8086
8087 /* Steal possbile out parameters to the callers context */
8088 talloc_steal(mem_ctx, state->out_mem_ctx);
8089
8090 /* Return result */
8091 *result = state->orig.out.result;
8092
8093 tevent_req_received(req);
8094 return NT_STATUS_OK;
8095 }
8096
8097 NTSTATUS rpccli_spoolss_ResetPrinter(struct rpc_pipe_client *cli,
8098 TALLOC_CTX *mem_ctx,
8099 struct policy_handle *handle /* [in] [ref] */,
8100 const char *data_type /* [in] [unique,charset(UTF16)] */,
8101 struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
8102 WERROR *werror)
8103 {
8104 struct spoolss_ResetPrinter r;
8105 NTSTATUS status;
8106
8107 /* In parameters */
8108 r.in.handle = handle;
8109 r.in.data_type = data_type;
8110 r.in.devmode_ctr = devmode_ctr;
8111
8112 status = cli->dispatch(cli,
8113 mem_ctx,
8114 &ndr_table_spoolss,
8115 NDR_SPOOLSS_RESETPRINTER,
8116 &r);
8117
8118 if (!NT_STATUS_IS_OK(status)) {
8119 return status;
8120 }
8121
8122 if (NT_STATUS_IS_ERR(status)) {
8123 return status;
8124 }
8125
8126 /* Return variables */
8127
8128 /* Return result */
8129 if (werror) {
8130 *werror = r.out.result;
8131 }
8132
8133 return werror_to_ntstatus(r.out.result);
8134 }
8135
8136 struct rpccli_spoolss_GetPrinterDriver2_state {
8137 struct spoolss_GetPrinterDriver2 orig;
8138 struct spoolss_GetPrinterDriver2 tmp;
8139 TALLOC_CTX *out_mem_ctx;
8140 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8141 };
8142
8143 static void rpccli_spoolss_GetPrinterDriver2_done(struct tevent_req *subreq);
8144
8145 struct tevent_req *rpccli_spoolss_GetPrinterDriver2_send(TALLOC_CTX *mem_ctx,
8146 struct tevent_context *ev,
8147 struct rpc_pipe_client *cli,
8148 struct policy_handle *_handle /* [in] [ref] */,
8149 const char *_architecture /* [in] [unique,charset(UTF16)] */,
8150 uint32_t _level /* [in] */,
8151 DATA_BLOB *_buffer /* [in] [unique] */,
8152 uint32_t _offered /* [in] */,
8153 uint32_t _client_major_version /* [in] */,
8154 uint32_t _client_minor_version /* [in] */,
8155 union spoolss_DriverInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
8156 uint32_t *_needed /* [out] [ref] */,
8157 uint32_t *_server_major_version /* [out] [ref] */,
8158 uint32_t *_server_minor_version /* [out] [ref] */)
8159 {
8160 struct tevent_req *req;
8161 struct rpccli_spoolss_GetPrinterDriver2_state *state;
8162 struct tevent_req *subreq;
8163
8164 req = tevent_req_create(mem_ctx, &state,
8165 struct rpccli_spoolss_GetPrinterDriver2_state);
8166 if (req == NULL) {
8167 return NULL;
8168 }
8169 state->out_mem_ctx = NULL;
8170 state->dispatch_recv = cli->dispatch_recv;
8171
8172 /* In parameters */
8173 state->orig.in.handle = _handle;
8174 state->orig.in.architecture = _architecture;
8175 state->orig.in.level = _level;
8176 state->orig.in.buffer = _buffer;
8177 state->orig.in.offered = _offered;
8178 state->orig.in.client_major_version = _client_major_version;
8179 state->orig.in.client_minor_version = _client_minor_version;
8180
8181 /* Out parameters */
8182 state->orig.out.info = _info;
8183 state->orig.out.needed = _needed;
8184 state->orig.out.server_major_version = _server_major_version;
8185 state->orig.out.server_minor_version = _server_minor_version;
8186
8187 /* Result */
8188 ZERO_STRUCT(state->orig.out.result);
8189
8190 state->out_mem_ctx = talloc_named_const(state, 0,
8191 "rpccli_spoolss_GetPrinterDriver2_out_memory");
8192 if (tevent_req_nomem(state->out_mem_ctx, req)) {
8193 return tevent_req_post(req, ev);
8194 }
8195
8196 /* make a temporary copy, that we pass to the dispatch function */
8197 state->tmp = state->orig;
8198
8199 subreq = cli->dispatch_send(state, ev, cli,
8200 &ndr_table_spoolss,
8201 NDR_SPOOLSS_GETPRINTERDRIVER2,
8202 &state->tmp);
8203 if (tevent_req_nomem(subreq, req)) {
8204 return tevent_req_post(req, ev);
8205 }
8206 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriver2_done, req);
8207 return req;
8208 }
8209
8210 static void rpccli_spoolss_GetPrinterDriver2_done(struct tevent_req *subreq)
8211 {
8212 struct tevent_req *req = tevent_req_callback_data(
8213 subreq, struct tevent_req);
8214 struct rpccli_spoolss_GetPrinterDriver2_state *state = tevent_req_data(
8215 req, struct rpccli_spoolss_GetPrinterDriver2_state);
8216 NTSTATUS status;
8217 TALLOC_CTX *mem_ctx;
8218
8219 if (state->out_mem_ctx) {
8220 mem_ctx = state->out_mem_ctx;
8221 } else {
8222 mem_ctx = state;
8223 }
8224
8225 status = state->dispatch_recv(subreq, mem_ctx);
8226 TALLOC_FREE(subreq);
8227 if (!NT_STATUS_IS_OK(status)) {
8228 tevent_req_nterror(req, status);
8229 return;
8230 }
8231
8232 /* Copy out parameters */
8233 if (state->orig.out.info && state->tmp.out.info) {
8234 *state->orig.out.info = *state->tmp.out.info;
8235 }
8236 *state->orig.out.needed = *state->tmp.out.needed;
8237 *state->orig.out.server_major_version = *state->tmp.out.server_major_version;
8238 *state->orig.out.server_minor_version = *state->tmp.out.server_minor_version;
8239
8240 /* Copy result */
8241 state->orig.out.result = state->tmp.out.result;
8242
8243 /* Reset temporary structure */
8244 ZERO_STRUCT(state->tmp);
8245
8246 tevent_req_done(req);
8247 }
8248
8249 NTSTATUS rpccli_spoolss_GetPrinterDriver2_recv(struct tevent_req *req,
8250 TALLOC_CTX *mem_ctx,
8251 WERROR *result)
8252 {
8253 struct rpccli_spoolss_GetPrinterDriver2_state *state = tevent_req_data(
8254 req, struct rpccli_spoolss_GetPrinterDriver2_state);
8255 NTSTATUS status;
8256
8257 if (tevent_req_is_nterror(req, &status)) {
8258 tevent_req_received(req);
8259 return status;
8260 }
8261
8262 /* Steal possbile out parameters to the callers context */
8263 talloc_steal(mem_ctx, state->out_mem_ctx);
8264
8265 /* Return result */
8266 *result = state->orig.out.result;
8267
8268 tevent_req_received(req);
8269 return NT_STATUS_OK;
8270 }
8271
8272 NTSTATUS rpccli_spoolss_GetPrinterDriver2(struct rpc_pipe_client *cli,
8273 TALLOC_CTX *mem_ctx,
8274 struct policy_handle *handle /* [in] [ref] */,
8275 const char *architecture /* [in] [unique,charset(UTF16)] */,
8276 uint32_t level /* [in] */,
8277 DATA_BLOB *buffer /* [in] [unique] */,
8278 uint32_t offered /* [in] */,
8279 uint32_t client_major_version /* [in] */,
8280 uint32_t client_minor_version /* [in] */,
8281 union spoolss_DriverInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
8282 uint32_t *needed /* [out] [ref] */,
8283 uint32_t *server_major_version /* [out] [ref] */,
8284 uint32_t *server_minor_version /* [out] [ref] */,
8285 WERROR *werror)
8286 {
8287 struct spoolss_GetPrinterDriver2 r;
8288 NTSTATUS status;
8289
8290 /* In parameters */
8291 r.in.handle = handle;
8292 r.in.architecture = architecture;
8293 r.in.level = level;
8294 r.in.buffer = buffer;
8295 r.in.offered = offered;
8296 r.in.client_major_version = client_major_version;
8297 r.in.client_minor_version = client_minor_version;
8298
8299 status = cli->dispatch(cli,
8300 mem_ctx,
8301 &ndr_table_spoolss,
8302 NDR_SPOOLSS_GETPRINTERDRIVER2,
8303 &r);
8304
8305 if (!NT_STATUS_IS_OK(status)) {
8306 return status;
8307 }
8308
8309 if (NT_STATUS_IS_ERR(status)) {
8310 return status;
8311 }
8312
8313 /* Return variables */
8314 if (info && r.out.info) {
8315 *info = *r.out.info;
8316 }
8317 *needed = *r.out.needed;
8318 *server_major_version = *r.out.server_major_version;
8319 *server_minor_version = *r.out.server_minor_version;
8320
8321 /* Return result */
8322 if (werror) {
8323 *werror = r.out.result;
8324 }
8325
8326 return werror_to_ntstatus(r.out.result);
8327 }
8328
8329 struct rpccli_spoolss_FindFirstPrinterChangeNotification_state {
8330 struct spoolss_FindFirstPrinterChangeNotification orig;
8331 struct spoolss_FindFirstPrinterChangeNotification tmp;
8332 TALLOC_CTX *out_mem_ctx;
8333 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8334 };
8335
8336 static void rpccli_spoolss_FindFirstPrinterChangeNotification_done(struct tevent_req *subreq);
8337
8338 struct tevent_req *rpccli_spoolss_FindFirstPrinterChangeNotification_send(TALLOC_CTX *mem_ctx,
8339 struct tevent_context *ev,
8340 struct rpc_pipe_client *cli)
8341 {
8342 struct tevent_req *req;
8343 struct rpccli_spoolss_FindFirstPrinterChangeNotification_state *state;
8344 struct tevent_req *subreq;
8345
8346 req = tevent_req_create(mem_ctx, &state,
8347 struct rpccli_spoolss_FindFirstPrinterChangeNotification_state);
8348 if (req == NULL) {
8349 return NULL;
8350 }
8351 state->out_mem_ctx = NULL;
8352 state->dispatch_recv = cli->dispatch_recv;
8353
8354 /* In parameters */
8355
8356 /* Out parameters */
8357
8358 /* Result */
8359 ZERO_STRUCT(state->orig.out.result);
8360
8361 /* make a temporary copy, that we pass to the dispatch function */
8362 state->tmp = state->orig;
8363
8364 subreq = cli->dispatch_send(state, ev, cli,
8365 &ndr_table_spoolss,
8366 NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION,
8367 &state->tmp);
8368 if (tevent_req_nomem(subreq, req)) {
8369 return tevent_req_post(req, ev);
8370 }
8371 tevent_req_set_callback(subreq, rpccli_spoolss_FindFirstPrinterChangeNotification_done, req);
8372 return req;
8373 }
8374
8375 static void rpccli_spoolss_FindFirstPrinterChangeNotification_done(struct tevent_req *subreq)
8376 {
8377 struct tevent_req *req = tevent_req_callback_data(
8378 subreq, struct tevent_req);
8379 struct rpccli_spoolss_FindFirstPrinterChangeNotification_state *state = tevent_req_data(
8380 req, struct rpccli_spoolss_FindFirstPrinterChangeNotification_state);
8381 NTSTATUS status;
8382 TALLOC_CTX *mem_ctx;
8383
8384 if (state->out_mem_ctx) {
8385 mem_ctx = state->out_mem_ctx;
8386 } else {
8387 mem_ctx = state;
8388 }
8389
8390 status = state->dispatch_recv(subreq, mem_ctx);
8391 TALLOC_FREE(subreq);
8392 if (!NT_STATUS_IS_OK(status)) {
8393 tevent_req_nterror(req, status);
8394 return;
8395 }
8396
8397 /* Copy out parameters */
8398
8399 /* Copy result */
8400 state->orig.out.result = state->tmp.out.result;
8401
8402 /* Reset temporary structure */
8403 ZERO_STRUCT(state->tmp);
8404
8405 tevent_req_done(req);
8406 }
8407
8408 NTSTATUS rpccli_spoolss_FindFirstPrinterChangeNotification_recv(struct tevent_req *req,
8409 TALLOC_CTX *mem_ctx,
8410 WERROR *result)
8411 {
8412 struct rpccli_spoolss_FindFirstPrinterChangeNotification_state *state = tevent_req_data(
8413 req, struct rpccli_spoolss_FindFirstPrinterChangeNotification_state);
8414 NTSTATUS status;
8415
8416 if (tevent_req_is_nterror(req, &status)) {
8417 tevent_req_received(req);
8418 return status;
8419 }
8420
8421 /* Steal possbile out parameters to the callers context */
8422 talloc_steal(mem_ctx, state->out_mem_ctx);
8423
8424 /* Return result */
8425 *result = state->orig.out.result;
8426
8427 tevent_req_received(req);
8428 return NT_STATUS_OK;
8429 }
8430
8431 NTSTATUS rpccli_spoolss_FindFirstPrinterChangeNotification(struct rpc_pipe_client *cli,
8432 TALLOC_CTX *mem_ctx,
8433 WERROR *werror)
8434 {
8435 struct spoolss_FindFirstPrinterChangeNotification r;
8436 NTSTATUS status;
8437
8438 /* In parameters */
8439
8440 status = cli->dispatch(cli,
8441 mem_ctx,
8442 &ndr_table_spoolss,
8443 NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION,
8444 &r);
8445
8446 if (!NT_STATUS_IS_OK(status)) {
8447 return status;
8448 }
8449
8450 if (NT_STATUS_IS_ERR(status)) {
8451 return status;
8452 }
8453
8454 /* Return variables */
8455
8456 /* Return result */
8457 if (werror) {
8458 *werror = r.out.result;
8459 }
8460
8461 return werror_to_ntstatus(r.out.result);
8462 }
8463
8464 struct rpccli_spoolss_FindNextPrinterChangeNotification_state {
8465 struct spoolss_FindNextPrinterChangeNotification orig;
8466 struct spoolss_FindNextPrinterChangeNotification tmp;
8467 TALLOC_CTX *out_mem_ctx;
8468 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8469 };
8470
8471 static void rpccli_spoolss_FindNextPrinterChangeNotification_done(struct tevent_req *subreq);
8472
8473 struct tevent_req *rpccli_spoolss_FindNextPrinterChangeNotification_send(TALLOC_CTX *mem_ctx,
8474 struct tevent_context *ev,
8475 struct rpc_pipe_client *cli)
8476 {
8477 struct tevent_req *req;
8478 struct rpccli_spoolss_FindNextPrinterChangeNotification_state *state;
8479 struct tevent_req *subreq;
8480
8481 req = tevent_req_create(mem_ctx, &state,
8482 struct rpccli_spoolss_FindNextPrinterChangeNotification_state);
8483 if (req == NULL) {
8484 return NULL;
8485 }
8486 state->out_mem_ctx = NULL;
8487 state->dispatch_recv = cli->dispatch_recv;
8488
8489 /* In parameters */
8490
8491 /* Out parameters */
8492
8493 /* Result */
8494 ZERO_STRUCT(state->orig.out.result);
8495
8496 /* make a temporary copy, that we pass to the dispatch function */
8497 state->tmp = state->orig;
8498
8499 subreq = cli->dispatch_send(state, ev, cli,
8500 &ndr_table_spoolss,
8501 NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION,
8502 &state->tmp);
8503 if (tevent_req_nomem(subreq, req)) {
8504 return tevent_req_post(req, ev);
8505 }
8506 tevent_req_set_callback(subreq, rpccli_spoolss_FindNextPrinterChangeNotification_done, req);
8507 return req;
8508 }
8509
8510 static void rpccli_spoolss_FindNextPrinterChangeNotification_done(struct tevent_req *subreq)
8511 {
8512 struct tevent_req *req = tevent_req_callback_data(
8513 subreq, struct tevent_req);
8514 struct rpccli_spoolss_FindNextPrinterChangeNotification_state *state = tevent_req_data(
8515 req, struct rpccli_spoolss_FindNextPrinterChangeNotification_state);
8516 NTSTATUS status;
8517 TALLOC_CTX *mem_ctx;
8518
8519 if (state->out_mem_ctx) {
8520 mem_ctx = state->out_mem_ctx;
8521 } else {
8522 mem_ctx = state;
8523 }
8524
8525 status = state->dispatch_recv(subreq, mem_ctx);
8526 TALLOC_FREE(subreq);
8527 if (!NT_STATUS_IS_OK(status)) {
8528 tevent_req_nterror(req, status);
8529 return;
8530 }
8531
8532 /* Copy out parameters */
8533
8534 /* Copy result */
8535 state->orig.out.result = state->tmp.out.result;
8536
8537 /* Reset temporary structure */
8538 ZERO_STRUCT(state->tmp);
8539
8540 tevent_req_done(req);
8541 }
8542
8543 NTSTATUS rpccli_spoolss_FindNextPrinterChangeNotification_recv(struct tevent_req *req,
8544 TALLOC_CTX *mem_ctx,
8545 WERROR *result)
8546 {
8547 struct rpccli_spoolss_FindNextPrinterChangeNotification_state *state = tevent_req_data(
8548 req, struct rpccli_spoolss_FindNextPrinterChangeNotification_state);
8549 NTSTATUS status;
8550
8551 if (tevent_req_is_nterror(req, &status)) {
8552 tevent_req_received(req);
8553 return status;
8554 }
8555
8556 /* Steal possbile out parameters to the callers context */
8557 talloc_steal(mem_ctx, state->out_mem_ctx);
8558
8559 /* Return result */
8560 *result = state->orig.out.result;
8561
8562 tevent_req_received(req);
8563 return NT_STATUS_OK;
8564 }
8565
8566 NTSTATUS rpccli_spoolss_FindNextPrinterChangeNotification(struct rpc_pipe_client *cli,
8567 TALLOC_CTX *mem_ctx,
8568 WERROR *werror)
8569 {
8570 struct spoolss_FindNextPrinterChangeNotification r;
8571 NTSTATUS status;
8572
8573 /* In parameters */
8574
8575 status = cli->dispatch(cli,
8576 mem_ctx,
8577 &ndr_table_spoolss,
8578 NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION,
8579 &r);
8580
8581 if (!NT_STATUS_IS_OK(status)) {
8582 return status;
8583 }
8584
8585 if (NT_STATUS_IS_ERR(status)) {
8586 return status;
8587 }
8588
8589 /* Return variables */
8590
8591 /* Return result */
8592 if (werror) {
8593 *werror = r.out.result;
8594 }
8595
8596 return werror_to_ntstatus(r.out.result);
8597 }
8598
8599 struct rpccli_spoolss_FindClosePrinterNotify_state {
8600 struct spoolss_FindClosePrinterNotify orig;
8601 struct spoolss_FindClosePrinterNotify tmp;
8602 TALLOC_CTX *out_mem_ctx;
8603 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8604 };
8605
8606 static void rpccli_spoolss_FindClosePrinterNotify_done(struct tevent_req *subreq);
8607
8608 struct tevent_req *rpccli_spoolss_FindClosePrinterNotify_send(TALLOC_CTX *mem_ctx,
8609 struct tevent_context *ev,
8610 struct rpc_pipe_client *cli,
8611 struct policy_handle *_handle /* [in] [ref] */)
8612 {
8613 struct tevent_req *req;
8614 struct rpccli_spoolss_FindClosePrinterNotify_state *state;
8615 struct tevent_req *subreq;
8616
8617 req = tevent_req_create(mem_ctx, &state,
8618 struct rpccli_spoolss_FindClosePrinterNotify_state);
8619 if (req == NULL) {
8620 return NULL;
8621 }
8622 state->out_mem_ctx = NULL;
8623 state->dispatch_recv = cli->dispatch_recv;
8624
8625 /* In parameters */
8626 state->orig.in.handle = _handle;
8627
8628 /* Out parameters */
8629
8630 /* Result */
8631 ZERO_STRUCT(state->orig.out.result);
8632
8633 /* make a temporary copy, that we pass to the dispatch function */
8634 state->tmp = state->orig;
8635
8636 subreq = cli->dispatch_send(state, ev, cli,
8637 &ndr_table_spoolss,
8638 NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY,
8639 &state->tmp);
8640 if (tevent_req_nomem(subreq, req)) {
8641 return tevent_req_post(req, ev);
8642 }
8643 tevent_req_set_callback(subreq, rpccli_spoolss_FindClosePrinterNotify_done, req);
8644 return req;
8645 }
8646
8647 static void rpccli_spoolss_FindClosePrinterNotify_done(struct tevent_req *subreq)
8648 {
8649 struct tevent_req *req = tevent_req_callback_data(
8650 subreq, struct tevent_req);
8651 struct rpccli_spoolss_FindClosePrinterNotify_state *state = tevent_req_data(
8652 req, struct rpccli_spoolss_FindClosePrinterNotify_state);
8653 NTSTATUS status;
8654 TALLOC_CTX *mem_ctx;
8655
8656 if (state->out_mem_ctx) {
8657 mem_ctx = state->out_mem_ctx;
8658 } else {
8659 mem_ctx = state;
8660 }
8661
8662 status = state->dispatch_recv(subreq, mem_ctx);
8663 TALLOC_FREE(subreq);
8664 if (!NT_STATUS_IS_OK(status)) {
8665 tevent_req_nterror(req, status);
8666 return;
8667 }
8668
8669 /* Copy out parameters */
8670
8671 /* Copy result */
8672 state->orig.out.result = state->tmp.out.result;
8673
8674 /* Reset temporary structure */
8675 ZERO_STRUCT(state->tmp);
8676
8677 tevent_req_done(req);
8678 }
8679
8680 NTSTATUS rpccli_spoolss_FindClosePrinterNotify_recv(struct tevent_req *req,
8681 TALLOC_CTX *mem_ctx,
8682 WERROR *result)
8683 {
8684 struct rpccli_spoolss_FindClosePrinterNotify_state *state = tevent_req_data(
8685 req, struct rpccli_spoolss_FindClosePrinterNotify_state);
8686 NTSTATUS status;
8687
8688 if (tevent_req_is_nterror(req, &status)) {
8689 tevent_req_received(req);
8690 return status;
8691 }
8692
8693 /* Steal possbile out parameters to the callers context */
8694 talloc_steal(mem_ctx, state->out_mem_ctx);
8695
8696 /* Return result */
8697 *result = state->orig.out.result;
8698
8699 tevent_req_received(req);
8700 return NT_STATUS_OK;
8701 }
8702
8703 NTSTATUS rpccli_spoolss_FindClosePrinterNotify(struct rpc_pipe_client *cli,
8704 TALLOC_CTX *mem_ctx,
8705 struct policy_handle *handle /* [in] [ref] */,
8706 WERROR *werror)
8707 {
8708 struct spoolss_FindClosePrinterNotify r;
8709 NTSTATUS status;
8710
8711 /* In parameters */
8712 r.in.handle = handle;
8713
8714 status = cli->dispatch(cli,
8715 mem_ctx,
8716 &ndr_table_spoolss,
8717 NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY,
8718 &r);
8719
8720 if (!NT_STATUS_IS_OK(status)) {
8721 return status;
8722 }
8723
8724 if (NT_STATUS_IS_ERR(status)) {
8725 return status;
8726 }
8727
8728 /* Return variables */
8729
8730 /* Return result */
8731 if (werror) {
8732 *werror = r.out.result;
8733 }
8734
8735 return werror_to_ntstatus(r.out.result);
8736 }
8737
8738 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state {
8739 struct spoolss_RouterFindFirstPrinterChangeNotificationOld orig;
8740 struct spoolss_RouterFindFirstPrinterChangeNotificationOld tmp;
8741 TALLOC_CTX *out_mem_ctx;
8742 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8743 };
8744
8745 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_done(struct tevent_req *subreq);
8746
8747 struct tevent_req *rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_send(TALLOC_CTX *mem_ctx,
8748 struct tevent_context *ev,
8749 struct rpc_pipe_client *cli)
8750 {
8751 struct tevent_req *req;
8752 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state *state;
8753 struct tevent_req *subreq;
8754
8755 req = tevent_req_create(mem_ctx, &state,
8756 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state);
8757 if (req == NULL) {
8758 return NULL;
8759 }
8760 state->out_mem_ctx = NULL;
8761 state->dispatch_recv = cli->dispatch_recv;
8762
8763 /* In parameters */
8764
8765 /* Out parameters */
8766
8767 /* Result */
8768 ZERO_STRUCT(state->orig.out.result);
8769
8770 /* make a temporary copy, that we pass to the dispatch function */
8771 state->tmp = state->orig;
8772
8773 subreq = cli->dispatch_send(state, ev, cli,
8774 &ndr_table_spoolss,
8775 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD,
8776 &state->tmp);
8777 if (tevent_req_nomem(subreq, req)) {
8778 return tevent_req_post(req, ev);
8779 }
8780 tevent_req_set_callback(subreq, rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_done, req);
8781 return req;
8782 }
8783
8784 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_done(struct tevent_req *subreq)
8785 {
8786 struct tevent_req *req = tevent_req_callback_data(
8787 subreq, struct tevent_req);
8788 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state *state = tevent_req_data(
8789 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state);
8790 NTSTATUS status;
8791 TALLOC_CTX *mem_ctx;
8792
8793 if (state->out_mem_ctx) {
8794 mem_ctx = state->out_mem_ctx;
8795 } else {
8796 mem_ctx = state;
8797 }
8798
8799 status = state->dispatch_recv(subreq, mem_ctx);
8800 TALLOC_FREE(subreq);
8801 if (!NT_STATUS_IS_OK(status)) {
8802 tevent_req_nterror(req, status);
8803 return;
8804 }
8805
8806 /* Copy out parameters */
8807
8808 /* Copy result */
8809 state->orig.out.result = state->tmp.out.result;
8810
8811 /* Reset temporary structure */
8812 ZERO_STRUCT(state->tmp);
8813
8814 tevent_req_done(req);
8815 }
8816
8817 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_recv(struct tevent_req *req,
8818 TALLOC_CTX *mem_ctx,
8819 WERROR *result)
8820 {
8821 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state *state = tevent_req_data(
8822 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state);
8823 NTSTATUS status;
8824
8825 if (tevent_req_is_nterror(req, &status)) {
8826 tevent_req_received(req);
8827 return status;
8828 }
8829
8830 /* Steal possbile out parameters to the callers context */
8831 talloc_steal(mem_ctx, state->out_mem_ctx);
8832
8833 /* Return result */
8834 *result = state->orig.out.result;
8835
8836 tevent_req_received(req);
8837 return NT_STATUS_OK;
8838 }
8839
8840 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct rpc_pipe_client *cli,
8841 TALLOC_CTX *mem_ctx,
8842 WERROR *werror)
8843 {
8844 struct spoolss_RouterFindFirstPrinterChangeNotificationOld r;
8845 NTSTATUS status;
8846
8847 /* In parameters */
8848
8849 status = cli->dispatch(cli,
8850 mem_ctx,
8851 &ndr_table_spoolss,
8852 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD,
8853 &r);
8854
8855 if (!NT_STATUS_IS_OK(status)) {
8856 return status;
8857 }
8858
8859 if (NT_STATUS_IS_ERR(status)) {
8860 return status;
8861 }
8862
8863 /* Return variables */
8864
8865 /* Return result */
8866 if (werror) {
8867 *werror = r.out.result;
8868 }
8869
8870 return werror_to_ntstatus(r.out.result);
8871 }
8872
8873 struct rpccli_spoolss_ReplyOpenPrinter_state {
8874 struct spoolss_ReplyOpenPrinter orig;
8875 struct spoolss_ReplyOpenPrinter tmp;
8876 TALLOC_CTX *out_mem_ctx;
8877 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8878 };
8879
8880 static void rpccli_spoolss_ReplyOpenPrinter_done(struct tevent_req *subreq);
8881
8882 struct tevent_req *rpccli_spoolss_ReplyOpenPrinter_send(TALLOC_CTX *mem_ctx,
8883 struct tevent_context *ev,
8884 struct rpc_pipe_client *cli,
8885 const char *_server_name /* [in] [charset(UTF16)] */,
8886 uint32_t _printer_local /* [in] */,
8887 enum winreg_Type _type /* [in] */,
8888 uint32_t _bufsize /* [in] [range(0,512)] */,
8889 uint8_t *_buffer /* [in] [unique,size_is(bufsize)] */,
8890 struct policy_handle *_handle /* [out] [ref] */)
8891 {
8892 struct tevent_req *req;
8893 struct rpccli_spoolss_ReplyOpenPrinter_state *state;
8894 struct tevent_req *subreq;
8895
8896 req = tevent_req_create(mem_ctx, &state,
8897 struct rpccli_spoolss_ReplyOpenPrinter_state);
8898 if (req == NULL) {
8899 return NULL;
8900 }
8901 state->out_mem_ctx = NULL;
8902 state->dispatch_recv = cli->dispatch_recv;
8903
8904 /* In parameters */
8905 state->orig.in.server_name = _server_name;
8906 state->orig.in.printer_local = _printer_local;
8907 state->orig.in.type = _type;
8908 state->orig.in.bufsize = _bufsize;
8909 state->orig.in.buffer = _buffer;
8910
8911 /* Out parameters */
8912 state->orig.out.handle = _handle;
8913
8914 /* Result */
8915 ZERO_STRUCT(state->orig.out.result);
8916
8917 state->out_mem_ctx = talloc_named_const(state, 0,
8918 "rpccli_spoolss_ReplyOpenPrinter_out_memory");
8919 if (tevent_req_nomem(state->out_mem_ctx, req)) {
8920 return tevent_req_post(req, ev);
8921 }
8922
8923 /* make a temporary copy, that we pass to the dispatch function */
8924 state->tmp = state->orig;
8925
8926 subreq = cli->dispatch_send(state, ev, cli,
8927 &ndr_table_spoolss,
8928 NDR_SPOOLSS_REPLYOPENPRINTER,
8929 &state->tmp);
8930 if (tevent_req_nomem(subreq, req)) {
8931 return tevent_req_post(req, ev);
8932 }
8933 tevent_req_set_callback(subreq, rpccli_spoolss_ReplyOpenPrinter_done, req);
8934 return req;
8935 }
8936
8937 static void rpccli_spoolss_ReplyOpenPrinter_done(struct tevent_req *subreq)
8938 {
8939 struct tevent_req *req = tevent_req_callback_data(
8940 subreq, struct tevent_req);
8941 struct rpccli_spoolss_ReplyOpenPrinter_state *state = tevent_req_data(
8942 req, struct rpccli_spoolss_ReplyOpenPrinter_state);
8943 NTSTATUS status;
8944 TALLOC_CTX *mem_ctx;
8945
8946 if (state->out_mem_ctx) {
8947 mem_ctx = state->out_mem_ctx;
8948 } else {
8949 mem_ctx = state;
8950 }
8951
8952 status = state->dispatch_recv(subreq, mem_ctx);
8953 TALLOC_FREE(subreq);
8954 if (!NT_STATUS_IS_OK(status)) {
8955 tevent_req_nterror(req, status);
8956 return;
8957 }
8958
8959 /* Copy out parameters */
8960 *state->orig.out.handle = *state->tmp.out.handle;
8961
8962 /* Copy result */
8963 state->orig.out.result = state->tmp.out.result;
8964
8965 /* Reset temporary structure */
8966 ZERO_STRUCT(state->tmp);
8967
8968 tevent_req_done(req);
8969 }
8970
8971 NTSTATUS rpccli_spoolss_ReplyOpenPrinter_recv(struct tevent_req *req,
8972 TALLOC_CTX *mem_ctx,
8973 WERROR *result)
8974 {
8975 struct rpccli_spoolss_ReplyOpenPrinter_state *state = tevent_req_data(
8976 req, struct rpccli_spoolss_ReplyOpenPrinter_state);
8977 NTSTATUS status;
8978
8979 if (tevent_req_is_nterror(req, &status)) {
8980 tevent_req_received(req);
8981 return status;
8982 }
8983
8984 /* Steal possbile out parameters to the callers context */
8985 talloc_steal(mem_ctx, state->out_mem_ctx);
8986
8987 /* Return result */
8988 *result = state->orig.out.result;
8989
8990 tevent_req_received(req);
8991 return NT_STATUS_OK;
8992 }
8993
8994 NTSTATUS rpccli_spoolss_ReplyOpenPrinter(struct rpc_pipe_client *cli,
8995 TALLOC_CTX *mem_ctx,
8996 const char *server_name /* [in] [charset(UTF16)] */,
8997 uint32_t printer_local /* [in] */,
8998 enum winreg_Type type /* [in] */,
8999 uint32_t bufsize /* [in] [range(0,512)] */,
9000 uint8_t *buffer /* [in] [unique,size_is(bufsize)] */,
9001 struct policy_handle *handle /* [out] [ref] */,
9002 WERROR *werror)
9003 {
9004 struct spoolss_ReplyOpenPrinter r;
9005 NTSTATUS status;
9006
9007 /* In parameters */
9008 r.in.server_name = server_name;
9009 r.in.printer_local = printer_local;
9010 r.in.type = type;
9011 r.in.bufsize = bufsize;
9012 r.in.buffer = buffer;
9013
9014 status = cli->dispatch(cli,
9015 mem_ctx,
9016 &ndr_table_spoolss,
9017 NDR_SPOOLSS_REPLYOPENPRINTER,
9018 &r);
9019
9020 if (!NT_STATUS_IS_OK(status)) {
9021 return status;
9022 }
9023
9024 if (NT_STATUS_IS_ERR(status)) {
9025 return status;
9026 }
9027
9028 /* Return variables */
9029 *handle = *r.out.handle;
9030
9031 /* Return result */
9032 if (werror) {
9033 *werror = r.out.result;
9034 }
9035
9036 return werror_to_ntstatus(r.out.result);
9037 }
9038
9039 struct rpccli_spoolss_RouterReplyPrinter_state {
9040 struct spoolss_RouterReplyPrinter orig;
9041 struct spoolss_RouterReplyPrinter tmp;
9042 TALLOC_CTX *out_mem_ctx;
9043 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9044 };
9045
9046 static void rpccli_spoolss_RouterReplyPrinter_done(struct tevent_req *subreq);
9047
9048 struct tevent_req *rpccli_spoolss_RouterReplyPrinter_send(TALLOC_CTX *mem_ctx,
9049 struct tevent_context *ev,
9050 struct rpc_pipe_client *cli,
9051 struct policy_handle *_handle /* [in] [ref] */,
9052 uint32_t _flags /* [in] */,
9053 uint32_t _bufsize /* [in] [range(0,512)] */,
9054 uint8_t *_buffer /* [in] [unique,size_is(bufsize)] */)
9055 {
9056 struct tevent_req *req;
9057 struct rpccli_spoolss_RouterReplyPrinter_state *state;
9058 struct tevent_req *subreq;
9059
9060 req = tevent_req_create(mem_ctx, &state,
9061 struct rpccli_spoolss_RouterReplyPrinter_state);
9062 if (req == NULL) {
9063 return NULL;
9064 }
9065 state->out_mem_ctx = NULL;
9066 state->dispatch_recv = cli->dispatch_recv;
9067
9068 /* In parameters */
9069 state->orig.in.handle = _handle;
9070 state->orig.in.flags = _flags;
9071 state->orig.in.bufsize = _bufsize;
9072 state->orig.in.buffer = _buffer;
9073
9074 /* Out parameters */
9075
9076 /* Result */
9077 ZERO_STRUCT(state->orig.out.result);
9078
9079 /* make a temporary copy, that we pass to the dispatch function */
9080 state->tmp = state->orig;
9081
9082 subreq = cli->dispatch_send(state, ev, cli,
9083 &ndr_table_spoolss,
9084 NDR_SPOOLSS_ROUTERREPLYPRINTER,
9085 &state->tmp);
9086 if (tevent_req_nomem(subreq, req)) {
9087 return tevent_req_post(req, ev);
9088 }
9089 tevent_req_set_callback(subreq, rpccli_spoolss_RouterReplyPrinter_done, req);
9090 return req;
9091 }
9092
9093 static void rpccli_spoolss_RouterReplyPrinter_done(struct tevent_req *subreq)
9094 {
9095 struct tevent_req *req = tevent_req_callback_data(
9096 subreq, struct tevent_req);
9097 struct rpccli_spoolss_RouterReplyPrinter_state *state = tevent_req_data(
9098 req, struct rpccli_spoolss_RouterReplyPrinter_state);
9099 NTSTATUS status;
9100 TALLOC_CTX *mem_ctx;
9101
9102 if (state->out_mem_ctx) {
9103 mem_ctx = state->out_mem_ctx;
9104 } else {
9105 mem_ctx = state;
9106 }
9107
9108 status = state->dispatch_recv(subreq, mem_ctx);
9109 TALLOC_FREE(subreq);
9110 if (!NT_STATUS_IS_OK(status)) {
9111 tevent_req_nterror(req, status);
9112 return;
9113 }
9114
9115 /* Copy out parameters */
9116
9117 /* Copy result */
9118 state->orig.out.result = state->tmp.out.result;
9119
9120 /* Reset temporary structure */
9121 ZERO_STRUCT(state->tmp);
9122
9123 tevent_req_done(req);
9124 }
9125
9126 NTSTATUS rpccli_spoolss_RouterReplyPrinter_recv(struct tevent_req *req,
9127 TALLOC_CTX *mem_ctx,
9128 WERROR *result)
9129 {
9130 struct rpccli_spoolss_RouterReplyPrinter_state *state = tevent_req_data(
9131 req, struct rpccli_spoolss_RouterReplyPrinter_state);
9132 NTSTATUS status;
9133
9134 if (tevent_req_is_nterror(req, &status)) {
9135 tevent_req_received(req);
9136 return status;
9137 }
9138
9139 /* Steal possbile out parameters to the callers context */
9140 talloc_steal(mem_ctx, state->out_mem_ctx);
9141
9142 /* Return result */
9143 *result = state->orig.out.result;
9144
9145 tevent_req_received(req);
9146 return NT_STATUS_OK;
9147 }
9148
9149 NTSTATUS rpccli_spoolss_RouterReplyPrinter(struct rpc_pipe_client *cli,
9150 TALLOC_CTX *mem_ctx,
9151 struct policy_handle *handle /* [in] [ref] */,
9152 uint32_t flags /* [in] */,
9153 uint32_t bufsize /* [in] [range(0,512)] */,
9154 uint8_t *buffer /* [in] [unique,size_is(bufsize)] */,
9155 WERROR *werror)
9156 {
9157 struct spoolss_RouterReplyPrinter r;
9158 NTSTATUS status;
9159
9160 /* In parameters */
9161 r.in.handle = handle;
9162 r.in.flags = flags;
9163 r.in.bufsize = bufsize;
9164 r.in.buffer = buffer;
9165
9166 status = cli->dispatch(cli,
9167 mem_ctx,
9168 &ndr_table_spoolss,
9169 NDR_SPOOLSS_ROUTERREPLYPRINTER,
9170 &r);
9171
9172 if (!NT_STATUS_IS_OK(status)) {
9173 return status;
9174 }
9175
9176 if (NT_STATUS_IS_ERR(status)) {
9177 return status;
9178 }
9179
9180 /* Return variables */
9181
9182 /* Return result */
9183 if (werror) {
9184 *werror = r.out.result;
9185 }
9186
9187 return werror_to_ntstatus(r.out.result);
9188 }
9189
9190 struct rpccli_spoolss_ReplyClosePrinter_state {
9191 struct spoolss_ReplyClosePrinter orig;
9192 struct spoolss_ReplyClosePrinter tmp;
9193 TALLOC_CTX *out_mem_ctx;
9194 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9195 };
9196
9197 static void rpccli_spoolss_ReplyClosePrinter_done(struct tevent_req *subreq);
9198
9199 struct tevent_req *rpccli_spoolss_ReplyClosePrinter_send(TALLOC_CTX *mem_ctx,
9200 struct tevent_context *ev,
9201 struct rpc_pipe_client *cli,
9202 struct policy_handle *_handle /* [in,out] [ref] */)
9203 {
9204 struct tevent_req *req;
9205 struct rpccli_spoolss_ReplyClosePrinter_state *state;
9206 struct tevent_req *subreq;
9207
9208 req = tevent_req_create(mem_ctx, &state,
9209 struct rpccli_spoolss_ReplyClosePrinter_state);
9210 if (req == NULL) {
9211 return NULL;
9212 }
9213 state->out_mem_ctx = NULL;
9214 state->dispatch_recv = cli->dispatch_recv;
9215
9216 /* In parameters */
9217 state->orig.in.handle = _handle;
9218
9219 /* Out parameters */
9220 state->orig.out.handle = _handle;
9221
9222 /* Result */
9223 ZERO_STRUCT(state->orig.out.result);
9224
9225 state->out_mem_ctx = talloc_named_const(state, 0,
9226 "rpccli_spoolss_ReplyClosePrinter_out_memory");
9227 if (tevent_req_nomem(state->out_mem_ctx, req)) {
9228 return tevent_req_post(req, ev);
9229 }
9230
9231 /* make a temporary copy, that we pass to the dispatch function */
9232 state->tmp = state->orig;
9233
9234 subreq = cli->dispatch_send(state, ev, cli,
9235 &ndr_table_spoolss,
9236 NDR_SPOOLSS_REPLYCLOSEPRINTER,
9237 &state->tmp);
9238 if (tevent_req_nomem(subreq, req)) {
9239 return tevent_req_post(req, ev);
9240 }
9241 tevent_req_set_callback(subreq, rpccli_spoolss_ReplyClosePrinter_done, req);
9242 return req;
9243 }
9244
9245 static void rpccli_spoolss_ReplyClosePrinter_done(struct tevent_req *subreq)
9246 {
9247 struct tevent_req *req = tevent_req_callback_data(
9248 subreq, struct tevent_req);
9249 struct rpccli_spoolss_ReplyClosePrinter_state *state = tevent_req_data(
9250 req, struct rpccli_spoolss_ReplyClosePrinter_state);
9251 NTSTATUS status;
9252 TALLOC_CTX *mem_ctx;
9253
9254 if (state->out_mem_ctx) {
9255 mem_ctx = state->out_mem_ctx;
9256 } else {
9257 mem_ctx = state;
9258 }
9259
9260 status = state->dispatch_recv(subreq, mem_ctx);
9261 TALLOC_FREE(subreq);
9262 if (!NT_STATUS_IS_OK(status)) {
9263 tevent_req_nterror(req, status);
9264 return;
9265 }
9266
9267 /* Copy out parameters */
9268 *state->orig.out.handle = *state->tmp.out.handle;
9269
9270 /* Copy result */
9271 state->orig.out.result = state->tmp.out.result;
9272
9273 /* Reset temporary structure */
9274 ZERO_STRUCT(state->tmp);
9275
9276 tevent_req_done(req);
9277 }
9278
9279 NTSTATUS rpccli_spoolss_ReplyClosePrinter_recv(struct tevent_req *req,
9280 TALLOC_CTX *mem_ctx,
9281 WERROR *result)
9282 {
9283 struct rpccli_spoolss_ReplyClosePrinter_state *state = tevent_req_data(
9284 req, struct rpccli_spoolss_ReplyClosePrinter_state);
9285 NTSTATUS status;
9286
9287 if (tevent_req_is_nterror(req, &status)) {
9288 tevent_req_received(req);
9289 return status;
9290 }
9291
9292 /* Steal possbile out parameters to the callers context */
9293 talloc_steal(mem_ctx, state->out_mem_ctx);
9294
9295 /* Return result */
9296 *result = state->orig.out.result;
9297
9298 tevent_req_received(req);
9299 return NT_STATUS_OK;
9300 }
9301
9302 NTSTATUS rpccli_spoolss_ReplyClosePrinter(struct rpc_pipe_client *cli,
9303 TALLOC_CTX *mem_ctx,
9304 struct policy_handle *handle /* [in,out] [ref] */,
9305 WERROR *werror)
9306 {
9307 struct spoolss_ReplyClosePrinter r;
9308 NTSTATUS status;
9309
9310 /* In parameters */
9311 r.in.handle = handle;
9312
9313 status = cli->dispatch(cli,
9314 mem_ctx,
9315 &ndr_table_spoolss,
9316 NDR_SPOOLSS_REPLYCLOSEPRINTER,
9317 &r);
9318
9319 if (!NT_STATUS_IS_OK(status)) {
9320 return status;
9321 }
9322
9323 if (NT_STATUS_IS_ERR(status)) {
9324 return status;
9325 }
9326
9327 /* Return variables */
9328 *handle = *r.out.handle;
9329
9330 /* Return result */
9331 if (werror) {
9332 *werror = r.out.result;
9333 }
9334
9335 return werror_to_ntstatus(r.out.result);
9336 }
9337
9338 struct rpccli_spoolss_AddPortEx_state {
9339 struct spoolss_AddPortEx orig;
9340 struct spoolss_AddPortEx tmp;
9341 TALLOC_CTX *out_mem_ctx;
9342 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9343 };
9344
9345 static void rpccli_spoolss_AddPortEx_done(struct tevent_req *subreq);
9346
9347 struct tevent_req *rpccli_spoolss_AddPortEx_send(TALLOC_CTX *mem_ctx,
9348 struct tevent_context *ev,
9349 struct rpc_pipe_client *cli)
9350 {
9351 struct tevent_req *req;
9352 struct rpccli_spoolss_AddPortEx_state *state;
9353 struct tevent_req *subreq;
9354
9355 req = tevent_req_create(mem_ctx, &state,
9356 struct rpccli_spoolss_AddPortEx_state);
9357 if (req == NULL) {
9358 return NULL;
9359 }
9360 state->out_mem_ctx = NULL;
9361 state->dispatch_recv = cli->dispatch_recv;
9362
9363 /* In parameters */
9364
9365 /* Out parameters */
9366
9367 /* Result */
9368 ZERO_STRUCT(state->orig.out.result);
9369
9370 /* make a temporary copy, that we pass to the dispatch function */
9371 state->tmp = state->orig;
9372
9373 subreq = cli->dispatch_send(state, ev, cli,
9374 &ndr_table_spoolss,
9375 NDR_SPOOLSS_ADDPORTEX,
9376 &state->tmp);
9377 if (tevent_req_nomem(subreq, req)) {
9378 return tevent_req_post(req, ev);
9379 }
9380 tevent_req_set_callback(subreq, rpccli_spoolss_AddPortEx_done, req);
9381 return req;
9382 }
9383
9384 static void rpccli_spoolss_AddPortEx_done(struct tevent_req *subreq)
9385 {
9386 struct tevent_req *req = tevent_req_callback_data(
9387 subreq, struct tevent_req);
9388 struct rpccli_spoolss_AddPortEx_state *state = tevent_req_data(
9389 req, struct rpccli_spoolss_AddPortEx_state);
9390 NTSTATUS status;
9391 TALLOC_CTX *mem_ctx;
9392
9393 if (state->out_mem_ctx) {
9394 mem_ctx = state->out_mem_ctx;
9395 } else {
9396 mem_ctx = state;
9397 }
9398
9399 status = state->dispatch_recv(subreq, mem_ctx);
9400 TALLOC_FREE(subreq);
9401 if (!NT_STATUS_IS_OK(status)) {
9402 tevent_req_nterror(req, status);
9403 return;
9404 }
9405
9406 /* Copy out parameters */
9407
9408 /* Copy result */
9409 state->orig.out.result = state->tmp.out.result;
9410
9411 /* Reset temporary structure */
9412 ZERO_STRUCT(state->tmp);
9413
9414 tevent_req_done(req);
9415 }
9416
9417 NTSTATUS rpccli_spoolss_AddPortEx_recv(struct tevent_req *req,
9418 TALLOC_CTX *mem_ctx,
9419 WERROR *result)
9420 {
9421 struct rpccli_spoolss_AddPortEx_state *state = tevent_req_data(
9422 req, struct rpccli_spoolss_AddPortEx_state);
9423 NTSTATUS status;
9424
9425 if (tevent_req_is_nterror(req, &status)) {
9426 tevent_req_received(req);
9427 return status;
9428 }
9429
9430 /* Steal possbile out parameters to the callers context */
9431 talloc_steal(mem_ctx, state->out_mem_ctx);
9432
9433 /* Return result */
9434 *result = state->orig.out.result;
9435
9436 tevent_req_received(req);
9437 return NT_STATUS_OK;
9438 }
9439
9440 NTSTATUS rpccli_spoolss_AddPortEx(struct rpc_pipe_client *cli,
9441 TALLOC_CTX *mem_ctx,
9442 WERROR *werror)
9443 {
9444 struct spoolss_AddPortEx r;
9445 NTSTATUS status;
9446
9447 /* In parameters */
9448
9449 status = cli->dispatch(cli,
9450 mem_ctx,
9451 &ndr_table_spoolss,
9452 NDR_SPOOLSS_ADDPORTEX,
9453 &r);
9454
9455 if (!NT_STATUS_IS_OK(status)) {
9456 return status;
9457 }
9458
9459 if (NT_STATUS_IS_ERR(status)) {
9460 return status;
9461 }
9462
9463 /* Return variables */
9464
9465 /* Return result */
9466 if (werror) {
9467 *werror = r.out.result;
9468 }
9469
9470 return werror_to_ntstatus(r.out.result);
9471 }
9472
9473 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state {
9474 struct spoolss_RouterFindFirstPrinterChangeNotification orig;
9475 struct spoolss_RouterFindFirstPrinterChangeNotification tmp;
9476 TALLOC_CTX *out_mem_ctx;
9477 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9478 };
9479
9480 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotification_done(struct tevent_req *subreq);
9481
9482 struct tevent_req *rpccli_spoolss_RouterFindFirstPrinterChangeNotification_send(TALLOC_CTX *mem_ctx,
9483 struct tevent_context *ev,
9484 struct rpc_pipe_client *cli)
9485 {
9486 struct tevent_req *req;
9487 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state *state;
9488 struct tevent_req *subreq;
9489
9490 req = tevent_req_create(mem_ctx, &state,
9491 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state);
9492 if (req == NULL) {
9493 return NULL;
9494 }
9495 state->out_mem_ctx = NULL;
9496 state->dispatch_recv = cli->dispatch_recv;
9497
9498 /* In parameters */
9499
9500 /* Out parameters */
9501
9502 /* Result */
9503 ZERO_STRUCT(state->orig.out.result);
9504
9505 /* make a temporary copy, that we pass to the dispatch function */
9506 state->tmp = state->orig;
9507
9508 subreq = cli->dispatch_send(state, ev, cli,
9509 &ndr_table_spoolss,
9510 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION,
9511 &state->tmp);
9512 if (tevent_req_nomem(subreq, req)) {
9513 return tevent_req_post(req, ev);
9514 }
9515 tevent_req_set_callback(subreq, rpccli_spoolss_RouterFindFirstPrinterChangeNotification_done, req);
9516 return req;
9517 }
9518
9519 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotification_done(struct tevent_req *subreq)
9520 {
9521 struct tevent_req *req = tevent_req_callback_data(
9522 subreq, struct tevent_req);
9523 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state *state = tevent_req_data(
9524 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state);
9525 NTSTATUS status;
9526 TALLOC_CTX *mem_ctx;
9527
9528 if (state->out_mem_ctx) {
9529 mem_ctx = state->out_mem_ctx;
9530 } else {
9531 mem_ctx = state;
9532 }
9533
9534 status = state->dispatch_recv(subreq, mem_ctx);
9535 TALLOC_FREE(subreq);
9536 if (!NT_STATUS_IS_OK(status)) {
9537 tevent_req_nterror(req, status);
9538 return;
9539 }
9540
9541 /* Copy out parameters */
9542
9543 /* Copy result */
9544 state->orig.out.result = state->tmp.out.result;
9545
9546 /* Reset temporary structure */
9547 ZERO_STRUCT(state->tmp);
9548
9549 tevent_req_done(req);
9550 }
9551
9552 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotification_recv(struct tevent_req *req,
9553 TALLOC_CTX *mem_ctx,
9554 WERROR *result)
9555 {
9556 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state *state = tevent_req_data(
9557 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state);
9558 NTSTATUS status;
9559
9560 if (tevent_req_is_nterror(req, &status)) {
9561 tevent_req_received(req);
9562 return status;
9563 }
9564
9565 /* Steal possbile out parameters to the callers context */
9566 talloc_steal(mem_ctx, state->out_mem_ctx);
9567
9568 /* Return result */
9569 *result = state->orig.out.result;
9570
9571 tevent_req_received(req);
9572 return NT_STATUS_OK;
9573 }
9574
9575 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotification(struct rpc_pipe_client *cli,
9576 TALLOC_CTX *mem_ctx,
9577 WERROR *werror)
9578 {
9579 struct spoolss_RouterFindFirstPrinterChangeNotification r;
9580 NTSTATUS status;
9581
9582 /* In parameters */
9583
9584 status = cli->dispatch(cli,
9585 mem_ctx,
9586 &ndr_table_spoolss,
9587 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION,
9588 &r);
9589
9590 if (!NT_STATUS_IS_OK(status)) {
9591 return status;
9592 }
9593
9594 if (NT_STATUS_IS_ERR(status)) {
9595 return status;
9596 }
9597
9598 /* Return variables */
9599
9600 /* Return result */
9601 if (werror) {
9602 *werror = r.out.result;
9603 }
9604
9605 return werror_to_ntstatus(r.out.result);
9606 }
9607
9608 struct rpccli_spoolss_SpoolerInit_state {
9609 struct spoolss_SpoolerInit orig;
9610 struct spoolss_SpoolerInit tmp;
9611 TALLOC_CTX *out_mem_ctx;
9612 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9613 };
9614
9615 static void rpccli_spoolss_SpoolerInit_done(struct tevent_req *subreq);
9616
9617 struct tevent_req *rpccli_spoolss_SpoolerInit_send(TALLOC_CTX *mem_ctx,
9618 struct tevent_context *ev,
9619 struct rpc_pipe_client *cli)
9620 {
9621 struct tevent_req *req;
9622 struct rpccli_spoolss_SpoolerInit_state *state;
9623 struct tevent_req *subreq;
9624
9625 req = tevent_req_create(mem_ctx, &state,
9626 struct rpccli_spoolss_SpoolerInit_state);
9627 if (req == NULL) {
9628 return NULL;
9629 }
9630 state->out_mem_ctx = NULL;
9631 state->dispatch_recv = cli->dispatch_recv;
9632
9633 /* In parameters */
9634
9635 /* Out parameters */
9636
9637 /* Result */
9638 ZERO_STRUCT(state->orig.out.result);
9639
9640 /* make a temporary copy, that we pass to the dispatch function */
9641 state->tmp = state->orig;
9642
9643 subreq = cli->dispatch_send(state, ev, cli,
9644 &ndr_table_spoolss,
9645 NDR_SPOOLSS_SPOOLERINIT,
9646 &state->tmp);
9647 if (tevent_req_nomem(subreq, req)) {
9648 return tevent_req_post(req, ev);
9649 }
9650 tevent_req_set_callback(subreq, rpccli_spoolss_SpoolerInit_done, req);
9651 return req;
9652 }
9653
9654 static void rpccli_spoolss_SpoolerInit_done(struct tevent_req *subreq)
9655 {
9656 struct tevent_req *req = tevent_req_callback_data(
9657 subreq, struct tevent_req);
9658 struct rpccli_spoolss_SpoolerInit_state *state = tevent_req_data(
9659 req, struct rpccli_spoolss_SpoolerInit_state);
9660 NTSTATUS status;
9661 TALLOC_CTX *mem_ctx;
9662
9663 if (state->out_mem_ctx) {
9664 mem_ctx = state->out_mem_ctx;
9665 } else {
9666 mem_ctx = state;
9667 }
9668
9669 status = state->dispatch_recv(subreq, mem_ctx);
9670 TALLOC_FREE(subreq);
9671 if (!NT_STATUS_IS_OK(status)) {
9672 tevent_req_nterror(req, status);
9673 return;
9674 }
9675
9676 /* Copy out parameters */
9677
9678 /* Copy result */
9679 state->orig.out.result = state->tmp.out.result;
9680
9681 /* Reset temporary structure */
9682 ZERO_STRUCT(state->tmp);
9683
9684 tevent_req_done(req);
9685 }
9686
9687 NTSTATUS rpccli_spoolss_SpoolerInit_recv(struct tevent_req *req,
9688 TALLOC_CTX *mem_ctx,
9689 WERROR *result)
9690 {
9691 struct rpccli_spoolss_SpoolerInit_state *state = tevent_req_data(
9692 req, struct rpccli_spoolss_SpoolerInit_state);
9693 NTSTATUS status;
9694
9695 if (tevent_req_is_nterror(req, &status)) {
9696 tevent_req_received(req);
9697 return status;
9698 }
9699
9700 /* Steal possbile out parameters to the callers context */
9701 talloc_steal(mem_ctx, state->out_mem_ctx);
9702
9703 /* Return result */
9704 *result = state->orig.out.result;
9705
9706 tevent_req_received(req);
9707 return NT_STATUS_OK;
9708 }
9709
9710 NTSTATUS rpccli_spoolss_SpoolerInit(struct rpc_pipe_client *cli,
9711 TALLOC_CTX *mem_ctx,
9712 WERROR *werror)
9713 {
9714 struct spoolss_SpoolerInit r;
9715 NTSTATUS status;
9716
9717 /* In parameters */
9718
9719 status = cli->dispatch(cli,
9720 mem_ctx,
9721 &ndr_table_spoolss,
9722 NDR_SPOOLSS_SPOOLERINIT,
9723 &r);
9724
9725 if (!NT_STATUS_IS_OK(status)) {
9726 return status;
9727 }
9728
9729 if (NT_STATUS_IS_ERR(status)) {
9730 return status;
9731 }
9732
9733 /* Return variables */
9734
9735 /* Return result */
9736 if (werror) {
9737 *werror = r.out.result;
9738 }
9739
9740 return werror_to_ntstatus(r.out.result);
9741 }
9742
9743 struct rpccli_spoolss_ResetPrinterEx_state {
9744 struct spoolss_ResetPrinterEx orig;
9745 struct spoolss_ResetPrinterEx tmp;
9746 TALLOC_CTX *out_mem_ctx;
9747 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9748 };
9749
9750 static void rpccli_spoolss_ResetPrinterEx_done(struct tevent_req *subreq);
9751
9752 struct tevent_req *rpccli_spoolss_ResetPrinterEx_send(TALLOC_CTX *mem_ctx,
9753 struct tevent_context *ev,
9754 struct rpc_pipe_client *cli)
9755 {
9756 struct tevent_req *req;
9757 struct rpccli_spoolss_ResetPrinterEx_state *state;
9758 struct tevent_req *subreq;
9759
9760 req = tevent_req_create(mem_ctx, &state,
9761 struct rpccli_spoolss_ResetPrinterEx_state);
9762 if (req == NULL) {
9763 return NULL;
9764 }
9765 state->out_mem_ctx = NULL;
9766 state->dispatch_recv = cli->dispatch_recv;
9767
9768 /* In parameters */
9769
9770 /* Out parameters */
9771
9772 /* Result */
9773 ZERO_STRUCT(state->orig.out.result);
9774
9775 /* make a temporary copy, that we pass to the dispatch function */
9776 state->tmp = state->orig;
9777
9778 subreq = cli->dispatch_send(state, ev, cli,
9779 &ndr_table_spoolss,
9780 NDR_SPOOLSS_RESETPRINTEREX,
9781 &state->tmp);
9782 if (tevent_req_nomem(subreq, req)) {
9783 return tevent_req_post(req, ev);
9784 }
9785 tevent_req_set_callback(subreq, rpccli_spoolss_ResetPrinterEx_done, req);
9786 return req;
9787 }
9788
9789 static void rpccli_spoolss_ResetPrinterEx_done(struct tevent_req *subreq)
9790 {
9791 struct tevent_req *req = tevent_req_callback_data(
9792 subreq, struct tevent_req);
9793 struct rpccli_spoolss_ResetPrinterEx_state *state = tevent_req_data(
9794 req, struct rpccli_spoolss_ResetPrinterEx_state);
9795 NTSTATUS status;
9796 TALLOC_CTX *mem_ctx;
9797
9798 if (state->out_mem_ctx) {
9799 mem_ctx = state->out_mem_ctx;
9800 } else {
9801 mem_ctx = state;
9802 }
9803
9804 status = state->dispatch_recv(subreq, mem_ctx);
9805 TALLOC_FREE(subreq);
9806 if (!NT_STATUS_IS_OK(status)) {
9807 tevent_req_nterror(req, status);
9808 return;
9809 }
9810
9811 /* Copy out parameters */
9812
9813 /* Copy result */
9814 state->orig.out.result = state->tmp.out.result;
9815
9816 /* Reset temporary structure */
9817 ZERO_STRUCT(state->tmp);
9818
9819 tevent_req_done(req);
9820 }
9821
9822 NTSTATUS rpccli_spoolss_ResetPrinterEx_recv(struct tevent_req *req,
9823 TALLOC_CTX *mem_ctx,
9824 WERROR *result)
9825 {
9826 struct rpccli_spoolss_ResetPrinterEx_state *state = tevent_req_data(
9827 req, struct rpccli_spoolss_ResetPrinterEx_state);
9828 NTSTATUS status;
9829
9830 if (tevent_req_is_nterror(req, &status)) {
9831 tevent_req_received(req);
9832 return status;
9833 }
9834
9835 /* Steal possbile out parameters to the callers context */
9836 talloc_steal(mem_ctx, state->out_mem_ctx);
9837
9838 /* Return result */
9839 *result = state->orig.out.result;
9840
9841 tevent_req_received(req);
9842 return NT_STATUS_OK;
9843 }
9844
9845 NTSTATUS rpccli_spoolss_ResetPrinterEx(struct rpc_pipe_client *cli,
9846 TALLOC_CTX *mem_ctx,
9847 WERROR *werror)
9848 {
9849 struct spoolss_ResetPrinterEx r;
9850 NTSTATUS status;
9851
9852 /* In parameters */
9853
9854 status = cli->dispatch(cli,
9855 mem_ctx,
9856 &ndr_table_spoolss,
9857 NDR_SPOOLSS_RESETPRINTEREX,
9858 &r);
9859
9860 if (!NT_STATUS_IS_OK(status)) {
9861 return status;
9862 }
9863
9864 if (NT_STATUS_IS_ERR(status)) {
9865 return status;
9866 }
9867
9868 /* Return variables */
9869
9870 /* Return result */
9871 if (werror) {
9872 *werror = r.out.result;
9873 }
9874
9875 return werror_to_ntstatus(r.out.result);
9876 }
9877
9878 struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state {
9879 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx orig;
9880 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx tmp;
9881 TALLOC_CTX *out_mem_ctx;
9882 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9883 };
9884
9885 static void rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_done(struct tevent_req *subreq);
9886
9887 struct tevent_req *rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_send(TALLOC_CTX *mem_ctx,
9888 struct tevent_context *ev,
9889 struct rpc_pipe_client *cli,
9890 struct policy_handle *_handle /* [in] [ref] */,
9891 uint32_t _flags /* [in] */,
9892 uint32_t _options /* [in] */,
9893 const char *_local_machine /* [in] [unique,charset(UTF16)] */,
9894 uint32_t _printer_local /* [in] */,
9895 struct spoolss_NotifyOption *_notify_options /* [in] [unique] */)
9896 {
9897 struct tevent_req *req;
9898 struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state *state;
9899 struct tevent_req *subreq;
9900
9901 req = tevent_req_create(mem_ctx, &state,
9902 struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state);
9903 if (req == NULL) {
9904 return NULL;
9905 }
9906 state->out_mem_ctx = NULL;
9907 state->dispatch_recv = cli->dispatch_recv;
9908
9909 /* In parameters */
9910 state->orig.in.handle = _handle;
9911 state->orig.in.flags = _flags;
9912 state->orig.in.options = _options;
9913 state->orig.in.local_machine = _local_machine;
9914 state->orig.in.printer_local = _printer_local;
9915 state->orig.in.notify_options = _notify_options;
9916
9917 /* Out parameters */
9918
9919 /* Result */
9920 ZERO_STRUCT(state->orig.out.result);
9921
9922 /* make a temporary copy, that we pass to the dispatch function */
9923 state->tmp = state->orig;
9924
9925 subreq = cli->dispatch_send(state, ev, cli,
9926 &ndr_table_spoolss,
9927 NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX,
9928 &state->tmp);
9929 if (tevent_req_nomem(subreq, req)) {
9930 return tevent_req_post(req, ev);
9931 }
9932 tevent_req_set_callback(subreq, rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_done, req);
9933 return req;
9934 }
9935
9936 static void rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_done(struct tevent_req *subreq)
9937 {
9938 struct tevent_req *req = tevent_req_callback_data(
9939 subreq, struct tevent_req);
9940 struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state *state = tevent_req_data(
9941 req, struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state);
9942 NTSTATUS status;
9943 TALLOC_CTX *mem_ctx;
9944
9945 if (state->out_mem_ctx) {
9946 mem_ctx = state->out_mem_ctx;
9947 } else {
9948 mem_ctx = state;
9949 }
9950
9951 status = state->dispatch_recv(subreq, mem_ctx);
9952 TALLOC_FREE(subreq);
9953 if (!NT_STATUS_IS_OK(status)) {
9954 tevent_req_nterror(req, status);
9955 return;
9956 }
9957
9958 /* Copy out parameters */
9959
9960 /* Copy result */
9961 state->orig.out.result = state->tmp.out.result;
9962
9963 /* Reset temporary structure */
9964 ZERO_STRUCT(state->tmp);
9965
9966 tevent_req_done(req);
9967 }
9968
9969 NTSTATUS rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_recv(struct tevent_req *req,
9970 TALLOC_CTX *mem_ctx,
9971 WERROR *result)
9972 {
9973 struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state *state = tevent_req_data(
9974 req, struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state);
9975 NTSTATUS status;
9976
9977 if (tevent_req_is_nterror(req, &status)) {
9978 tevent_req_received(req);
9979 return status;
9980 }
9981
9982 /* Steal possbile out parameters to the callers context */
9983 talloc_steal(mem_ctx, state->out_mem_ctx);
9984
9985 /* Return result */
9986 *result = state->orig.out.result;
9987
9988 tevent_req_received(req);
9989 return NT_STATUS_OK;
9990 }
9991
9992 NTSTATUS rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct rpc_pipe_client *cli,
9993 TALLOC_CTX *mem_ctx,
9994 struct policy_handle *handle /* [in] [ref] */,
9995 uint32_t flags /* [in] */,
9996 uint32_t options /* [in] */,
9997 const char *local_machine /* [in] [unique,charset(UTF16)] */,
9998 uint32_t printer_local /* [in] */,
9999 struct spoolss_NotifyOption *notify_options /* [in] [unique] */,
10000 WERROR *werror)
10001 {
10002 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx r;
10003 NTSTATUS status;
10004
10005 /* In parameters */
10006 r.in.handle = handle;
10007 r.in.flags = flags;
10008 r.in.options = options;
10009 r.in.local_machine = local_machine;
10010 r.in.printer_local = printer_local;
10011 r.in.notify_options = notify_options;
10012
10013 status = cli->dispatch(cli,
10014 mem_ctx,
10015 &ndr_table_spoolss,
10016 NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX,
10017 &r);
10018
10019 if (!NT_STATUS_IS_OK(status)) {
10020 return status;
10021 }
10022
10023 if (NT_STATUS_IS_ERR(status)) {
10024 return status;
10025 }
10026
10027 /* Return variables */
10028
10029 /* Return result */
10030 if (werror) {
10031 *werror = r.out.result;
10032 }
10033
10034 return werror_to_ntstatus(r.out.result);
10035 }
10036
10037 struct rpccli_spoolss_RouterReplyPrinterEx_state {
10038 struct spoolss_RouterReplyPrinterEx orig;
10039 struct spoolss_RouterReplyPrinterEx tmp;
10040 TALLOC_CTX *out_mem_ctx;
10041 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10042 };
10043
10044 static void rpccli_spoolss_RouterReplyPrinterEx_done(struct tevent_req *subreq);
10045
10046 struct tevent_req *rpccli_spoolss_RouterReplyPrinterEx_send(TALLOC_CTX *mem_ctx,
10047 struct tevent_context *ev,
10048 struct rpc_pipe_client *cli,
10049 struct policy_handle *_handle /* [in] [ref] */,
10050 uint32_t _color /* [in] */,
10051 uint32_t _flags /* [in] */,
10052 uint32_t *_reply_result /* [out] [ref] */,
10053 uint32_t _reply_type /* [in] */,
10054 union spoolss_ReplyPrinterInfo _info /* [in] [switch_is(reply_type)] */)
10055 {
10056 struct tevent_req *req;
10057 struct rpccli_spoolss_RouterReplyPrinterEx_state *state;
10058 struct tevent_req *subreq;
10059
10060 req = tevent_req_create(mem_ctx, &state,
10061 struct rpccli_spoolss_RouterReplyPrinterEx_state);
10062 if (req == NULL) {
10063 return NULL;
10064 }
10065 state->out_mem_ctx = NULL;
10066 state->dispatch_recv = cli->dispatch_recv;
10067
10068 /* In parameters */
10069 state->orig.in.handle = _handle;
10070 state->orig.in.color = _color;
10071 state->orig.in.flags = _flags;
10072 state->orig.in.reply_type = _reply_type;
10073 state->orig.in.info = _info;
10074
10075 /* Out parameters */
10076 state->orig.out.reply_result = _reply_result;
10077
10078 /* Result */
10079 ZERO_STRUCT(state->orig.out.result);
10080
10081 state->out_mem_ctx = talloc_named_const(state, 0,
10082 "rpccli_spoolss_RouterReplyPrinterEx_out_memory");
10083 if (tevent_req_nomem(state->out_mem_ctx, req)) {
10084 return tevent_req_post(req, ev);
10085 }
10086
10087 /* make a temporary copy, that we pass to the dispatch function */
10088 state->tmp = state->orig;
10089
10090 subreq = cli->dispatch_send(state, ev, cli,
10091 &ndr_table_spoolss,
10092 NDR_SPOOLSS_ROUTERREPLYPRINTEREX,
10093 &state->tmp);
10094 if (tevent_req_nomem(subreq, req)) {
10095 return tevent_req_post(req, ev);
10096 }
10097 tevent_req_set_callback(subreq, rpccli_spoolss_RouterReplyPrinterEx_done, req);
10098 return req;
10099 }
10100
10101 static void rpccli_spoolss_RouterReplyPrinterEx_done(struct tevent_req *subreq)
10102 {
10103 struct tevent_req *req = tevent_req_callback_data(
10104 subreq, struct tevent_req);
10105 struct rpccli_spoolss_RouterReplyPrinterEx_state *state = tevent_req_data(
10106 req, struct rpccli_spoolss_RouterReplyPrinterEx_state);
10107 NTSTATUS status;
10108 TALLOC_CTX *mem_ctx;
10109
10110 if (state->out_mem_ctx) {
10111 mem_ctx = state->out_mem_ctx;
10112 } else {
10113 mem_ctx = state;
10114 }
10115
10116 status = state->dispatch_recv(subreq, mem_ctx);
10117 TALLOC_FREE(subreq);
10118 if (!NT_STATUS_IS_OK(status)) {
10119 tevent_req_nterror(req, status);
10120 return;
10121 }
10122
10123 /* Copy out parameters */
10124 *state->orig.out.reply_result = *state->tmp.out.reply_result;
10125
10126 /* Copy result */
10127 state->orig.out.result = state->tmp.out.result;
10128
10129 /* Reset temporary structure */
10130 ZERO_STRUCT(state->tmp);
10131
10132 tevent_req_done(req);
10133 }
10134
10135 NTSTATUS rpccli_spoolss_RouterReplyPrinterEx_recv(struct tevent_req *req,
10136 TALLOC_CTX *mem_ctx,
10137 WERROR *result)
10138 {
10139 struct rpccli_spoolss_RouterReplyPrinterEx_state *state = tevent_req_data(
10140 req, struct rpccli_spoolss_RouterReplyPrinterEx_state);
10141 NTSTATUS status;
10142
10143 if (tevent_req_is_nterror(req, &status)) {
10144 tevent_req_received(req);
10145 return status;
10146 }
10147
10148 /* Steal possbile out parameters to the callers context */
10149 talloc_steal(mem_ctx, state->out_mem_ctx);
10150
10151 /* Return result */
10152 *result = state->orig.out.result;
10153
10154 tevent_req_received(req);
10155 return NT_STATUS_OK;
10156 }
10157
10158 NTSTATUS rpccli_spoolss_RouterReplyPrinterEx(struct rpc_pipe_client *cli,
10159 TALLOC_CTX *mem_ctx,
10160 struct policy_handle *handle /* [in] [ref] */,
10161 uint32_t color /* [in] */,
10162 uint32_t flags /* [in] */,
10163 uint32_t *reply_result /* [out] [ref] */,
10164 uint32_t reply_type /* [in] */,
10165 union spoolss_ReplyPrinterInfo info /* [in] [switch_is(reply_type)] */,
10166 WERROR *werror)
10167 {
10168 struct spoolss_RouterReplyPrinterEx r;
10169 NTSTATUS status;
10170
10171 /* In parameters */
10172 r.in.handle = handle;
10173 r.in.color = color;
10174 r.in.flags = flags;
10175 r.in.reply_type = reply_type;
10176 r.in.info = info;
10177
10178 status = cli->dispatch(cli,
10179 mem_ctx,
10180 &ndr_table_spoolss,
10181 NDR_SPOOLSS_ROUTERREPLYPRINTEREX,
10182 &r);
10183
10184 if (!NT_STATUS_IS_OK(status)) {
10185 return status;
10186 }
10187
10188 if (NT_STATUS_IS_ERR(status)) {
10189 return status;
10190 }
10191
10192 /* Return variables */
10193 *reply_result = *r.out.reply_result;
10194
10195 /* Return result */
10196 if (werror) {
10197 *werror = r.out.result;
10198 }
10199
10200 return werror_to_ntstatus(r.out.result);
10201 }
10202
10203 struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state {
10204 struct spoolss_RouterRefreshPrinterChangeNotify orig;
10205 struct spoolss_RouterRefreshPrinterChangeNotify tmp;
10206 TALLOC_CTX *out_mem_ctx;
10207 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10208 };
10209
10210 static void rpccli_spoolss_RouterRefreshPrinterChangeNotify_done(struct tevent_req *subreq);
10211
10212 struct tevent_req *rpccli_spoolss_RouterRefreshPrinterChangeNotify_send(TALLOC_CTX *mem_ctx,
10213 struct tevent_context *ev,
10214 struct rpc_pipe_client *cli,
10215 struct policy_handle *_handle /* [in] [ref] */,
10216 uint32_t _change_low /* [in] */,
10217 struct spoolss_NotifyOption *_options /* [in] [unique] */,
10218 struct spoolss_NotifyInfo **_info /* [out] [ref] */)
10219 {
10220 struct tevent_req *req;
10221 struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state *state;
10222 struct tevent_req *subreq;
10223
10224 req = tevent_req_create(mem_ctx, &state,
10225 struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state);
10226 if (req == NULL) {
10227 return NULL;
10228 }
10229 state->out_mem_ctx = NULL;
10230 state->dispatch_recv = cli->dispatch_recv;
10231
10232 /* In parameters */
10233 state->orig.in.handle = _handle;
10234 state->orig.in.change_low = _change_low;
10235 state->orig.in.options = _options;
10236
10237 /* Out parameters */
10238 state->orig.out.info = _info;
10239
10240 /* Result */
10241 ZERO_STRUCT(state->orig.out.result);
10242
10243 state->out_mem_ctx = talloc_named_const(state, 0,
10244 "rpccli_spoolss_RouterRefreshPrinterChangeNotify_out_memory");
10245 if (tevent_req_nomem(state->out_mem_ctx, req)) {
10246 return tevent_req_post(req, ev);
10247 }
10248
10249 /* make a temporary copy, that we pass to the dispatch function */
10250 state->tmp = state->orig;
10251
10252 subreq = cli->dispatch_send(state, ev, cli,
10253 &ndr_table_spoolss,
10254 NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY,
10255 &state->tmp);
10256 if (tevent_req_nomem(subreq, req)) {
10257 return tevent_req_post(req, ev);
10258 }
10259 tevent_req_set_callback(subreq, rpccli_spoolss_RouterRefreshPrinterChangeNotify_done, req);
10260 return req;
10261 }
10262
10263 static void rpccli_spoolss_RouterRefreshPrinterChangeNotify_done(struct tevent_req *subreq)
10264 {
10265 struct tevent_req *req = tevent_req_callback_data(
10266 subreq, struct tevent_req);
10267 struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state *state = tevent_req_data(
10268 req, struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state);
10269 NTSTATUS status;
10270 TALLOC_CTX *mem_ctx;
10271
10272 if (state->out_mem_ctx) {
10273 mem_ctx = state->out_mem_ctx;
10274 } else {
10275 mem_ctx = state;
10276 }
10277
10278 status = state->dispatch_recv(subreq, mem_ctx);
10279 TALLOC_FREE(subreq);
10280 if (!NT_STATUS_IS_OK(status)) {
10281 tevent_req_nterror(req, status);
10282 return;
10283 }
10284
10285 /* Copy out parameters */
10286 *state->orig.out.info = *state->tmp.out.info;
10287
10288 /* Copy result */
10289 state->orig.out.result = state->tmp.out.result;
10290
10291 /* Reset temporary structure */
10292 ZERO_STRUCT(state->tmp);
10293
10294 tevent_req_done(req);
10295 }
10296
10297 NTSTATUS rpccli_spoolss_RouterRefreshPrinterChangeNotify_recv(struct tevent_req *req,
10298 TALLOC_CTX *mem_ctx,
10299 WERROR *result)
10300 {
10301 struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state *state = tevent_req_data(
10302 req, struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state);
10303 NTSTATUS status;
10304
10305 if (tevent_req_is_nterror(req, &status)) {
10306 tevent_req_received(req);
10307 return status;
10308 }
10309
10310 /* Steal possbile out parameters to the callers context */
10311 talloc_steal(mem_ctx, state->out_mem_ctx);
10312
10313 /* Return result */
10314 *result = state->orig.out.result;
10315
10316 tevent_req_received(req);
10317 return NT_STATUS_OK;
10318 }
10319
10320 NTSTATUS rpccli_spoolss_RouterRefreshPrinterChangeNotify(struct rpc_pipe_client *cli,
10321 TALLOC_CTX *mem_ctx,
10322 struct policy_handle *handle /* [in] [ref] */,
10323 uint32_t change_low /* [in] */,
10324 struct spoolss_NotifyOption *options /* [in] [unique] */,
10325 struct spoolss_NotifyInfo **info /* [out] [ref] */,
10326 WERROR *werror)
10327 {
10328 struct spoolss_RouterRefreshPrinterChangeNotify r;
10329 NTSTATUS status;
10330
10331 /* In parameters */
10332 r.in.handle = handle;
10333 r.in.change_low = change_low;
10334 r.in.options = options;
10335
10336 status = cli->dispatch(cli,
10337 mem_ctx,
10338 &ndr_table_spoolss,
10339 NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY,
10340 &r);
10341
10342 if (!NT_STATUS_IS_OK(status)) {
10343 return status;
10344 }
10345
10346 if (NT_STATUS_IS_ERR(status)) {
10347 return status;
10348 }
10349
10350 /* Return variables */
10351 *info = *r.out.info;
10352
10353 /* Return result */
10354 if (werror) {
10355 *werror = r.out.result;
10356 }
10357
10358 return werror_to_ntstatus(r.out.result);
10359 }
10360
10361 struct rpccli_spoolss_44_state {
10362 struct spoolss_44 orig;
10363 struct spoolss_44 tmp;
10364 TALLOC_CTX *out_mem_ctx;
10365 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10366 };
10367
10368 static void rpccli_spoolss_44_done(struct tevent_req *subreq);
10369
10370 struct tevent_req *rpccli_spoolss_44_send(TALLOC_CTX *mem_ctx,
10371 struct tevent_context *ev,
10372 struct rpc_pipe_client *cli)
10373 {
10374 struct tevent_req *req;
10375 struct rpccli_spoolss_44_state *state;
10376 struct tevent_req *subreq;
10377
10378 req = tevent_req_create(mem_ctx, &state,
10379 struct rpccli_spoolss_44_state);
10380 if (req == NULL) {
10381 return NULL;
10382 }
10383 state->out_mem_ctx = NULL;
10384 state->dispatch_recv = cli->dispatch_recv;
10385
10386 /* In parameters */
10387
10388 /* Out parameters */
10389
10390 /* Result */
10391 ZERO_STRUCT(state->orig.out.result);
10392
10393 /* make a temporary copy, that we pass to the dispatch function */
10394 state->tmp = state->orig;
10395
10396 subreq = cli->dispatch_send(state, ev, cli,
10397 &ndr_table_spoolss,
10398 NDR_SPOOLSS_44,
10399 &state->tmp);
10400 if (tevent_req_nomem(subreq, req)) {
10401 return tevent_req_post(req, ev);
10402 }
10403 tevent_req_set_callback(subreq, rpccli_spoolss_44_done, req);
10404 return req;
10405 }
10406
10407 static void rpccli_spoolss_44_done(struct tevent_req *subreq)
10408 {
10409 struct tevent_req *req = tevent_req_callback_data(
10410 subreq, struct tevent_req);
10411 struct rpccli_spoolss_44_state *state = tevent_req_data(
10412 req, struct rpccli_spoolss_44_state);
10413 NTSTATUS status;
10414 TALLOC_CTX *mem_ctx;
10415
10416 if (state->out_mem_ctx) {
10417 mem_ctx = state->out_mem_ctx;
10418 } else {
10419 mem_ctx = state;
10420 }
10421
10422 status = state->dispatch_recv(subreq, mem_ctx);
10423 TALLOC_FREE(subreq);
10424 if (!NT_STATUS_IS_OK(status)) {
10425 tevent_req_nterror(req, status);
10426 return;
10427 }
10428
10429 /* Copy out parameters */
10430
10431 /* Copy result */
10432 state->orig.out.result = state->tmp.out.result;
10433
10434 /* Reset temporary structure */
10435 ZERO_STRUCT(state->tmp);
10436
10437 tevent_req_done(req);
10438 }
10439
10440 NTSTATUS rpccli_spoolss_44_recv(struct tevent_req *req,
10441 TALLOC_CTX *mem_ctx,
10442 WERROR *result)
10443 {
10444 struct rpccli_spoolss_44_state *state = tevent_req_data(
10445 req, struct rpccli_spoolss_44_state);
10446 NTSTATUS status;
10447
10448 if (tevent_req_is_nterror(req, &status)) {
10449 tevent_req_received(req);
10450 return status;
10451 }
10452
10453 /* Steal possbile out parameters to the callers context */
10454 talloc_steal(mem_ctx, state->out_mem_ctx);
10455
10456 /* Return result */
10457 *result = state->orig.out.result;
10458
10459 tevent_req_received(req);
10460 return NT_STATUS_OK;
10461 }
10462
10463 NTSTATUS rpccli_spoolss_44(struct rpc_pipe_client *cli,
10464 TALLOC_CTX *mem_ctx,
10465 WERROR *werror)
10466 {
10467 struct spoolss_44 r;
10468 NTSTATUS status;
10469
10470 /* In parameters */
10471
10472 status = cli->dispatch(cli,
10473 mem_ctx,
10474 &ndr_table_spoolss,
10475 NDR_SPOOLSS_44,
10476 &r);
10477
10478 if (!NT_STATUS_IS_OK(status)) {
10479 return status;
10480 }
10481
10482 if (NT_STATUS_IS_ERR(status)) {
10483 return status;
10484 }
10485
10486 /* Return variables */
10487
10488 /* Return result */
10489 if (werror) {
10490 *werror = r.out.result;
10491 }
10492
10493 return werror_to_ntstatus(r.out.result);
10494 }
10495
10496 struct rpccli_spoolss_OpenPrinterEx_state {
10497 struct spoolss_OpenPrinterEx orig;
10498 struct spoolss_OpenPrinterEx tmp;
10499 TALLOC_CTX *out_mem_ctx;
10500 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10501 };
10502
10503 static void rpccli_spoolss_OpenPrinterEx_done(struct tevent_req *subreq);
10504
10505 struct tevent_req *rpccli_spoolss_OpenPrinterEx_send(TALLOC_CTX *mem_ctx,
10506 struct tevent_context *ev,
10507 struct rpc_pipe_client *cli,
10508 const char *_printername /* [in] [unique,charset(UTF16)] */,
10509 const char *_datatype /* [in] [unique,charset(UTF16)] */,
10510 struct spoolss_DevmodeContainer _devmode_ctr /* [in] */,
10511 uint32_t _access_mask /* [in] */,
10512 uint32_t _level /* [in] */,
10513 union spoolss_UserLevel _userlevel /* [in] [switch_is(level)] */,
10514 struct policy_handle *_handle /* [out] [ref] */)
10515 {
10516 struct tevent_req *req;
10517 struct rpccli_spoolss_OpenPrinterEx_state *state;
10518 struct tevent_req *subreq;
10519
10520 req = tevent_req_create(mem_ctx, &state,
10521 struct rpccli_spoolss_OpenPrinterEx_state);
10522 if (req == NULL) {
10523 return NULL;
10524 }
10525 state->out_mem_ctx = NULL;
10526 state->dispatch_recv = cli->dispatch_recv;
10527
10528 /* In parameters */
10529 state->orig.in.printername = _printername;
10530 state->orig.in.datatype = _datatype;
10531 state->orig.in.devmode_ctr = _devmode_ctr;
10532 state->orig.in.access_mask = _access_mask;
10533 state->orig.in.level = _level;
10534 state->orig.in.userlevel = _userlevel;
10535
10536 /* Out parameters */
10537 state->orig.out.handle = _handle;
10538
10539 /* Result */
10540 ZERO_STRUCT(state->orig.out.result);
10541
10542 state->out_mem_ctx = talloc_named_const(state, 0,
10543 "rpccli_spoolss_OpenPrinterEx_out_memory");
10544 if (tevent_req_nomem(state->out_mem_ctx, req)) {
10545 return tevent_req_post(req, ev);
10546 }
10547
10548 /* make a temporary copy, that we pass to the dispatch function */
10549 state->tmp = state->orig;
10550
10551 subreq = cli->dispatch_send(state, ev, cli,
10552 &ndr_table_spoolss,
10553 NDR_SPOOLSS_OPENPRINTEREX,
10554 &state->tmp);
10555 if (tevent_req_nomem(subreq, req)) {
10556 return tevent_req_post(req, ev);
10557 }
10558 tevent_req_set_callback(subreq, rpccli_spoolss_OpenPrinterEx_done, req);
10559 return req;
10560 }
10561
10562 static void rpccli_spoolss_OpenPrinterEx_done(struct tevent_req *subreq)
10563 {
10564 struct tevent_req *req = tevent_req_callback_data(
10565 subreq, struct tevent_req);
10566 struct rpccli_spoolss_OpenPrinterEx_state *state = tevent_req_data(
10567 req, struct rpccli_spoolss_OpenPrinterEx_state);
10568 NTSTATUS status;
10569 TALLOC_CTX *mem_ctx;
10570
10571 if (state->out_mem_ctx) {
10572 mem_ctx = state->out_mem_ctx;
10573 } else {
10574 mem_ctx = state;
10575 }
10576
10577 status = state->dispatch_recv(subreq, mem_ctx);
10578 TALLOC_FREE(subreq);
10579 if (!NT_STATUS_IS_OK(status)) {
10580 tevent_req_nterror(req, status);
10581 return;
10582 }
10583
10584 /* Copy out parameters */
10585 *state->orig.out.handle = *state->tmp.out.handle;
10586
10587 /* Copy result */
10588 state->orig.out.result = state->tmp.out.result;
10589
10590 /* Reset temporary structure */
10591 ZERO_STRUCT(state->tmp);
10592
10593 tevent_req_done(req);
10594 }
10595
10596 NTSTATUS rpccli_spoolss_OpenPrinterEx_recv(struct tevent_req *req,
10597 TALLOC_CTX *mem_ctx,
10598 WERROR *result)
10599 {
10600 struct rpccli_spoolss_OpenPrinterEx_state *state = tevent_req_data(
10601 req, struct rpccli_spoolss_OpenPrinterEx_state);
10602 NTSTATUS status;
10603
10604 if (tevent_req_is_nterror(req, &status)) {
10605 tevent_req_received(req);
10606 return status;
10607 }
10608
10609 /* Steal possbile out parameters to the callers context */
10610 talloc_steal(mem_ctx, state->out_mem_ctx);
10611
10612 /* Return result */
10613 *result = state->orig.out.result;
10614
10615 tevent_req_received(req);
10616 return NT_STATUS_OK;
10617 }
10618
10619 NTSTATUS rpccli_spoolss_OpenPrinterEx(struct rpc_pipe_client *cli,
10620 TALLOC_CTX *mem_ctx,
10621 const char *printername /* [in] [unique,charset(UTF16)] */,
10622 const char *datatype /* [in] [unique,charset(UTF16)] */,
10623 struct spoolss_DevmodeContainer devmode_ctr /* [in] */,
10624 uint32_t access_mask /* [in] */,
10625 uint32_t level /* [in] */,
10626 union spoolss_UserLevel userlevel /* [in] [switch_is(level)] */,
10627 struct policy_handle *handle /* [out] [ref] */,
10628 WERROR *werror)
10629 {
10630 struct spoolss_OpenPrinterEx r;
10631 NTSTATUS status;
10632
10633 /* In parameters */
10634 r.in.printername = printername;
10635 r.in.datatype = datatype;
10636 r.in.devmode_ctr = devmode_ctr;
10637 r.in.access_mask = access_mask;
10638 r.in.level = level;
10639 r.in.userlevel = userlevel;
10640
10641 status = cli->dispatch(cli,
10642 mem_ctx,
10643 &ndr_table_spoolss,
10644 NDR_SPOOLSS_OPENPRINTEREX,
10645 &r);
10646
10647 if (!NT_STATUS_IS_OK(status)) {
10648 return status;
10649 }
10650
10651 if (NT_STATUS_IS_ERR(status)) {
10652 return status;
10653 }
10654
10655 /* Return variables */
10656 *handle = *r.out.handle;
10657
10658 /* Return result */
10659 if (werror) {
10660 *werror = r.out.result;
10661 }
10662
10663 return werror_to_ntstatus(r.out.result);
10664 }
10665
10666 struct rpccli_spoolss_AddPrinterEx_state {
10667 struct spoolss_AddPrinterEx orig;
10668 struct spoolss_AddPrinterEx tmp;
10669 TALLOC_CTX *out_mem_ctx;
10670 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10671 };
10672
10673 static void rpccli_spoolss_AddPrinterEx_done(struct tevent_req *subreq);
10674
10675 struct tevent_req *rpccli_spoolss_AddPrinterEx_send(TALLOC_CTX *mem_ctx,
10676 struct tevent_context *ev,
10677 struct rpc_pipe_client *cli,
10678 const char *_server /* [in] [unique,charset(UTF16)] */,
10679 struct spoolss_SetPrinterInfoCtr *_info_ctr /* [in] [ref] */,
10680 struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */,
10681 struct sec_desc_buf *_secdesc_ctr /* [in] [ref] */,
10682 struct spoolss_UserLevelCtr *_userlevel_ctr /* [in] [ref] */,
10683 struct policy_handle *_handle /* [out] [ref] */)
10684 {
10685 struct tevent_req *req;
10686 struct rpccli_spoolss_AddPrinterEx_state *state;
10687 struct tevent_req *subreq;
10688
10689 req = tevent_req_create(mem_ctx, &state,
10690 struct rpccli_spoolss_AddPrinterEx_state);
10691 if (req == NULL) {
10692 return NULL;
10693 }
10694 state->out_mem_ctx = NULL;
10695 state->dispatch_recv = cli->dispatch_recv;
10696
10697 /* In parameters */
10698 state->orig.in.server = _server;
10699 state->orig.in.info_ctr = _info_ctr;
10700 state->orig.in.devmode_ctr = _devmode_ctr;
10701 state->orig.in.secdesc_ctr = _secdesc_ctr;
10702 state->orig.in.userlevel_ctr = _userlevel_ctr;
10703
10704 /* Out parameters */
10705 state->orig.out.handle = _handle;
10706
10707 /* Result */
10708 ZERO_STRUCT(state->orig.out.result);
10709
10710 state->out_mem_ctx = talloc_named_const(state, 0,
10711 "rpccli_spoolss_AddPrinterEx_out_memory");
10712 if (tevent_req_nomem(state->out_mem_ctx, req)) {
10713 return tevent_req_post(req, ev);
10714 }
10715
10716 /* make a temporary copy, that we pass to the dispatch function */
10717 state->tmp = state->orig;
10718
10719 subreq = cli->dispatch_send(state, ev, cli,
10720 &ndr_table_spoolss,
10721 NDR_SPOOLSS_ADDPRINTEREX,
10722 &state->tmp);
10723 if (tevent_req_nomem(subreq, req)) {
10724 return tevent_req_post(req, ev);
10725 }
10726 tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterEx_done, req);
10727 return req;
10728 }
10729
10730 static void rpccli_spoolss_AddPrinterEx_done(struct tevent_req *subreq)
10731 {
10732 struct tevent_req *req = tevent_req_callback_data(
10733 subreq, struct tevent_req);
10734 struct rpccli_spoolss_AddPrinterEx_state *state = tevent_req_data(
10735 req, struct rpccli_spoolss_AddPrinterEx_state);
10736 NTSTATUS status;
10737 TALLOC_CTX *mem_ctx;
10738
10739 if (state->out_mem_ctx) {
10740 mem_ctx = state->out_mem_ctx;
10741 } else {
10742 mem_ctx = state;
10743 }
10744
10745 status = state->dispatch_recv(subreq, mem_ctx);
10746 TALLOC_FREE(subreq);
10747 if (!NT_STATUS_IS_OK(status)) {
10748 tevent_req_nterror(req, status);
10749 return;
10750 }
10751
10752 /* Copy out parameters */
10753 *state->orig.out.handle = *state->tmp.out.handle;
10754
10755 /* Copy result */
10756 state->orig.out.result = state->tmp.out.result;
10757
10758 /* Reset temporary structure */
10759 ZERO_STRUCT(state->tmp);
10760
10761 tevent_req_done(req);
10762 }
10763
10764 NTSTATUS rpccli_spoolss_AddPrinterEx_recv(struct tevent_req *req,
10765 TALLOC_CTX *mem_ctx,
10766 WERROR *result)
10767 {
10768 struct rpccli_spoolss_AddPrinterEx_state *state = tevent_req_data(
10769 req, struct rpccli_spoolss_AddPrinterEx_state);
10770 NTSTATUS status;
10771
10772 if (tevent_req_is_nterror(req, &status)) {
10773 tevent_req_received(req);
10774 return status;
10775 }
10776
10777 /* Steal possbile out parameters to the callers context */
10778 talloc_steal(mem_ctx, state->out_mem_ctx);
10779
10780 /* Return result */
10781 *result = state->orig.out.result;
10782
10783 tevent_req_received(req);
10784 return NT_STATUS_OK;
10785 }
10786
10787 NTSTATUS rpccli_spoolss_AddPrinterEx(struct rpc_pipe_client *cli,
10788 TALLOC_CTX *mem_ctx,
10789 const char *server /* [in] [unique,charset(UTF16)] */,
10790 struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */,
10791 struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
10792 struct sec_desc_buf *secdesc_ctr /* [in] [ref] */,
10793 struct spoolss_UserLevelCtr *userlevel_ctr /* [in] [ref] */,
10794 struct policy_handle *handle /* [out] [ref] */,
10795 WERROR *werror)
10796 {
10797 struct spoolss_AddPrinterEx r;
10798 NTSTATUS status;
10799
10800 /* In parameters */
10801 r.in.server = server;
10802 r.in.info_ctr = info_ctr;
10803 r.in.devmode_ctr = devmode_ctr;
10804 r.in.secdesc_ctr = secdesc_ctr;
10805 r.in.userlevel_ctr = userlevel_ctr;
10806
10807 status = cli->dispatch(cli,
10808 mem_ctx,
10809 &ndr_table_spoolss,
10810 NDR_SPOOLSS_ADDPRINTEREX,
10811 &r);
10812
10813 if (!NT_STATUS_IS_OK(status)) {
10814 return status;
10815 }
10816
10817 if (NT_STATUS_IS_ERR(status)) {
10818 return status;
10819 }
10820
10821 /* Return variables */
10822 *handle = *r.out.handle;
10823
10824 /* Return result */
10825 if (werror) {
10826 *werror = r.out.result;
10827 }
10828
10829 return werror_to_ntstatus(r.out.result);
10830 }
10831
10832 struct rpccli_spoolss_47_state {
10833 struct spoolss_47 orig;
10834 struct spoolss_47 tmp;
10835 TALLOC_CTX *out_mem_ctx;
10836 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10837 };
10838
10839 static void rpccli_spoolss_47_done(struct tevent_req *subreq);
10840
10841 struct tevent_req *rpccli_spoolss_47_send(TALLOC_CTX *mem_ctx,
10842 struct tevent_context *ev,
10843 struct rpc_pipe_client *cli)
10844 {
10845 struct tevent_req *req;
10846 struct rpccli_spoolss_47_state *state;
10847 struct tevent_req *subreq;
10848
10849 req = tevent_req_create(mem_ctx, &state,
10850 struct rpccli_spoolss_47_state);
10851 if (req == NULL) {
10852 return NULL;
10853 }
10854 state->out_mem_ctx = NULL;
10855 state->dispatch_recv = cli->dispatch_recv;
10856
10857 /* In parameters */
10858
10859 /* Out parameters */
10860
10861 /* Result */
10862 ZERO_STRUCT(state->orig.out.result);
10863
10864 /* make a temporary copy, that we pass to the dispatch function */
10865 state->tmp = state->orig;
10866
10867 subreq = cli->dispatch_send(state, ev, cli,
10868 &ndr_table_spoolss,
10869 NDR_SPOOLSS_47,
10870 &state->tmp);
10871 if (tevent_req_nomem(subreq, req)) {
10872 return tevent_req_post(req, ev);
10873 }
10874 tevent_req_set_callback(subreq, rpccli_spoolss_47_done, req);
10875 return req;
10876 }
10877
10878 static void rpccli_spoolss_47_done(struct tevent_req *subreq)
10879 {
10880 struct tevent_req *req = tevent_req_callback_data(
10881 subreq, struct tevent_req);
10882 struct rpccli_spoolss_47_state *state = tevent_req_data(
10883 req, struct rpccli_spoolss_47_state);
10884 NTSTATUS status;
10885 TALLOC_CTX *mem_ctx;
10886
10887 if (state->out_mem_ctx) {
10888 mem_ctx = state->out_mem_ctx;
10889 } else {
10890 mem_ctx = state;
10891 }
10892
10893 status = state->dispatch_recv(subreq, mem_ctx);
10894 TALLOC_FREE(subreq);
10895 if (!NT_STATUS_IS_OK(status)) {
10896 tevent_req_nterror(req, status);
10897 return;
10898 }
10899
10900 /* Copy out parameters */
10901
10902 /* Copy result */
10903 state->orig.out.result = state->tmp.out.result;
10904
10905 /* Reset temporary structure */
10906 ZERO_STRUCT(state->tmp);
10907
10908 tevent_req_done(req);
10909 }
10910
10911 NTSTATUS rpccli_spoolss_47_recv(struct tevent_req *req,
10912 TALLOC_CTX *mem_ctx,
10913 WERROR *result)
10914 {
10915 struct rpccli_spoolss_47_state *state = tevent_req_data(
10916 req, struct rpccli_spoolss_47_state);
10917 NTSTATUS status;
10918
10919 if (tevent_req_is_nterror(req, &status)) {
10920 tevent_req_received(req);
10921 return status;
10922 }
10923
10924 /* Steal possbile out parameters to the callers context */
10925 talloc_steal(mem_ctx, state->out_mem_ctx);
10926
10927 /* Return result */
10928 *result = state->orig.out.result;
10929
10930 tevent_req_received(req);
10931 return NT_STATUS_OK;
10932 }
10933
10934 NTSTATUS rpccli_spoolss_47(struct rpc_pipe_client *cli,
10935 TALLOC_CTX *mem_ctx,
10936 WERROR *werror)
10937 {
10938 struct spoolss_47 r;
10939 NTSTATUS status;
10940
10941 /* In parameters */
10942
10943 status = cli->dispatch(cli,
10944 mem_ctx,
10945 &ndr_table_spoolss,
10946 NDR_SPOOLSS_47,
10947 &r);
10948
10949 if (!NT_STATUS_IS_OK(status)) {
10950 return status;
10951 }
10952
10953 if (NT_STATUS_IS_ERR(status)) {
10954 return status;
10955 }
10956
10957 /* Return variables */
10958
10959 /* Return result */
10960 if (werror) {
10961 *werror = r.out.result;
10962 }
10963
10964 return werror_to_ntstatus(r.out.result);
10965 }
10966
10967 struct rpccli_spoolss_EnumPrinterData_state {
10968 struct spoolss_EnumPrinterData orig;
10969 struct spoolss_EnumPrinterData tmp;
10970 TALLOC_CTX *out_mem_ctx;
10971 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10972 };
10973
10974 static void rpccli_spoolss_EnumPrinterData_done(struct tevent_req *subreq);
10975
10976 struct tevent_req *rpccli_spoolss_EnumPrinterData_send(TALLOC_CTX *mem_ctx,
10977 struct tevent_context *ev,
10978 struct rpc_pipe_client *cli,
10979 struct policy_handle *_handle /* [in] [ref] */,
10980 uint32_t _enum_index /* [in] */,
10981 const char *_value_name /* [out] [charset(UTF16),size_is(value_offered/2)] */,
10982 uint32_t _value_offered /* [in] */,
10983 uint32_t *_value_needed /* [out] [ref] */,
10984 enum winreg_Type *_type /* [out] [ref] */,
10985 uint8_t *_data /* [out] [ref,flag(LIBNDR_PRINT_ARRAY_HEX),size_is(data_offered)] */,
10986 uint32_t _data_offered /* [in] */,
10987 uint32_t *_data_needed /* [out] [ref] */)
10988 {
10989 struct tevent_req *req;
10990 struct rpccli_spoolss_EnumPrinterData_state *state;
10991 struct tevent_req *subreq;
10992
10993 req = tevent_req_create(mem_ctx, &state,
10994 struct rpccli_spoolss_EnumPrinterData_state);
10995 if (req == NULL) {
10996 return NULL;
10997 }
10998 state->out_mem_ctx = NULL;
10999 state->dispatch_recv = cli->dispatch_recv;
11000
11001 /* In parameters */
11002 state->orig.in.handle = _handle;
11003 state->orig.in.enum_index = _enum_index;
11004 state->orig.in.value_offered = _value_offered;
11005 state->orig.in.data_offered = _data_offered;
11006
11007 /* Out parameters */
11008 state->orig.out.value_name = _value_name;
11009 state->orig.out.value_needed = _value_needed;
11010 state->orig.out.type = _type;
11011 state->orig.out.data = _data;
11012 state->orig.out.data_needed = _data_needed;
11013
11014 /* Result */
11015 ZERO_STRUCT(state->orig.out.result);
11016
11017 state->out_mem_ctx = talloc_named_const(state, 0,
11018 "rpccli_spoolss_EnumPrinterData_out_memory");
11019 if (tevent_req_nomem(state->out_mem_ctx, req)) {
11020 return tevent_req_post(req, ev);
11021 }
11022
11023 /* make a temporary copy, that we pass to the dispatch function */
11024 state->tmp = state->orig;
11025
11026 subreq = cli->dispatch_send(state, ev, cli,
11027 &ndr_table_spoolss,
11028 NDR_SPOOLSS_ENUMPRINTERDATA,
11029 &state->tmp);
11030 if (tevent_req_nomem(subreq, req)) {
11031 return tevent_req_post(req, ev);
11032 }
11033 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinterData_done, req);
11034 return req;
11035 }
11036
11037 static void rpccli_spoolss_EnumPrinterData_done(struct tevent_req *subreq)
11038 {
11039 struct tevent_req *req = tevent_req_callback_data(
11040 subreq, struct tevent_req);
11041 struct rpccli_spoolss_EnumPrinterData_state *state = tevent_req_data(
11042 req, struct rpccli_spoolss_EnumPrinterData_state);
11043 NTSTATUS status;
11044 TALLOC_CTX *mem_ctx;
11045
11046 if (state->out_mem_ctx) {
11047 mem_ctx = state->out_mem_ctx;
11048 } else {
11049 mem_ctx = state;
11050 }
11051
11052 status = state->dispatch_recv(subreq, mem_ctx);
11053 TALLOC_FREE(subreq);
11054 if (!NT_STATUS_IS_OK(status)) {
11055 tevent_req_nterror(req, status);
11056 return;
11057 }
11058
11059 /* Copy out parameters */
11060 memcpy(discard_const_p(uint8_t *, state->orig.out.value_name), state->tmp.out.value_name, (state->tmp.in.value_offered / 2) * sizeof(*state->orig.out.value_name));
11061 *state->orig.out.value_needed = *state->tmp.out.value_needed;
11062 *state->orig.out.type = *state->tmp.out.type;
11063 memcpy(state->orig.out.data, state->tmp.out.data, (state->tmp.in.data_offered) * sizeof(*state->orig.out.data));
11064 *state->orig.out.data_needed = *state->tmp.out.data_needed;
11065
11066 /* Copy result */
11067 state->orig.out.result = state->tmp.out.result;
11068
11069 /* Reset temporary structure */
11070 ZERO_STRUCT(state->tmp);
11071
11072 tevent_req_done(req);
11073 }
11074
11075 NTSTATUS rpccli_spoolss_EnumPrinterData_recv(struct tevent_req *req,
11076 TALLOC_CTX *mem_ctx,
11077 WERROR *result)
11078 {
11079 struct rpccli_spoolss_EnumPrinterData_state *state = tevent_req_data(
11080 req, struct rpccli_spoolss_EnumPrinterData_state);
11081 NTSTATUS status;
11082
11083 if (tevent_req_is_nterror(req, &status)) {
11084 tevent_req_received(req);
11085 return status;
11086 }
11087
11088 /* Steal possbile out parameters to the callers context */
11089 talloc_steal(mem_ctx, state->out_mem_ctx);
11090
11091 /* Return result */
11092 *result = state->orig.out.result;
11093
11094 tevent_req_received(req);
11095 return NT_STATUS_OK;
11096 }
11097
11098 NTSTATUS rpccli_spoolss_EnumPrinterData(struct rpc_pipe_client *cli,
11099 TALLOC_CTX *mem_ctx,
11100 struct policy_handle *handle /* [in] [ref] */,
11101 uint32_t enum_index /* [in] */,
11102 const char *value_name /* [out] [charset(UTF16),size_is(value_offered/2)] */,
11103 uint32_t value_offered /* [in] */,
11104 uint32_t *value_needed /* [out] [ref] */,
11105 enum winreg_Type *type /* [out] [ref] */,
11106 uint8_t *data /* [out] [ref,flag(LIBNDR_PRINT_ARRAY_HEX),size_is(data_offered)] */,
11107 uint32_t data_offered /* [in] */,
11108 uint32_t *data_needed /* [out] [ref] */,
11109 WERROR *werror)
11110 {
11111 struct spoolss_EnumPrinterData r;
11112 NTSTATUS status;
11113
11114 /* In parameters */
11115 r.in.handle = handle;
11116 r.in.enum_index = enum_index;
11117 r.in.value_offered = value_offered;
11118 r.in.data_offered = data_offered;
11119
11120 status = cli->dispatch(cli,
11121 mem_ctx,
11122 &ndr_table_spoolss,
11123 NDR_SPOOLSS_ENUMPRINTERDATA,
11124 &r);
11125
11126 if (!NT_STATUS_IS_OK(status)) {
11127 return status;
11128 }
11129
11130 if (NT_STATUS_IS_ERR(status)) {
11131 return status;
11132 }
11133
11134 /* Return variables */
11135 memcpy(discard_const_p(uint8_t *, value_name), r.out.value_name, (r.in.value_offered / 2) * sizeof(*value_name));
11136 *value_needed = *r.out.value_needed;
11137 *type = *r.out.type;
11138 memcpy(data, r.out.data, (r.in.data_offered) * sizeof(*data));
11139 *data_needed = *r.out.data_needed;
11140
11141 /* Return result */
11142 if (werror) {
11143 *werror = r.out.result;
11144 }
11145
11146 return werror_to_ntstatus(r.out.result);
11147 }
11148
11149 struct rpccli_spoolss_DeletePrinterData_state {
11150 struct spoolss_DeletePrinterData orig;
11151 struct spoolss_DeletePrinterData tmp;
11152 TALLOC_CTX *out_mem_ctx;
11153 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11154 };
11155
11156 static void rpccli_spoolss_DeletePrinterData_done(struct tevent_req *subreq);
11157
11158 struct tevent_req *rpccli_spoolss_DeletePrinterData_send(TALLOC_CTX *mem_ctx,
11159 struct tevent_context *ev,
11160 struct rpc_pipe_client *cli,
11161 struct policy_handle *_handle /* [in] [ref] */,
11162 const char *_value_name /* [in] [charset(UTF16)] */)
11163 {
11164 struct tevent_req *req;
11165 struct rpccli_spoolss_DeletePrinterData_state *state;
11166 struct tevent_req *subreq;
11167
11168 req = tevent_req_create(mem_ctx, &state,
11169 struct rpccli_spoolss_DeletePrinterData_state);
11170 if (req == NULL) {
11171 return NULL;
11172 }
11173 state->out_mem_ctx = NULL;
11174 state->dispatch_recv = cli->dispatch_recv;
11175
11176 /* In parameters */
11177 state->orig.in.handle = _handle;
11178 state->orig.in.value_name = _value_name;
11179
11180 /* Out parameters */
11181
11182 /* Result */
11183 ZERO_STRUCT(state->orig.out.result);
11184
11185 /* make a temporary copy, that we pass to the dispatch function */
11186 state->tmp = state->orig;
11187
11188 subreq = cli->dispatch_send(state, ev, cli,
11189 &ndr_table_spoolss,
11190 NDR_SPOOLSS_DELETEPRINTERDATA,
11191 &state->tmp);
11192 if (tevent_req_nomem(subreq, req)) {
11193 return tevent_req_post(req, ev);
11194 }
11195 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterData_done, req);
11196 return req;
11197 }
11198
11199 static void rpccli_spoolss_DeletePrinterData_done(struct tevent_req *subreq)
11200 {
11201 struct tevent_req *req = tevent_req_callback_data(
11202 subreq, struct tevent_req);
11203 struct rpccli_spoolss_DeletePrinterData_state *state = tevent_req_data(
11204 req, struct rpccli_spoolss_DeletePrinterData_state);
11205 NTSTATUS status;
11206 TALLOC_CTX *mem_ctx;
11207
11208 if (state->out_mem_ctx) {
11209 mem_ctx = state->out_mem_ctx;
11210 } else {
11211 mem_ctx = state;
11212 }
11213
11214 status = state->dispatch_recv(subreq, mem_ctx);
11215 TALLOC_FREE(subreq);
11216 if (!NT_STATUS_IS_OK(status)) {
11217 tevent_req_nterror(req, status);
11218 return;
11219 }
11220
11221 /* Copy out parameters */
11222
11223 /* Copy result */
11224 state->orig.out.result = state->tmp.out.result;
11225
11226 /* Reset temporary structure */
11227 ZERO_STRUCT(state->tmp);
11228
11229 tevent_req_done(req);
11230 }
11231
11232 NTSTATUS rpccli_spoolss_DeletePrinterData_recv(struct tevent_req *req,
11233 TALLOC_CTX *mem_ctx,
11234 WERROR *result)
11235 {
11236 struct rpccli_spoolss_DeletePrinterData_state *state = tevent_req_data(
11237 req, struct rpccli_spoolss_DeletePrinterData_state);
11238 NTSTATUS status;
11239
11240 if (tevent_req_is_nterror(req, &status)) {
11241 tevent_req_received(req);
11242 return status;
11243 }
11244
11245 /* Steal possbile out parameters to the callers context */
11246 talloc_steal(mem_ctx, state->out_mem_ctx);
11247
11248 /* Return result */
11249 *result = state->orig.out.result;
11250
11251 tevent_req_received(req);
11252 return NT_STATUS_OK;
11253 }
11254
11255 NTSTATUS rpccli_spoolss_DeletePrinterData(struct rpc_pipe_client *cli,
11256 TALLOC_CTX *mem_ctx,
11257 struct policy_handle *handle /* [in] [ref] */,
11258 const char *value_name /* [in] [charset(UTF16)] */,
11259 WERROR *werror)
11260 {
11261 struct spoolss_DeletePrinterData r;
11262 NTSTATUS status;
11263
11264 /* In parameters */
11265 r.in.handle = handle;
11266 r.in.value_name = value_name;
11267
11268 status = cli->dispatch(cli,
11269 mem_ctx,
11270 &ndr_table_spoolss,
11271 NDR_SPOOLSS_DELETEPRINTERDATA,
11272 &r);
11273
11274 if (!NT_STATUS_IS_OK(status)) {
11275 return status;
11276 }
11277
11278 if (NT_STATUS_IS_ERR(status)) {
11279 return status;
11280 }
11281
11282 /* Return variables */
11283
11284 /* Return result */
11285 if (werror) {
11286 *werror = r.out.result;
11287 }
11288
11289 return werror_to_ntstatus(r.out.result);
11290 }
11291
11292 struct rpccli_spoolss_4a_state {
11293 struct spoolss_4a orig;
11294 struct spoolss_4a tmp;
11295 TALLOC_CTX *out_mem_ctx;
11296 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11297 };
11298
11299 static void rpccli_spoolss_4a_done(struct tevent_req *subreq);
11300
11301 struct tevent_req *rpccli_spoolss_4a_send(TALLOC_CTX *mem_ctx,
11302 struct tevent_context *ev,
11303 struct rpc_pipe_client *cli)
11304 {
11305 struct tevent_req *req;
11306 struct rpccli_spoolss_4a_state *state;
11307 struct tevent_req *subreq;
11308
11309 req = tevent_req_create(mem_ctx, &state,
11310 struct rpccli_spoolss_4a_state);
11311 if (req == NULL) {
11312 return NULL;
11313 }
11314 state->out_mem_ctx = NULL;
11315 state->dispatch_recv = cli->dispatch_recv;
11316
11317 /* In parameters */
11318
11319 /* Out parameters */
11320
11321 /* Result */
11322 ZERO_STRUCT(state->orig.out.result);
11323
11324 /* make a temporary copy, that we pass to the dispatch function */
11325 state->tmp = state->orig;
11326
11327 subreq = cli->dispatch_send(state, ev, cli,
11328 &ndr_table_spoolss,
11329 NDR_SPOOLSS_4A,
11330 &state->tmp);
11331 if (tevent_req_nomem(subreq, req)) {
11332 return tevent_req_post(req, ev);
11333 }
11334 tevent_req_set_callback(subreq, rpccli_spoolss_4a_done, req);
11335 return req;
11336 }
11337
11338 static void rpccli_spoolss_4a_done(struct tevent_req *subreq)
11339 {
11340 struct tevent_req *req = tevent_req_callback_data(
11341 subreq, struct tevent_req);
11342 struct rpccli_spoolss_4a_state *state = tevent_req_data(
11343 req, struct rpccli_spoolss_4a_state);
11344 NTSTATUS status;
11345 TALLOC_CTX *mem_ctx;
11346
11347 if (state->out_mem_ctx) {
11348 mem_ctx = state->out_mem_ctx;
11349 } else {
11350 mem_ctx = state;
11351 }
11352
11353 status = state->dispatch_recv(subreq, mem_ctx);
11354 TALLOC_FREE(subreq);
11355 if (!NT_STATUS_IS_OK(status)) {
11356 tevent_req_nterror(req, status);
11357 return;
11358 }
11359
11360 /* Copy out parameters */
11361
11362 /* Copy result */
11363 state->orig.out.result = state->tmp.out.result;
11364
11365 /* Reset temporary structure */
11366 ZERO_STRUCT(state->tmp);
11367
11368 tevent_req_done(req);
11369 }
11370
11371 NTSTATUS rpccli_spoolss_4a_recv(struct tevent_req *req,
11372 TALLOC_CTX *mem_ctx,
11373 WERROR *result)
11374 {
11375 struct rpccli_spoolss_4a_state *state = tevent_req_data(
11376 req, struct rpccli_spoolss_4a_state);
11377 NTSTATUS status;
11378
11379 if (tevent_req_is_nterror(req, &status)) {
11380 tevent_req_received(req);
11381 return status;
11382 }
11383
11384 /* Steal possbile out parameters to the callers context */
11385 talloc_steal(mem_ctx, state->out_mem_ctx);
11386
11387 /* Return result */
11388 *result = state->orig.out.result;
11389
11390 tevent_req_received(req);
11391 return NT_STATUS_OK;
11392 }
11393
11394 NTSTATUS rpccli_spoolss_4a(struct rpc_pipe_client *cli,
11395 TALLOC_CTX *mem_ctx,
11396 WERROR *werror)
11397 {
11398 struct spoolss_4a r;
11399 NTSTATUS status;
11400
11401 /* In parameters */
11402
11403 status = cli->dispatch(cli,
11404 mem_ctx,
11405 &ndr_table_spoolss,
11406 NDR_SPOOLSS_4A,
11407 &r);
11408
11409 if (!NT_STATUS_IS_OK(status)) {
11410 return status;
11411 }
11412
11413 if (NT_STATUS_IS_ERR(status)) {
11414 return status;
11415 }
11416
11417 /* Return variables */
11418
11419 /* Return result */
11420 if (werror) {
11421 *werror = r.out.result;
11422 }
11423
11424 return werror_to_ntstatus(r.out.result);
11425 }
11426
11427 struct rpccli_spoolss_4b_state {
11428 struct spoolss_4b orig;
11429 struct spoolss_4b tmp;
11430 TALLOC_CTX *out_mem_ctx;
11431 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11432 };
11433
11434 static void rpccli_spoolss_4b_done(struct tevent_req *subreq);
11435
11436 struct tevent_req *rpccli_spoolss_4b_send(TALLOC_CTX *mem_ctx,
11437 struct tevent_context *ev,
11438 struct rpc_pipe_client *cli)
11439 {
11440 struct tevent_req *req;
11441 struct rpccli_spoolss_4b_state *state;
11442 struct tevent_req *subreq;
11443
11444 req = tevent_req_create(mem_ctx, &state,
11445 struct rpccli_spoolss_4b_state);
11446 if (req == NULL) {
11447 return NULL;
11448 }
11449 state->out_mem_ctx = NULL;
11450 state->dispatch_recv = cli->dispatch_recv;
11451
11452 /* In parameters */
11453
11454 /* Out parameters */
11455
11456 /* Result */
11457 ZERO_STRUCT(state->orig.out.result);
11458
11459 /* make a temporary copy, that we pass to the dispatch function */
11460 state->tmp = state->orig;
11461
11462 subreq = cli->dispatch_send(state, ev, cli,
11463 &ndr_table_spoolss,
11464 NDR_SPOOLSS_4B,
11465 &state->tmp);
11466 if (tevent_req_nomem(subreq, req)) {
11467 return tevent_req_post(req, ev);
11468 }
11469 tevent_req_set_callback(subreq, rpccli_spoolss_4b_done, req);
11470 return req;
11471 }
11472
11473 static void rpccli_spoolss_4b_done(struct tevent_req *subreq)
11474 {
11475 struct tevent_req *req = tevent_req_callback_data(
11476 subreq, struct tevent_req);
11477 struct rpccli_spoolss_4b_state *state = tevent_req_data(
11478 req, struct rpccli_spoolss_4b_state);
11479 NTSTATUS status;
11480 TALLOC_CTX *mem_ctx;
11481
11482 if (state->out_mem_ctx) {
11483 mem_ctx = state->out_mem_ctx;
11484 } else {
11485 mem_ctx = state;
11486 }
11487
11488 status = state->dispatch_recv(subreq, mem_ctx);
11489 TALLOC_FREE(subreq);
11490 if (!NT_STATUS_IS_OK(status)) {
11491 tevent_req_nterror(req, status);
11492 return;
11493 }
11494
11495 /* Copy out parameters */
11496
11497 /* Copy result */
11498 state->orig.out.result = state->tmp.out.result;
11499
11500 /* Reset temporary structure */
11501 ZERO_STRUCT(state->tmp);
11502
11503 tevent_req_done(req);
11504 }
11505
11506 NTSTATUS rpccli_spoolss_4b_recv(struct tevent_req *req,
11507 TALLOC_CTX *mem_ctx,
11508 WERROR *result)
11509 {
11510 struct rpccli_spoolss_4b_state *state = tevent_req_data(
11511 req, struct rpccli_spoolss_4b_state);
11512 NTSTATUS status;
11513
11514 if (tevent_req_is_nterror(req, &status)) {
11515 tevent_req_received(req);
11516 return status;
11517 }
11518
11519 /* Steal possbile out parameters to the callers context */
11520 talloc_steal(mem_ctx, state->out_mem_ctx);
11521
11522 /* Return result */
11523 *result = state->orig.out.result;
11524
11525 tevent_req_received(req);
11526 return NT_STATUS_OK;
11527 }
11528
11529 NTSTATUS rpccli_spoolss_4b(struct rpc_pipe_client *cli,
11530 TALLOC_CTX *mem_ctx,
11531 WERROR *werror)
11532 {
11533 struct spoolss_4b r;
11534 NTSTATUS status;
11535
11536 /* In parameters */
11537
11538 status = cli->dispatch(cli,
11539 mem_ctx,
11540 &ndr_table_spoolss,
11541 NDR_SPOOLSS_4B,
11542 &r);
11543
11544 if (!NT_STATUS_IS_OK(status)) {
11545 return status;
11546 }
11547
11548 if (NT_STATUS_IS_ERR(status)) {
11549 return status;
11550 }
11551
11552 /* Return variables */
11553
11554 /* Return result */
11555 if (werror) {
11556 *werror = r.out.result;
11557 }
11558
11559 return werror_to_ntstatus(r.out.result);
11560 }
11561
11562 struct rpccli_spoolss_4c_state {
11563 struct spoolss_4c orig;
11564 struct spoolss_4c tmp;
11565 TALLOC_CTX *out_mem_ctx;
11566 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11567 };
11568
11569 static void rpccli_spoolss_4c_done(struct tevent_req *subreq);
11570
11571 struct tevent_req *rpccli_spoolss_4c_send(TALLOC_CTX *mem_ctx,
11572 struct tevent_context *ev,
11573 struct rpc_pipe_client *cli)
11574 {
11575 struct tevent_req *req;
11576 struct rpccli_spoolss_4c_state *state;
11577 struct tevent_req *subreq;
11578
11579 req = tevent_req_create(mem_ctx, &state,
11580 struct rpccli_spoolss_4c_state);
11581 if (req == NULL) {
11582 return NULL;
11583 }
11584 state->out_mem_ctx = NULL;
11585 state->dispatch_recv = cli->dispatch_recv;
11586
11587 /* In parameters */
11588
11589 /* Out parameters */
11590
11591 /* Result */
11592 ZERO_STRUCT(state->orig.out.result);
11593
11594 /* make a temporary copy, that we pass to the dispatch function */
11595 state->tmp = state->orig;
11596
11597 subreq = cli->dispatch_send(state, ev, cli,
11598 &ndr_table_spoolss,
11599 NDR_SPOOLSS_4C,
11600 &state->tmp);
11601 if (tevent_req_nomem(subreq, req)) {
11602 return tevent_req_post(req, ev);
11603 }
11604 tevent_req_set_callback(subreq, rpccli_spoolss_4c_done, req);
11605 return req;
11606 }
11607
11608 static void rpccli_spoolss_4c_done(struct tevent_req *subreq)
11609 {
11610 struct tevent_req *req = tevent_req_callback_data(
11611 subreq, struct tevent_req);
11612 struct rpccli_spoolss_4c_state *state = tevent_req_data(
11613 req, struct rpccli_spoolss_4c_state);
11614 NTSTATUS status;
11615 TALLOC_CTX *mem_ctx;
11616
11617 if (state->out_mem_ctx) {
11618 mem_ctx = state->out_mem_ctx;
11619 } else {
11620 mem_ctx = state;
11621 }
11622
11623 status = state->dispatch_recv(subreq, mem_ctx);
11624 TALLOC_FREE(subreq);
11625 if (!NT_STATUS_IS_OK(status)) {
11626 tevent_req_nterror(req, status);
11627 return;
11628 }
11629
11630 /* Copy out parameters */
11631
11632 /* Copy result */
11633 state->orig.out.result = state->tmp.out.result;
11634
11635 /* Reset temporary structure */
11636 ZERO_STRUCT(state->tmp);
11637
11638 tevent_req_done(req);
11639 }
11640
11641 NTSTATUS rpccli_spoolss_4c_recv(struct tevent_req *req,
11642 TALLOC_CTX *mem_ctx,
11643 WERROR *result)
11644 {
11645 struct rpccli_spoolss_4c_state *state = tevent_req_data(
11646 req, struct rpccli_spoolss_4c_state);
11647 NTSTATUS status;
11648
11649 if (tevent_req_is_nterror(req, &status)) {
11650 tevent_req_received(req);
11651 return status;
11652 }
11653
11654 /* Steal possbile out parameters to the callers context */
11655 talloc_steal(mem_ctx, state->out_mem_ctx);
11656
11657 /* Return result */
11658 *result = state->orig.out.result;
11659
11660 tevent_req_received(req);
11661 return NT_STATUS_OK;
11662 }
11663
11664 NTSTATUS rpccli_spoolss_4c(struct rpc_pipe_client *cli,
11665 TALLOC_CTX *mem_ctx,
11666 WERROR *werror)
11667 {
11668 struct spoolss_4c r;
11669 NTSTATUS status;
11670
11671 /* In parameters */
11672
11673 status = cli->dispatch(cli,
11674 mem_ctx,
11675 &ndr_table_spoolss,
11676 NDR_SPOOLSS_4C,
11677 &r);
11678
11679 if (!NT_STATUS_IS_OK(status)) {
11680 return status;
11681 }
11682
11683 if (NT_STATUS_IS_ERR(status)) {
11684 return status;
11685 }
11686
11687 /* Return variables */
11688
11689 /* Return result */
11690 if (werror) {
11691 *werror = r.out.result;
11692 }
11693
11694 return werror_to_ntstatus(r.out.result);
11695 }
11696
11697 struct rpccli_spoolss_SetPrinterDataEx_state {
11698 struct spoolss_SetPrinterDataEx orig;
11699 struct spoolss_SetPrinterDataEx tmp;
11700 TALLOC_CTX *out_mem_ctx;
11701 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11702 };
11703
11704 static void rpccli_spoolss_SetPrinterDataEx_done(struct tevent_req *subreq);
11705
11706 struct tevent_req *rpccli_spoolss_SetPrinterDataEx_send(TALLOC_CTX *mem_ctx,
11707 struct tevent_context *ev,
11708 struct rpc_pipe_client *cli,
11709 struct policy_handle *_handle /* [in] [ref] */,
11710 const char *_key_name /* [in] [charset(UTF16)] */,
11711 const char *_value_name /* [in] [charset(UTF16)] */,
11712 enum winreg_Type _type /* [in] */,
11713 uint8_t *_buffer /* [in] [ref,size_is(offered)] */,
11714 uint32_t _offered /* [in] */)
11715 {
11716 struct tevent_req *req;
11717 struct rpccli_spoolss_SetPrinterDataEx_state *state;
11718 struct tevent_req *subreq;
11719
11720 req = tevent_req_create(mem_ctx, &state,
11721 struct rpccli_spoolss_SetPrinterDataEx_state);
11722 if (req == NULL) {
11723 return NULL;
11724 }
11725 state->out_mem_ctx = NULL;
11726 state->dispatch_recv = cli->dispatch_recv;
11727
11728 /* In parameters */
11729 state->orig.in.handle = _handle;
11730 state->orig.in.key_name = _key_name;
11731 state->orig.in.value_name = _value_name;
11732 state->orig.in.type = _type;
11733 state->orig.in.buffer = _buffer;
11734 state->orig.in.offered = _offered;
11735
11736 /* Out parameters */
11737
11738 /* Result */
11739 ZERO_STRUCT(state->orig.out.result);
11740
11741 /* make a temporary copy, that we pass to the dispatch function */
11742 state->tmp = state->orig;
11743
11744 subreq = cli->dispatch_send(state, ev, cli,
11745 &ndr_table_spoolss,
11746 NDR_SPOOLSS_SETPRINTERDATAEX,
11747 &state->tmp);
11748 if (tevent_req_nomem(subreq, req)) {
11749 return tevent_req_post(req, ev);
11750 }
11751 tevent_req_set_callback(subreq, rpccli_spoolss_SetPrinterDataEx_done, req);
11752 return req;
11753 }
11754
11755 static void rpccli_spoolss_SetPrinterDataEx_done(struct tevent_req *subreq)
11756 {
11757 struct tevent_req *req = tevent_req_callback_data(
11758 subreq, struct tevent_req);
11759 struct rpccli_spoolss_SetPrinterDataEx_state *state = tevent_req_data(
11760 req, struct rpccli_spoolss_SetPrinterDataEx_state);
11761 NTSTATUS status;
11762 TALLOC_CTX *mem_ctx;
11763
11764 if (state->out_mem_ctx) {
11765 mem_ctx = state->out_mem_ctx;
11766 } else {
11767 mem_ctx = state;
11768 }
11769
11770 status = state->dispatch_recv(subreq, mem_ctx);
11771 TALLOC_FREE(subreq);
11772 if (!NT_STATUS_IS_OK(status)) {
11773 tevent_req_nterror(req, status);
11774 return;
11775 }
11776
11777 /* Copy out parameters */
11778
11779 /* Copy result */
11780 state->orig.out.result = state->tmp.out.result;
11781
11782 /* Reset temporary structure */
11783 ZERO_STRUCT(state->tmp);
11784
11785 tevent_req_done(req);
11786 }
11787
11788 NTSTATUS rpccli_spoolss_SetPrinterDataEx_recv(struct tevent_req *req,
11789 TALLOC_CTX *mem_ctx,
11790 WERROR *result)
11791 {
11792 struct rpccli_spoolss_SetPrinterDataEx_state *state = tevent_req_data(
11793 req, struct rpccli_spoolss_SetPrinterDataEx_state);
11794 NTSTATUS status;
11795
11796 if (tevent_req_is_nterror(req, &status)) {
11797 tevent_req_received(req);
11798 return status;
11799 }
11800
11801 /* Steal possbile out parameters to the callers context */
11802 talloc_steal(mem_ctx, state->out_mem_ctx);
11803
11804 /* Return result */
11805 *result = state->orig.out.result;
11806
11807 tevent_req_received(req);
11808 return NT_STATUS_OK;
11809 }
11810
11811 NTSTATUS rpccli_spoolss_SetPrinterDataEx(struct rpc_pipe_client *cli,
11812 TALLOC_CTX *mem_ctx,
11813 struct policy_handle *handle /* [in] [ref] */,
11814 const char *key_name /* [in] [charset(UTF16)] */,
11815 const char *value_name /* [in] [charset(UTF16)] */,
11816 enum winreg_Type type /* [in] */,
11817 uint8_t *buffer /* [in] [ref,size_is(offered)] */,
11818 uint32_t offered /* [in] */,
11819 WERROR *werror)
11820 {
11821 struct spoolss_SetPrinterDataEx r;
11822 NTSTATUS status;
11823
11824 /* In parameters */
11825 r.in.handle = handle;
11826 r.in.key_name = key_name;
11827 r.in.value_name = value_name;
11828 r.in.type = type;
11829 r.in.buffer = buffer;
11830 r.in.offered = offered;
11831
11832 status = cli->dispatch(cli,
11833 mem_ctx,
11834 &ndr_table_spoolss,
11835 NDR_SPOOLSS_SETPRINTERDATAEX,
11836 &r);
11837
11838 if (!NT_STATUS_IS_OK(status)) {
11839 return status;
11840 }
11841
11842 if (NT_STATUS_IS_ERR(status)) {
11843 return status;
11844 }
11845
11846 /* Return variables */
11847
11848 /* Return result */
11849 if (werror) {
11850 *werror = r.out.result;
11851 }
11852
11853 return werror_to_ntstatus(r.out.result);
11854 }
11855
11856 struct rpccli_spoolss_GetPrinterDataEx_state {
11857 struct spoolss_GetPrinterDataEx orig;
11858 struct spoolss_GetPrinterDataEx tmp;
11859 TALLOC_CTX *out_mem_ctx;
11860 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11861 };
11862
11863 static void rpccli_spoolss_GetPrinterDataEx_done(struct tevent_req *subreq);
11864
11865 struct tevent_req *rpccli_spoolss_GetPrinterDataEx_send(TALLOC_CTX *mem_ctx,
11866 struct tevent_context *ev,
11867 struct rpc_pipe_client *cli,
11868 struct policy_handle *_handle /* [in] [ref] */,
11869 const char *_key_name /* [in] [charset(UTF16)] */,
11870 const char *_value_name /* [in] [charset(UTF16)] */,
11871 enum winreg_Type *_type /* [out] [ref] */,
11872 uint8_t *_buffer /* [out] [ref,size_is(offered)] */,
11873 uint32_t _offered /* [in] */,
11874 uint32_t *_needed /* [out] [ref] */)
11875 {
11876 struct tevent_req *req;
11877 struct rpccli_spoolss_GetPrinterDataEx_state *state;
11878 struct tevent_req *subreq;
11879
11880 req = tevent_req_create(mem_ctx, &state,
11881 struct rpccli_spoolss_GetPrinterDataEx_state);
11882 if (req == NULL) {
11883 return NULL;
11884 }
11885 state->out_mem_ctx = NULL;
11886 state->dispatch_recv = cli->dispatch_recv;
11887
11888 /* In parameters */
11889 state->orig.in.handle = _handle;
11890 state->orig.in.key_name = _key_name;
11891 state->orig.in.value_name = _value_name;
11892 state->orig.in.offered = _offered;
11893
11894 /* Out parameters */
11895 state->orig.out.type = _type;
11896 state->orig.out.buffer = _buffer;
11897 state->orig.out.needed = _needed;
11898
11899 /* Result */
11900 ZERO_STRUCT(state->orig.out.result);
11901
11902 state->out_mem_ctx = talloc_named_const(state, 0,
11903 "rpccli_spoolss_GetPrinterDataEx_out_memory");
11904 if (tevent_req_nomem(state->out_mem_ctx, req)) {
11905 return tevent_req_post(req, ev);
11906 }
11907
11908 /* make a temporary copy, that we pass to the dispatch function */
11909 state->tmp = state->orig;
11910
11911 subreq = cli->dispatch_send(state, ev, cli,
11912 &ndr_table_spoolss,
11913 NDR_SPOOLSS_GETPRINTERDATAEX,
11914 &state->tmp);
11915 if (tevent_req_nomem(subreq, req)) {
11916 return tevent_req_post(req, ev);
11917 }
11918 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDataEx_done, req);
11919 return req;
11920 }
11921
11922 static void rpccli_spoolss_GetPrinterDataEx_done(struct tevent_req *subreq)
11923 {
11924 struct tevent_req *req = tevent_req_callback_data(
11925 subreq, struct tevent_req);
11926 struct rpccli_spoolss_GetPrinterDataEx_state *state = tevent_req_data(
11927 req, struct rpccli_spoolss_GetPrinterDataEx_state);
11928 NTSTATUS status;
11929 TALLOC_CTX *mem_ctx;
11930
11931 if (state->out_mem_ctx) {
11932 mem_ctx = state->out_mem_ctx;
11933 } else {
11934 mem_ctx = state;
11935 }
11936
11937 status = state->dispatch_recv(subreq, mem_ctx);
11938 TALLOC_FREE(subreq);
11939 if (!NT_STATUS_IS_OK(status)) {
11940 tevent_req_nterror(req, status);
11941 return;
11942 }
11943
11944 /* Copy out parameters */
11945 *state->orig.out.type = *state->tmp.out.type;
11946 memcpy(state->orig.out.buffer, state->tmp.out.buffer, (state->tmp.in.offered) * sizeof(*state->orig.out.buffer));
11947 *state->orig.out.needed = *state->tmp.out.needed;
11948
11949 /* Copy result */
11950 state->orig.out.result = state->tmp.out.result;
11951
11952 /* Reset temporary structure */
11953 ZERO_STRUCT(state->tmp);
11954
11955 tevent_req_done(req);
11956 }
11957
11958 NTSTATUS rpccli_spoolss_GetPrinterDataEx_recv(struct tevent_req *req,
11959 TALLOC_CTX *mem_ctx,
11960 WERROR *result)
11961 {
11962 struct rpccli_spoolss_GetPrinterDataEx_state *state = tevent_req_data(
11963 req, struct rpccli_spoolss_GetPrinterDataEx_state);
11964 NTSTATUS status;
11965
11966 if (tevent_req_is_nterror(req, &status)) {
11967 tevent_req_received(req);
11968 return status;
11969 }
11970
11971 /* Steal possbile out parameters to the callers context */
11972 talloc_steal(mem_ctx, state->out_mem_ctx);
11973
11974 /* Return result */
11975 *result = state->orig.out.result;
11976
11977 tevent_req_received(req);
11978 return NT_STATUS_OK;
11979 }
11980
11981 NTSTATUS rpccli_spoolss_GetPrinterDataEx(struct rpc_pipe_client *cli,
11982 TALLOC_CTX *mem_ctx,
11983 struct policy_handle *handle /* [in] [ref] */,
11984 const char *key_name /* [in] [charset(UTF16)] */,
11985 const char *value_name /* [in] [charset(UTF16)] */,
11986 enum winreg_Type *type /* [out] [ref] */,
11987 uint8_t *buffer /* [out] [ref,size_is(offered)] */,
11988 uint32_t offered /* [in] */,
11989 uint32_t *needed /* [out] [ref] */,
11990 WERROR *werror)
11991 {
11992 struct spoolss_GetPrinterDataEx r;
11993 NTSTATUS status;
11994
11995 /* In parameters */
11996 r.in.handle = handle;
11997 r.in.key_name = key_name;
11998 r.in.value_name = value_name;
11999 r.in.offered = offered;
12000
12001 status = cli->dispatch(cli,
12002 mem_ctx,
12003 &ndr_table_spoolss,
12004 NDR_SPOOLSS_GETPRINTERDATAEX,
12005 &r);
12006
12007 if (!NT_STATUS_IS_OK(status)) {
12008 return status;
12009 }
12010
12011 if (NT_STATUS_IS_ERR(status)) {
12012 return status;
12013 }
12014
12015 /* Return variables */
12016 *type = *r.out.type;
12017 memcpy(buffer, r.out.buffer, (r.in.offered) * sizeof(*buffer));
12018 *needed = *r.out.needed;
12019
12020 /* Return result */
12021 if (werror) {
12022 *werror = r.out.result;
12023 }
12024
12025 return werror_to_ntstatus(r.out.result);
12026 }
12027
12028 struct rpccli_spoolss_EnumPrinterDataEx_state {
12029 struct spoolss_EnumPrinterDataEx orig;
12030 struct spoolss_EnumPrinterDataEx tmp;
12031 TALLOC_CTX *out_mem_ctx;
12032 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12033 };
12034
12035 static void rpccli_spoolss_EnumPrinterDataEx_done(struct tevent_req *subreq);
12036
12037 struct tevent_req *rpccli_spoolss_EnumPrinterDataEx_send(TALLOC_CTX *mem_ctx,
12038 struct tevent_context *ev,
12039 struct rpc_pipe_client *cli,
12040 struct policy_handle *_handle /* [in] [ref] */,
12041 const char *_key_name /* [in] [charset(UTF16)] */,
12042 uint32_t _offered /* [in] */,
12043 uint32_t *_count /* [out] [ref] */,
12044 struct spoolss_PrinterEnumValues **_info /* [out] [ref,size_is(,*count)] */,
12045 uint32_t *_needed /* [out] [ref] */)
12046 {
12047 struct tevent_req *req;
12048 struct rpccli_spoolss_EnumPrinterDataEx_state *state;
12049 struct tevent_req *subreq;
12050
12051 req = tevent_req_create(mem_ctx, &state,
12052 struct rpccli_spoolss_EnumPrinterDataEx_state);
12053 if (req == NULL) {
12054 return NULL;
12055 }
12056 state->out_mem_ctx = NULL;
12057 state->dispatch_recv = cli->dispatch_recv;
12058
12059 /* In parameters */
12060 state->orig.in.handle = _handle;
12061 state->orig.in.key_name = _key_name;
12062 state->orig.in.offered = _offered;
12063
12064 /* Out parameters */
12065 state->orig.out.count = _count;
12066 state->orig.out.info = _info;
12067 state->orig.out.needed = _needed;
12068
12069 /* Result */
12070 ZERO_STRUCT(state->orig.out.result);
12071
12072 state->out_mem_ctx = talloc_named_const(state, 0,
12073 "rpccli_spoolss_EnumPrinterDataEx_out_memory");
12074 if (tevent_req_nomem(state->out_mem_ctx, req)) {
12075 return tevent_req_post(req, ev);
12076 }
12077
12078 /* make a temporary copy, that we pass to the dispatch function */
12079 state->tmp = state->orig;
12080
12081 subreq = cli->dispatch_send(state, ev, cli,
12082 &ndr_table_spoolss,
12083 NDR_SPOOLSS_ENUMPRINTERDATAEX,
12084 &state->tmp);
12085 if (tevent_req_nomem(subreq, req)) {
12086 return tevent_req_post(req, ev);
12087 }
12088 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinterDataEx_done, req);
12089 return req;
12090 }
12091
12092 static void rpccli_spoolss_EnumPrinterDataEx_done(struct tevent_req *subreq)
12093 {
12094 struct tevent_req *req = tevent_req_callback_data(
12095 subreq, struct tevent_req);
12096 struct rpccli_spoolss_EnumPrinterDataEx_state *state = tevent_req_data(
12097 req, struct rpccli_spoolss_EnumPrinterDataEx_state);
12098 NTSTATUS status;
12099 TALLOC_CTX *mem_ctx;
12100
12101 if (state->out_mem_ctx) {
12102 mem_ctx = state->out_mem_ctx;
12103 } else {
12104 mem_ctx = state;
12105 }
12106
12107 status = state->dispatch_recv(subreq, mem_ctx);
12108 TALLOC_FREE(subreq);
12109 if (!NT_STATUS_IS_OK(status)) {
12110 tevent_req_nterror(req, status);
12111 return;
12112 }
12113
12114 /* Copy out parameters */
12115 *state->orig.out.count = *state->tmp.out.count;
12116 *state->orig.out.info = *state->tmp.out.info;
12117 *state->orig.out.needed = *state->tmp.out.needed;
12118
12119 /* Copy result */
12120 state->orig.out.result = state->tmp.out.result;
12121
12122 /* Reset temporary structure */
12123 ZERO_STRUCT(state->tmp);
12124
12125 tevent_req_done(req);
12126 }
12127
12128 NTSTATUS rpccli_spoolss_EnumPrinterDataEx_recv(struct tevent_req *req,
12129 TALLOC_CTX *mem_ctx,
12130 WERROR *result)
12131 {
12132 struct rpccli_spoolss_EnumPrinterDataEx_state *state = tevent_req_data(
12133 req, struct rpccli_spoolss_EnumPrinterDataEx_state);
12134 NTSTATUS status;
12135
12136 if (tevent_req_is_nterror(req, &status)) {
12137 tevent_req_received(req);
12138 return status;
12139 }
12140
12141 /* Steal possbile out parameters to the callers context */
12142 talloc_steal(mem_ctx, state->out_mem_ctx);
12143
12144 /* Return result */
12145 *result = state->orig.out.result;
12146
12147 tevent_req_received(req);
12148 return NT_STATUS_OK;
12149 }
12150
12151 NTSTATUS rpccli_spoolss_EnumPrinterDataEx(struct rpc_pipe_client *cli,
12152 TALLOC_CTX *mem_ctx,
12153 struct policy_handle *handle /* [in] [ref] */,
12154 const char *key_name /* [in] [charset(UTF16)] */,
12155 uint32_t offered /* [in] */,
12156 uint32_t *count /* [out] [ref] */,
12157 struct spoolss_PrinterEnumValues **info /* [out] [ref,size_is(,*count)] */,
12158 uint32_t *needed /* [out] [ref] */,
12159 WERROR *werror)
12160 {
12161 struct spoolss_EnumPrinterDataEx r;
12162 NTSTATUS status;
12163
12164 /* In parameters */
12165 r.in.handle = handle;
12166 r.in.key_name = key_name;
12167 r.in.offered = offered;
12168
12169 status = cli->dispatch(cli,
12170 mem_ctx,
12171 &ndr_table_spoolss,
12172 NDR_SPOOLSS_ENUMPRINTERDATAEX,
12173 &r);
12174
12175 if (!NT_STATUS_IS_OK(status)) {
12176 return status;
12177 }
12178
12179 if (NT_STATUS_IS_ERR(status)) {
12180 return status;
12181 }
12182
12183 /* Return variables */
12184 *count = *r.out.count;
12185 *info = *r.out.info;
12186 *needed = *r.out.needed;
12187
12188 /* Return result */
12189 if (werror) {
12190 *werror = r.out.result;
12191 }
12192
12193 return werror_to_ntstatus(r.out.result);
12194 }
12195
12196 struct rpccli_spoolss_EnumPrinterKey_state {
12197 struct spoolss_EnumPrinterKey orig;
12198 struct spoolss_EnumPrinterKey tmp;
12199 TALLOC_CTX *out_mem_ctx;
12200 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12201 };
12202
12203 static void rpccli_spoolss_EnumPrinterKey_done(struct tevent_req *subreq);
12204
12205 struct tevent_req *rpccli_spoolss_EnumPrinterKey_send(TALLOC_CTX *mem_ctx,
12206 struct tevent_context *ev,
12207 struct rpc_pipe_client *cli,
12208 struct policy_handle *_handle /* [in] [ref] */,
12209 const char *_key_name /* [in] [charset(UTF16)] */,
12210 uint16_t *_key_buffer /* [out] [ref,size_is(offered/2)] */,
12211 uint32_t _offered /* [in] */,
12212 uint32_t *_needed /* [out] [ref] */)
12213 {
12214 struct tevent_req *req;
12215 struct rpccli_spoolss_EnumPrinterKey_state *state;
12216 struct tevent_req *subreq;
12217
12218 req = tevent_req_create(mem_ctx, &state,
12219 struct rpccli_spoolss_EnumPrinterKey_state);
12220 if (req == NULL) {
12221 return NULL;
12222 }
12223 state->out_mem_ctx = NULL;
12224 state->dispatch_recv = cli->dispatch_recv;
12225
12226 /* In parameters */
12227 state->orig.in.handle = _handle;
12228 state->orig.in.key_name = _key_name;
12229 state->orig.in.offered = _offered;
12230
12231 /* Out parameters */
12232 state->orig.out.key_buffer = _key_buffer;
12233 state->orig.out.needed = _needed;
12234
12235 /* Result */
12236 ZERO_STRUCT(state->orig.out.result);
12237
12238 state->out_mem_ctx = talloc_named_const(state, 0,
12239 "rpccli_spoolss_EnumPrinterKey_out_memory");
12240 if (tevent_req_nomem(state->out_mem_ctx, req)) {
12241 return tevent_req_post(req, ev);
12242 }
12243
12244 /* make a temporary copy, that we pass to the dispatch function */
12245 state->tmp = state->orig;
12246
12247 subreq = cli->dispatch_send(state, ev, cli,
12248 &ndr_table_spoolss,
12249 NDR_SPOOLSS_ENUMPRINTERKEY,
12250 &state->tmp);
12251 if (tevent_req_nomem(subreq, req)) {
12252 return tevent_req_post(req, ev);
12253 }
12254 tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinterKey_done, req);
12255 return req;
12256 }
12257
12258 static void rpccli_spoolss_EnumPrinterKey_done(struct tevent_req *subreq)
12259 {
12260 struct tevent_req *req = tevent_req_callback_data(
12261 subreq, struct tevent_req);
12262 struct rpccli_spoolss_EnumPrinterKey_state *state = tevent_req_data(
12263 req, struct rpccli_spoolss_EnumPrinterKey_state);
12264 NTSTATUS status;
12265 TALLOC_CTX *mem_ctx;
12266
12267 if (state->out_mem_ctx) {
12268 mem_ctx = state->out_mem_ctx;
12269 } else {
12270 mem_ctx = state;
12271 }
12272
12273 status = state->dispatch_recv(subreq, mem_ctx);
12274 TALLOC_FREE(subreq);
12275 if (!NT_STATUS_IS_OK(status)) {
12276 tevent_req_nterror(req, status);
12277 return;
12278 }
12279
12280 /* Copy out parameters */
12281 memcpy(state->orig.out.key_buffer, state->tmp.out.key_buffer, (state->tmp.in.offered / 2) * sizeof(*state->orig.out.key_buffer));
12282 *state->orig.out.needed = *state->tmp.out.needed;
12283
12284 /* Copy result */
12285 state->orig.out.result = state->tmp.out.result;
12286
12287 /* Reset temporary structure */
12288 ZERO_STRUCT(state->tmp);
12289
12290 tevent_req_done(req);
12291 }
12292
12293 NTSTATUS rpccli_spoolss_EnumPrinterKey_recv(struct tevent_req *req,
12294 TALLOC_CTX *mem_ctx,
12295 WERROR *result)
12296 {
12297 struct rpccli_spoolss_EnumPrinterKey_state *state = tevent_req_data(
12298 req, struct rpccli_spoolss_EnumPrinterKey_state);
12299 NTSTATUS status;
12300
12301 if (tevent_req_is_nterror(req, &status)) {
12302 tevent_req_received(req);
12303 return status;
12304 }
12305
12306 /* Steal possbile out parameters to the callers context */
12307 talloc_steal(mem_ctx, state->out_mem_ctx);
12308
12309 /* Return result */
12310 *result = state->orig.out.result;
12311
12312 tevent_req_received(req);
12313 return NT_STATUS_OK;
12314 }
12315
12316 NTSTATUS rpccli_spoolss_EnumPrinterKey(struct rpc_pipe_client *cli,
12317 TALLOC_CTX *mem_ctx,
12318 struct policy_handle *handle /* [in] [ref] */,
12319 const char *key_name /* [in] [charset(UTF16)] */,
12320 uint16_t *key_buffer /* [out] [ref,size_is(offered/2)] */,
12321 uint32_t offered /* [in] */,
12322 uint32_t *needed /* [out] [ref] */,
12323 WERROR *werror)
12324 {
12325 struct spoolss_EnumPrinterKey r;
12326 NTSTATUS status;
12327
12328 /* In parameters */
12329 r.in.handle = handle;
12330 r.in.key_name = key_name;
12331 r.in.offered = offered;
12332
12333 status = cli->dispatch(cli,
12334 mem_ctx,
12335 &ndr_table_spoolss,
12336 NDR_SPOOLSS_ENUMPRINTERKEY,
12337 &r);
12338
12339 if (!NT_STATUS_IS_OK(status)) {
12340 return status;
12341 }
12342
12343 if (NT_STATUS_IS_ERR(status)) {
12344 return status;
12345 }
12346
12347 /* Return variables */
12348 memcpy(key_buffer, r.out.key_buffer, (r.in.offered / 2) * sizeof(*key_buffer));
12349 *needed = *r.out.needed;
12350
12351 /* Return result */
12352 if (werror) {
12353 *werror = r.out.result;
12354 }
12355
12356 return werror_to_ntstatus(r.out.result);
12357 }
12358
12359 struct rpccli_spoolss_DeletePrinterDataEx_state {
12360 struct spoolss_DeletePrinterDataEx orig;
12361 struct spoolss_DeletePrinterDataEx tmp;
12362 TALLOC_CTX *out_mem_ctx;
12363 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12364 };
12365
12366 static void rpccli_spoolss_DeletePrinterDataEx_done(struct tevent_req *subreq);
12367
12368 struct tevent_req *rpccli_spoolss_DeletePrinterDataEx_send(TALLOC_CTX *mem_ctx,
12369 struct tevent_context *ev,
12370 struct rpc_pipe_client *cli,
12371 struct policy_handle *_handle /* [in] [ref] */,
12372 const char *_key_name /* [in] [charset(UTF16)] */,
12373 const char *_value_name /* [in] [charset(UTF16)] */)
12374 {
12375 struct tevent_req *req;
12376 struct rpccli_spoolss_DeletePrinterDataEx_state *state;
12377 struct tevent_req *subreq;
12378
12379 req = tevent_req_create(mem_ctx, &state,
12380 struct rpccli_spoolss_DeletePrinterDataEx_state);
12381 if (req == NULL) {
12382 return NULL;
12383 }
12384 state->out_mem_ctx = NULL;
12385 state->dispatch_recv = cli->dispatch_recv;
12386
12387 /* In parameters */
12388 state->orig.in.handle = _handle;
12389 state->orig.in.key_name = _key_name;
12390 state->orig.in.value_name = _value_name;
12391
12392 /* Out parameters */
12393
12394 /* Result */
12395 ZERO_STRUCT(state->orig.out.result);
12396
12397 /* make a temporary copy, that we pass to the dispatch function */
12398 state->tmp = state->orig;
12399
12400 subreq = cli->dispatch_send(state, ev, cli,
12401 &ndr_table_spoolss,
12402 NDR_SPOOLSS_DELETEPRINTERDATAEX,
12403 &state->tmp);
12404 if (tevent_req_nomem(subreq, req)) {
12405 return tevent_req_post(req, ev);
12406 }
12407 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterDataEx_done, req);
12408 return req;
12409 }
12410
12411 static void rpccli_spoolss_DeletePrinterDataEx_done(struct tevent_req *subreq)
12412 {
12413 struct tevent_req *req = tevent_req_callback_data(
12414 subreq, struct tevent_req);
12415 struct rpccli_spoolss_DeletePrinterDataEx_state *state = tevent_req_data(
12416 req, struct rpccli_spoolss_DeletePrinterDataEx_state);
12417 NTSTATUS status;
12418 TALLOC_CTX *mem_ctx;
12419
12420 if (state->out_mem_ctx) {
12421 mem_ctx = state->out_mem_ctx;
12422 } else {
12423 mem_ctx = state;
12424 }
12425
12426 status = state->dispatch_recv(subreq, mem_ctx);
12427 TALLOC_FREE(subreq);
12428 if (!NT_STATUS_IS_OK(status)) {
12429 tevent_req_nterror(req, status);
12430 return;
12431 }
12432
12433 /* Copy out parameters */
12434
12435 /* Copy result */
12436 state->orig.out.result = state->tmp.out.result;
12437
12438 /* Reset temporary structure */
12439 ZERO_STRUCT(state->tmp);
12440
12441 tevent_req_done(req);
12442 }
12443
12444 NTSTATUS rpccli_spoolss_DeletePrinterDataEx_recv(struct tevent_req *req,
12445 TALLOC_CTX *mem_ctx,
12446 WERROR *result)
12447 {
12448 struct rpccli_spoolss_DeletePrinterDataEx_state *state = tevent_req_data(
12449 req, struct rpccli_spoolss_DeletePrinterDataEx_state);
12450 NTSTATUS status;
12451
12452 if (tevent_req_is_nterror(req, &status)) {
12453 tevent_req_received(req);
12454 return status;
12455 }
12456
12457 /* Steal possbile out parameters to the callers context */
12458 talloc_steal(mem_ctx, state->out_mem_ctx);
12459
12460 /* Return result */
12461 *result = state->orig.out.result;
12462
12463 tevent_req_received(req);
12464 return NT_STATUS_OK;
12465 }
12466
12467 NTSTATUS rpccli_spoolss_DeletePrinterDataEx(struct rpc_pipe_client *cli,
12468 TALLOC_CTX *mem_ctx,
12469 struct policy_handle *handle /* [in] [ref] */,
12470 const char *key_name /* [in] [charset(UTF16)] */,
12471 const char *value_name /* [in] [charset(UTF16)] */,
12472 WERROR *werror)
12473 {
12474 struct spoolss_DeletePrinterDataEx r;
12475 NTSTATUS status;
12476
12477 /* In parameters */
12478 r.in.handle = handle;
12479 r.in.key_name = key_name;
12480 r.in.value_name = value_name;
12481
12482 status = cli->dispatch(cli,
12483 mem_ctx,
12484 &ndr_table_spoolss,
12485 NDR_SPOOLSS_DELETEPRINTERDATAEX,
12486 &r);
12487
12488 if (!NT_STATUS_IS_OK(status)) {
12489 return status;
12490 }
12491
12492 if (NT_STATUS_IS_ERR(status)) {
12493 return status;
12494 }
12495
12496 /* Return variables */
12497
12498 /* Return result */
12499 if (werror) {
12500 *werror = r.out.result;
12501 }
12502
12503 return werror_to_ntstatus(r.out.result);
12504 }
12505
12506 struct rpccli_spoolss_DeletePrinterKey_state {
12507 struct spoolss_DeletePrinterKey orig;
12508 struct spoolss_DeletePrinterKey tmp;
12509 TALLOC_CTX *out_mem_ctx;
12510 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12511 };
12512
12513 static void rpccli_spoolss_DeletePrinterKey_done(struct tevent_req *subreq);
12514
12515 struct tevent_req *rpccli_spoolss_DeletePrinterKey_send(TALLOC_CTX *mem_ctx,
12516 struct tevent_context *ev,
12517 struct rpc_pipe_client *cli,
12518 struct policy_handle *_handle /* [in] [ref] */,
12519 const char *_key_name /* [in] [charset(UTF16)] */)
12520 {
12521 struct tevent_req *req;
12522 struct rpccli_spoolss_DeletePrinterKey_state *state;
12523 struct tevent_req *subreq;
12524
12525 req = tevent_req_create(mem_ctx, &state,
12526 struct rpccli_spoolss_DeletePrinterKey_state);
12527 if (req == NULL) {
12528 return NULL;
12529 }
12530 state->out_mem_ctx = NULL;
12531 state->dispatch_recv = cli->dispatch_recv;
12532
12533 /* In parameters */
12534 state->orig.in.handle = _handle;
12535 state->orig.in.key_name = _key_name;
12536
12537 /* Out parameters */
12538
12539 /* Result */
12540 ZERO_STRUCT(state->orig.out.result);
12541
12542 /* make a temporary copy, that we pass to the dispatch function */
12543 state->tmp = state->orig;
12544
12545 subreq = cli->dispatch_send(state, ev, cli,
12546 &ndr_table_spoolss,
12547 NDR_SPOOLSS_DELETEPRINTERKEY,
12548 &state->tmp);
12549 if (tevent_req_nomem(subreq, req)) {
12550 return tevent_req_post(req, ev);
12551 }
12552 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterKey_done, req);
12553 return req;
12554 }
12555
12556 static void rpccli_spoolss_DeletePrinterKey_done(struct tevent_req *subreq)
12557 {
12558 struct tevent_req *req = tevent_req_callback_data(
12559 subreq, struct tevent_req);
12560 struct rpccli_spoolss_DeletePrinterKey_state *state = tevent_req_data(
12561 req, struct rpccli_spoolss_DeletePrinterKey_state);
12562 NTSTATUS status;
12563 TALLOC_CTX *mem_ctx;
12564
12565 if (state->out_mem_ctx) {
12566 mem_ctx = state->out_mem_ctx;
12567 } else {
12568 mem_ctx = state;
12569 }
12570
12571 status = state->dispatch_recv(subreq, mem_ctx);
12572 TALLOC_FREE(subreq);
12573 if (!NT_STATUS_IS_OK(status)) {
12574 tevent_req_nterror(req, status);
12575 return;
12576 }
12577
12578 /* Copy out parameters */
12579
12580 /* Copy result */
12581 state->orig.out.result = state->tmp.out.result;
12582
12583 /* Reset temporary structure */
12584 ZERO_STRUCT(state->tmp);
12585
12586 tevent_req_done(req);
12587 }
12588
12589 NTSTATUS rpccli_spoolss_DeletePrinterKey_recv(struct tevent_req *req,
12590 TALLOC_CTX *mem_ctx,
12591 WERROR *result)
12592 {
12593 struct rpccli_spoolss_DeletePrinterKey_state *state = tevent_req_data(
12594 req, struct rpccli_spoolss_DeletePrinterKey_state);
12595 NTSTATUS status;
12596
12597 if (tevent_req_is_nterror(req, &status)) {
12598 tevent_req_received(req);
12599 return status;
12600 }
12601
12602 /* Steal possbile out parameters to the callers context */
12603 talloc_steal(mem_ctx, state->out_mem_ctx);
12604
12605 /* Return result */
12606 *result = state->orig.out.result;
12607
12608 tevent_req_received(req);
12609 return NT_STATUS_OK;
12610 }
12611
12612 NTSTATUS rpccli_spoolss_DeletePrinterKey(struct rpc_pipe_client *cli,
12613 TALLOC_CTX *mem_ctx,
12614 struct policy_handle *handle /* [in] [ref] */,
12615 const char *key_name /* [in] [charset(UTF16)] */,
12616 WERROR *werror)
12617 {
12618 struct spoolss_DeletePrinterKey r;
12619 NTSTATUS status;
12620
12621 /* In parameters */
12622 r.in.handle = handle;
12623 r.in.key_name = key_name;
12624
12625 status = cli->dispatch(cli,
12626 mem_ctx,
12627 &ndr_table_spoolss,
12628 NDR_SPOOLSS_DELETEPRINTERKEY,
12629 &r);
12630
12631 if (!NT_STATUS_IS_OK(status)) {
12632 return status;
12633 }
12634
12635 if (NT_STATUS_IS_ERR(status)) {
12636 return status;
12637 }
12638
12639 /* Return variables */
12640
12641 /* Return result */
12642 if (werror) {
12643 *werror = r.out.result;
12644 }
12645
12646 return werror_to_ntstatus(r.out.result);
12647 }
12648
12649 struct rpccli_spoolss_53_state {
12650 struct spoolss_53 orig;
12651 struct spoolss_53 tmp;
12652 TALLOC_CTX *out_mem_ctx;
12653 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12654 };
12655
12656 static void rpccli_spoolss_53_done(struct tevent_req *subreq);
12657
12658 struct tevent_req *rpccli_spoolss_53_send(TALLOC_CTX *mem_ctx,
12659 struct tevent_context *ev,
12660 struct rpc_pipe_client *cli)
12661 {
12662 struct tevent_req *req;
12663 struct rpccli_spoolss_53_state *state;
12664 struct tevent_req *subreq;
12665
12666 req = tevent_req_create(mem_ctx, &state,
12667 struct rpccli_spoolss_53_state);
12668 if (req == NULL) {
12669 return NULL;
12670 }
12671 state->out_mem_ctx = NULL;
12672 state->dispatch_recv = cli->dispatch_recv;
12673
12674 /* In parameters */
12675
12676 /* Out parameters */
12677
12678 /* Result */
12679 ZERO_STRUCT(state->orig.out.result);
12680
12681 /* make a temporary copy, that we pass to the dispatch function */
12682 state->tmp = state->orig;
12683
12684 subreq = cli->dispatch_send(state, ev, cli,
12685 &ndr_table_spoolss,
12686 NDR_SPOOLSS_53,
12687 &state->tmp);
12688 if (tevent_req_nomem(subreq, req)) {
12689 return tevent_req_post(req, ev);
12690 }
12691 tevent_req_set_callback(subreq, rpccli_spoolss_53_done, req);
12692 return req;
12693 }
12694
12695 static void rpccli_spoolss_53_done(struct tevent_req *subreq)
12696 {
12697 struct tevent_req *req = tevent_req_callback_data(
12698 subreq, struct tevent_req);
12699 struct rpccli_spoolss_53_state *state = tevent_req_data(
12700 req, struct rpccli_spoolss_53_state);
12701 NTSTATUS status;
12702 TALLOC_CTX *mem_ctx;
12703
12704 if (state->out_mem_ctx) {
12705 mem_ctx = state->out_mem_ctx;
12706 } else {
12707 mem_ctx = state;
12708 }
12709
12710 status = state->dispatch_recv(subreq, mem_ctx);
12711 TALLOC_FREE(subreq);
12712 if (!NT_STATUS_IS_OK(status)) {
12713 tevent_req_nterror(req, status);
12714 return;
12715 }
12716
12717 /* Copy out parameters */
12718
12719 /* Copy result */
12720 state->orig.out.result = state->tmp.out.result;
12721
12722 /* Reset temporary structure */
12723 ZERO_STRUCT(state->tmp);
12724
12725 tevent_req_done(req);
12726 }
12727
12728 NTSTATUS rpccli_spoolss_53_recv(struct tevent_req *req,
12729 TALLOC_CTX *mem_ctx,
12730 WERROR *result)
12731 {
12732 struct rpccli_spoolss_53_state *state = tevent_req_data(
12733 req, struct rpccli_spoolss_53_state);
12734 NTSTATUS status;
12735
12736 if (tevent_req_is_nterror(req, &status)) {
12737 tevent_req_received(req);
12738 return status;
12739 }
12740
12741 /* Steal possbile out parameters to the callers context */
12742 talloc_steal(mem_ctx, state->out_mem_ctx);
12743
12744 /* Return result */
12745 *result = state->orig.out.result;
12746
12747 tevent_req_received(req);
12748 return NT_STATUS_OK;
12749 }
12750
12751 NTSTATUS rpccli_spoolss_53(struct rpc_pipe_client *cli,
12752 TALLOC_CTX *mem_ctx,
12753 WERROR *werror)
12754 {
12755 struct spoolss_53 r;
12756 NTSTATUS status;
12757
12758 /* In parameters */
12759
12760 status = cli->dispatch(cli,
12761 mem_ctx,
12762 &ndr_table_spoolss,
12763 NDR_SPOOLSS_53,
12764 &r);
12765
12766 if (!NT_STATUS_IS_OK(status)) {
12767 return status;
12768 }
12769
12770 if (NT_STATUS_IS_ERR(status)) {
12771 return status;
12772 }
12773
12774 /* Return variables */
12775
12776 /* Return result */
12777 if (werror) {
12778 *werror = r.out.result;
12779 }
12780
12781 return werror_to_ntstatus(r.out.result);
12782 }
12783
12784 struct rpccli_spoolss_DeletePrinterDriverEx_state {
12785 struct spoolss_DeletePrinterDriverEx orig;
12786 struct spoolss_DeletePrinterDriverEx tmp;
12787 TALLOC_CTX *out_mem_ctx;
12788 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12789 };
12790
12791 static void rpccli_spoolss_DeletePrinterDriverEx_done(struct tevent_req *subreq);
12792
12793 struct tevent_req *rpccli_spoolss_DeletePrinterDriverEx_send(TALLOC_CTX *mem_ctx,
12794 struct tevent_context *ev,
12795 struct rpc_pipe_client *cli,
12796 const char *_server /* [in] [unique,charset(UTF16)] */,
12797 const char *_architecture /* [in] [charset(UTF16)] */,
12798 const char *_driver /* [in] [charset(UTF16)] */,
12799 uint32_t _delete_flags /* [in] */,
12800 uint32_t _version /* [in] */)
12801 {
12802 struct tevent_req *req;
12803 struct rpccli_spoolss_DeletePrinterDriverEx_state *state;
12804 struct tevent_req *subreq;
12805
12806 req = tevent_req_create(mem_ctx, &state,
12807 struct rpccli_spoolss_DeletePrinterDriverEx_state);
12808 if (req == NULL) {
12809 return NULL;
12810 }
12811 state->out_mem_ctx = NULL;
12812 state->dispatch_recv = cli->dispatch_recv;
12813
12814 /* In parameters */
12815 state->orig.in.server = _server;
12816 state->orig.in.architecture = _architecture;
12817 state->orig.in.driver = _driver;
12818 state->orig.in.delete_flags = _delete_flags;
12819 state->orig.in.version = _version;
12820
12821 /* Out parameters */
12822
12823 /* Result */
12824 ZERO_STRUCT(state->orig.out.result);
12825
12826 /* make a temporary copy, that we pass to the dispatch function */
12827 state->tmp = state->orig;
12828
12829 subreq = cli->dispatch_send(state, ev, cli,
12830 &ndr_table_spoolss,
12831 NDR_SPOOLSS_DELETEPRINTERDRIVEREX,
12832 &state->tmp);
12833 if (tevent_req_nomem(subreq, req)) {
12834 return tevent_req_post(req, ev);
12835 }
12836 tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterDriverEx_done, req);
12837 return req;
12838 }
12839
12840 static void rpccli_spoolss_DeletePrinterDriverEx_done(struct tevent_req *subreq)
12841 {
12842 struct tevent_req *req = tevent_req_callback_data(
12843 subreq, struct tevent_req);
12844 struct rpccli_spoolss_DeletePrinterDriverEx_state *state = tevent_req_data(
12845 req, struct rpccli_spoolss_DeletePrinterDriverEx_state);
12846 NTSTATUS status;
12847 TALLOC_CTX *mem_ctx;
12848
12849 if (state->out_mem_ctx) {
12850 mem_ctx = state->out_mem_ctx;
12851 } else {
12852 mem_ctx = state;
12853 }
12854
12855 status = state->dispatch_recv(subreq, mem_ctx);
12856 TALLOC_FREE(subreq);
12857 if (!NT_STATUS_IS_OK(status)) {
12858 tevent_req_nterror(req, status);
12859 return;
12860 }
12861
12862 /* Copy out parameters */
12863
12864 /* Copy result */
12865 state->orig.out.result = state->tmp.out.result;
12866
12867 /* Reset temporary structure */
12868 ZERO_STRUCT(state->tmp);
12869
12870 tevent_req_done(req);
12871 }
12872
12873 NTSTATUS rpccli_spoolss_DeletePrinterDriverEx_recv(struct tevent_req *req,
12874 TALLOC_CTX *mem_ctx,
12875 WERROR *result)
12876 {
12877 struct rpccli_spoolss_DeletePrinterDriverEx_state *state = tevent_req_data(
12878 req, struct rpccli_spoolss_DeletePrinterDriverEx_state);
12879 NTSTATUS status;
12880
12881 if (tevent_req_is_nterror(req, &status)) {
12882 tevent_req_received(req);
12883 return status;
12884 }
12885
12886 /* Steal possbile out parameters to the callers context */
12887 talloc_steal(mem_ctx, state->out_mem_ctx);
12888
12889 /* Return result */
12890 *result = state->orig.out.result;
12891
12892 tevent_req_received(req);
12893 return NT_STATUS_OK;
12894 }
12895
12896 NTSTATUS rpccli_spoolss_DeletePrinterDriverEx(struct rpc_pipe_client *cli,
12897 TALLOC_CTX *mem_ctx,
12898 const char *server /* [in] [unique,charset(UTF16)] */,
12899 const char *architecture /* [in] [charset(UTF16)] */,
12900 const char *driver /* [in] [charset(UTF16)] */,
12901 uint32_t delete_flags /* [in] */,
12902 uint32_t version /* [in] */,
12903 WERROR *werror)
12904 {
12905 struct spoolss_DeletePrinterDriverEx r;
12906 NTSTATUS status;
12907
12908 /* In parameters */
12909 r.in.server = server;
12910 r.in.architecture = architecture;
12911 r.in.driver = driver;
12912 r.in.delete_flags = delete_flags;
12913 r.in.version = version;
12914
12915 status = cli->dispatch(cli,
12916 mem_ctx,
12917 &ndr_table_spoolss,
12918 NDR_SPOOLSS_DELETEPRINTERDRIVEREX,
12919 &r);
12920
12921 if (!NT_STATUS_IS_OK(status)) {
12922 return status;
12923 }
12924
12925 if (NT_STATUS_IS_ERR(status)) {
12926 return status;
12927 }
12928
12929 /* Return variables */
12930
12931 /* Return result */
12932 if (werror) {
12933 *werror = r.out.result;
12934 }
12935
12936 return werror_to_ntstatus(r.out.result);
12937 }
12938
12939 struct rpccli_spoolss_55_state {
12940 struct spoolss_55 orig;
12941 struct spoolss_55 tmp;
12942 TALLOC_CTX *out_mem_ctx;
12943 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12944 };
12945
12946 static void rpccli_spoolss_55_done(struct tevent_req *subreq);
12947
12948 struct tevent_req *rpccli_spoolss_55_send(TALLOC_CTX *mem_ctx,
12949 struct tevent_context *ev,
12950 struct rpc_pipe_client *cli)
12951 {
12952 struct tevent_req *req;
12953 struct rpccli_spoolss_55_state *state;
12954 struct tevent_req *subreq;
12955
12956 req = tevent_req_create(mem_ctx, &state,
12957 struct rpccli_spoolss_55_state);
12958 if (req == NULL) {
12959 return NULL;
12960 }
12961 state->out_mem_ctx = NULL;
12962 state->dispatch_recv = cli->dispatch_recv;
12963
12964 /* In parameters */
12965
12966 /* Out parameters */
12967
12968 /* Result */
12969 ZERO_STRUCT(state->orig.out.result);
12970
12971 /* make a temporary copy, that we pass to the dispatch function */
12972 state->tmp = state->orig;
12973
12974 subreq = cli->dispatch_send(state, ev, cli,
12975 &ndr_table_spoolss,
12976 NDR_SPOOLSS_55,
12977 &state->tmp);
12978 if (tevent_req_nomem(subreq, req)) {
12979 return tevent_req_post(req, ev);
12980 }
12981 tevent_req_set_callback(subreq, rpccli_spoolss_55_done, req);
12982 return req;
12983 }
12984
12985 static void rpccli_spoolss_55_done(struct tevent_req *subreq)
12986 {
12987 struct tevent_req *req = tevent_req_callback_data(
12988 subreq, struct tevent_req);
12989 struct rpccli_spoolss_55_state *state = tevent_req_data(
12990 req, struct rpccli_spoolss_55_state);
12991 NTSTATUS status;
12992 TALLOC_CTX *mem_ctx;
12993
12994 if (state->out_mem_ctx) {
12995 mem_ctx = state->out_mem_ctx;
12996 } else {
12997 mem_ctx = state;
12998 }
12999
13000 status = state->dispatch_recv(subreq, mem_ctx);
13001 TALLOC_FREE(subreq);
13002 if (!NT_STATUS_IS_OK(status)) {
13003 tevent_req_nterror(req, status);
13004 return;
13005 }
13006
13007 /* Copy out parameters */
13008
13009 /* Copy result */
13010 state->orig.out.result = state->tmp.out.result;
13011
13012 /* Reset temporary structure */
13013 ZERO_STRUCT(state->tmp);
13014
13015 tevent_req_done(req);
13016 }
13017
13018 NTSTATUS rpccli_spoolss_55_recv(struct tevent_req *req,
13019 TALLOC_CTX *mem_ctx,
13020 WERROR *result)
13021 {
13022 struct rpccli_spoolss_55_state *state = tevent_req_data(
13023 req, struct rpccli_spoolss_55_state);
13024 NTSTATUS status;
13025
13026 if (tevent_req_is_nterror(req, &status)) {
13027 tevent_req_received(req);
13028 return status;
13029 }
13030
13031 /* Steal possbile out parameters to the callers context */
13032 talloc_steal(mem_ctx, state->out_mem_ctx);
13033
13034 /* Return result */
13035 *result = state->orig.out.result;
13036
13037 tevent_req_received(req);
13038 return NT_STATUS_OK;
13039 }
13040
13041 NTSTATUS rpccli_spoolss_55(struct rpc_pipe_client *cli,
13042 TALLOC_CTX *mem_ctx,
13043 WERROR *werror)
13044 {
13045 struct spoolss_55 r;
13046 NTSTATUS status;
13047
13048 /* In parameters */
13049
13050 status = cli->dispatch(cli,
13051 mem_ctx,
13052 &ndr_table_spoolss,
13053 NDR_SPOOLSS_55,
13054 &r);
13055
13056 if (!NT_STATUS_IS_OK(status)) {
13057 return status;
13058 }
13059
13060 if (NT_STATUS_IS_ERR(status)) {
13061 return status;
13062 }
13063
13064 /* Return variables */
13065
13066 /* Return result */
13067 if (werror) {
13068 *werror = r.out.result;
13069 }
13070
13071 return werror_to_ntstatus(r.out.result);
13072 }
13073
13074 struct rpccli_spoolss_56_state {
13075 struct spoolss_56 orig;
13076 struct spoolss_56 tmp;
13077 TALLOC_CTX *out_mem_ctx;
13078 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13079 };
13080
13081 static void rpccli_spoolss_56_done(struct tevent_req *subreq);
13082
13083 struct tevent_req *rpccli_spoolss_56_send(TALLOC_CTX *mem_ctx,
13084 struct tevent_context *ev,
13085 struct rpc_pipe_client *cli)
13086 {
13087 struct tevent_req *req;
13088 struct rpccli_spoolss_56_state *state;
13089 struct tevent_req *subreq;
13090
13091 req = tevent_req_create(mem_ctx, &state,
13092 struct rpccli_spoolss_56_state);
13093 if (req == NULL) {
13094 return NULL;
13095 }
13096 state->out_mem_ctx = NULL;
13097 state->dispatch_recv = cli->dispatch_recv;
13098
13099 /* In parameters */
13100
13101 /* Out parameters */
13102
13103 /* Result */
13104 ZERO_STRUCT(state->orig.out.result);
13105
13106 /* make a temporary copy, that we pass to the dispatch function */
13107 state->tmp = state->orig;
13108
13109 subreq = cli->dispatch_send(state, ev, cli,
13110 &ndr_table_spoolss,
13111 NDR_SPOOLSS_56,
13112 &state->tmp);
13113 if (tevent_req_nomem(subreq, req)) {
13114 return tevent_req_post(req, ev);
13115 }
13116 tevent_req_set_callback(subreq, rpccli_spoolss_56_done, req);
13117 return req;
13118 }
13119
13120 static void rpccli_spoolss_56_done(struct tevent_req *subreq)
13121 {
13122 struct tevent_req *req = tevent_req_callback_data(
13123 subreq, struct tevent_req);
13124 struct rpccli_spoolss_56_state *state = tevent_req_data(
13125 req, struct rpccli_spoolss_56_state);
13126 NTSTATUS status;
13127 TALLOC_CTX *mem_ctx;
13128
13129 if (state->out_mem_ctx) {
13130 mem_ctx = state->out_mem_ctx;
13131 } else {
13132 mem_ctx = state;
13133 }
13134
13135 status = state->dispatch_recv(subreq, mem_ctx);
13136 TALLOC_FREE(subreq);
13137 if (!NT_STATUS_IS_OK(status)) {
13138 tevent_req_nterror(req, status);
13139 return;
13140 }
13141
13142 /* Copy out parameters */
13143
13144 /* Copy result */
13145 state->orig.out.result = state->tmp.out.result;
13146
13147 /* Reset temporary structure */
13148 ZERO_STRUCT(state->tmp);
13149
13150 tevent_req_done(req);
13151 }
13152
13153 NTSTATUS rpccli_spoolss_56_recv(struct tevent_req *req,
13154 TALLOC_CTX *mem_ctx,
13155 WERROR *result)
13156 {
13157 struct rpccli_spoolss_56_state *state = tevent_req_data(
13158 req, struct rpccli_spoolss_56_state);
13159 NTSTATUS status;
13160
13161 if (tevent_req_is_nterror(req, &status)) {
13162 tevent_req_received(req);
13163 return status;
13164 }
13165
13166 /* Steal possbile out parameters to the callers context */
13167 talloc_steal(mem_ctx, state->out_mem_ctx);
13168
13169 /* Return result */
13170 *result = state->orig.out.result;
13171
13172 tevent_req_received(req);
13173 return NT_STATUS_OK;
13174 }
13175
13176 NTSTATUS rpccli_spoolss_56(struct rpc_pipe_client *cli,
13177 TALLOC_CTX *mem_ctx,
13178 WERROR *werror)
13179 {
13180 struct spoolss_56 r;
13181 NTSTATUS status;
13182
13183 /* In parameters */
13184
13185 status = cli->dispatch(cli,
13186 mem_ctx,
13187 &ndr_table_spoolss,
13188 NDR_SPOOLSS_56,
13189 &r);
13190
13191 if (!NT_STATUS_IS_OK(status)) {
13192 return status;
13193 }
13194
13195 if (NT_STATUS_IS_ERR(status)) {
13196 return status;
13197 }
13198
13199 /* Return variables */
13200
13201 /* Return result */
13202 if (werror) {
13203 *werror = r.out.result;
13204 }
13205
13206 return werror_to_ntstatus(r.out.result);
13207 }
13208
13209 struct rpccli_spoolss_57_state {
13210 struct spoolss_57 orig;
13211 struct spoolss_57 tmp;
13212 TALLOC_CTX *out_mem_ctx;
13213 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13214 };
13215
13216 static void rpccli_spoolss_57_done(struct tevent_req *subreq);
13217
13218 struct tevent_req *rpccli_spoolss_57_send(TALLOC_CTX *mem_ctx,
13219 struct tevent_context *ev,
13220 struct rpc_pipe_client *cli)
13221 {
13222 struct tevent_req *req;
13223 struct rpccli_spoolss_57_state *state;
13224 struct tevent_req *subreq;
13225
13226 req = tevent_req_create(mem_ctx, &state,
13227 struct rpccli_spoolss_57_state);
13228 if (req == NULL) {
13229 return NULL;
13230 }
13231 state->out_mem_ctx = NULL;
13232 state->dispatch_recv = cli->dispatch_recv;
13233
13234 /* In parameters */
13235
13236 /* Out parameters */
13237
13238 /* Result */
13239 ZERO_STRUCT(state->orig.out.result);
13240
13241 /* make a temporary copy, that we pass to the dispatch function */
13242 state->tmp = state->orig;
13243
13244 subreq = cli->dispatch_send(state, ev, cli,
13245 &ndr_table_spoolss,
13246 NDR_SPOOLSS_57,
13247 &state->tmp);
13248 if (tevent_req_nomem(subreq, req)) {
13249 return tevent_req_post(req, ev);
13250 }
13251 tevent_req_set_callback(subreq, rpccli_spoolss_57_done, req);
13252 return req;
13253 }
13254
13255 static void rpccli_spoolss_57_done(struct tevent_req *subreq)
13256 {
13257 struct tevent_req *req = tevent_req_callback_data(
13258 subreq, struct tevent_req);
13259 struct rpccli_spoolss_57_state *state = tevent_req_data(
13260 req, struct rpccli_spoolss_57_state);
13261 NTSTATUS status;
13262 TALLOC_CTX *mem_ctx;
13263
13264 if (state->out_mem_ctx) {
13265 mem_ctx = state->out_mem_ctx;
13266 } else {
13267 mem_ctx = state;
13268 }
13269
13270 status = state->dispatch_recv(subreq, mem_ctx);
13271 TALLOC_FREE(subreq);
13272 if (!NT_STATUS_IS_OK(status)) {
13273 tevent_req_nterror(req, status);
13274 return;
13275 }
13276
13277 /* Copy out parameters */
13278
13279 /* Copy result */
13280 state->orig.out.result = state->tmp.out.result;
13281
13282 /* Reset temporary structure */
13283 ZERO_STRUCT(state->tmp);
13284
13285 tevent_req_done(req);
13286 }
13287
13288 NTSTATUS rpccli_spoolss_57_recv(struct tevent_req *req,
13289 TALLOC_CTX *mem_ctx,
13290 WERROR *result)
13291 {
13292 struct rpccli_spoolss_57_state *state = tevent_req_data(
13293 req, struct rpccli_spoolss_57_state);
13294 NTSTATUS status;
13295
13296 if (tevent_req_is_nterror(req, &status)) {
13297 tevent_req_received(req);
13298 return status;
13299 }
13300
13301 /* Steal possbile out parameters to the callers context */
13302 talloc_steal(mem_ctx, state->out_mem_ctx);
13303
13304 /* Return result */
13305 *result = state->orig.out.result;
13306
13307 tevent_req_received(req);
13308 return NT_STATUS_OK;
13309 }
13310
13311 NTSTATUS rpccli_spoolss_57(struct rpc_pipe_client *cli,
13312 TALLOC_CTX *mem_ctx,
13313 WERROR *werror)
13314 {
13315 struct spoolss_57 r;
13316 NTSTATUS status;
13317
13318 /* In parameters */
13319
13320 status = cli->dispatch(cli,
13321 mem_ctx,
13322 &ndr_table_spoolss,
13323 NDR_SPOOLSS_57,
13324 &r);
13325
13326 if (!NT_STATUS_IS_OK(status)) {
13327 return status;
13328 }
13329
13330 if (NT_STATUS_IS_ERR(status)) {
13331 return status;
13332 }
13333
13334 /* Return variables */
13335
13336 /* Return result */
13337 if (werror) {
13338 *werror = r.out.result;
13339 }
13340
13341 return werror_to_ntstatus(r.out.result);
13342 }
13343
13344 struct rpccli_spoolss_XcvData_state {
13345 struct spoolss_XcvData orig;
13346 struct spoolss_XcvData tmp;
13347 TALLOC_CTX *out_mem_ctx;
13348 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13349 };
13350
13351 static void rpccli_spoolss_XcvData_done(struct tevent_req *subreq);
13352
13353 struct tevent_req *rpccli_spoolss_XcvData_send(TALLOC_CTX *mem_ctx,
13354 struct tevent_context *ev,
13355 struct rpc_pipe_client *cli,
13356 struct policy_handle *_handle /* [in] [ref] */,
13357 const char *_function_name /* [in] [charset(UTF16)] */,
13358 DATA_BLOB _in_data /* [in] */,
13359 uint32_t __in_data_length /* [in] [value(r->in.in_data.length)] */,
13360 uint8_t *_out_data /* [out] [ref,size_is(out_data_size)] */,
13361 uint32_t _out_data_size /* [in] */,
13362 uint32_t *_needed /* [out] [ref] */,
13363 uint32_t *_status_code /* [in,out] [ref] */)
13364 {
13365 struct tevent_req *req;
13366 struct rpccli_spoolss_XcvData_state *state;
13367 struct tevent_req *subreq;
13368
13369 req = tevent_req_create(mem_ctx, &state,
13370 struct rpccli_spoolss_XcvData_state);
13371 if (req == NULL) {
13372 return NULL;
13373 }
13374 state->out_mem_ctx = NULL;
13375 state->dispatch_recv = cli->dispatch_recv;
13376
13377 /* In parameters */
13378 state->orig.in.handle = _handle;
13379 state->orig.in.function_name = _function_name;
13380 state->orig.in.in_data = _in_data;
13381 state->orig.in._in_data_length = __in_data_length;
13382 state->orig.in.out_data_size = _out_data_size;
13383 state->orig.in.status_code = _status_code;
13384
13385 /* Out parameters */
13386 state->orig.out.out_data = _out_data;
13387 state->orig.out.needed = _needed;
13388 state->orig.out.status_code = _status_code;
13389
13390 /* Result */
13391 ZERO_STRUCT(state->orig.out.result);
13392
13393 state->out_mem_ctx = talloc_named_const(state, 0,
13394 "rpccli_spoolss_XcvData_out_memory");
13395 if (tevent_req_nomem(state->out_mem_ctx, req)) {
13396 return tevent_req_post(req, ev);
13397 }
13398
13399 /* make a temporary copy, that we pass to the dispatch function */
13400 state->tmp = state->orig;
13401
13402 subreq = cli->dispatch_send(state, ev, cli,
13403 &ndr_table_spoolss,
13404 NDR_SPOOLSS_XCVDATA,
13405 &state->tmp);
13406 if (tevent_req_nomem(subreq, req)) {
13407 return tevent_req_post(req, ev);
13408 }
13409 tevent_req_set_callback(subreq, rpccli_spoolss_XcvData_done, req);
13410 return req;
13411 }
13412
13413 static void rpccli_spoolss_XcvData_done(struct tevent_req *subreq)
13414 {
13415 struct tevent_req *req = tevent_req_callback_data(
13416 subreq, struct tevent_req);
13417 struct rpccli_spoolss_XcvData_state *state = tevent_req_data(
13418 req, struct rpccli_spoolss_XcvData_state);
13419 NTSTATUS status;
13420 TALLOC_CTX *mem_ctx;
13421
13422 if (state->out_mem_ctx) {
13423 mem_ctx = state->out_mem_ctx;
13424 } else {
13425 mem_ctx = state;
13426 }
13427
13428 status = state->dispatch_recv(subreq, mem_ctx);
13429 TALLOC_FREE(subreq);
13430 if (!NT_STATUS_IS_OK(status)) {
13431 tevent_req_nterror(req, status);
13432 return;
13433 }
13434
13435 /* Copy out parameters */
13436 memcpy(state->orig.out.out_data, state->tmp.out.out_data, (state->tmp.in.out_data_size) * sizeof(*state->orig.out.out_data));
13437 *state->orig.out.needed = *state->tmp.out.needed;
13438 *state->orig.out.status_code = *state->tmp.out.status_code;
13439
13440 /* Copy result */
13441 state->orig.out.result = state->tmp.out.result;
13442
13443 /* Reset temporary structure */
13444 ZERO_STRUCT(state->tmp);
13445
13446 tevent_req_done(req);
13447 }
13448
13449 NTSTATUS rpccli_spoolss_XcvData_recv(struct tevent_req *req,
13450 TALLOC_CTX *mem_ctx,
13451 WERROR *result)
13452 {
13453 struct rpccli_spoolss_XcvData_state *state = tevent_req_data(
13454 req, struct rpccli_spoolss_XcvData_state);
13455 NTSTATUS status;
13456
13457 if (tevent_req_is_nterror(req, &status)) {
13458 tevent_req_received(req);
13459 return status;
13460 }
13461
13462 /* Steal possbile out parameters to the callers context */
13463 talloc_steal(mem_ctx, state->out_mem_ctx);
13464
13465 /* Return result */
13466 *result = state->orig.out.result;
13467
13468 tevent_req_received(req);
13469 return NT_STATUS_OK;
13470 }
13471
13472 NTSTATUS rpccli_spoolss_XcvData(struct rpc_pipe_client *cli,
13473 TALLOC_CTX *mem_ctx,
13474 struct policy_handle *handle /* [in] [ref] */,
13475 const char *function_name /* [in] [charset(UTF16)] */,
13476 DATA_BLOB in_data /* [in] */,
13477 uint32_t _in_data_length /* [in] [value(r->in.in_data.length)] */,
13478 uint8_t *out_data /* [out] [ref,size_is(out_data_size)] */,
13479 uint32_t out_data_size /* [in] */,
13480 uint32_t *needed /* [out] [ref] */,
13481 uint32_t *status_code /* [in,out] [ref] */,
13482 WERROR *werror)
13483 {
13484 struct spoolss_XcvData r;
13485 NTSTATUS status;
13486
13487 /* In parameters */
13488 r.in.handle = handle;
13489 r.in.function_name = function_name;
13490 r.in.in_data = in_data;
13491 r.in._in_data_length = _in_data_length;
13492 r.in.out_data_size = out_data_size;
13493 r.in.status_code = status_code;
13494
13495 status = cli->dispatch(cli,
13496 mem_ctx,
13497 &ndr_table_spoolss,
13498 NDR_SPOOLSS_XCVDATA,
13499 &r);
13500
13501 if (!NT_STATUS_IS_OK(status)) {
13502 return status;
13503 }
13504
13505 if (NT_STATUS_IS_ERR(status)) {
13506 return status;
13507 }
13508
13509 /* Return variables */
13510 memcpy(out_data, r.out.out_data, (r.in.out_data_size) * sizeof(*out_data));
13511 *needed = *r.out.needed;
13512 *status_code = *r.out.status_code;
13513
13514 /* Return result */
13515 if (werror) {
13516 *werror = r.out.result;
13517 }
13518
13519 return werror_to_ntstatus(r.out.result);
13520 }
13521
13522 struct rpccli_spoolss_AddPrinterDriverEx_state {
13523 struct spoolss_AddPrinterDriverEx orig;
13524 struct spoolss_AddPrinterDriverEx tmp;
13525 TALLOC_CTX *out_mem_ctx;
13526 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13527 };
13528
13529 static void rpccli_spoolss_AddPrinterDriverEx_done(struct tevent_req *subreq);
13530
13531 struct tevent_req *rpccli_spoolss_AddPrinterDriverEx_send(TALLOC_CTX *mem_ctx,
13532 struct tevent_context *ev,
13533 struct rpc_pipe_client *cli,
13534 const char *_servername /* [in] [unique,charset(UTF16)] */,
13535 struct spoolss_AddDriverInfoCtr *_info_ctr /* [in] [ref] */,
13536 uint32_t _flags /* [in] */)
13537 {
13538 struct tevent_req *req;
13539 struct rpccli_spoolss_AddPrinterDriverEx_state *state;
13540 struct tevent_req *subreq;
13541
13542 req = tevent_req_create(mem_ctx, &state,
13543 struct rpccli_spoolss_AddPrinterDriverEx_state);
13544 if (req == NULL) {
13545 return NULL;
13546 }
13547 state->out_mem_ctx = NULL;
13548 state->dispatch_recv = cli->dispatch_recv;
13549
13550 /* In parameters */
13551 state->orig.in.servername = _servername;
13552 state->orig.in.info_ctr = _info_ctr;
13553 state->orig.in.flags = _flags;
13554
13555 /* Out parameters */
13556
13557 /* Result */
13558 ZERO_STRUCT(state->orig.out.result);
13559
13560 /* make a temporary copy, that we pass to the dispatch function */
13561 state->tmp = state->orig;
13562
13563 subreq = cli->dispatch_send(state, ev, cli,
13564 &ndr_table_spoolss,
13565 NDR_SPOOLSS_ADDPRINTERDRIVEREX,
13566 &state->tmp);
13567 if (tevent_req_nomem(subreq, req)) {
13568 return tevent_req_post(req, ev);
13569 }
13570 tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterDriverEx_done, req);
13571 return req;
13572 }
13573
13574 static void rpccli_spoolss_AddPrinterDriverEx_done(struct tevent_req *subreq)
13575 {
13576 struct tevent_req *req = tevent_req_callback_data(
13577 subreq, struct tevent_req);
13578 struct rpccli_spoolss_AddPrinterDriverEx_state *state = tevent_req_data(
13579 req, struct rpccli_spoolss_AddPrinterDriverEx_state);
13580 NTSTATUS status;
13581 TALLOC_CTX *mem_ctx;
13582
13583 if (state->out_mem_ctx) {
13584 mem_ctx = state->out_mem_ctx;
13585 } else {
13586 mem_ctx = state;
13587 }
13588
13589 status = state->dispatch_recv(subreq, mem_ctx);
13590 TALLOC_FREE(subreq);
13591 if (!NT_STATUS_IS_OK(status)) {
13592 tevent_req_nterror(req, status);
13593 return;
13594 }
13595
13596 /* Copy out parameters */
13597
13598 /* Copy result */
13599 state->orig.out.result = state->tmp.out.result;
13600
13601 /* Reset temporary structure */
13602 ZERO_STRUCT(state->tmp);
13603
13604 tevent_req_done(req);
13605 }
13606
13607 NTSTATUS rpccli_spoolss_AddPrinterDriverEx_recv(struct tevent_req *req,
13608 TALLOC_CTX *mem_ctx,
13609 WERROR *result)
13610 {
13611 struct rpccli_spoolss_AddPrinterDriverEx_state *state = tevent_req_data(
13612 req, struct rpccli_spoolss_AddPrinterDriverEx_state);
13613 NTSTATUS status;
13614
13615 if (tevent_req_is_nterror(req, &status)) {
13616 tevent_req_received(req);
13617 return status;
13618 }
13619
13620 /* Steal possbile out parameters to the callers context */
13621 talloc_steal(mem_ctx, state->out_mem_ctx);
13622
13623 /* Return result */
13624 *result = state->orig.out.result;
13625
13626 tevent_req_received(req);
13627 return NT_STATUS_OK;
13628 }
13629
13630 NTSTATUS rpccli_spoolss_AddPrinterDriverEx(struct rpc_pipe_client *cli,
13631 TALLOC_CTX *mem_ctx,
13632 const char *servername /* [in] [unique,charset(UTF16)] */,
13633 struct spoolss_AddDriverInfoCtr *info_ctr /* [in] [ref] */,
13634 uint32_t flags /* [in] */,
13635 WERROR *werror)
13636 {
13637 struct spoolss_AddPrinterDriverEx r;
13638 NTSTATUS status;
13639
13640 /* In parameters */
13641 r.in.servername = servername;
13642 r.in.info_ctr = info_ctr;
13643 r.in.flags = flags;
13644
13645 status = cli->dispatch(cli,
13646 mem_ctx,
13647 &ndr_table_spoolss,
13648 NDR_SPOOLSS_ADDPRINTERDRIVEREX,
13649 &r);
13650
13651 if (!NT_STATUS_IS_OK(status)) {
13652 return status;
13653 }
13654
13655 if (NT_STATUS_IS_ERR(status)) {
13656 return status;
13657 }
13658
13659 /* Return variables */
13660
13661 /* Return result */
13662 if (werror) {
13663 *werror = r.out.result;
13664 }
13665
13666 return werror_to_ntstatus(r.out.result);
13667 }
13668
13669 struct rpccli_spoolss_5a_state {
13670 struct spoolss_5a orig;
13671 struct spoolss_5a tmp;
13672 TALLOC_CTX *out_mem_ctx;
13673 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13674 };
13675
13676 static void rpccli_spoolss_5a_done(struct tevent_req *subreq);
13677
13678 struct tevent_req *rpccli_spoolss_5a_send(TALLOC_CTX *mem_ctx,
13679 struct tevent_context *ev,
13680 struct rpc_pipe_client *cli)
13681 {
13682 struct tevent_req *req;
13683 struct rpccli_spoolss_5a_state *state;
13684 struct tevent_req *subreq;
13685
13686 req = tevent_req_create(mem_ctx, &state,
13687 struct rpccli_spoolss_5a_state);
13688 if (req == NULL) {
13689 return NULL;
13690 }
13691 state->out_mem_ctx = NULL;
13692 state->dispatch_recv = cli->dispatch_recv;
13693
13694 /* In parameters */
13695
13696 /* Out parameters */
13697
13698 /* Result */
13699 ZERO_STRUCT(state->orig.out.result);
13700
13701 /* make a temporary copy, that we pass to the dispatch function */
13702 state->tmp = state->orig;
13703
13704 subreq = cli->dispatch_send(state, ev, cli,
13705 &ndr_table_spoolss,
13706 NDR_SPOOLSS_5A,
13707 &state->tmp);
13708 if (tevent_req_nomem(subreq, req)) {
13709 return tevent_req_post(req, ev);
13710 }
13711 tevent_req_set_callback(subreq, rpccli_spoolss_5a_done, req);
13712 return req;
13713 }
13714
13715 static void rpccli_spoolss_5a_done(struct tevent_req *subreq)
13716 {
13717 struct tevent_req *req = tevent_req_callback_data(
13718 subreq, struct tevent_req);
13719 struct rpccli_spoolss_5a_state *state = tevent_req_data(
13720 req, struct rpccli_spoolss_5a_state);
13721 NTSTATUS status;
13722 TALLOC_CTX *mem_ctx;
13723
13724 if (state->out_mem_ctx) {
13725 mem_ctx = state->out_mem_ctx;
13726 } else {
13727 mem_ctx = state;
13728 }
13729
13730 status = state->dispatch_recv(subreq, mem_ctx);
13731 TALLOC_FREE(subreq);
13732 if (!NT_STATUS_IS_OK(status)) {
13733 tevent_req_nterror(req, status);
13734 return;
13735 }
13736
13737 /* Copy out parameters */
13738
13739 /* Copy result */
13740 state->orig.out.result = state->tmp.out.result;
13741
13742 /* Reset temporary structure */
13743 ZERO_STRUCT(state->tmp);
13744
13745 tevent_req_done(req);
13746 }
13747
13748 NTSTATUS rpccli_spoolss_5a_recv(struct tevent_req *req,
13749 TALLOC_CTX *mem_ctx,
13750 WERROR *result)
13751 {
13752 struct rpccli_spoolss_5a_state *state = tevent_req_data(
13753 req, struct rpccli_spoolss_5a_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_5a(struct rpc_pipe_client *cli,
13772 TALLOC_CTX *mem_ctx,
13773 WERROR *werror)
13774 {
13775 struct spoolss_5a r;
13776 NTSTATUS status;
13777
13778 /* In parameters */
13779
13780 status = cli->dispatch(cli,
13781 mem_ctx,
13782 &ndr_table_spoolss,
13783 NDR_SPOOLSS_5A,
13784 &r);
13785
13786 if (!NT_STATUS_IS_OK(status)) {
13787 return status;
13788 }
13789
13790 if (NT_STATUS_IS_ERR(status)) {
13791 return status;
13792 }
13793
13794 /* Return variables */
13795
13796 /* Return result */
13797 if (werror) {
13798 *werror = r.out.result;
13799 }
13800
13801 return werror_to_ntstatus(r.out.result);
13802 }
13803
13804 struct rpccli_spoolss_5b_state {
13805 struct spoolss_5b orig;
13806 struct spoolss_5b tmp;
13807 TALLOC_CTX *out_mem_ctx;
13808 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13809 };
13810
13811 static void rpccli_spoolss_5b_done(struct tevent_req *subreq);
13812
13813 struct tevent_req *rpccli_spoolss_5b_send(TALLOC_CTX *mem_ctx,
13814 struct tevent_context *ev,
13815 struct rpc_pipe_client *cli)
13816 {
13817 struct tevent_req *req;
13818 struct rpccli_spoolss_5b_state *state;
13819 struct tevent_req *subreq;
13820
13821 req = tevent_req_create(mem_ctx, &state,
13822 struct rpccli_spoolss_5b_state);
13823 if (req == NULL) {
13824 return NULL;
13825 }
13826 state->out_mem_ctx = NULL;
13827 state->dispatch_recv = cli->dispatch_recv;
13828
13829 /* In parameters */
13830
13831 /* Out parameters */
13832
13833 /* Result */
13834 ZERO_STRUCT(state->orig.out.result);
13835
13836 /* make a temporary copy, that we pass to the dispatch function */
13837 state->tmp = state->orig;
13838
13839 subreq = cli->dispatch_send(state, ev, cli,
13840 &ndr_table_spoolss,
13841 NDR_SPOOLSS_5B,
13842 &state->tmp);
13843 if (tevent_req_nomem(subreq, req)) {
13844 return tevent_req_post(req, ev);
13845 }
13846 tevent_req_set_callback(subreq, rpccli_spoolss_5b_done, req);
13847 return req;
13848 }
13849
13850 static void rpccli_spoolss_5b_done(struct tevent_req *subreq)
13851 {
13852 struct tevent_req *req = tevent_req_callback_data(
13853 subreq, struct tevent_req);
13854 struct rpccli_spoolss_5b_state *state = tevent_req_data(
13855 req, struct rpccli_spoolss_5b_state);
13856 NTSTATUS status;
13857 TALLOC_CTX *mem_ctx;
13858
13859 if (state->out_mem_ctx) {
13860 mem_ctx = state->out_mem_ctx;
13861 } else {
13862 mem_ctx = state;
13863 }
13864
13865 status = state->dispatch_recv(subreq, mem_ctx);
13866 TALLOC_FREE(subreq);
13867 if (!NT_STATUS_IS_OK(status)) {
13868 tevent_req_nterror(req, status);
13869 return;
13870 }
13871
13872 /* Copy out parameters */
13873
13874 /* Copy result */
13875 state->orig.out.result = state->tmp.out.result;
13876
13877 /* Reset temporary structure */
13878 ZERO_STRUCT(state->tmp);
13879
13880 tevent_req_done(req);
13881 }
13882
13883 NTSTATUS rpccli_spoolss_5b_recv(struct tevent_req *req,
13884 TALLOC_CTX *mem_ctx,
13885 WERROR *result)
13886 {
13887 struct rpccli_spoolss_5b_state *state = tevent_req_data(
13888 req, struct rpccli_spoolss_5b_state);
13889 NTSTATUS status;
13890
13891 if (tevent_req_is_nterror(req, &status)) {
13892 tevent_req_received(req);
13893 return status;
13894 }
13895
13896 /* Steal possbile out parameters to the callers context */
13897 talloc_steal(mem_ctx, state->out_mem_ctx);
13898
13899 /* Return result */
13900 *result = state->orig.out.result;
13901
13902 tevent_req_received(req);
13903 return NT_STATUS_OK;
13904 }
13905
13906 NTSTATUS rpccli_spoolss_5b(struct rpc_pipe_client *cli,
13907 TALLOC_CTX *mem_ctx,
13908 WERROR *werror)
13909 {
13910 struct spoolss_5b r;
13911 NTSTATUS status;
13912
13913 /* In parameters */
13914
13915 status = cli->dispatch(cli,
13916 mem_ctx,
13917 &ndr_table_spoolss,
13918 NDR_SPOOLSS_5B,
13919 &r);
13920
13921 if (!NT_STATUS_IS_OK(status)) {
13922 return status;
13923 }
13924
13925 if (NT_STATUS_IS_ERR(status)) {
13926 return status;
13927 }
13928
13929 /* Return variables */
13930
13931 /* Return result */
13932 if (werror) {
13933 *werror = r.out.result;
13934 }
13935
13936 return werror_to_ntstatus(r.out.result);
13937 }
13938
13939 struct rpccli_spoolss_5c_state {
13940 struct spoolss_5c orig;
13941 struct spoolss_5c tmp;
13942 TALLOC_CTX *out_mem_ctx;
13943 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13944 };
13945
13946 static void rpccli_spoolss_5c_done(struct tevent_req *subreq);
13947
13948 struct tevent_req *rpccli_spoolss_5c_send(TALLOC_CTX *mem_ctx,
13949 struct tevent_context *ev,
13950 struct rpc_pipe_client *cli)
13951 {
13952 struct tevent_req *req;
13953 struct rpccli_spoolss_5c_state *state;
13954 struct tevent_req *subreq;
13955
13956 req = tevent_req_create(mem_ctx, &state,
13957 struct rpccli_spoolss_5c_state);
13958 if (req == NULL) {
13959 return NULL;
13960 }
13961 state->out_mem_ctx = NULL;
13962 state->dispatch_recv = cli->dispatch_recv;
13963
13964 /* In parameters */
13965
13966 /* Out parameters */
13967
13968 /* Result */
13969 ZERO_STRUCT(state->orig.out.result);
13970
13971 /* make a temporary copy, that we pass to the dispatch function */
13972 state->tmp = state->orig;
13973
13974 subreq = cli->dispatch_send(state, ev, cli,
13975 &ndr_table_spoolss,
13976 NDR_SPOOLSS_5C,
13977 &state->tmp);
13978 if (tevent_req_nomem(subreq, req)) {
13979 return tevent_req_post(req, ev);
13980 }
13981 tevent_req_set_callback(subreq, rpccli_spoolss_5c_done, req);
13982 return req;
13983 }
13984
13985 static void rpccli_spoolss_5c_done(struct tevent_req *subreq)
13986 {
13987 struct tevent_req *req = tevent_req_callback_data(
13988 subreq, struct tevent_req);
13989 struct rpccli_spoolss_5c_state *state = tevent_req_data(
13990 req, struct rpccli_spoolss_5c_state);
13991 NTSTATUS status;
13992 TALLOC_CTX *mem_ctx;
13993
13994 if (state->out_mem_ctx) {
13995 mem_ctx = state->out_mem_ctx;
13996 } else {
13997 mem_ctx = state;
13998 }
13999
14000 status = state->dispatch_recv(subreq, mem_ctx);
14001 TALLOC_FREE(subreq);
14002 if (!NT_STATUS_IS_OK(status)) {
14003 tevent_req_nterror(req, status);
14004 return;
14005 }
14006
14007 /* Copy out parameters */
14008
14009 /* Copy result */
14010 state->orig.out.result = state->tmp.out.result;
14011
14012 /* Reset temporary structure */
14013 ZERO_STRUCT(state->tmp);
14014
14015 tevent_req_done(req);
14016 }
14017
14018 NTSTATUS rpccli_spoolss_5c_recv(struct tevent_req *req,
14019 TALLOC_CTX *mem_ctx,
14020 WERROR *result)
14021 {
14022 struct rpccli_spoolss_5c_state *state = tevent_req_data(
14023 req, struct rpccli_spoolss_5c_state);
14024 NTSTATUS status;
14025
14026 if (tevent_req_is_nterror(req, &status)) {
14027 tevent_req_received(req);
14028 return status;
14029 }
14030
14031 /* Steal possbile out parameters to the callers context */
14032 talloc_steal(mem_ctx, state->out_mem_ctx);
14033
14034 /* Return result */
14035 *result = state->orig.out.result;
14036
14037 tevent_req_received(req);
14038 return NT_STATUS_OK;
14039 }
14040
14041 NTSTATUS rpccli_spoolss_5c(struct rpc_pipe_client *cli,
14042 TALLOC_CTX *mem_ctx,
14043 WERROR *werror)
14044 {
14045 struct spoolss_5c r;
14046 NTSTATUS status;
14047
14048 /* In parameters */
14049
14050 status = cli->dispatch(cli,
14051 mem_ctx,
14052 &ndr_table_spoolss,
14053 NDR_SPOOLSS_5C,
14054 &r);
14055
14056 if (!NT_STATUS_IS_OK(status)) {
14057 return status;
14058 }
14059
14060 if (NT_STATUS_IS_ERR(status)) {
14061 return status;
14062 }
14063
14064 /* Return variables */
14065
14066 /* Return result */
14067 if (werror) {
14068 *werror = r.out.result;
14069 }
14070
14071 return werror_to_ntstatus(r.out.result);
14072 }
14073
14074 struct rpccli_spoolss_5d_state {
14075 struct spoolss_5d orig;
14076 struct spoolss_5d tmp;
14077 TALLOC_CTX *out_mem_ctx;
14078 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14079 };
14080
14081 static void rpccli_spoolss_5d_done(struct tevent_req *subreq);
14082
14083 struct tevent_req *rpccli_spoolss_5d_send(TALLOC_CTX *mem_ctx,
14084 struct tevent_context *ev,
14085 struct rpc_pipe_client *cli)
14086 {
14087 struct tevent_req *req;
14088 struct rpccli_spoolss_5d_state *state;
14089 struct tevent_req *subreq;
14090
14091 req = tevent_req_create(mem_ctx, &state,
14092 struct rpccli_spoolss_5d_state);
14093 if (req == NULL) {
14094 return NULL;
14095 }
14096 state->out_mem_ctx = NULL;
14097 state->dispatch_recv = cli->dispatch_recv;
14098
14099 /* In parameters */
14100
14101 /* Out parameters */
14102
14103 /* Result */
14104 ZERO_STRUCT(state->orig.out.result);
14105
14106 /* make a temporary copy, that we pass to the dispatch function */
14107 state->tmp = state->orig;
14108
14109 subreq = cli->dispatch_send(state, ev, cli,
14110 &ndr_table_spoolss,
14111 NDR_SPOOLSS_5D,
14112 &state->tmp);
14113 if (tevent_req_nomem(subreq, req)) {
14114 return tevent_req_post(req, ev);
14115 }
14116 tevent_req_set_callback(subreq, rpccli_spoolss_5d_done, req);
14117 return req;
14118 }
14119
14120 static void rpccli_spoolss_5d_done(struct tevent_req *subreq)
14121 {
14122 struct tevent_req *req = tevent_req_callback_data(
14123 subreq, struct tevent_req);
14124 struct rpccli_spoolss_5d_state *state = tevent_req_data(
14125 req, struct rpccli_spoolss_5d_state);
14126 NTSTATUS status;
14127 TALLOC_CTX *mem_ctx;
14128
14129 if (state->out_mem_ctx) {
14130 mem_ctx = state->out_mem_ctx;
14131 } else {
14132 mem_ctx = state;
14133 }
14134
14135 status = state->dispatch_recv(subreq, mem_ctx);
14136 TALLOC_FREE(subreq);
14137 if (!NT_STATUS_IS_OK(status)) {
14138 tevent_req_nterror(req, status);
14139 return;
14140 }
14141
14142 /* Copy out parameters */
14143
14144 /* Copy result */
14145 state->orig.out.result = state->tmp.out.result;
14146
14147 /* Reset temporary structure */
14148 ZERO_STRUCT(state->tmp);
14149
14150 tevent_req_done(req);
14151 }
14152
14153 NTSTATUS rpccli_spoolss_5d_recv(struct tevent_req *req,
14154 TALLOC_CTX *mem_ctx,
14155 WERROR *result)
14156 {
14157 struct rpccli_spoolss_5d_state *state = tevent_req_data(
14158 req, struct rpccli_spoolss_5d_state);
14159 NTSTATUS status;
14160
14161 if (tevent_req_is_nterror(req, &status)) {
14162 tevent_req_received(req);
14163 return status;
14164 }
14165
14166 /* Steal possbile out parameters to the callers context */
14167 talloc_steal(mem_ctx, state->out_mem_ctx);
14168
14169 /* Return result */
14170 *result = state->orig.out.result;
14171
14172 tevent_req_received(req);
14173 return NT_STATUS_OK;
14174 }
14175
14176 NTSTATUS rpccli_spoolss_5d(struct rpc_pipe_client *cli,
14177 TALLOC_CTX *mem_ctx,
14178 WERROR *werror)
14179 {
14180 struct spoolss_5d r;
14181 NTSTATUS status;
14182
14183 /* In parameters */
14184
14185 status = cli->dispatch(cli,
14186 mem_ctx,
14187 &ndr_table_spoolss,
14188 NDR_SPOOLSS_5D,
14189 &r);
14190
14191 if (!NT_STATUS_IS_OK(status)) {
14192 return status;
14193 }
14194
14195 if (NT_STATUS_IS_ERR(status)) {
14196 return status;
14197 }
14198
14199 /* Return variables */
14200
14201 /* Return result */
14202 if (werror) {
14203 *werror = r.out.result;
14204 }
14205
14206 return werror_to_ntstatus(r.out.result);
14207 }
14208
14209 struct rpccli_spoolss_5e_state {
14210 struct spoolss_5e orig;
14211 struct spoolss_5e tmp;
14212 TALLOC_CTX *out_mem_ctx;
14213 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14214 };
14215
14216 static void rpccli_spoolss_5e_done(struct tevent_req *subreq);
14217
14218 struct tevent_req *rpccli_spoolss_5e_send(TALLOC_CTX *mem_ctx,
14219 struct tevent_context *ev,
14220 struct rpc_pipe_client *cli)
14221 {
14222 struct tevent_req *req;
14223 struct rpccli_spoolss_5e_state *state;
14224 struct tevent_req *subreq;
14225
14226 req = tevent_req_create(mem_ctx, &state,
14227 struct rpccli_spoolss_5e_state);
14228 if (req == NULL) {
14229 return NULL;
14230 }
14231 state->out_mem_ctx = NULL;
14232 state->dispatch_recv = cli->dispatch_recv;
14233
14234 /* In parameters */
14235
14236 /* Out parameters */
14237
14238 /* Result */
14239 ZERO_STRUCT(state->orig.out.result);
14240
14241 /* make a temporary copy, that we pass to the dispatch function */
14242 state->tmp = state->orig;
14243
14244 subreq = cli->dispatch_send(state, ev, cli,
14245 &ndr_table_spoolss,
14246 NDR_SPOOLSS_5E,
14247 &state->tmp);
14248 if (tevent_req_nomem(subreq, req)) {
14249 return tevent_req_post(req, ev);
14250 }
14251 tevent_req_set_callback(subreq, rpccli_spoolss_5e_done, req);
14252 return req;
14253 }
14254
14255 static void rpccli_spoolss_5e_done(struct tevent_req *subreq)
14256 {
14257 struct tevent_req *req = tevent_req_callback_data(
14258 subreq, struct tevent_req);
14259 struct rpccli_spoolss_5e_state *state = tevent_req_data(
14260 req, struct rpccli_spoolss_5e_state);
14261 NTSTATUS status;
14262 TALLOC_CTX *mem_ctx;
14263
14264 if (state->out_mem_ctx) {
14265 mem_ctx = state->out_mem_ctx;
14266 } else {
14267 mem_ctx = state;
14268 }
14269
14270 status = state->dispatch_recv(subreq, mem_ctx);
14271 TALLOC_FREE(subreq);
14272 if (!NT_STATUS_IS_OK(status)) {
14273 tevent_req_nterror(req, status);
14274 return;
14275 }
14276
14277 /* Copy out parameters */
14278
14279 /* Copy result */
14280 state->orig.out.result = state->tmp.out.result;
14281
14282 /* Reset temporary structure */
14283 ZERO_STRUCT(state->tmp);
14284
14285 tevent_req_done(req);
14286 }
14287
14288 NTSTATUS rpccli_spoolss_5e_recv(struct tevent_req *req,
14289 TALLOC_CTX *mem_ctx,
14290 WERROR *result)
14291 {
14292 struct rpccli_spoolss_5e_state *state = tevent_req_data(
14293 req, struct rpccli_spoolss_5e_state);
14294 NTSTATUS status;
14295
14296 if (tevent_req_is_nterror(req, &status)) {
14297 tevent_req_received(req);
14298 return status;
14299 }
14300
14301 /* Steal possbile out parameters to the callers context */
14302 talloc_steal(mem_ctx, state->out_mem_ctx);
14303
14304 /* Return result */
14305 *result = state->orig.out.result;
14306
14307 tevent_req_received(req);
14308 return NT_STATUS_OK;
14309 }
14310
14311 NTSTATUS rpccli_spoolss_5e(struct rpc_pipe_client *cli,
14312 TALLOC_CTX *mem_ctx,
14313 WERROR *werror)
14314 {
14315 struct spoolss_5e r;
14316 NTSTATUS status;
14317
14318 /* In parameters */
14319
14320 status = cli->dispatch(cli,
14321 mem_ctx,
14322 &ndr_table_spoolss,
14323 NDR_SPOOLSS_5E,
14324 &r);
14325
14326 if (!NT_STATUS_IS_OK(status)) {
14327 return status;
14328 }
14329
14330 if (NT_STATUS_IS_ERR(status)) {
14331 return status;
14332 }
14333
14334 /* Return variables */
14335
14336 /* Return result */
14337 if (werror) {
14338 *werror = r.out.result;
14339 }
14340
14341 return werror_to_ntstatus(r.out.result);
14342 }
14343
14344 struct rpccli_spoolss_5f_state {
14345 struct spoolss_5f orig;
14346 struct spoolss_5f tmp;
14347 TALLOC_CTX *out_mem_ctx;
14348 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14349 };
14350
14351 static void rpccli_spoolss_5f_done(struct tevent_req *subreq);
14352
14353 struct tevent_req *rpccli_spoolss_5f_send(TALLOC_CTX *mem_ctx,
14354 struct tevent_context *ev,
14355 struct rpc_pipe_client *cli)
14356 {
14357 struct tevent_req *req;
14358 struct rpccli_spoolss_5f_state *state;
14359 struct tevent_req *subreq;
14360
14361 req = tevent_req_create(mem_ctx, &state,
14362 struct rpccli_spoolss_5f_state);
14363 if (req == NULL) {
14364 return NULL;
14365 }
14366 state->out_mem_ctx = NULL;
14367 state->dispatch_recv = cli->dispatch_recv;
14368
14369 /* In parameters */
14370
14371 /* Out parameters */
14372
14373 /* Result */
14374 ZERO_STRUCT(state->orig.out.result);
14375
14376 /* make a temporary copy, that we pass to the dispatch function */
14377 state->tmp = state->orig;
14378
14379 subreq = cli->dispatch_send(state, ev, cli,
14380 &ndr_table_spoolss,
14381 NDR_SPOOLSS_5F,
14382 &state->tmp);
14383 if (tevent_req_nomem(subreq, req)) {
14384 return tevent_req_post(req, ev);
14385 }
14386 tevent_req_set_callback(subreq, rpccli_spoolss_5f_done, req);
14387 return req;
14388 }
14389
14390 static void rpccli_spoolss_5f_done(struct tevent_req *subreq)
14391 {
14392 struct tevent_req *req = tevent_req_callback_data(
14393 subreq, struct tevent_req);
14394 struct rpccli_spoolss_5f_state *state = tevent_req_data(
14395 req, struct rpccli_spoolss_5f_state);
14396 NTSTATUS status;
14397 TALLOC_CTX *mem_ctx;
14398
14399 if (state->out_mem_ctx) {
14400 mem_ctx = state->out_mem_ctx;
14401 } else {
14402 mem_ctx = state;
14403 }
14404
14405 status = state->dispatch_recv(subreq, mem_ctx);
14406 TALLOC_FREE(subreq);
14407 if (!NT_STATUS_IS_OK(status)) {
14408 tevent_req_nterror(req, status);
14409 return;
14410 }
14411
14412 /* Copy out parameters */
14413
14414 /* Copy result */
14415 state->orig.out.result = state->tmp.out.result;
14416
14417 /* Reset temporary structure */
14418 ZERO_STRUCT(state->tmp);
14419
14420 tevent_req_done(req);
14421 }
14422
14423 NTSTATUS rpccli_spoolss_5f_recv(struct tevent_req *req,
14424 TALLOC_CTX *mem_ctx,
14425 WERROR *result)
14426 {
14427 struct rpccli_spoolss_5f_state *state = tevent_req_data(
14428 req, struct rpccli_spoolss_5f_state);
14429 NTSTATUS status;
14430
14431 if (tevent_req_is_nterror(req, &status)) {
14432 tevent_req_received(req);
14433 return status;
14434 }
14435
14436 /* Steal possbile out parameters to the callers context */
14437 talloc_steal(mem_ctx, state->out_mem_ctx);
14438
14439 /* Return result */
14440 *result = state->orig.out.result;
14441
14442 tevent_req_received(req);
14443 return NT_STATUS_OK;
14444 }
14445
14446 NTSTATUS rpccli_spoolss_5f(struct rpc_pipe_client *cli,
14447 TALLOC_CTX *mem_ctx,
14448 WERROR *werror)
14449 {
14450 struct spoolss_5f r;
14451 NTSTATUS status;
14452
14453 /* In parameters */
14454
14455 status = cli->dispatch(cli,
14456 mem_ctx,
14457 &ndr_table_spoolss,
14458 NDR_SPOOLSS_5F,
14459 &r);
14460
14461 if (!NT_STATUS_IS_OK(status)) {
14462 return status;
14463 }
14464
14465 if (NT_STATUS_IS_ERR(status)) {
14466 return status;
14467 }
14468
14469 /* Return variables */
14470
14471 /* Return result */
14472 if (werror) {
14473 *werror = r.out.result;
14474 }
14475
14476 return werror_to_ntstatus(r.out.result);
14477 }
14478
14479 struct rpccli_spoolss_60_state {
14480 struct spoolss_60 orig;
14481 struct spoolss_60 tmp;
14482 TALLOC_CTX *out_mem_ctx;
14483 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14484 };
14485
14486 static void rpccli_spoolss_60_done(struct tevent_req *subreq);
14487
14488 struct tevent_req *rpccli_spoolss_60_send(TALLOC_CTX *mem_ctx,
14489 struct tevent_context *ev,
14490 struct rpc_pipe_client *cli)
14491 {
14492 struct tevent_req *req;
14493 struct rpccli_spoolss_60_state *state;
14494 struct tevent_req *subreq;
14495
14496 req = tevent_req_create(mem_ctx, &state,
14497 struct rpccli_spoolss_60_state);
14498 if (req == NULL) {
14499 return NULL;
14500 }
14501 state->out_mem_ctx = NULL;
14502 state->dispatch_recv = cli->dispatch_recv;
14503
14504 /* In parameters */
14505
14506 /* Out parameters */
14507
14508 /* Result */
14509 ZERO_STRUCT(state->orig.out.result);
14510
14511 /* make a temporary copy, that we pass to the dispatch function */
14512 state->tmp = state->orig;
14513
14514 subreq = cli->dispatch_send(state, ev, cli,
14515 &ndr_table_spoolss,
14516 NDR_SPOOLSS_60,
14517 &state->tmp);
14518 if (tevent_req_nomem(subreq, req)) {
14519 return tevent_req_post(req, ev);
14520 }
14521 tevent_req_set_callback(subreq, rpccli_spoolss_60_done, req);
14522 return req;
14523 }
14524
14525 static void rpccli_spoolss_60_done(struct tevent_req *subreq)
14526 {
14527 struct tevent_req *req = tevent_req_callback_data(
14528 subreq, struct tevent_req);
14529 struct rpccli_spoolss_60_state *state = tevent_req_data(
14530 req, struct rpccli_spoolss_60_state);
14531 NTSTATUS status;
14532 TALLOC_CTX *mem_ctx;
14533
14534 if (state->out_mem_ctx) {
14535 mem_ctx = state->out_mem_ctx;
14536 } else {
14537 mem_ctx = state;
14538 }
14539
14540 status = state->dispatch_recv(subreq, mem_ctx);
14541 TALLOC_FREE(subreq);
14542 if (!NT_STATUS_IS_OK(status)) {
14543 tevent_req_nterror(req, status);
14544 return;
14545 }
14546
14547 /* Copy out parameters */
14548
14549 /* Copy result */
14550 state->orig.out.result = state->tmp.out.result;
14551
14552 /* Reset temporary structure */
14553 ZERO_STRUCT(state->tmp);
14554
14555 tevent_req_done(req);
14556 }
14557
14558 NTSTATUS rpccli_spoolss_60_recv(struct tevent_req *req,
14559 TALLOC_CTX *mem_ctx,
14560 WERROR *result)
14561 {
14562 struct rpccli_spoolss_60_state *state = tevent_req_data(
14563 req, struct rpccli_spoolss_60_state);
14564 NTSTATUS status;
14565
14566 if (tevent_req_is_nterror(req, &status)) {
14567 tevent_req_received(req);
14568 return status;
14569 }
14570
14571 /* Steal possbile out parameters to the callers context */
14572 talloc_steal(mem_ctx, state->out_mem_ctx);
14573
14574 /* Return result */
14575 *result = state->orig.out.result;
14576
14577 tevent_req_received(req);
14578 return NT_STATUS_OK;
14579 }
14580
14581 NTSTATUS rpccli_spoolss_60(struct rpc_pipe_client *cli,
14582 TALLOC_CTX *mem_ctx,
14583 WERROR *werror)
14584 {
14585 struct spoolss_60 r;
14586 NTSTATUS status;
14587
14588 /* In parameters */
14589
14590 status = cli->dispatch(cli,
14591 mem_ctx,
14592 &ndr_table_spoolss,
14593 NDR_SPOOLSS_60,
14594 &r);
14595
14596 if (!NT_STATUS_IS_OK(status)) {
14597 return status;
14598 }
14599
14600 if (NT_STATUS_IS_ERR(status)) {
14601 return status;
14602 }
14603
14604 /* Return variables */
14605
14606 /* Return result */
14607 if (werror) {
14608 *werror = r.out.result;
14609 }
14610
14611 return werror_to_ntstatus(r.out.result);
14612 }
14613
14614 struct rpccli_spoolss_61_state {
14615 struct spoolss_61 orig;
14616 struct spoolss_61 tmp;
14617 TALLOC_CTX *out_mem_ctx;
14618 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14619 };
14620
14621 static void rpccli_spoolss_61_done(struct tevent_req *subreq);
14622
14623 struct tevent_req *rpccli_spoolss_61_send(TALLOC_CTX *mem_ctx,
14624 struct tevent_context *ev,
14625 struct rpc_pipe_client *cli)
14626 {
14627 struct tevent_req *req;
14628 struct rpccli_spoolss_61_state *state;
14629 struct tevent_req *subreq;
14630
14631 req = tevent_req_create(mem_ctx, &state,
14632 struct rpccli_spoolss_61_state);
14633 if (req == NULL) {
14634 return NULL;
14635 }
14636 state->out_mem_ctx = NULL;
14637 state->dispatch_recv = cli->dispatch_recv;
14638
14639 /* In parameters */
14640
14641 /* Out parameters */
14642
14643 /* Result */
14644 ZERO_STRUCT(state->orig.out.result);
14645
14646 /* make a temporary copy, that we pass to the dispatch function */
14647 state->tmp = state->orig;
14648
14649 subreq = cli->dispatch_send(state, ev, cli,
14650 &ndr_table_spoolss,
14651 NDR_SPOOLSS_61,
14652 &state->tmp);
14653 if (tevent_req_nomem(subreq, req)) {
14654 return tevent_req_post(req, ev);
14655 }
14656 tevent_req_set_callback(subreq, rpccli_spoolss_61_done, req);
14657 return req;
14658 }
14659
14660 static void rpccli_spoolss_61_done(struct tevent_req *subreq)
14661 {
14662 struct tevent_req *req = tevent_req_callback_data(
14663 subreq, struct tevent_req);
14664 struct rpccli_spoolss_61_state *state = tevent_req_data(
14665 req, struct rpccli_spoolss_61_state);
14666 NTSTATUS status;
14667 TALLOC_CTX *mem_ctx;
14668
14669 if (state->out_mem_ctx) {
14670 mem_ctx = state->out_mem_ctx;
14671 } else {
14672 mem_ctx = state;
14673 }
14674
14675 status = state->dispatch_recv(subreq, mem_ctx);
14676 TALLOC_FREE(subreq);
14677 if (!NT_STATUS_IS_OK(status)) {
14678 tevent_req_nterror(req, status);
14679 return;
14680 }
14681
14682 /* Copy out parameters */
14683
14684 /* Copy result */
14685 state->orig.out.result = state->tmp.out.result;
14686
14687 /* Reset temporary structure */
14688 ZERO_STRUCT(state->tmp);
14689
14690 tevent_req_done(req);
14691 }
14692
14693 NTSTATUS rpccli_spoolss_61_recv(struct tevent_req *req,
14694 TALLOC_CTX *mem_ctx,
14695 WERROR *result)
14696 {
14697 struct rpccli_spoolss_61_state *state = tevent_req_data(
14698 req, struct rpccli_spoolss_61_state);
14699 NTSTATUS status;
14700
14701 if (tevent_req_is_nterror(req, &status)) {
14702 tevent_req_received(req);
14703 return status;
14704 }
14705
14706 /* Steal possbile out parameters to the callers context */
14707 talloc_steal(mem_ctx, state->out_mem_ctx);
14708
14709 /* Return result */
14710 *result = state->orig.out.result;
14711
14712 tevent_req_received(req);
14713 return NT_STATUS_OK;
14714 }
14715
14716 NTSTATUS rpccli_spoolss_61(struct rpc_pipe_client *cli,
14717 TALLOC_CTX *mem_ctx,
14718 WERROR *werror)
14719 {
14720 struct spoolss_61 r;
14721 NTSTATUS status;
14722
14723 /* In parameters */
14724
14725 status = cli->dispatch(cli,
14726 mem_ctx,
14727 &ndr_table_spoolss,
14728 NDR_SPOOLSS_61,
14729 &r);
14730
14731 if (!NT_STATUS_IS_OK(status)) {
14732 return status;
14733 }
14734
14735 if (NT_STATUS_IS_ERR(status)) {
14736 return status;
14737 }
14738
14739 /* Return variables */
14740
14741 /* Return result */
14742 if (werror) {
14743 *werror = r.out.result;
14744 }
14745
14746 return werror_to_ntstatus(r.out.result);
14747 }
14748
14749 struct rpccli_spoolss_62_state {
14750 struct spoolss_62 orig;
14751 struct spoolss_62 tmp;
14752 TALLOC_CTX *out_mem_ctx;
14753 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14754 };
14755
14756 static void rpccli_spoolss_62_done(struct tevent_req *subreq);
14757
14758 struct tevent_req *rpccli_spoolss_62_send(TALLOC_CTX *mem_ctx,
14759 struct tevent_context *ev,
14760 struct rpc_pipe_client *cli)
14761 {
14762 struct tevent_req *req;
14763 struct rpccli_spoolss_62_state *state;
14764 struct tevent_req *subreq;
14765
14766 req = tevent_req_create(mem_ctx, &state,
14767 struct rpccli_spoolss_62_state);
14768 if (req == NULL) {
14769 return NULL;
14770 }
14771 state->out_mem_ctx = NULL;
14772 state->dispatch_recv = cli->dispatch_recv;
14773
14774 /* In parameters */
14775
14776 /* Out parameters */
14777
14778 /* Result */
14779 ZERO_STRUCT(state->orig.out.result);
14780
14781 /* make a temporary copy, that we pass to the dispatch function */
14782 state->tmp = state->orig;
14783
14784 subreq = cli->dispatch_send(state, ev, cli,
14785 &ndr_table_spoolss,
14786 NDR_SPOOLSS_62,
14787 &state->tmp);
14788 if (tevent_req_nomem(subreq, req)) {
14789 return tevent_req_post(req, ev);
14790 }
14791 tevent_req_set_callback(subreq, rpccli_spoolss_62_done, req);
14792 return req;
14793 }
14794
14795 static void rpccli_spoolss_62_done(struct tevent_req *subreq)
14796 {
14797 struct tevent_req *req = tevent_req_callback_data(
14798 subreq, struct tevent_req);
14799 struct rpccli_spoolss_62_state *state = tevent_req_data(
14800 req, struct rpccli_spoolss_62_state);
14801 NTSTATUS status;
14802 TALLOC_CTX *mem_ctx;
14803
14804 if (state->out_mem_ctx) {
14805 mem_ctx = state->out_mem_ctx;
14806 } else {
14807 mem_ctx = state;
14808 }
14809
14810 status = state->dispatch_recv(subreq, mem_ctx);
14811 TALLOC_FREE(subreq);
14812 if (!NT_STATUS_IS_OK(status)) {
14813 tevent_req_nterror(req, status);
14814 return;
14815 }
14816
14817 /* Copy out parameters */
14818
14819 /* Copy result */
14820 state->orig.out.result = state->tmp.out.result;
14821
14822 /* Reset temporary structure */
14823 ZERO_STRUCT(state->tmp);
14824
14825 tevent_req_done(req);
14826 }
14827
14828 NTSTATUS rpccli_spoolss_62_recv(struct tevent_req *req,
14829 TALLOC_CTX *mem_ctx,
14830 WERROR *result)
14831 {
14832 struct rpccli_spoolss_62_state *state = tevent_req_data(
14833 req, struct rpccli_spoolss_62_state);
14834 NTSTATUS status;
14835
14836 if (tevent_req_is_nterror(req, &status)) {
14837 tevent_req_received(req);
14838 return status;
14839 }
14840
14841 /* Steal possbile out parameters to the callers context */
14842 talloc_steal(mem_ctx, state->out_mem_ctx);
14843
14844 /* Return result */
14845 *result = state->orig.out.result;
14846
14847 tevent_req_received(req);
14848 return NT_STATUS_OK;
14849 }
14850
14851 NTSTATUS rpccli_spoolss_62(struct rpc_pipe_client *cli,
14852 TALLOC_CTX *mem_ctx,
14853 WERROR *werror)
14854 {
14855 struct spoolss_62 r;
14856 NTSTATUS status;
14857
14858 /* In parameters */
14859
14860 status = cli->dispatch(cli,
14861 mem_ctx,
14862 &ndr_table_spoolss,
14863 NDR_SPOOLSS_62,
14864 &r);
14865
14866 if (!NT_STATUS_IS_OK(status)) {
14867 return status;
14868 }
14869
14870 if (NT_STATUS_IS_ERR(status)) {
14871 return status;
14872 }
14873
14874 /* Return variables */
14875
14876 /* Return result */
14877 if (werror) {
14878 *werror = r.out.result;
14879 }
14880
14881 return werror_to_ntstatus(r.out.result);
14882 }
14883
14884 struct rpccli_spoolss_63_state {
14885 struct spoolss_63 orig;
14886 struct spoolss_63 tmp;
14887 TALLOC_CTX *out_mem_ctx;
14888 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14889 };
14890
14891 static void rpccli_spoolss_63_done(struct tevent_req *subreq);
14892
14893 struct tevent_req *rpccli_spoolss_63_send(TALLOC_CTX *mem_ctx,
14894 struct tevent_context *ev,
14895 struct rpc_pipe_client *cli)
14896 {
14897 struct tevent_req *req;
14898 struct rpccli_spoolss_63_state *state;
14899 struct tevent_req *subreq;
14900
14901 req = tevent_req_create(mem_ctx, &state,
14902 struct rpccli_spoolss_63_state);
14903 if (req == NULL) {
14904 return NULL;
14905 }
14906 state->out_mem_ctx = NULL;
14907 state->dispatch_recv = cli->dispatch_recv;
14908
14909 /* In parameters */
14910
14911 /* Out parameters */
14912
14913 /* Result */
14914 ZERO_STRUCT(state->orig.out.result);
14915
14916 /* make a temporary copy, that we pass to the dispatch function */
14917 state->tmp = state->orig;
14918
14919 subreq = cli->dispatch_send(state, ev, cli,
14920 &ndr_table_spoolss,
14921 NDR_SPOOLSS_63,
14922 &state->tmp);
14923 if (tevent_req_nomem(subreq, req)) {
14924 return tevent_req_post(req, ev);
14925 }
14926 tevent_req_set_callback(subreq, rpccli_spoolss_63_done, req);
14927 return req;
14928 }
14929
14930 static void rpccli_spoolss_63_done(struct tevent_req *subreq)
14931 {
14932 struct tevent_req *req = tevent_req_callback_data(
14933 subreq, struct tevent_req);
14934 struct rpccli_spoolss_63_state *state = tevent_req_data(
14935 req, struct rpccli_spoolss_63_state);
14936 NTSTATUS status;
14937 TALLOC_CTX *mem_ctx;
14938
14939 if (state->out_mem_ctx) {
14940 mem_ctx = state->out_mem_ctx;
14941 } else {
14942 mem_ctx = state;
14943 }
14944
14945 status = state->dispatch_recv(subreq, mem_ctx);
14946 TALLOC_FREE(subreq);
14947 if (!NT_STATUS_IS_OK(status)) {
14948 tevent_req_nterror(req, status);
14949 return;
14950 }
14951
14952 /* Copy out parameters */
14953
14954 /* Copy result */
14955 state->orig.out.result = state->tmp.out.result;
14956
14957 /* Reset temporary structure */
14958 ZERO_STRUCT(state->tmp);
14959
14960 tevent_req_done(req);
14961 }
14962
14963 NTSTATUS rpccli_spoolss_63_recv(struct tevent_req *req,
14964 TALLOC_CTX *mem_ctx,
14965 WERROR *result)
14966 {
14967 struct rpccli_spoolss_63_state *state = tevent_req_data(
14968 req, struct rpccli_spoolss_63_state);
14969 NTSTATUS status;
14970
14971 if (tevent_req_is_nterror(req, &status)) {
14972 tevent_req_received(req);
14973 return status;
14974 }
14975
14976 /* Steal possbile out parameters to the callers context */
14977 talloc_steal(mem_ctx, state->out_mem_ctx);
14978
14979 /* Return result */
14980 *result = state->orig.out.result;
14981
14982 tevent_req_received(req);
14983 return NT_STATUS_OK;
14984 }
14985
14986 NTSTATUS rpccli_spoolss_63(struct rpc_pipe_client *cli,
14987 TALLOC_CTX *mem_ctx,
14988 WERROR *werror)
14989 {
14990 struct spoolss_63 r;
14991 NTSTATUS status;
14992
14993 /* In parameters */
14994
14995 status = cli->dispatch(cli,
14996 mem_ctx,
14997 &ndr_table_spoolss,
14998 NDR_SPOOLSS_63,
14999 &r);
15000
15001 if (!NT_STATUS_IS_OK(status)) {
15002 return status;
15003 }
15004
15005 if (NT_STATUS_IS_ERR(status)) {
15006 return status;
15007 }
15008
15009 /* Return variables */
15010
15011 /* Return result */
15012 if (werror) {
15013 *werror = r.out.result;
15014 }
15015
15016 return werror_to_ntstatus(r.out.result);
15017 }
15018
15019 struct rpccli_spoolss_64_state {
15020 struct spoolss_64 orig;
15021 struct spoolss_64 tmp;
15022 TALLOC_CTX *out_mem_ctx;
15023 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15024 };
15025
15026 static void rpccli_spoolss_64_done(struct tevent_req *subreq);
15027
15028 struct tevent_req *rpccli_spoolss_64_send(TALLOC_CTX *mem_ctx,
15029 struct tevent_context *ev,
15030 struct rpc_pipe_client *cli)
15031 {
15032 struct tevent_req *req;
15033 struct rpccli_spoolss_64_state *state;
15034 struct tevent_req *subreq;
15035
15036 req = tevent_req_create(mem_ctx, &state,
15037 struct rpccli_spoolss_64_state);
15038 if (req == NULL) {
15039 return NULL;
15040 }
15041 state->out_mem_ctx = NULL;
15042 state->dispatch_recv = cli->dispatch_recv;
15043
15044 /* In parameters */
15045
15046 /* Out parameters */
15047
15048 /* Result */
15049 ZERO_STRUCT(state->orig.out.result);
15050
15051 /* make a temporary copy, that we pass to the dispatch function */
15052 state->tmp = state->orig;
15053
15054 subreq = cli->dispatch_send(state, ev, cli,
15055 &ndr_table_spoolss,
15056 NDR_SPOOLSS_64,
15057 &state->tmp);
15058 if (tevent_req_nomem(subreq, req)) {
15059 return tevent_req_post(req, ev);
15060 }
15061 tevent_req_set_callback(subreq, rpccli_spoolss_64_done, req);
15062 return req;
15063 }
15064
15065 static void rpccli_spoolss_64_done(struct tevent_req *subreq)
15066 {
15067 struct tevent_req *req = tevent_req_callback_data(
15068 subreq, struct tevent_req);
15069 struct rpccli_spoolss_64_state *state = tevent_req_data(
15070 req, struct rpccli_spoolss_64_state);
15071 NTSTATUS status;
15072 TALLOC_CTX *mem_ctx;
15073
15074 if (state->out_mem_ctx) {
15075 mem_ctx = state->out_mem_ctx;
15076 } else {
15077 mem_ctx = state;
15078 }
15079
15080 status = state->dispatch_recv(subreq, mem_ctx);
15081 TALLOC_FREE(subreq);
15082 if (!NT_STATUS_IS_OK(status)) {
15083 tevent_req_nterror(req, status);
15084 return;
15085 }
15086
15087 /* Copy out parameters */
15088
15089 /* Copy result */
15090 state->orig.out.result = state->tmp.out.result;
15091
15092 /* Reset temporary structure */
15093 ZERO_STRUCT(state->tmp);
15094
15095 tevent_req_done(req);
15096 }
15097
15098 NTSTATUS rpccli_spoolss_64_recv(struct tevent_req *req,
15099 TALLOC_CTX *mem_ctx,
15100 WERROR *result)
15101 {
15102 struct rpccli_spoolss_64_state *state = tevent_req_data(
15103 req, struct rpccli_spoolss_64_state);
15104 NTSTATUS status;
15105
15106 if (tevent_req_is_nterror(req, &status)) {
15107 tevent_req_received(req);
15108 return status;
15109 }
15110
15111 /* Steal possbile out parameters to the callers context */
15112 talloc_steal(mem_ctx, state->out_mem_ctx);
15113
15114 /* Return result */
15115 *result = state->orig.out.result;
15116
15117 tevent_req_received(req);
15118 return NT_STATUS_OK;
15119 }
15120
15121 NTSTATUS rpccli_spoolss_64(struct rpc_pipe_client *cli,
15122 TALLOC_CTX *mem_ctx,
15123 WERROR *werror)
15124 {
15125 struct spoolss_64 r;
15126 NTSTATUS status;
15127
15128 /* In parameters */
15129
15130 status = cli->dispatch(cli,
15131 mem_ctx,
15132 &ndr_table_spoolss,
15133 NDR_SPOOLSS_64,
15134 &r);
15135
15136 if (!NT_STATUS_IS_OK(status)) {
15137 return status;
15138 }
15139
15140 if (NT_STATUS_IS_ERR(status)) {
15141 return status;
15142 }
15143
15144 /* Return variables */
15145
15146 /* Return result */
15147 if (werror) {
15148 *werror = r.out.result;
15149 }
15150
15151 return werror_to_ntstatus(r.out.result);
15152 }
15153
15154 struct rpccli_spoolss_65_state {
15155 struct spoolss_65 orig;
15156 struct spoolss_65 tmp;
15157 TALLOC_CTX *out_mem_ctx;
15158 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15159 };
15160
15161 static void rpccli_spoolss_65_done(struct tevent_req *subreq);
15162
15163 struct tevent_req *rpccli_spoolss_65_send(TALLOC_CTX *mem_ctx,
15164 struct tevent_context *ev,
15165 struct rpc_pipe_client *cli)
15166 {
15167 struct tevent_req *req;
15168 struct rpccli_spoolss_65_state *state;
15169 struct tevent_req *subreq;
15170
15171 req = tevent_req_create(mem_ctx, &state,
15172 struct rpccli_spoolss_65_state);
15173 if (req == NULL) {
15174 return NULL;
15175 }
15176 state->out_mem_ctx = NULL;
15177 state->dispatch_recv = cli->dispatch_recv;
15178
15179 /* In parameters */
15180
15181 /* Out parameters */
15182
15183 /* Result */
15184 ZERO_STRUCT(state->orig.out.result);
15185
15186 /* make a temporary copy, that we pass to the dispatch function */
15187 state->tmp = state->orig;
15188
15189 subreq = cli->dispatch_send(state, ev, cli,
15190 &ndr_table_spoolss,
15191 NDR_SPOOLSS_65,
15192 &state->tmp);
15193 if (tevent_req_nomem(subreq, req)) {
15194 return tevent_req_post(req, ev);
15195 }
15196 tevent_req_set_callback(subreq, rpccli_spoolss_65_done, req);
15197 return req;
15198 }
15199
15200 static void rpccli_spoolss_65_done(struct tevent_req *subreq)
15201 {
15202 struct tevent_req *req = tevent_req_callback_data(
15203 subreq, struct tevent_req);
15204 struct rpccli_spoolss_65_state *state = tevent_req_data(
15205 req, struct rpccli_spoolss_65_state);
15206 NTSTATUS status;
15207 TALLOC_CTX *mem_ctx;
15208
15209 if (state->out_mem_ctx) {
15210 mem_ctx = state->out_mem_ctx;
15211 } else {
15212 mem_ctx = state;
15213 }
15214
15215 status = state->dispatch_recv(subreq, mem_ctx);
15216 TALLOC_FREE(subreq);
15217 if (!NT_STATUS_IS_OK(status)) {
15218 tevent_req_nterror(req, status);
15219 return;
15220 }
15221
15222 /* Copy out parameters */
15223
15224 /* Copy result */
15225 state->orig.out.result = state->tmp.out.result;
15226
15227 /* Reset temporary structure */
15228 ZERO_STRUCT(state->tmp);
15229
15230 tevent_req_done(req);
15231 }
15232
15233 NTSTATUS rpccli_spoolss_65_recv(struct tevent_req *req,
15234 TALLOC_CTX *mem_ctx,
15235 WERROR *result)
15236 {
15237 struct rpccli_spoolss_65_state *state = tevent_req_data(
15238 req, struct rpccli_spoolss_65_state);
15239 NTSTATUS status;
15240
15241 if (tevent_req_is_nterror(req, &status)) {
15242 tevent_req_received(req);
15243 return status;
15244 }
15245
15246 /* Steal possbile out parameters to the callers context */
15247 talloc_steal(mem_ctx, state->out_mem_ctx);
15248
15249 /* Return result */
15250 *result = state->orig.out.result;
15251
15252 tevent_req_received(req);
15253 return NT_STATUS_OK;
15254 }
15255
15256 NTSTATUS rpccli_spoolss_65(struct rpc_pipe_client *cli,
15257 TALLOC_CTX *mem_ctx,
15258 WERROR *werror)
15259 {
15260 struct spoolss_65 r;
15261 NTSTATUS status;
15262
15263 /* In parameters */
15264
15265 status = cli->dispatch(cli,
15266 mem_ctx,
15267 &ndr_table_spoolss,
15268 NDR_SPOOLSS_65,
15269 &r);
15270
15271 if (!NT_STATUS_IS_OK(status)) {
15272 return status;
15273 }
15274
15275 if (NT_STATUS_IS_ERR(status)) {
15276 return status;
15277 }
15278
15279 /* Return variables */
15280
15281 /* Return result */
15282 if (werror) {
15283 *werror = r.out.result;
15284 }
15285
15286 return werror_to_ntstatus(r.out.result);
15287 }
15288
15289 struct rpccli_spoolss_GetCorePrinterDrivers_state {
15290 struct spoolss_GetCorePrinterDrivers orig;
15291 struct spoolss_GetCorePrinterDrivers tmp;
15292 TALLOC_CTX *out_mem_ctx;
15293 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15294 };
15295
15296 static void rpccli_spoolss_GetCorePrinterDrivers_done(struct tevent_req *subreq);
15297
15298 struct tevent_req *rpccli_spoolss_GetCorePrinterDrivers_send(TALLOC_CTX *mem_ctx,
15299 struct tevent_context *ev,
15300 struct rpc_pipe_client *cli,
15301 const char *_servername /* [in] [unique,charset(UTF16)] */,
15302 const char *_architecture /* [in] [ref,charset(UTF16)] */,
15303 uint32_t _core_driver_size /* [in] */,
15304 const char *_core_driver_dependencies /* [in] [ref,charset(UTF16),size_is(core_driver_size)] */,
15305 uint32_t _core_printer_driver_count /* [in] */,
15306 struct spoolss_CorePrinterDriver *_core_printer_drivers /* [out] [ref,size_is(core_printer_driver_count)] */)
15307 {
15308 struct tevent_req *req;
15309 struct rpccli_spoolss_GetCorePrinterDrivers_state *state;
15310 struct tevent_req *subreq;
15311
15312 req = tevent_req_create(mem_ctx, &state,
15313 struct rpccli_spoolss_GetCorePrinterDrivers_state);
15314 if (req == NULL) {
15315 return NULL;
15316 }
15317 state->out_mem_ctx = NULL;
15318 state->dispatch_recv = cli->dispatch_recv;
15319
15320 /* In parameters */
15321 state->orig.in.servername = _servername;
15322 state->orig.in.architecture = _architecture;
15323 state->orig.in.core_driver_size = _core_driver_size;
15324 state->orig.in.core_driver_dependencies = _core_driver_dependencies;
15325 state->orig.in.core_printer_driver_count = _core_printer_driver_count;
15326
15327 /* Out parameters */
15328 state->orig.out.core_printer_drivers = _core_printer_drivers;
15329
15330 /* Result */
15331 ZERO_STRUCT(state->orig.out.result);
15332
15333 state->out_mem_ctx = talloc_named_const(state, 0,
15334 "rpccli_spoolss_GetCorePrinterDrivers_out_memory");
15335 if (tevent_req_nomem(state->out_mem_ctx, req)) {
15336 return tevent_req_post(req, ev);
15337 }
15338
15339 /* make a temporary copy, that we pass to the dispatch function */
15340 state->tmp = state->orig;
15341
15342 subreq = cli->dispatch_send(state, ev, cli,
15343 &ndr_table_spoolss,
15344 NDR_SPOOLSS_GETCOREPRINTERDRIVERS,
15345 &state->tmp);
15346 if (tevent_req_nomem(subreq, req)) {
15347 return tevent_req_post(req, ev);
15348 }
15349 tevent_req_set_callback(subreq, rpccli_spoolss_GetCorePrinterDrivers_done, req);
15350 return req;
15351 }
15352
15353 static void rpccli_spoolss_GetCorePrinterDrivers_done(struct tevent_req *subreq)
15354 {
15355 struct tevent_req *req = tevent_req_callback_data(
15356 subreq, struct tevent_req);
15357 struct rpccli_spoolss_GetCorePrinterDrivers_state *state = tevent_req_data(
15358 req, struct rpccli_spoolss_GetCorePrinterDrivers_state);
15359 NTSTATUS status;
15360 TALLOC_CTX *mem_ctx;
15361
15362 if (state->out_mem_ctx) {
15363 mem_ctx = state->out_mem_ctx;
15364 } else {
15365 mem_ctx = state;
15366 }
15367
15368 status = state->dispatch_recv(subreq, mem_ctx);
15369 TALLOC_FREE(subreq);
15370 if (!NT_STATUS_IS_OK(status)) {
15371 tevent_req_nterror(req, status);
15372 return;
15373 }
15374
15375 /* Copy out parameters */
15376 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));
15377
15378 /* Copy result */
15379 state->orig.out.result = state->tmp.out.result;
15380
15381 /* Reset temporary structure */
15382 ZERO_STRUCT(state->tmp);
15383
15384 tevent_req_done(req);
15385 }
15386
15387 NTSTATUS rpccli_spoolss_GetCorePrinterDrivers_recv(struct tevent_req *req,
15388 TALLOC_CTX *mem_ctx,
15389 WERROR *result)
15390 {
15391 struct rpccli_spoolss_GetCorePrinterDrivers_state *state = tevent_req_data(
15392 req, struct rpccli_spoolss_GetCorePrinterDrivers_state);
15393 NTSTATUS status;
15394
15395 if (tevent_req_is_nterror(req, &status)) {
15396 tevent_req_received(req);
15397 return status;
15398 }
15399
15400 /* Steal possbile out parameters to the callers context */
15401 talloc_steal(mem_ctx, state->out_mem_ctx);
15402
15403 /* Return result */
15404 *result = state->orig.out.result;
15405
15406 tevent_req_received(req);
15407 return NT_STATUS_OK;
15408 }
15409
15410 NTSTATUS rpccli_spoolss_GetCorePrinterDrivers(struct rpc_pipe_client *cli,
15411 TALLOC_CTX *mem_ctx,
15412 const char *servername /* [in] [unique,charset(UTF16)] */,
15413 const char *architecture /* [in] [ref,charset(UTF16)] */,
15414 uint32_t core_driver_size /* [in] */,
15415 const char *core_driver_dependencies /* [in] [ref,charset(UTF16),size_is(core_driver_size)] */,
15416 uint32_t core_printer_driver_count /* [in] */,
15417 struct spoolss_CorePrinterDriver *core_printer_drivers /* [out] [ref,size_is(core_printer_driver_count)] */,
15418 WERROR *werror)
15419 {
15420 struct spoolss_GetCorePrinterDrivers r;
15421 NTSTATUS status;
15422
15423 /* In parameters */
15424 r.in.servername = servername;
15425 r.in.architecture = architecture;
15426 r.in.core_driver_size = core_driver_size;
15427 r.in.core_driver_dependencies = core_driver_dependencies;
15428 r.in.core_printer_driver_count = core_printer_driver_count;
15429
15430 status = cli->dispatch(cli,
15431 mem_ctx,
15432 &ndr_table_spoolss,
15433 NDR_SPOOLSS_GETCOREPRINTERDRIVERS,
15434 &r);
15435
15436 if (!NT_STATUS_IS_OK(status)) {
15437 return status;
15438 }
15439
15440 if (NT_STATUS_IS_ERR(status)) {
15441 return status;
15442 }
15443
15444 /* Return variables */
15445 memcpy(core_printer_drivers, r.out.core_printer_drivers, (r.in.core_printer_driver_count) * sizeof(*core_printer_drivers));
15446
15447 /* Return result */
15448 if (werror) {
15449 *werror = r.out.result;
15450 }
15451
15452 return werror_to_ntstatus(r.out.result);
15453 }
15454
15455 struct rpccli_spoolss_67_state {
15456 struct spoolss_67 orig;
15457 struct spoolss_67 tmp;
15458 TALLOC_CTX *out_mem_ctx;
15459 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15460 };
15461
15462 static void rpccli_spoolss_67_done(struct tevent_req *subreq);
15463
15464 struct tevent_req *rpccli_spoolss_67_send(TALLOC_CTX *mem_ctx,
15465 struct tevent_context *ev,
15466 struct rpc_pipe_client *cli)
15467 {
15468 struct tevent_req *req;
15469 struct rpccli_spoolss_67_state *state;
15470 struct tevent_req *subreq;
15471
15472 req = tevent_req_create(mem_ctx, &state,
15473 struct rpccli_spoolss_67_state);
15474 if (req == NULL) {
15475 return NULL;
15476 }
15477 state->out_mem_ctx = NULL;
15478 state->dispatch_recv = cli->dispatch_recv;
15479
15480 /* In parameters */
15481
15482 /* Out parameters */
15483
15484 /* Result */
15485 ZERO_STRUCT(state->orig.out.result);
15486
15487 /* make a temporary copy, that we pass to the dispatch function */
15488 state->tmp = state->orig;
15489
15490 subreq = cli->dispatch_send(state, ev, cli,
15491 &ndr_table_spoolss,
15492 NDR_SPOOLSS_67,
15493 &state->tmp);
15494 if (tevent_req_nomem(subreq, req)) {
15495 return tevent_req_post(req, ev);
15496 }
15497 tevent_req_set_callback(subreq, rpccli_spoolss_67_done, req);
15498 return req;
15499 }
15500
15501 static void rpccli_spoolss_67_done(struct tevent_req *subreq)
15502 {
15503 struct tevent_req *req = tevent_req_callback_data(
15504 subreq, struct tevent_req);
15505 struct rpccli_spoolss_67_state *state = tevent_req_data(
15506 req, struct rpccli_spoolss_67_state);
15507 NTSTATUS status;
15508 TALLOC_CTX *mem_ctx;
15509
15510 if (state->out_mem_ctx) {
15511 mem_ctx = state->out_mem_ctx;
15512 } else {
15513 mem_ctx = state;
15514 }
15515
15516 status = state->dispatch_recv(subreq, mem_ctx);
15517 TALLOC_FREE(subreq);
15518 if (!NT_STATUS_IS_OK(status)) {
15519 tevent_req_nterror(req, status);
15520 return;
15521 }
15522
15523 /* Copy out parameters */
15524
15525 /* Copy result */
15526 state->orig.out.result = state->tmp.out.result;
15527
15528 /* Reset temporary structure */
15529 ZERO_STRUCT(state->tmp);
15530
15531 tevent_req_done(req);
15532 }
15533
15534 NTSTATUS rpccli_spoolss_67_recv(struct tevent_req *req,
15535 TALLOC_CTX *mem_ctx,
15536 WERROR *result)
15537 {
15538 struct rpccli_spoolss_67_state *state = tevent_req_data(
15539 req, struct rpccli_spoolss_67_state);
15540 NTSTATUS status;
15541
15542 if (tevent_req_is_nterror(req, &status)) {
15543 tevent_req_received(req);
15544 return status;
15545 }
15546
15547 /* Steal possbile out parameters to the callers context */
15548 talloc_steal(mem_ctx, state->out_mem_ctx);
15549
15550 /* Return result */
15551 *result = state->orig.out.result;
15552
15553 tevent_req_received(req);
15554 return NT_STATUS_OK;
15555 }
15556
15557 NTSTATUS rpccli_spoolss_67(struct rpc_pipe_client *cli,
15558 TALLOC_CTX *mem_ctx,
15559 WERROR *werror)
15560 {
15561 struct spoolss_67 r;
15562 NTSTATUS status;
15563
15564 /* In parameters */
15565
15566 status = cli->dispatch(cli,
15567 mem_ctx,
15568 &ndr_table_spoolss,
15569 NDR_SPOOLSS_67,
15570 &r);
15571
15572 if (!NT_STATUS_IS_OK(status)) {
15573 return status;
15574 }
15575
15576 if (NT_STATUS_IS_ERR(status)) {
15577 return status;
15578 }
15579
15580 /* Return variables */
15581
15582 /* Return result */
15583 if (werror) {
15584 *werror = r.out.result;
15585 }
15586
15587 return werror_to_ntstatus(r.out.result);
15588 }
15589
15590 struct rpccli_spoolss_GetPrinterDriverPackagePath_state {
15591 struct spoolss_GetPrinterDriverPackagePath orig;
15592 struct spoolss_GetPrinterDriverPackagePath tmp;
15593 TALLOC_CTX *out_mem_ctx;
15594 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15595 };
15596
15597 static void rpccli_spoolss_GetPrinterDriverPackagePath_done(struct tevent_req *subreq);
15598
15599 struct tevent_req *rpccli_spoolss_GetPrinterDriverPackagePath_send(TALLOC_CTX *mem_ctx,
15600 struct tevent_context *ev,
15601 struct rpc_pipe_client *cli,
15602 const char *_servername /* [in] [unique,charset(UTF16)] */,
15603 const char *_architecture /* [in] [ref,charset(UTF16)] */,
15604 const char *_language /* [in] [unique,charset(UTF16)] */,
15605 const char *_package_id /* [in] [ref,charset(UTF16)] */,
15606 const char *_driver_package_cab /* [in,out] [unique,charset(UTF16),size_is(driver_package_cab_size)] */,
15607 uint32_t _driver_package_cab_size /* [in] */,
15608 uint32_t *_required /* [out] [ref] */)
15609 {
15610 struct tevent_req *req;
15611 struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state;
15612 struct tevent_req *subreq;
15613
15614 req = tevent_req_create(mem_ctx, &state,
15615 struct rpccli_spoolss_GetPrinterDriverPackagePath_state);
15616 if (req == NULL) {
15617 return NULL;
15618 }
15619 state->out_mem_ctx = NULL;
15620 state->dispatch_recv = cli->dispatch_recv;
15621
15622 /* In parameters */
15623 state->orig.in.servername = _servername;
15624 state->orig.in.architecture = _architecture;
15625 state->orig.in.language = _language;
15626 state->orig.in.package_id = _package_id;
15627 state->orig.in.driver_package_cab = _driver_package_cab;
15628 state->orig.in.driver_package_cab_size = _driver_package_cab_size;
15629
15630 /* Out parameters */
15631 state->orig.out.driver_package_cab = _driver_package_cab;
15632 state->orig.out.required = _required;
15633
15634 /* Result */
15635 ZERO_STRUCT(state->orig.out.result);
15636
15637 state->out_mem_ctx = talloc_named_const(state, 0,
15638 "rpccli_spoolss_GetPrinterDriverPackagePath_out_memory");
15639 if (tevent_req_nomem(state->out_mem_ctx, req)) {
15640 return tevent_req_post(req, ev);
15641 }
15642
15643 /* make a temporary copy, that we pass to the dispatch function */
15644 state->tmp = state->orig;
15645
15646 subreq = cli->dispatch_send(state, ev, cli,
15647 &ndr_table_spoolss,
15648 NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH,
15649 &state->tmp);
15650 if (tevent_req_nomem(subreq, req)) {
15651 return tevent_req_post(req, ev);
15652 }
15653 tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriverPackagePath_done, req);
15654 return req;
15655 }
15656
15657 static void rpccli_spoolss_GetPrinterDriverPackagePath_done(struct tevent_req *subreq)
15658 {
15659 struct tevent_req *req = tevent_req_callback_data(
15660 subreq, struct tevent_req);
15661 struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state = tevent_req_data(
15662 req, struct rpccli_spoolss_GetPrinterDriverPackagePath_state);
15663 NTSTATUS status;
15664 TALLOC_CTX *mem_ctx;
15665
15666 if (state->out_mem_ctx) {
15667 mem_ctx = state->out_mem_ctx;
15668 } else {
15669 mem_ctx = state;
15670 }
15671
15672 status = state->dispatch_recv(subreq, mem_ctx);
15673 TALLOC_FREE(subreq);
15674 if (!NT_STATUS_IS_OK(status)) {
15675 tevent_req_nterror(req, status);
15676 return;
15677 }
15678
15679 /* Copy out parameters */
15680 if (state->orig.out.driver_package_cab && state->tmp.out.driver_package_cab) {
15681 memcpy(discard_const_p(uint8_t *, 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));
15682 }
15683 *state->orig.out.required = *state->tmp.out.required;
15684
15685 /* Copy result */
15686 state->orig.out.result = state->tmp.out.result;
15687
15688 /* Reset temporary structure */
15689 ZERO_STRUCT(state->tmp);
15690
15691 tevent_req_done(req);
15692 }
15693
15694 NTSTATUS rpccli_spoolss_GetPrinterDriverPackagePath_recv(struct tevent_req *req,
15695 TALLOC_CTX *mem_ctx,
15696 WERROR *result)
15697 {
15698 struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state = tevent_req_data(
15699 req, struct rpccli_spoolss_GetPrinterDriverPackagePath_state);
15700 NTSTATUS status;
15701
15702 if (tevent_req_is_nterror(req, &status)) {
15703 tevent_req_received(req);
15704 return status;
15705 }
15706
15707 /* Steal possbile out parameters to the callers context */
15708 talloc_steal(mem_ctx, state->out_mem_ctx);
15709
15710 /* Return result */
15711 *result = state->orig.out.result;
15712
15713 tevent_req_received(req);
15714 return NT_STATUS_OK;
15715 }
15716
15717 NTSTATUS rpccli_spoolss_GetPrinterDriverPackagePath(struct rpc_pipe_client *cli,
15718 TALLOC_CTX *mem_ctx,
15719 const char *servername /* [in] [unique,charset(UTF16)] */,
15720 const char *architecture /* [in] [ref,charset(UTF16)] */,
15721 const char *language /* [in] [unique,charset(UTF16)] */,
15722 const char *package_id /* [in] [ref,charset(UTF16)] */,
15723 const char *driver_package_cab /* [in,out] [unique,charset(UTF16),size_is(driver_package_cab_size)] */,
15724 uint32_t driver_package_cab_size /* [in] */,
15725 uint32_t *required /* [out] [ref] */,
15726 WERROR *werror)
15727 {
15728 struct spoolss_GetPrinterDriverPackagePath r;
15729 NTSTATUS status;
15730
15731 /* In parameters */
15732 r.in.servername = servername;
15733 r.in.architecture = architecture;
15734 r.in.language = language;
15735 r.in.package_id = package_id;
15736 r.in.driver_package_cab = driver_package_cab;
15737 r.in.driver_package_cab_size = driver_package_cab_size;
15738
15739 status = cli->dispatch(cli,
15740 mem_ctx,
15741 &ndr_table_spoolss,
15742 NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH,
15743 &r);
15744
15745 if (!NT_STATUS_IS_OK(status)) {
15746 return status;
15747 }
15748
15749 if (NT_STATUS_IS_ERR(status)) {
15750 return status;
15751 }
15752
15753 /* Return variables */
15754 if (driver_package_cab && r.out.driver_package_cab) {
15755 memcpy(discard_const_p(uint8_t *, driver_package_cab), r.out.driver_package_cab, (r.in.driver_package_cab_size) * sizeof(*driver_package_cab));
15756 }
15757 *required = *r.out.required;
15758
15759 /* Return result */
15760 if (werror) {
15761 *werror = r.out.result;
15762 }
15763
15764 return werror_to_ntstatus(r.out.result);
15765 }
15766
15767 struct rpccli_spoolss_69_state {
15768 struct spoolss_69 orig;
15769 struct spoolss_69 tmp;
15770 TALLOC_CTX *out_mem_ctx;
15771 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15772 };
15773
15774 static void rpccli_spoolss_69_done(struct tevent_req *subreq);
15775
15776 struct tevent_req *rpccli_spoolss_69_send(TALLOC_CTX *mem_ctx,
15777 struct tevent_context *ev,
15778 struct rpc_pipe_client *cli)
15779 {
15780 struct tevent_req *req;
15781 struct rpccli_spoolss_69_state *state;
15782 struct tevent_req *subreq;
15783
15784 req = tevent_req_create(mem_ctx, &state,
15785 struct rpccli_spoolss_69_state);
15786 if (req == NULL) {
15787 return NULL;
15788 }
15789 state->out_mem_ctx = NULL;
15790 state->dispatch_recv = cli->dispatch_recv;
15791
15792 /* In parameters */
15793
15794 /* Out parameters */
15795
15796 /* Result */
15797 ZERO_STRUCT(state->orig.out.result);
15798
15799 /* make a temporary copy, that we pass to the dispatch function */
15800 state->tmp = state->orig;
15801
15802 subreq = cli->dispatch_send(state, ev, cli,
15803 &ndr_table_spoolss,
15804 NDR_SPOOLSS_69,
15805 &state->tmp);
15806 if (tevent_req_nomem(subreq, req)) {
15807 return tevent_req_post(req, ev);
15808 }
15809 tevent_req_set_callback(subreq, rpccli_spoolss_69_done, req);
15810 return req;
15811 }
15812
15813 static void rpccli_spoolss_69_done(struct tevent_req *subreq)
15814 {
15815 struct tevent_req *req = tevent_req_callback_data(
15816 subreq, struct tevent_req);
15817 struct rpccli_spoolss_69_state *state = tevent_req_data(
15818 req, struct rpccli_spoolss_69_state);
15819 NTSTATUS status;
15820 TALLOC_CTX *mem_ctx;
15821
15822 if (state->out_mem_ctx) {
15823 mem_ctx = state->out_mem_ctx;
15824 } else {
15825 mem_ctx = state;
15826 }
15827
15828 status = state->dispatch_recv(subreq, mem_ctx);
15829 TALLOC_FREE(subreq);
15830 if (!NT_STATUS_IS_OK(status)) {
15831 tevent_req_nterror(req, status);
15832 return;
15833 }
15834
15835 /* Copy out parameters */
15836
15837 /* Copy result */
15838 state->orig.out.result = state->tmp.out.result;
15839
15840 /* Reset temporary structure */
15841 ZERO_STRUCT(state->tmp);
15842
15843 tevent_req_done(req);
15844 }
15845
15846 NTSTATUS rpccli_spoolss_69_recv(struct tevent_req *req,
15847 TALLOC_CTX *mem_ctx,
15848 WERROR *result)
15849 {
15850 struct rpccli_spoolss_69_state *state = tevent_req_data(
15851 req, struct rpccli_spoolss_69_state);
15852 NTSTATUS status;
15853
15854 if (tevent_req_is_nterror(req, &status)) {
15855 tevent_req_received(req);
15856 return status;
15857 }
15858
15859 /* Steal possbile out parameters to the callers context */
15860 talloc_steal(mem_ctx, state->out_mem_ctx);
15861
15862 /* Return result */
15863 *result = state->orig.out.result;
15864
15865 tevent_req_received(req);
15866 return NT_STATUS_OK;
15867 }
15868
15869 NTSTATUS rpccli_spoolss_69(struct rpc_pipe_client *cli,
15870 TALLOC_CTX *mem_ctx,
15871 WERROR *werror)
15872 {
15873 struct spoolss_69 r;
15874 NTSTATUS status;
15875
15876 /* In parameters */
15877
15878 status = cli->dispatch(cli,
15879 mem_ctx,
15880 &ndr_table_spoolss,
15881 NDR_SPOOLSS_69,
15882 &r);
15883
15884 if (!NT_STATUS_IS_OK(status)) {
15885 return status;
15886 }
15887
15888 if (NT_STATUS_IS_ERR(status)) {
15889 return status;
15890 }
15891
15892 /* Return variables */
15893
15894 /* Return result */
15895 if (werror) {
15896 *werror = r.out.result;
15897 }
15898
15899 return werror_to_ntstatus(r.out.result);
15900 }
15901
15902 struct rpccli_spoolss_6a_state {
15903 struct spoolss_6a orig;
15904 struct spoolss_6a tmp;
15905 TALLOC_CTX *out_mem_ctx;
15906 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15907 };
15908
15909 static void rpccli_spoolss_6a_done(struct tevent_req *subreq);
15910
15911 struct tevent_req *rpccli_spoolss_6a_send(TALLOC_CTX *mem_ctx,
15912 struct tevent_context *ev,
15913 struct rpc_pipe_client *cli)
15914 {
15915 struct tevent_req *req;
15916 struct rpccli_spoolss_6a_state *state;
15917 struct tevent_req *subreq;
15918
15919 req = tevent_req_create(mem_ctx, &state,
15920 struct rpccli_spoolss_6a_state);
15921 if (req == NULL) {
15922 return NULL;
15923 }
15924 state->out_mem_ctx = NULL;
15925 state->dispatch_recv = cli->dispatch_recv;
15926
15927 /* In parameters */
15928
15929 /* Out parameters */
15930
15931 /* Result */
15932 ZERO_STRUCT(state->orig.out.result);
15933
15934 /* make a temporary copy, that we pass to the dispatch function */
15935 state->tmp = state->orig;
15936
15937 subreq = cli->dispatch_send(state, ev, cli,
15938 &ndr_table_spoolss,
15939 NDR_SPOOLSS_6A,
15940 &state->tmp);
15941 if (tevent_req_nomem(subreq, req)) {
15942 return tevent_req_post(req, ev);
15943 }
15944 tevent_req_set_callback(subreq, rpccli_spoolss_6a_done, req);
15945 return req;
15946 }
15947
15948 static void rpccli_spoolss_6a_done(struct tevent_req *subreq)
15949 {
15950 struct tevent_req *req = tevent_req_callback_data(
15951 subreq, struct tevent_req);
15952 struct rpccli_spoolss_6a_state *state = tevent_req_data(
15953 req, struct rpccli_spoolss_6a_state);
15954 NTSTATUS status;
15955 TALLOC_CTX *mem_ctx;
15956
15957 if (state->out_mem_ctx) {
15958 mem_ctx = state->out_mem_ctx;
15959 } else {
15960 mem_ctx = state;
15961 }
15962
15963 status = state->dispatch_recv(subreq, mem_ctx);
15964 TALLOC_FREE(subreq);
15965 if (!NT_STATUS_IS_OK(status)) {
15966 tevent_req_nterror(req, status);
15967 return;
15968 }
15969
15970 /* Copy out parameters */
15971
15972 /* Copy result */
15973 state->orig.out.result = state->tmp.out.result;
15974
15975 /* Reset temporary structure */
15976 ZERO_STRUCT(state->tmp);
15977
15978 tevent_req_done(req);
15979 }
15980
15981 NTSTATUS rpccli_spoolss_6a_recv(struct tevent_req *req,
15982 TALLOC_CTX *mem_ctx,
15983 WERROR *result)
15984 {
15985 struct rpccli_spoolss_6a_state *state = tevent_req_data(
15986 req, struct rpccli_spoolss_6a_state);
15987 NTSTATUS status;
15988
15989 if (tevent_req_is_nterror(req, &status)) {
15990 tevent_req_received(req);
15991 return status;
15992 }
15993
15994 /* Steal possbile out parameters to the callers context */
15995 talloc_steal(mem_ctx, state->out_mem_ctx);
15996
15997 /* Return result */
15998 *result = state->orig.out.result;
15999
16000 tevent_req_received(req);
16001 return NT_STATUS_OK;
16002 }
16003
16004 NTSTATUS rpccli_spoolss_6a(struct rpc_pipe_client *cli,
16005 TALLOC_CTX *mem_ctx,
16006 WERROR *werror)
16007 {
16008 struct spoolss_6a r;
16009 NTSTATUS status;
16010
16011 /* In parameters */
16012
16013 status = cli->dispatch(cli,
16014 mem_ctx,
16015 &ndr_table_spoolss,
16016 NDR_SPOOLSS_6A,
16017 &r);
16018
16019 if (!NT_STATUS_IS_OK(status)) {
16020 return status;
16021 }
16022
16023 if (NT_STATUS_IS_ERR(status)) {
16024 return status;
16025 }
16026
16027 /* Return variables */
16028
16029 /* Return result */
16030 if (werror) {
16031 *werror = r.out.result;
16032 }
16033
16034 return werror_to_ntstatus(r.out.result);
16035 }
16036
16037 struct rpccli_spoolss_6b_state {
16038 struct spoolss_6b orig;
16039 struct spoolss_6b tmp;
16040 TALLOC_CTX *out_mem_ctx;
16041 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16042 };
16043
16044 static void rpccli_spoolss_6b_done(struct tevent_req *subreq);
16045
16046 struct tevent_req *rpccli_spoolss_6b_send(TALLOC_CTX *mem_ctx,
16047 struct tevent_context *ev,
16048 struct rpc_pipe_client *cli)
16049 {
16050 struct tevent_req *req;
16051 struct rpccli_spoolss_6b_state *state;
16052 struct tevent_req *subreq;
16053
16054 req = tevent_req_create(mem_ctx, &state,
16055 struct rpccli_spoolss_6b_state);
16056 if (req == NULL) {
16057 return NULL;
16058 }
16059 state->out_mem_ctx = NULL;
16060 state->dispatch_recv = cli->dispatch_recv;
16061
16062 /* In parameters */
16063
16064 /* Out parameters */
16065
16066 /* Result */
16067 ZERO_STRUCT(state->orig.out.result);
16068
16069 /* make a temporary copy, that we pass to the dispatch function */
16070 state->tmp = state->orig;
16071
16072 subreq = cli->dispatch_send(state, ev, cli,
16073 &ndr_table_spoolss,
16074 NDR_SPOOLSS_6B,
16075 &state->tmp);
16076 if (tevent_req_nomem(subreq, req)) {
16077 return tevent_req_post(req, ev);
16078 }
16079 tevent_req_set_callback(subreq, rpccli_spoolss_6b_done, req);
16080 return req;
16081 }
16082
16083 static void rpccli_spoolss_6b_done(struct tevent_req *subreq)
16084 {
16085 struct tevent_req *req = tevent_req_callback_data(
16086 subreq, struct tevent_req);
16087 struct rpccli_spoolss_6b_state *state = tevent_req_data(
16088 req, struct rpccli_spoolss_6b_state);
16089 NTSTATUS status;
16090 TALLOC_CTX *mem_ctx;
16091
16092 if (state->out_mem_ctx) {
16093 mem_ctx = state->out_mem_ctx;
16094 } else {
16095 mem_ctx = state;
16096 }
16097
16098 status = state->dispatch_recv(subreq, mem_ctx);
16099 TALLOC_FREE(subreq);
16100 if (!NT_STATUS_IS_OK(status)) {
16101 tevent_req_nterror(req, status);
16102 return;
16103 }
16104
16105 /* Copy out parameters */
16106
16107 /* Copy result */
16108 state->orig.out.result = state->tmp.out.result;
16109
16110 /* Reset temporary structure */
16111 ZERO_STRUCT(state->tmp);
16112
16113 tevent_req_done(req);
16114 }
16115
16116 NTSTATUS rpccli_spoolss_6b_recv(struct tevent_req *req,
16117 TALLOC_CTX *mem_ctx,
16118 WERROR *result)
16119 {
16120 struct rpccli_spoolss_6b_state *state = tevent_req_data(
16121 req, struct rpccli_spoolss_6b_state);
16122 NTSTATUS status;
16123
16124 if (tevent_req_is_nterror(req, &status)) {
16125 tevent_req_received(req);
16126 return status;
16127 }
16128
16129 /* Steal possbile out parameters to the callers context */
16130 talloc_steal(mem_ctx, state->out_mem_ctx);
16131
16132 /* Return result */
16133 *result = state->orig.out.result;
16134
16135 tevent_req_received(req);
16136 return NT_STATUS_OK;
16137 }
16138
16139 NTSTATUS rpccli_spoolss_6b(struct rpc_pipe_client *cli,
16140 TALLOC_CTX *mem_ctx,
16141 WERROR *werror)
16142 {
16143 struct spoolss_6b r;
16144 NTSTATUS status;
16145
16146 /* In parameters */
16147
16148 status = cli->dispatch(cli,
16149 mem_ctx,
16150 &ndr_table_spoolss,
16151 NDR_SPOOLSS_6B,
16152 &r);
16153
16154 if (!NT_STATUS_IS_OK(status)) {
16155 return status;
16156 }
16157
16158 if (NT_STATUS_IS_ERR(status)) {
16159 return status;
16160 }
16161
16162 /* Return variables */
16163
16164 /* Return result */
16165 if (werror) {
16166 *werror = r.out.result;
16167 }
16168
16169 return werror_to_ntstatus(r.out.result);
16170 }
16171
16172 struct rpccli_spoolss_6c_state {
16173 struct spoolss_6c orig;
16174 struct spoolss_6c tmp;
16175 TALLOC_CTX *out_mem_ctx;
16176 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16177 };
16178
16179 static void rpccli_spoolss_6c_done(struct tevent_req *subreq);
16180
16181 struct tevent_req *rpccli_spoolss_6c_send(TALLOC_CTX *mem_ctx,
16182 struct tevent_context *ev,
16183 struct rpc_pipe_client *cli)
16184 {
16185 struct tevent_req *req;
16186 struct rpccli_spoolss_6c_state *state;
16187 struct tevent_req *subreq;
16188
16189 req = tevent_req_create(mem_ctx, &state,
16190 struct rpccli_spoolss_6c_state);
16191 if (req == NULL) {
16192 return NULL;
16193 }
16194 state->out_mem_ctx = NULL;
16195 state->dispatch_recv = cli->dispatch_recv;
16196
16197 /* In parameters */
16198
16199 /* Out parameters */
16200
16201 /* Result */
16202 ZERO_STRUCT(state->orig.out.result);
16203
16204 /* make a temporary copy, that we pass to the dispatch function */
16205 state->tmp = state->orig;
16206
16207 subreq = cli->dispatch_send(state, ev, cli,
16208 &ndr_table_spoolss,
16209 NDR_SPOOLSS_6C,
16210 &state->tmp);
16211 if (tevent_req_nomem(subreq, req)) {
16212 return tevent_req_post(req, ev);
16213 }
16214 tevent_req_set_callback(subreq, rpccli_spoolss_6c_done, req);
16215 return req;
16216 }
16217
16218 static void rpccli_spoolss_6c_done(struct tevent_req *subreq)
16219 {
16220 struct tevent_req *req = tevent_req_callback_data(
16221 subreq, struct tevent_req);
16222 struct rpccli_spoolss_6c_state *state = tevent_req_data(
16223 req, struct rpccli_spoolss_6c_state);
16224 NTSTATUS status;
16225 TALLOC_CTX *mem_ctx;
16226
16227 if (state->out_mem_ctx) {
16228 mem_ctx = state->out_mem_ctx;
16229 } else {
16230 mem_ctx = state;
16231 }
16232
16233 status = state->dispatch_recv(subreq, mem_ctx);
16234 TALLOC_FREE(subreq);
16235 if (!NT_STATUS_IS_OK(status)) {
16236 tevent_req_nterror(req, status);
16237 return;
16238 }
16239
16240 /* Copy out parameters */
16241
16242 /* Copy result */
16243 state->orig.out.result = state->tmp.out.result;
16244
16245 /* Reset temporary structure */
16246 ZERO_STRUCT(state->tmp);
16247
16248 tevent_req_done(req);
16249 }
16250
16251 NTSTATUS rpccli_spoolss_6c_recv(struct tevent_req *req,
16252 TALLOC_CTX *mem_ctx,
16253 WERROR *result)
16254 {
16255 struct rpccli_spoolss_6c_state *state = tevent_req_data(
16256 req, struct rpccli_spoolss_6c_state);
16257 NTSTATUS status;
16258
16259 if (tevent_req_is_nterror(req, &status)) {
16260 tevent_req_received(req);
16261 return status;
16262 }
16263
16264 /* Steal possbile out parameters to the callers context */
16265 talloc_steal(mem_ctx, state->out_mem_ctx);
16266
16267 /* Return result */
16268 *result = state->orig.out.result;
16269
16270 tevent_req_received(req);
16271 return NT_STATUS_OK;
16272 }
16273
16274 NTSTATUS rpccli_spoolss_6c(struct rpc_pipe_client *cli,
16275 TALLOC_CTX *mem_ctx,
16276 WERROR *werror)
16277 {
16278 struct spoolss_6c r;
16279 NTSTATUS status;
16280
16281 /* In parameters */
16282
16283 status = cli->dispatch(cli,
16284 mem_ctx,
16285 &ndr_table_spoolss,
16286 NDR_SPOOLSS_6C,
16287 &r);
16288
16289 if (!NT_STATUS_IS_OK(status)) {
16290 return status;
16291 }
16292
16293 if (NT_STATUS_IS_ERR(status)) {
16294 return status;
16295 }
16296
16297 /* Return variables */
16298
16299 /* Return result */
16300 if (werror) {
16301 *werror = r.out.result;
16302 }
16303
16304 return werror_to_ntstatus(r.out.result);
16305 }
16306
16307 struct rpccli_spoolss_6d_state {
16308 struct spoolss_6d orig;
16309 struct spoolss_6d tmp;
16310 TALLOC_CTX *out_mem_ctx;
16311 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16312 };
16313
16314 static void rpccli_spoolss_6d_done(struct tevent_req *subreq);
16315
16316 struct tevent_req *rpccli_spoolss_6d_send(TALLOC_CTX *mem_ctx,
16317 struct tevent_context *ev,
16318 struct rpc_pipe_client *cli)
16319 {
16320 struct tevent_req *req;
16321 struct rpccli_spoolss_6d_state *state;
16322 struct tevent_req *subreq;
16323
16324 req = tevent_req_create(mem_ctx, &state,
16325 struct rpccli_spoolss_6d_state);
16326 if (req == NULL) {
16327 return NULL;
16328 }
16329 state->out_mem_ctx = NULL;
16330 state->dispatch_recv = cli->dispatch_recv;
16331
16332 /* In parameters */
16333
16334 /* Out parameters */
16335
16336 /* Result */
16337 ZERO_STRUCT(state->orig.out.result);
16338
16339 /* make a temporary copy, that we pass to the dispatch function */
16340 state->tmp = state->orig;
16341
16342 subreq = cli->dispatch_send(state, ev, cli,
16343 &ndr_table_spoolss,
16344 NDR_SPOOLSS_6D,
16345 &state->tmp);
16346 if (tevent_req_nomem(subreq, req)) {
16347 return tevent_req_post(req, ev);
16348 }
16349 tevent_req_set_callback(subreq, rpccli_spoolss_6d_done, req);
16350 return req;
16351 }
16352
16353 static void rpccli_spoolss_6d_done(struct tevent_req *subreq)
16354 {
16355 struct tevent_req *req = tevent_req_callback_data(
16356 subreq, struct tevent_req);
16357 struct rpccli_spoolss_6d_state *state = tevent_req_data(
16358 req, struct rpccli_spoolss_6d_state);
16359 NTSTATUS status;
16360 TALLOC_CTX *mem_ctx;
16361
16362 if (state->out_mem_ctx) {
16363 mem_ctx = state->out_mem_ctx;
16364 } else {
16365 mem_ctx = state;
16366 }
16367
16368 status = state->dispatch_recv(subreq, mem_ctx);
16369 TALLOC_FREE(subreq);
16370 if (!NT_STATUS_IS_OK(status)) {
16371 tevent_req_nterror(req, status);
16372 return;
16373 }
16374
16375 /* Copy out parameters */
16376
16377 /* Copy result */
16378 state->orig.out.result = state->tmp.out.result;
16379
16380 /* Reset temporary structure */
16381 ZERO_STRUCT(state->tmp);
16382
16383 tevent_req_done(req);
16384 }
16385
16386 NTSTATUS rpccli_spoolss_6d_recv(struct tevent_req *req,
16387 TALLOC_CTX *mem_ctx,
16388 WERROR *result)
16389 {
16390 struct rpccli_spoolss_6d_state *state = tevent_req_data(
16391 req, struct rpccli_spoolss_6d_state);
16392 NTSTATUS status;
16393
16394 if (tevent_req_is_nterror(req, &status)) {
16395 tevent_req_received(req);
16396 return status;
16397 }
16398
16399 /* Steal possbile out parameters to the callers context */
16400 talloc_steal(mem_ctx, state->out_mem_ctx);
16401
16402 /* Return result */
16403 *result = state->orig.out.result;
16404
16405 tevent_req_received(req);
16406 return NT_STATUS_OK;
16407 }
16408
16409 NTSTATUS rpccli_spoolss_6d(struct rpc_pipe_client *cli,
16410 TALLOC_CTX *mem_ctx,
16411 WERROR *werror)
16412 {
16413 struct spoolss_6d r;
16414 NTSTATUS status;
16415
16416 /* In parameters */
16417
16418 status = cli->dispatch(cli,
16419 mem_ctx,
16420 &ndr_table_spoolss,
16421 NDR_SPOOLSS_6D,
16422 &r);
16423
16424 if (!NT_STATUS_IS_OK(status)) {
16425 return status;
16426 }
16427
16428 if (NT_STATUS_IS_ERR(status)) {
16429 return status;
16430 }
16431
16432 /* Return variables */
16433
16434 /* Return result */
16435 if (werror) {
16436 *werror = r.out.result;
16437 }
16438
16439 return werror_to_ntstatus(r.out.result);
16440 }
16441