?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ctdb-server: Clean up connection tracking functions
[samba4-gss.git] / source3 / rpc_server / spoolss / srv_iremotewinspool.c
blob5bc4228f83f629fe0e886df6f1d3c1761a919a3b
1 /*
2 * Unix SMB/CIFS implementation.
3 * server auto-generated by pidl. DO NOT MODIFY!
4 */
5
6 #include "includes.h"
7 #include "ntdomain.h"
8 #include "librpc/rpc/dcesrv_core.h"
9 #include "librpc/gen_ndr/ndr_spoolss.h"
10 #include "librpc/gen_ndr/ndr_winspool.h"
11 #include "librpc/gen_ndr/ndr_winspool_scompat.h"
12 #include "librpc/gen_ndr/ndr_spoolss_scompat.h"
13 #include "rpc_server/rpc_config.h"
14 #include "rpc_server/rpc_server.h"
15 #include "rpc_server/spoolss/iremotewinspool_util.h"
16
17 static bool forward_opnum_to_spoolss(uint16_t opnum) {
18 switch (opnum) {
19 case 58: /* winspool_SyncRegisterForRemoteNotifications */
20 case 59: /* winspool_SyncUnRegisterForRemoteNotifications */
21 case 60: /* winspool_SyncRefreshRemoteNotifications */
22 case 61: /* winspool_AsyncGetRemoteNotifications */
23 case 62: /* winspool_AsyncInstallPrinterDriverFromPackage */
24 case 63: /* winspool_AsyncUploadPrinterDriverPackage */
25 case 65: /* winspool_AsyncCorePrinterDriverInstalled */
26 case 67: /* winspool_AsyncDeletePrinterDriverPackage */
27 return false;
28 default:
29 break;
30 }
31 return true;
32 }
33
34 /* iremotewinspool - dcerpc server boilerplate generated by pidl */
35 static NTSTATUS iremotewinspool__op_bind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
36 {
37 #ifdef DCESRV_INTERFACE_IREMOTEWINSPOOL_BIND
38 return DCESRV_INTERFACE_IREMOTEWINSPOOL_BIND(context,iface);
39 #else
40 return NT_STATUS_OK;
41 #endif
42 }
43
44 static void iremotewinspool__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
45 {
46 #ifdef DCESRV_INTERFACE_IREMOTEWINSPOOL_UNBIND
47 DCESRV_INTERFACE_IREMOTEWINSPOOL_UNBIND(context, iface);
48 #else
49 return;
50 #endif
51 }
52
53 NTSTATUS iremotewinspool__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r)
54 {
55 enum ndr_err_code ndr_err;
56 uint16_t opnum = dce_call->pkt.u.request.opnum;
57 uint16_t mapped_opnum;
58
59 dce_call->fault_code = 0;
60
61 if (forward_opnum_to_spoolss(opnum)) {
62 bool ok;
63 ok = iremotewinspool_map_opcode(opnum, &mapped_opnum);
64 if (ok) {
65 dce_call->pkt.u.request.opnum = mapped_opnum;
66 }
67 return spoolss__op_ndr_pull(dce_call, mem_ctx, pull, r);
68 }
69
70 if (opnum >= ndr_table_iremotewinspool.num_calls) {
71 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
72 return NT_STATUS_NET_WRITE_FAULT;
73 }
74
75 *r = talloc_named(mem_ctx, ndr_table_iremotewinspool.calls[opnum].struct_size, "struct %s", ndr_table_iremotewinspool.calls[opnum].name);
76 NT_STATUS_HAVE_NO_MEMORY(*r);
77
78 /* unravel the NDR for the packet */
79 ndr_err = ndr_table_iremotewinspool.calls[opnum].ndr_pull(pull, NDR_IN, *r);
80 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
81 dce_call->fault_code = DCERPC_FAULT_NDR;
82 return NT_STATUS_NET_WRITE_FAULT;
83 }
84
85 return NT_STATUS_OK;
86 }
87
88 static NTSTATUS iremotewinspool__op_dispatch_internal(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r, bool rpcint_call)
89 {
90 uint16_t opnum = dce_call->pkt.u.request.opnum;
91 struct pipes_struct *p = NULL;
92 NTSTATUS status = NT_STATUS_OK;
93 bool impersonated = false;
94 bool ok;
95 struct GUID object_uuid;
96
97 ok = dce_call->pkt.pfc_flags & DCERPC_PFC_FLAG_OBJECT_UUID;
98 if (!ok) {
99 dce_call->fault_code = DCERPC_NCA_S_UNSUPPORTED_TYPE;
100 return NT_STATUS_NET_WRITE_FAULT;
101 }
102
103 status = GUID_from_string(IREMOTEWINSPOOL_OBJECT_GUID, &object_uuid);
104 if (!NT_STATUS_IS_OK(status)) {
105 dce_call->fault_code = DCERPC_NCA_S_UNSUPPORTED_TYPE;
106 return NT_STATUS_NET_WRITE_FAULT;
107 }
108
109 if (!GUID_equal(&dce_call->pkt.u.request.object.object, &object_uuid)) {
110 dce_call->fault_code = DCERPC_NCA_S_UNSUPPORTED_TYPE;
111 return NT_STATUS_NET_WRITE_FAULT;
112 }
113
114 if (forward_opnum_to_spoolss(opnum)) {
115 return spoolss__op_dispatch(dce_call, mem_ctx, r);
116 }
117
118 /* Retrieve pipes struct */
119 p = dcesrv_get_pipes_struct(dce_call->conn);
120 p->dce_call = dce_call;
121 p->mem_ctx = mem_ctx;
122 /* Reset pipes struct fault state */
123 p->fault_state = 0;
124
125 /* Impersonate */
126 if (!rpcint_call) {
127 impersonated = become_authenticated_pipe_user(
128 dce_call->auth_state->session_info);
129 if (!impersonated) {
130 dce_call->fault_code = DCERPC_FAULT_ACCESS_DENIED;
131 status = NT_STATUS_NET_WRITE_FAULT;
132 goto fail;
133 }
134 }
135
136 switch (opnum) {
137 case 0: { /* winspool_AsyncOpenPrinter */
138 struct winspool_AsyncOpenPrinter *r2 = (struct winspool_AsyncOpenPrinter *)r;
139 if (DEBUGLEVEL >= 10) {
140 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncOpenPrinter, NDR_IN, r2);
141 }
142 NDR_ZERO_STRUCT(r2->out);
143 r2->out.pHandle = talloc_zero(r2, struct policy_handle);
144 if (r2->out.pHandle == NULL) {
145 status = NT_STATUS_NO_MEMORY;
146 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
147 goto fail;
148 }
149
150 r2->out.result = _winspool_AsyncOpenPrinter(p, r2);
151 break;
152 }
153 case 1: { /* winspool_AsyncAddPrinter */
154 struct winspool_AsyncAddPrinter *r2 = (struct winspool_AsyncAddPrinter *)r;
155 if (DEBUGLEVEL >= 10) {
156 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddPrinter, NDR_IN, r2);
157 }
158 NDR_ZERO_STRUCT(r2->out);
159 r2->out.pHandle = talloc_zero(r2, struct policy_handle);
160 if (r2->out.pHandle == NULL) {
161 status = NT_STATUS_NO_MEMORY;
162 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
163 goto fail;
164 }
165
166 r2->out.result = _winspool_AsyncAddPrinter(p, r2);
167 break;
168 }
169 case 2: { /* winspool_AsyncSetJob */
170 struct winspool_AsyncSetJob *r2 = (struct winspool_AsyncSetJob *)r;
171 if (DEBUGLEVEL >= 10) {
172 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSetJob, NDR_IN, r2);
173 }
174 r2->out.result = _winspool_AsyncSetJob(p, r2);
175 break;
176 }
177 case 3: { /* winspool_AsyncGetJob */
178 struct winspool_AsyncGetJob *r2 = (struct winspool_AsyncGetJob *)r;
179 if (DEBUGLEVEL >= 10) {
180 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetJob, NDR_IN, r2);
181 }
182 NDR_ZERO_STRUCT(r2->out);
183 r2->out.pJob = r2->in.pJob;
184 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
185 if (r2->out.pcbNeeded == NULL) {
186 status = NT_STATUS_NO_MEMORY;
187 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
188 goto fail;
189 }
190
191 r2->out.result = _winspool_AsyncGetJob(p, r2);
192 break;
193 }
194 case 4: { /* winspool_AsyncEnumJobs */
195 struct winspool_AsyncEnumJobs *r2 = (struct winspool_AsyncEnumJobs *)r;
196 if (DEBUGLEVEL >= 10) {
197 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumJobs, NDR_IN, r2);
198 }
199 NDR_ZERO_STRUCT(r2->out);
200 r2->out.pJob = r2->in.pJob;
201 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
202 if (r2->out.pcbNeeded == NULL) {
203 status = NT_STATUS_NO_MEMORY;
204 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
205 goto fail;
206 }
207
208 r2->out.pcReturned = talloc_zero(r2, uint32_t);
209 if (r2->out.pcReturned == NULL) {
210 status = NT_STATUS_NO_MEMORY;
211 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
212 goto fail;
213 }
214
215 r2->out.result = _winspool_AsyncEnumJobs(p, r2);
216 break;
217 }
218 case 5: { /* winspool_AsyncAddJob */
219 struct winspool_AsyncAddJob *r2 = (struct winspool_AsyncAddJob *)r;
220 if (DEBUGLEVEL >= 10) {
221 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddJob, NDR_IN, r2);
222 }
223 NDR_ZERO_STRUCT(r2->out);
224 r2->out.pAddJob = r2->in.pAddJob;
225 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
226 if (r2->out.pcbNeeded == NULL) {
227 status = NT_STATUS_NO_MEMORY;
228 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
229 goto fail;
230 }
231
232 r2->out.result = _winspool_AsyncAddJob(p, r2);
233 break;
234 }
235 case 6: { /* winspool_AsyncScheduleJob */
236 struct winspool_AsyncScheduleJob *r2 = (struct winspool_AsyncScheduleJob *)r;
237 if (DEBUGLEVEL >= 10) {
238 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncScheduleJob, NDR_IN, r2);
239 }
240 r2->out.result = _winspool_AsyncScheduleJob(p, r2);
241 break;
242 }
243 case 7: { /* winspool_AsyncDeletePrinter */
244 struct winspool_AsyncDeletePrinter *r2 = (struct winspool_AsyncDeletePrinter *)r;
245 if (DEBUGLEVEL >= 10) {
246 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinter, NDR_IN, r2);
247 }
248 r2->out.result = _winspool_AsyncDeletePrinter(p, r2);
249 break;
250 }
251 case 8: { /* winspool_AsyncSetPrinter */
252 struct winspool_AsyncSetPrinter *r2 = (struct winspool_AsyncSetPrinter *)r;
253 if (DEBUGLEVEL >= 10) {
254 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSetPrinter, NDR_IN, r2);
255 }
256 r2->out.result = _winspool_AsyncSetPrinter(p, r2);
257 break;
258 }
259 case 9: { /* winspool_AsyncGetPrinter */
260 struct winspool_AsyncGetPrinter *r2 = (struct winspool_AsyncGetPrinter *)r;
261 if (DEBUGLEVEL >= 10) {
262 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetPrinter, NDR_IN, r2);
263 }
264 NDR_ZERO_STRUCT(r2->out);
265 r2->out.pPrinter = r2->in.pPrinter;
266 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
267 if (r2->out.pcbNeeded == NULL) {
268 status = NT_STATUS_NO_MEMORY;
269 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
270 goto fail;
271 }
272
273 r2->out.result = _winspool_AsyncGetPrinter(p, r2);
274 break;
275 }
276 case 10: { /* winspool_AsyncStartDocPrinter */
277 struct winspool_AsyncStartDocPrinter *r2 = (struct winspool_AsyncStartDocPrinter *)r;
278 if (DEBUGLEVEL >= 10) {
279 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncStartDocPrinter, NDR_IN, r2);
280 }
281 NDR_ZERO_STRUCT(r2->out);
282 r2->out.pJobId = talloc_zero(r2, uint32_t);
283 if (r2->out.pJobId == NULL) {
284 status = NT_STATUS_NO_MEMORY;
285 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
286 goto fail;
287 }
288
289 r2->out.result = _winspool_AsyncStartDocPrinter(p, r2);
290 break;
291 }
292 case 11: { /* winspool_AsyncStartPagePrinter */
293 struct winspool_AsyncStartPagePrinter *r2 = (struct winspool_AsyncStartPagePrinter *)r;
294 if (DEBUGLEVEL >= 10) {
295 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncStartPagePrinter, NDR_IN, r2);
296 }
297 r2->out.result = _winspool_AsyncStartPagePrinter(p, r2);
298 break;
299 }
300 case 12: { /* winspool_AsyncWritePrinter */
301 struct winspool_AsyncWritePrinter *r2 = (struct winspool_AsyncWritePrinter *)r;
302 if (DEBUGLEVEL >= 10) {
303 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncWritePrinter, NDR_IN, r2);
304 }
305 NDR_ZERO_STRUCT(r2->out);
306 r2->out.pcWritten = talloc_zero(r2, uint32_t);
307 if (r2->out.pcWritten == NULL) {
308 status = NT_STATUS_NO_MEMORY;
309 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
310 goto fail;
311 }
312
313 r2->out.result = _winspool_AsyncWritePrinter(p, r2);
314 break;
315 }
316 case 13: { /* winspool_AsyncEndPagePrinter */
317 struct winspool_AsyncEndPagePrinter *r2 = (struct winspool_AsyncEndPagePrinter *)r;
318 if (DEBUGLEVEL >= 10) {
319 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEndPagePrinter, NDR_IN, r2);
320 }
321 r2->out.result = _winspool_AsyncEndPagePrinter(p, r2);
322 break;
323 }
324 case 14: { /* winspool_AsyncEndDocPrinter */
325 struct winspool_AsyncEndDocPrinter *r2 = (struct winspool_AsyncEndDocPrinter *)r;
326 if (DEBUGLEVEL >= 10) {
327 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEndDocPrinter, NDR_IN, r2);
328 }
329 r2->out.result = _winspool_AsyncEndDocPrinter(p, r2);
330 break;
331 }
332 case 15: { /* winspool_AsyncAbortPrinter */
333 struct winspool_AsyncAbortPrinter *r2 = (struct winspool_AsyncAbortPrinter *)r;
334 if (DEBUGLEVEL >= 10) {
335 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAbortPrinter, NDR_IN, r2);
336 }
337 r2->out.result = _winspool_AsyncAbortPrinter(p, r2);
338 break;
339 }
340 case 16: { /* winspool_AsyncGetPrinterData */
341 struct winspool_AsyncGetPrinterData *r2 = (struct winspool_AsyncGetPrinterData *)r;
342 if (DEBUGLEVEL >= 10) {
343 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetPrinterData, NDR_IN, r2);
344 }
345 NDR_ZERO_STRUCT(r2->out);
346 r2->out.pType = talloc_zero(r2, uint32_t);
347 if (r2->out.pType == NULL) {
348 status = NT_STATUS_NO_MEMORY;
349 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
350 goto fail;
351 }
352
353 r2->out.pData = talloc_zero_array(r2, uint8_t, r2->in.nSize);
354 if (r2->out.pData == NULL) {
355 status = NT_STATUS_NO_MEMORY;
356 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
357 goto fail;
358 }
359
360 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
361 if (r2->out.pcbNeeded == NULL) {
362 status = NT_STATUS_NO_MEMORY;
363 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
364 goto fail;
365 }
366
367 r2->out.result = _winspool_AsyncGetPrinterData(p, r2);
368 break;
369 }
370 case 17: { /* winspool_AsyncGetPrinterDataEx */
371 struct winspool_AsyncGetPrinterDataEx *r2 = (struct winspool_AsyncGetPrinterDataEx *)r;
372 if (DEBUGLEVEL >= 10) {
373 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetPrinterDataEx, NDR_IN, r2);
374 }
375 NDR_ZERO_STRUCT(r2->out);
376 r2->out.pType = talloc_zero(r2, uint32_t);
377 if (r2->out.pType == NULL) {
378 status = NT_STATUS_NO_MEMORY;
379 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
380 goto fail;
381 }
382
383 r2->out.pData = talloc_zero_array(r2, uint8_t, r2->in.nSize);
384 if (r2->out.pData == NULL) {
385 status = NT_STATUS_NO_MEMORY;
386 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
387 goto fail;
388 }
389
390 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
391 if (r2->out.pcbNeeded == NULL) {
392 status = NT_STATUS_NO_MEMORY;
393 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
394 goto fail;
395 }
396
397 r2->out.result = _winspool_AsyncGetPrinterDataEx(p, r2);
398 break;
399 }
400 case 18: { /* winspool_AsyncSetPrinterData */
401 struct winspool_AsyncSetPrinterData *r2 = (struct winspool_AsyncSetPrinterData *)r;
402 if (DEBUGLEVEL >= 10) {
403 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSetPrinterData, NDR_IN, r2);
404 }
405 r2->out.result = _winspool_AsyncSetPrinterData(p, r2);
406 break;
407 }
408 case 19: { /* winspool_AsyncSetPrinterDataEx */
409 struct winspool_AsyncSetPrinterDataEx *r2 = (struct winspool_AsyncSetPrinterDataEx *)r;
410 if (DEBUGLEVEL >= 10) {
411 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSetPrinterDataEx, NDR_IN, r2);
412 }
413 r2->out.result = _winspool_AsyncSetPrinterDataEx(p, r2);
414 break;
415 }
416 case 20: { /* winspool_AsyncClosePrinter */
417 struct winspool_AsyncClosePrinter *r2 = (struct winspool_AsyncClosePrinter *)r;
418 if (DEBUGLEVEL >= 10) {
419 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncClosePrinter, NDR_IN, r2);
420 }
421 NDR_ZERO_STRUCT(r2->out);
422 r2->out.phPrinter = r2->in.phPrinter;
423 r2->out.result = _winspool_AsyncClosePrinter(p, r2);
424 break;
425 }
426 case 21: { /* winspool_AsyncAddForm */
427 struct winspool_AsyncAddForm *r2 = (struct winspool_AsyncAddForm *)r;
428 if (DEBUGLEVEL >= 10) {
429 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddForm, NDR_IN, r2);
430 }
431 r2->out.result = _winspool_AsyncAddForm(p, r2);
432 break;
433 }
434 case 22: { /* winspool_AsyncDeleteForm */
435 struct winspool_AsyncDeleteForm *r2 = (struct winspool_AsyncDeleteForm *)r;
436 if (DEBUGLEVEL >= 10) {
437 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeleteForm, NDR_IN, r2);
438 }
439 r2->out.result = _winspool_AsyncDeleteForm(p, r2);
440 break;
441 }
442 case 23: { /* winspool_AsyncGetForm */
443 struct winspool_AsyncGetForm *r2 = (struct winspool_AsyncGetForm *)r;
444 if (DEBUGLEVEL >= 10) {
445 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetForm, NDR_IN, r2);
446 }
447 NDR_ZERO_STRUCT(r2->out);
448 r2->out.pForm = r2->in.pForm;
449 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
450 if (r2->out.pcbNeeded == NULL) {
451 status = NT_STATUS_NO_MEMORY;
452 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
453 goto fail;
454 }
455
456 r2->out.result = _winspool_AsyncGetForm(p, r2);
457 break;
458 }
459 case 24: { /* winspool_AsyncSetForm */
460 struct winspool_AsyncSetForm *r2 = (struct winspool_AsyncSetForm *)r;
461 if (DEBUGLEVEL >= 10) {
462 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSetForm, NDR_IN, r2);
463 }
464 r2->out.result = _winspool_AsyncSetForm(p, r2);
465 break;
466 }
467 case 25: { /* winspool_AsyncEnumForms */
468 struct winspool_AsyncEnumForms *r2 = (struct winspool_AsyncEnumForms *)r;
469 if (DEBUGLEVEL >= 10) {
470 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumForms, NDR_IN, r2);
471 }
472 NDR_ZERO_STRUCT(r2->out);
473 r2->out.pForm = r2->in.pForm;
474 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
475 if (r2->out.pcbNeeded == NULL) {
476 status = NT_STATUS_NO_MEMORY;
477 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
478 goto fail;
479 }
480
481 r2->out.pcReturned = talloc_zero(r2, uint32_t);
482 if (r2->out.pcReturned == NULL) {
483 status = NT_STATUS_NO_MEMORY;
484 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
485 goto fail;
486 }
487
488 r2->out.result = _winspool_AsyncEnumForms(p, r2);
489 break;
490 }
491 case 26: { /* winspool_AsyncGetPrinterDriver */
492 struct winspool_AsyncGetPrinterDriver *r2 = (struct winspool_AsyncGetPrinterDriver *)r;
493 if (DEBUGLEVEL >= 10) {
494 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetPrinterDriver, NDR_IN, r2);
495 }
496 NDR_ZERO_STRUCT(r2->out);
497 r2->out.pDriver = r2->in.pDriver;
498 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
499 if (r2->out.pcbNeeded == NULL) {
500 status = NT_STATUS_NO_MEMORY;
501 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
502 goto fail;
503 }
504
505 r2->out.pdwServerMaxVersion = talloc_zero(r2, uint32_t);
506 if (r2->out.pdwServerMaxVersion == NULL) {
507 status = NT_STATUS_NO_MEMORY;
508 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
509 goto fail;
510 }
511
512 r2->out.pdwServerMinVersion = talloc_zero(r2, uint32_t);
513 if (r2->out.pdwServerMinVersion == NULL) {
514 status = NT_STATUS_NO_MEMORY;
515 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
516 goto fail;
517 }
518
519 r2->out.result = _winspool_AsyncGetPrinterDriver(p, r2);
520 break;
521 }
522 case 27: { /* winspool_AsyncEnumPrinterData */
523 struct winspool_AsyncEnumPrinterData *r2 = (struct winspool_AsyncEnumPrinterData *)r;
524 if (DEBUGLEVEL >= 10) {
525 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPrinterData, NDR_IN, r2);
526 }
527 NDR_ZERO_STRUCT(r2->out);
528 r2->out.pValueName = talloc_zero_array(r2, uint16_t, r2->in.cbValueName / 2);
529 if (r2->out.pValueName == NULL) {
530 status = NT_STATUS_NO_MEMORY;
531 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
532 goto fail;
533 }
534
535 r2->out.pcbValueName = talloc_zero(r2, uint32_t);
536 if (r2->out.pcbValueName == NULL) {
537 status = NT_STATUS_NO_MEMORY;
538 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
539 goto fail;
540 }
541
542 r2->out.pType = talloc_zero(r2, uint32_t);
543 if (r2->out.pType == NULL) {
544 status = NT_STATUS_NO_MEMORY;
545 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
546 goto fail;
547 }
548
549 r2->out.pData = talloc_zero_array(r2, uint8_t, r2->in.cbData);
550 if (r2->out.pData == NULL) {
551 status = NT_STATUS_NO_MEMORY;
552 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
553 goto fail;
554 }
555
556 r2->out.pcbData = talloc_zero(r2, uint32_t);
557 if (r2->out.pcbData == NULL) {
558 status = NT_STATUS_NO_MEMORY;
559 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
560 goto fail;
561 }
562
563 r2->out.result = _winspool_AsyncEnumPrinterData(p, r2);
564 break;
565 }
566 case 28: { /* winspool_AsyncEnumPrinterDataEx */
567 struct winspool_AsyncEnumPrinterDataEx *r2 = (struct winspool_AsyncEnumPrinterDataEx *)r;
568 if (DEBUGLEVEL >= 10) {
569 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPrinterDataEx, NDR_IN, r2);
570 }
571 NDR_ZERO_STRUCT(r2->out);
572 r2->out.pEnumValues = talloc_zero_array(r2, uint8_t, r2->in.cbEnumValues);
573 if (r2->out.pEnumValues == NULL) {
574 status = NT_STATUS_NO_MEMORY;
575 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
576 goto fail;
577 }
578
579 r2->out.pcbEnumValues = talloc_zero(r2, uint32_t);
580 if (r2->out.pcbEnumValues == NULL) {
581 status = NT_STATUS_NO_MEMORY;
582 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
583 goto fail;
584 }
585
586 r2->out.pnEnumValues = talloc_zero(r2, uint32_t);
587 if (r2->out.pnEnumValues == NULL) {
588 status = NT_STATUS_NO_MEMORY;
589 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
590 goto fail;
591 }
592
593 r2->out.result = _winspool_AsyncEnumPrinterDataEx(p, r2);
594 break;
595 }
596 case 29: { /* winspool_AsyncEnumPrinterKey */
597 struct winspool_AsyncEnumPrinterKey *r2 = (struct winspool_AsyncEnumPrinterKey *)r;
598 if (DEBUGLEVEL >= 10) {
599 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPrinterKey, NDR_IN, r2);
600 }
601 NDR_ZERO_STRUCT(r2->out);
602 r2->out.pSubkey = talloc_zero_array(r2, uint16_t, r2->in.cbSubkey / 2);
603 if (r2->out.pSubkey == NULL) {
604 status = NT_STATUS_NO_MEMORY;
605 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
606 goto fail;
607 }
608
609 r2->out.pcbSubkey = talloc_zero(r2, uint32_t);
610 if (r2->out.pcbSubkey == NULL) {
611 status = NT_STATUS_NO_MEMORY;
612 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
613 goto fail;
614 }
615
616 r2->out.result = _winspool_AsyncEnumPrinterKey(p, r2);
617 break;
618 }
619 case 30: { /* winspool_AsyncDeletePrinterData */
620 struct winspool_AsyncDeletePrinterData *r2 = (struct winspool_AsyncDeletePrinterData *)r;
621 if (DEBUGLEVEL >= 10) {
622 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinterData, NDR_IN, r2);
623 }
624 r2->out.result = _winspool_AsyncDeletePrinterData(p, r2);
625 break;
626 }
627 case 31: { /* winspool_AsyncDeletePrinterDataEx */
628 struct winspool_AsyncDeletePrinterDataEx *r2 = (struct winspool_AsyncDeletePrinterDataEx *)r;
629 if (DEBUGLEVEL >= 10) {
630 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinterDataEx, NDR_IN, r2);
631 }
632 r2->out.result = _winspool_AsyncDeletePrinterDataEx(p, r2);
633 break;
634 }
635 case 32: { /* winspool_AsyncDeletePrinterKey */
636 struct winspool_AsyncDeletePrinterKey *r2 = (struct winspool_AsyncDeletePrinterKey *)r;
637 if (DEBUGLEVEL >= 10) {
638 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinterKey, NDR_IN, r2);
639 }
640 r2->out.result = _winspool_AsyncDeletePrinterKey(p, r2);
641 break;
642 }
643 case 33: { /* winspool_AsyncXcvData */
644 struct winspool_AsyncXcvData *r2 = (struct winspool_AsyncXcvData *)r;
645 if (DEBUGLEVEL >= 10) {
646 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncXcvData, NDR_IN, r2);
647 }
648 NDR_ZERO_STRUCT(r2->out);
649 r2->out.pdwStatus = r2->in.pdwStatus;
650 r2->out.pOutputData = talloc_zero_array(r2, uint8_t, r2->in.cbOutputData);
651 if (r2->out.pOutputData == NULL) {
652 status = NT_STATUS_NO_MEMORY;
653 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
654 goto fail;
655 }
656
657 r2->out.pcbOutputNeeded = talloc_zero(r2, uint32_t);
658 if (r2->out.pcbOutputNeeded == NULL) {
659 status = NT_STATUS_NO_MEMORY;
660 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
661 goto fail;
662 }
663
664 r2->out.result = _winspool_AsyncXcvData(p, r2);
665 break;
666 }
667 case 34: { /* winspool_AsyncSendRecvBidiData */
668 struct winspool_AsyncSendRecvBidiData *r2 = (struct winspool_AsyncSendRecvBidiData *)r;
669 if (DEBUGLEVEL >= 10) {
670 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSendRecvBidiData, NDR_IN, r2);
671 }
672 NDR_ZERO_STRUCT(r2->out);
673 r2->out.ppRespData = talloc_zero(r2, struct RPC_BIDI_RESPONSE_CONTAINER *);
674 if (r2->out.ppRespData == NULL) {
675 status = NT_STATUS_NO_MEMORY;
676 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
677 goto fail;
678 }
679
680 r2->out.result = _winspool_AsyncSendRecvBidiData(p, r2);
681 break;
682 }
683 case 35: { /* winspool_AsyncCreatePrinterIC */
684 struct winspool_AsyncCreatePrinterIC *r2 = (struct winspool_AsyncCreatePrinterIC *)r;
685 if (DEBUGLEVEL >= 10) {
686 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncCreatePrinterIC, NDR_IN, r2);
687 }
688 NDR_ZERO_STRUCT(r2->out);
689 r2->out.pHandle = talloc_zero(r2, struct policy_handle);
690 if (r2->out.pHandle == NULL) {
691 status = NT_STATUS_NO_MEMORY;
692 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
693 goto fail;
694 }
695
696 r2->out.result = _winspool_AsyncCreatePrinterIC(p, r2);
697 break;
698 }
699 case 36: { /* winspool_AsyncPlayGdiScriptOnPrinterIC */
700 struct winspool_AsyncPlayGdiScriptOnPrinterIC *r2 = (struct winspool_AsyncPlayGdiScriptOnPrinterIC *)r;
701 if (DEBUGLEVEL >= 10) {
702 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncPlayGdiScriptOnPrinterIC, NDR_IN, r2);
703 }
704 NDR_ZERO_STRUCT(r2->out);
705 r2->out.pOut = talloc_zero_array(r2, uint8_t, r2->in.cOut);
706 if (r2->out.pOut == NULL) {
707 status = NT_STATUS_NO_MEMORY;
708 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
709 goto fail;
710 }
711
712 r2->out.result = _winspool_AsyncPlayGdiScriptOnPrinterIC(p, r2);
713 break;
714 }
715 case 37: { /* winspool_AsyncDeletePrinterIC */
716 struct winspool_AsyncDeletePrinterIC *r2 = (struct winspool_AsyncDeletePrinterIC *)r;
717 if (DEBUGLEVEL >= 10) {
718 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinterIC, NDR_IN, r2);
719 }
720 NDR_ZERO_STRUCT(r2->out);
721 r2->out.phPrinterIC = r2->in.phPrinterIC;
722 r2->out.result = _winspool_AsyncDeletePrinterIC(p, r2);
723 break;
724 }
725 case 38: { /* winspool_AsyncEnumPrinters */
726 struct winspool_AsyncEnumPrinters *r2 = (struct winspool_AsyncEnumPrinters *)r;
727 if (DEBUGLEVEL >= 10) {
728 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPrinters, NDR_IN, r2);
729 }
730 NDR_ZERO_STRUCT(r2->out);
731 r2->out.pPrinterEnum = r2->in.pPrinterEnum;
732 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
733 if (r2->out.pcbNeeded == NULL) {
734 status = NT_STATUS_NO_MEMORY;
735 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
736 goto fail;
737 }
738
739 r2->out.pcReturned = talloc_zero(r2, uint32_t);
740 if (r2->out.pcReturned == NULL) {
741 status = NT_STATUS_NO_MEMORY;
742 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
743 goto fail;
744 }
745
746 r2->out.result = _winspool_AsyncEnumPrinters(p, r2);
747 break;
748 }
749 case 39: { /* winspool_AsyncAddPrinterDriver */
750 struct winspool_AsyncAddPrinterDriver *r2 = (struct winspool_AsyncAddPrinterDriver *)r;
751 if (DEBUGLEVEL >= 10) {
752 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddPrinterDriver, NDR_IN, r2);
753 }
754 r2->out.result = _winspool_AsyncAddPrinterDriver(p, r2);
755 break;
756 }
757 case 40: { /* winspool_AsyncEnumPrinterDrivers */
758 struct winspool_AsyncEnumPrinterDrivers *r2 = (struct winspool_AsyncEnumPrinterDrivers *)r;
759 if (DEBUGLEVEL >= 10) {
760 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPrinterDrivers, NDR_IN, r2);
761 }
762 NDR_ZERO_STRUCT(r2->out);
763 r2->out.pDrivers = r2->in.pDrivers;
764 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
765 if (r2->out.pcbNeeded == NULL) {
766 status = NT_STATUS_NO_MEMORY;
767 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
768 goto fail;
769 }
770
771 r2->out.pcReturned = talloc_zero(r2, uint32_t);
772 if (r2->out.pcReturned == NULL) {
773 status = NT_STATUS_NO_MEMORY;
774 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
775 goto fail;
776 }
777
778 r2->out.result = _winspool_AsyncEnumPrinterDrivers(p, r2);
779 break;
780 }
781 case 41: { /* winspool_AsyncGetPrinterDriverDirectory */
782 struct winspool_AsyncGetPrinterDriverDirectory *r2 = (struct winspool_AsyncGetPrinterDriverDirectory *)r;
783 if (DEBUGLEVEL >= 10) {
784 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetPrinterDriverDirectory, NDR_IN, r2);
785 }
786 NDR_ZERO_STRUCT(r2->out);
787 r2->out.pDriverDirectory = r2->in.pDriverDirectory;
788 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
789 if (r2->out.pcbNeeded == NULL) {
790 status = NT_STATUS_NO_MEMORY;
791 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
792 goto fail;
793 }
794
795 r2->out.result = _winspool_AsyncGetPrinterDriverDirectory(p, r2);
796 break;
797 }
798 case 42: { /* winspool_AsyncDeletePrinterDriver */
799 struct winspool_AsyncDeletePrinterDriver *r2 = (struct winspool_AsyncDeletePrinterDriver *)r;
800 if (DEBUGLEVEL >= 10) {
801 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinterDriver, NDR_IN, r2);
802 }
803 r2->out.result = _winspool_AsyncDeletePrinterDriver(p, r2);
804 break;
805 }
806 case 43: { /* winspool_AsyncDeletePrinterDriverEx */
807 struct winspool_AsyncDeletePrinterDriverEx *r2 = (struct winspool_AsyncDeletePrinterDriverEx *)r;
808 if (DEBUGLEVEL >= 10) {
809 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinterDriverEx, NDR_IN, r2);
810 }
811 r2->out.result = _winspool_AsyncDeletePrinterDriverEx(p, r2);
812 break;
813 }
814 case 44: { /* winspool_AsyncAddPrintProcessor */
815 struct winspool_AsyncAddPrintProcessor *r2 = (struct winspool_AsyncAddPrintProcessor *)r;
816 if (DEBUGLEVEL >= 10) {
817 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddPrintProcessor, NDR_IN, r2);
818 }
819 r2->out.result = _winspool_AsyncAddPrintProcessor(p, r2);
820 break;
821 }
822 case 45: { /* winspool_AsyncEnumPrintProcessors */
823 struct winspool_AsyncEnumPrintProcessors *r2 = (struct winspool_AsyncEnumPrintProcessors *)r;
824 if (DEBUGLEVEL >= 10) {
825 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPrintProcessors, NDR_IN, r2);
826 }
827 NDR_ZERO_STRUCT(r2->out);
828 r2->out.pPrintProcessorInfo = r2->in.pPrintProcessorInfo;
829 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
830 if (r2->out.pcbNeeded == NULL) {
831 status = NT_STATUS_NO_MEMORY;
832 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
833 goto fail;
834 }
835
836 r2->out.pcReturned = talloc_zero(r2, uint32_t);
837 if (r2->out.pcReturned == NULL) {
838 status = NT_STATUS_NO_MEMORY;
839 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
840 goto fail;
841 }
842
843 r2->out.result = _winspool_AsyncEnumPrintProcessors(p, r2);
844 break;
845 }
846 case 46: { /* winspool_AsyncGetPrintProcessorDirectory */
847 struct winspool_AsyncGetPrintProcessorDirectory *r2 = (struct winspool_AsyncGetPrintProcessorDirectory *)r;
848 if (DEBUGLEVEL >= 10) {
849 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetPrintProcessorDirectory, NDR_IN, r2);
850 }
851 NDR_ZERO_STRUCT(r2->out);
852 r2->out.pPrintProcessorDirectory = r2->in.pPrintProcessorDirectory;
853 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
854 if (r2->out.pcbNeeded == NULL) {
855 status = NT_STATUS_NO_MEMORY;
856 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
857 goto fail;
858 }
859
860 r2->out.result = _winspool_AsyncGetPrintProcessorDirectory(p, r2);
861 break;
862 }
863 case 47: { /* winspool_AsyncEnumPorts */
864 struct winspool_AsyncEnumPorts *r2 = (struct winspool_AsyncEnumPorts *)r;
865 if (DEBUGLEVEL >= 10) {
866 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPorts, NDR_IN, r2);
867 }
868 NDR_ZERO_STRUCT(r2->out);
869 r2->out.pPort = r2->in.pPort;
870 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
871 if (r2->out.pcbNeeded == NULL) {
872 status = NT_STATUS_NO_MEMORY;
873 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
874 goto fail;
875 }
876
877 r2->out.pcReturned = talloc_zero(r2, uint32_t);
878 if (r2->out.pcReturned == NULL) {
879 status = NT_STATUS_NO_MEMORY;
880 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
881 goto fail;
882 }
883
884 r2->out.result = _winspool_AsyncEnumPorts(p, r2);
885 break;
886 }
887 case 48: { /* winspool_AsyncEnumMonitors */
888 struct winspool_AsyncEnumMonitors *r2 = (struct winspool_AsyncEnumMonitors *)r;
889 if (DEBUGLEVEL >= 10) {
890 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumMonitors, NDR_IN, r2);
891 }
892 NDR_ZERO_STRUCT(r2->out);
893 r2->out.pMonitor = r2->in.pMonitor;
894 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
895 if (r2->out.pcbNeeded == NULL) {
896 status = NT_STATUS_NO_MEMORY;
897 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
898 goto fail;
899 }
900
901 r2->out.pcReturned = talloc_zero(r2, uint32_t);
902 if (r2->out.pcReturned == NULL) {
903 status = NT_STATUS_NO_MEMORY;
904 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
905 goto fail;
906 }
907
908 r2->out.result = _winspool_AsyncEnumMonitors(p, r2);
909 break;
910 }
911 case 49: { /* winspool_AsyncAddPort */
912 struct winspool_AsyncAddPort *r2 = (struct winspool_AsyncAddPort *)r;
913 if (DEBUGLEVEL >= 10) {
914 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddPort, NDR_IN, r2);
915 }
916 r2->out.result = _winspool_AsyncAddPort(p, r2);
917 break;
918 }
919 case 50: { /* winspool_AsyncSetPort */
920 struct winspool_AsyncSetPort *r2 = (struct winspool_AsyncSetPort *)r;
921 if (DEBUGLEVEL >= 10) {
922 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSetPort, NDR_IN, r2);
923 }
924 r2->out.result = _winspool_AsyncSetPort(p, r2);
925 break;
926 }
927 case 51: { /* winspool_AsyncAddMonitor */
928 struct winspool_AsyncAddMonitor *r2 = (struct winspool_AsyncAddMonitor *)r;
929 if (DEBUGLEVEL >= 10) {
930 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddMonitor, NDR_IN, r2);
931 }
932 r2->out.result = _winspool_AsyncAddMonitor(p, r2);
933 break;
934 }
935 case 52: { /* winspool_AsyncDeleteMonitor */
936 struct winspool_AsyncDeleteMonitor *r2 = (struct winspool_AsyncDeleteMonitor *)r;
937 if (DEBUGLEVEL >= 10) {
938 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeleteMonitor, NDR_IN, r2);
939 }
940 r2->out.result = _winspool_AsyncDeleteMonitor(p, r2);
941 break;
942 }
943 case 53: { /* winspool_AsyncDeletePrintProcessor */
944 struct winspool_AsyncDeletePrintProcessor *r2 = (struct winspool_AsyncDeletePrintProcessor *)r;
945 if (DEBUGLEVEL >= 10) {
946 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrintProcessor, NDR_IN, r2);
947 }
948 r2->out.result = _winspool_AsyncDeletePrintProcessor(p, r2);
949 break;
950 }
951 case 54: { /* winspool_AsyncEnumPrintProcessorDatatypes */
952 struct winspool_AsyncEnumPrintProcessorDatatypes *r2 = (struct winspool_AsyncEnumPrintProcessorDatatypes *)r;
953 if (DEBUGLEVEL >= 10) {
954 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPrintProcessorDatatypes, NDR_IN, r2);
955 }
956 NDR_ZERO_STRUCT(r2->out);
957 r2->out.pDatatypes = r2->in.pDatatypes;
958 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
959 if (r2->out.pcbNeeded == NULL) {
960 status = NT_STATUS_NO_MEMORY;
961 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
962 goto fail;
963 }
964
965 r2->out.pcReturned = talloc_zero(r2, uint32_t);
966 if (r2->out.pcReturned == NULL) {
967 status = NT_STATUS_NO_MEMORY;
968 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
969 goto fail;
970 }
971
972 r2->out.result = _winspool_AsyncEnumPrintProcessorDatatypes(p, r2);
973 break;
974 }
975 case 55: { /* winspool_AsyncAddPerMachineConnection */
976 struct winspool_AsyncAddPerMachineConnection *r2 = (struct winspool_AsyncAddPerMachineConnection *)r;
977 if (DEBUGLEVEL >= 10) {
978 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddPerMachineConnection, NDR_IN, r2);
979 }
980 r2->out.result = _winspool_AsyncAddPerMachineConnection(p, r2);
981 break;
982 }
983 case 56: { /* winspool_AsyncDeletePerMachineConnection */
984 struct winspool_AsyncDeletePerMachineConnection *r2 = (struct winspool_AsyncDeletePerMachineConnection *)r;
985 if (DEBUGLEVEL >= 10) {
986 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePerMachineConnection, NDR_IN, r2);
987 }
988 r2->out.result = _winspool_AsyncDeletePerMachineConnection(p, r2);
989 break;
990 }
991 case 57: { /* winspool_AsyncEnumPerMachineConnections */
992 struct winspool_AsyncEnumPerMachineConnections *r2 = (struct winspool_AsyncEnumPerMachineConnections *)r;
993 if (DEBUGLEVEL >= 10) {
994 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPerMachineConnections, NDR_IN, r2);
995 }
996 NDR_ZERO_STRUCT(r2->out);
997 r2->out.pPrinterEnum = r2->in.pPrinterEnum;
998 r2->out.pcbNeeded = talloc_zero(r2, uint32_t);
999 if (r2->out.pcbNeeded == NULL) {
1000 status = NT_STATUS_NO_MEMORY;
1001 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
1002 goto fail;
1003 }
1004
1005 r2->out.pcReturned = talloc_zero(r2, uint32_t);
1006 if (r2->out.pcReturned == NULL) {
1007 status = NT_STATUS_NO_MEMORY;
1008 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
1009 goto fail;
1010 }
1011
1012 r2->out.result = _winspool_AsyncEnumPerMachineConnections(p, r2);
1013 break;
1014 }
1015 case 58: { /* winspool_SyncRegisterForRemoteNotifications */
1016 struct winspool_SyncRegisterForRemoteNotifications *r2 = (struct winspool_SyncRegisterForRemoteNotifications *)r;
1017 if (DEBUGLEVEL >= 10) {
1018 NDR_PRINT_FUNCTION_DEBUG(winspool_SyncRegisterForRemoteNotifications, NDR_IN, r2);
1019 }
1020 NDR_ZERO_STRUCT(r2->out);
1021 r2->out.phRpcHandle = talloc_zero(r2, struct policy_handle);
1022 if (r2->out.phRpcHandle == NULL) {
1023 status = NT_STATUS_NO_MEMORY;
1024 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
1025 goto fail;
1026 }
1027
1028 r2->out.result = _winspool_SyncRegisterForRemoteNotifications(p, r2);
1029 break;
1030 }
1031 case 59: { /* winspool_SyncUnRegisterForRemoteNotifications */
1032 struct winspool_SyncUnRegisterForRemoteNotifications *r2 = (struct winspool_SyncUnRegisterForRemoteNotifications *)r;
1033 if (DEBUGLEVEL >= 10) {
1034 NDR_PRINT_FUNCTION_DEBUG(winspool_SyncUnRegisterForRemoteNotifications, NDR_IN, r2);
1035 }
1036 NDR_ZERO_STRUCT(r2->out);
1037 r2->out.phRpcHandle = r2->in.phRpcHandle;
1038 r2->out.result = _winspool_SyncUnRegisterForRemoteNotifications(p, r2);
1039 break;
1040 }
1041 case 60: { /* winspool_SyncRefreshRemoteNotifications */
1042 struct winspool_SyncRefreshRemoteNotifications *r2 = (struct winspool_SyncRefreshRemoteNotifications *)r;
1043 if (DEBUGLEVEL >= 10) {
1044 NDR_PRINT_FUNCTION_DEBUG(winspool_SyncRefreshRemoteNotifications, NDR_IN, r2);
1045 }
1046 NDR_ZERO_STRUCT(r2->out);
1047 r2->out.ppNotifyData = talloc_zero(r2, struct winspool_PrintPropertiesCollection *);
1048 if (r2->out.ppNotifyData == NULL) {
1049 status = NT_STATUS_NO_MEMORY;
1050 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
1051 goto fail;
1052 }
1053
1054 r2->out.result = _winspool_SyncRefreshRemoteNotifications(p, r2);
1055 break;
1056 }
1057 case 61: { /* winspool_AsyncGetRemoteNotifications */
1058 struct winspool_AsyncGetRemoteNotifications *r2 = (struct winspool_AsyncGetRemoteNotifications *)r;
1059 if (DEBUGLEVEL >= 10) {
1060 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetRemoteNotifications, NDR_IN, r2);
1061 }
1062 NDR_ZERO_STRUCT(r2->out);
1063 r2->out.ppNotifyData = talloc_zero(r2, struct winspool_PrintPropertiesCollection *);
1064 if (r2->out.ppNotifyData == NULL) {
1065 status = NT_STATUS_NO_MEMORY;
1066 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
1067 goto fail;
1068 }
1069
1070 r2->out.result = _winspool_AsyncGetRemoteNotifications(p, r2);
1071 break;
1072 }
1073 case 62: { /* winspool_AsyncInstallPrinterDriverFromPackage */
1074 struct winspool_AsyncInstallPrinterDriverFromPackage *r2 = (struct winspool_AsyncInstallPrinterDriverFromPackage *)r;
1075 if (DEBUGLEVEL >= 10) {
1076 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncInstallPrinterDriverFromPackage, NDR_IN, r2);
1077 }
1078 r2->out.result = _winspool_AsyncInstallPrinterDriverFromPackage(p, r2);
1079 break;
1080 }
1081 case 63: { /* winspool_AsyncUploadPrinterDriverPackage */
1082 struct winspool_AsyncUploadPrinterDriverPackage *r2 = (struct winspool_AsyncUploadPrinterDriverPackage *)r;
1083 if (DEBUGLEVEL >= 10) {
1084 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncUploadPrinterDriverPackage, NDR_IN, r2);
1085 }
1086 NDR_ZERO_STRUCT(r2->out);
1087 r2->out.pszDestInfPath = r2->in.pszDestInfPath;
1088 r2->out.pcchDestInfPath = r2->in.pcchDestInfPath;
1089 r2->out.result = _winspool_AsyncUploadPrinterDriverPackage(p, r2);
1090 break;
1091 }
1092 case 64: { /* winspool_AsyncGetCorePrinterDrivers */
1093 struct winspool_AsyncGetCorePrinterDrivers *r2 = (struct winspool_AsyncGetCorePrinterDrivers *)r;
1094 if (DEBUGLEVEL >= 10) {
1095 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetCorePrinterDrivers, NDR_IN, r2);
1096 }
1097 NDR_ZERO_STRUCT(r2->out);
1098 r2->out.pCorePrinterDrivers = talloc_zero_array(r2, struct spoolss_CorePrinterDriver, r2->in.cCorePrinterDrivers);
1099 if (r2->out.pCorePrinterDrivers == NULL) {
1100 status = NT_STATUS_NO_MEMORY;
1101 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
1102 goto fail;
1103 }
1104
1105 r2->out.result = _winspool_AsyncGetCorePrinterDrivers(p, r2);
1106 break;
1107 }
1108 case 65: { /* winspool_AsyncCorePrinterDriverInstalled */
1109 struct winspool_AsyncCorePrinterDriverInstalled *r2 = (struct winspool_AsyncCorePrinterDriverInstalled *)r;
1110 if (DEBUGLEVEL >= 10) {
1111 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncCorePrinterDriverInstalled, NDR_IN, r2);
1112 }
1113 NDR_ZERO_STRUCT(r2->out);
1114 r2->out.pbDriverInstalled = talloc_zero(r2, int32_t);
1115 if (r2->out.pbDriverInstalled == NULL) {
1116 status = NT_STATUS_NO_MEMORY;
1117 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
1118 goto fail;
1119 }
1120
1121 r2->out.result = _winspool_AsyncCorePrinterDriverInstalled(p, r2);
1122 break;
1123 }
1124 case 66: { /* winspool_AsyncGetPrinterDriverPackagePath */
1125 struct winspool_AsyncGetPrinterDriverPackagePath *r2 = (struct winspool_AsyncGetPrinterDriverPackagePath *)r;
1126 if (DEBUGLEVEL >= 10) {
1127 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetPrinterDriverPackagePath, NDR_IN, r2);
1128 }
1129 NDR_ZERO_STRUCT(r2->out);
1130 r2->out.pszDriverPackageCab = r2->in.pszDriverPackageCab;
1131 r2->out.pcchRequiredSize = talloc_zero(r2, uint32_t);
1132 if (r2->out.pcchRequiredSize == NULL) {
1133 status = NT_STATUS_NO_MEMORY;
1134 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
1135 goto fail;
1136 }
1137
1138 r2->out.result = _winspool_AsyncGetPrinterDriverPackagePath(p, r2);
1139 break;
1140 }
1141 case 67: { /* winspool_AsyncDeletePrinterDriverPackage */
1142 struct winspool_AsyncDeletePrinterDriverPackage *r2 = (struct winspool_AsyncDeletePrinterDriverPackage *)r;
1143 if (DEBUGLEVEL >= 10) {
1144 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinterDriverPackage, NDR_IN, r2);
1145 }
1146 r2->out.result = _winspool_AsyncDeletePrinterDriverPackage(p, r2);
1147 break;
1148 }
1149 case 68: { /* winspool_AsyncReadPrinter */
1150 struct winspool_AsyncReadPrinter *r2 = (struct winspool_AsyncReadPrinter *)r;
1151 if (DEBUGLEVEL >= 10) {
1152 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncReadPrinter, NDR_IN, r2);
1153 }
1154 NDR_ZERO_STRUCT(r2->out);
1155 r2->out.pBuf = talloc_zero_array(r2, uint8_t, r2->in.cbBuf);
1156 if (r2->out.pBuf == NULL) {
1157 status = NT_STATUS_NO_MEMORY;
1158 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
1159 goto fail;
1160 }
1161
1162 r2->out.pcNoBytesRead = talloc_zero(r2, uint32_t);
1163 if (r2->out.pcNoBytesRead == NULL) {
1164 status = NT_STATUS_NO_MEMORY;
1165 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
1166 goto fail;
1167 }
1168
1169 r2->out.result = _winspool_AsyncReadPrinter(p, r2);
1170 break;
1171 }
1172 case 69: { /* winspool_AsyncResetPrinter */
1173 struct winspool_AsyncResetPrinter *r2 = (struct winspool_AsyncResetPrinter *)r;
1174 if (DEBUGLEVEL >= 10) {
1175 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncResetPrinter, NDR_IN, r2);
1176 }
1177 r2->out.result = _winspool_AsyncResetPrinter(p, r2);
1178 break;
1179 }
1180 case 70: { /* winspool_AsyncGetJobNamedPropertyValue */
1181 struct winspool_AsyncGetJobNamedPropertyValue *r2 = (struct winspool_AsyncGetJobNamedPropertyValue *)r;
1182 if (DEBUGLEVEL >= 10) {
1183 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetJobNamedPropertyValue, NDR_IN, r2);
1184 }
1185 NDR_ZERO_STRUCT(r2->out);
1186 r2->out.pValue = talloc_zero(r2, struct spoolss_PrintPropertyValue);
1187 if (r2->out.pValue == NULL) {
1188 status = NT_STATUS_NO_MEMORY;
1189 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
1190 goto fail;
1191 }
1192
1193 r2->out.result = _winspool_AsyncGetJobNamedPropertyValue(p, r2);
1194 break;
1195 }
1196 case 71: { /* winspool_AsyncSetJobNamedProperty */
1197 struct winspool_AsyncSetJobNamedProperty *r2 = (struct winspool_AsyncSetJobNamedProperty *)r;
1198 if (DEBUGLEVEL >= 10) {
1199 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSetJobNamedProperty, NDR_IN, r2);
1200 }
1201 r2->out.result = _winspool_AsyncSetJobNamedProperty(p, r2);
1202 break;
1203 }
1204 case 72: { /* winspool_AsyncDeleteJobNamedProperty */
1205 struct winspool_AsyncDeleteJobNamedProperty *r2 = (struct winspool_AsyncDeleteJobNamedProperty *)r;
1206 if (DEBUGLEVEL >= 10) {
1207 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeleteJobNamedProperty, NDR_IN, r2);
1208 }
1209 r2->out.result = _winspool_AsyncDeleteJobNamedProperty(p, r2);
1210 break;
1211 }
1212 case 73: { /* winspool_AsyncEnumJobNamedProperties */
1213 struct winspool_AsyncEnumJobNamedProperties *r2 = (struct winspool_AsyncEnumJobNamedProperties *)r;
1214 if (DEBUGLEVEL >= 10) {
1215 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumJobNamedProperties, NDR_IN, r2);
1216 }
1217 NDR_ZERO_STRUCT(r2->out);
1218 r2->out.pcProperties = talloc_zero(r2, uint32_t);
1219 if (r2->out.pcProperties == NULL) {
1220 status = NT_STATUS_NO_MEMORY;
1221 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
1222 goto fail;
1223 }
1224
1225 r2->out.ppProperties = talloc_zero(r2, struct spoolss_PrintNamedProperty *);
1226 if (r2->out.ppProperties == NULL) {
1227 status = NT_STATUS_NO_MEMORY;
1228 p->fault_state = DCERPC_FAULT_CANT_PERFORM;
1229 goto fail;
1230 }
1231
1232 r2->out.result = _winspool_AsyncEnumJobNamedProperties(p, r2);
1233 break;
1234 }
1235 case 74: { /* winspool_AsyncLogJobInfoForBranchOffice */
1236 struct winspool_AsyncLogJobInfoForBranchOffice *r2 = (struct winspool_AsyncLogJobInfoForBranchOffice *)r;
1237 if (DEBUGLEVEL >= 10) {
1238 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncLogJobInfoForBranchOffice, NDR_IN, r2);
1239 }
1240 r2->out.result = _winspool_AsyncLogJobInfoForBranchOffice(p, r2);
1241 break;
1242 }
1243 default:
1244 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
1245 break;
1246 }
1247
1248 fail:
1249 /* Unimpersonate */
1250 if (impersonated) {
1251 unbecome_authenticated_pipe_user();
1252 }
1253
1254 p->dce_call = NULL;
1255 p->mem_ctx = NULL;
1256 /* Check pipes struct fault state */
1257 if (p->fault_state != 0) {
1258 dce_call->fault_code = p->fault_state;
1259 }
1260 if (dce_call->fault_code != 0) {
1261 status = NT_STATUS_NET_WRITE_FAULT;
1262 }
1263
1264 return status;
1265 }
1266
1267 NTSTATUS iremotewinspool__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
1268 {
1269 return iremotewinspool__op_dispatch_internal(dce_call, mem_ctx, r, false);
1270 }
1271
1272 NTSTATUS iremotewinspool__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
1273 {
1274 uint16_t opnum = dce_call->pkt.u.request.opnum;
1275
1276 if (forward_opnum_to_spoolss(opnum)) {
1277 return spoolss__op_reply(dce_call, mem_ctx, r);
1278 }
1279
1280 switch (opnum) {
1281 case 0: { /* winspool_AsyncOpenPrinter */
1282 struct winspool_AsyncOpenPrinter *r2 = (struct winspool_AsyncOpenPrinter *)r;
1283 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1284 DEBUG(5,("function winspool_AsyncOpenPrinter replied async\n"));
1285 }
1286 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1287 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncOpenPrinter, NDR_OUT | NDR_SET_VALUES, r2);
1288 }
1289 if (dce_call->fault_code != 0) {
1290 DBG_WARNING("dcerpc_fault %s in winspool_AsyncOpenPrinter\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1291 }
1292 break;
1293 }
1294 case 1: { /* winspool_AsyncAddPrinter */
1295 struct winspool_AsyncAddPrinter *r2 = (struct winspool_AsyncAddPrinter *)r;
1296 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1297 DEBUG(5,("function winspool_AsyncAddPrinter replied async\n"));
1298 }
1299 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1300 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddPrinter, NDR_OUT | NDR_SET_VALUES, r2);
1301 }
1302 if (dce_call->fault_code != 0) {
1303 DBG_WARNING("dcerpc_fault %s in winspool_AsyncAddPrinter\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1304 }
1305 break;
1306 }
1307 case 2: { /* winspool_AsyncSetJob */
1308 struct winspool_AsyncSetJob *r2 = (struct winspool_AsyncSetJob *)r;
1309 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1310 DEBUG(5,("function winspool_AsyncSetJob replied async\n"));
1311 }
1312 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1313 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSetJob, NDR_OUT | NDR_SET_VALUES, r2);
1314 }
1315 if (dce_call->fault_code != 0) {
1316 DBG_WARNING("dcerpc_fault %s in winspool_AsyncSetJob\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1317 }
1318 break;
1319 }
1320 case 3: { /* winspool_AsyncGetJob */
1321 struct winspool_AsyncGetJob *r2 = (struct winspool_AsyncGetJob *)r;
1322 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1323 DEBUG(5,("function winspool_AsyncGetJob replied async\n"));
1324 }
1325 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1326 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetJob, NDR_OUT | NDR_SET_VALUES, r2);
1327 }
1328 if (dce_call->fault_code != 0) {
1329 DBG_WARNING("dcerpc_fault %s in winspool_AsyncGetJob\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1330 }
1331 break;
1332 }
1333 case 4: { /* winspool_AsyncEnumJobs */
1334 struct winspool_AsyncEnumJobs *r2 = (struct winspool_AsyncEnumJobs *)r;
1335 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1336 DEBUG(5,("function winspool_AsyncEnumJobs replied async\n"));
1337 }
1338 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1339 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumJobs, NDR_OUT | NDR_SET_VALUES, r2);
1340 }
1341 if (dce_call->fault_code != 0) {
1342 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEnumJobs\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1343 }
1344 break;
1345 }
1346 case 5: { /* winspool_AsyncAddJob */
1347 struct winspool_AsyncAddJob *r2 = (struct winspool_AsyncAddJob *)r;
1348 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1349 DEBUG(5,("function winspool_AsyncAddJob replied async\n"));
1350 }
1351 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1352 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddJob, NDR_OUT | NDR_SET_VALUES, r2);
1353 }
1354 if (dce_call->fault_code != 0) {
1355 DBG_WARNING("dcerpc_fault %s in winspool_AsyncAddJob\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1356 }
1357 break;
1358 }
1359 case 6: { /* winspool_AsyncScheduleJob */
1360 struct winspool_AsyncScheduleJob *r2 = (struct winspool_AsyncScheduleJob *)r;
1361 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1362 DEBUG(5,("function winspool_AsyncScheduleJob replied async\n"));
1363 }
1364 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1365 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncScheduleJob, NDR_OUT | NDR_SET_VALUES, r2);
1366 }
1367 if (dce_call->fault_code != 0) {
1368 DBG_WARNING("dcerpc_fault %s in winspool_AsyncScheduleJob\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1369 }
1370 break;
1371 }
1372 case 7: { /* winspool_AsyncDeletePrinter */
1373 struct winspool_AsyncDeletePrinter *r2 = (struct winspool_AsyncDeletePrinter *)r;
1374 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1375 DEBUG(5,("function winspool_AsyncDeletePrinter replied async\n"));
1376 }
1377 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1378 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinter, NDR_OUT | NDR_SET_VALUES, r2);
1379 }
1380 if (dce_call->fault_code != 0) {
1381 DBG_WARNING("dcerpc_fault %s in winspool_AsyncDeletePrinter\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1382 }
1383 break;
1384 }
1385 case 8: { /* winspool_AsyncSetPrinter */
1386 struct winspool_AsyncSetPrinter *r2 = (struct winspool_AsyncSetPrinter *)r;
1387 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1388 DEBUG(5,("function winspool_AsyncSetPrinter replied async\n"));
1389 }
1390 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1391 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSetPrinter, NDR_OUT | NDR_SET_VALUES, r2);
1392 }
1393 if (dce_call->fault_code != 0) {
1394 DBG_WARNING("dcerpc_fault %s in winspool_AsyncSetPrinter\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1395 }
1396 break;
1397 }
1398 case 9: { /* winspool_AsyncGetPrinter */
1399 struct winspool_AsyncGetPrinter *r2 = (struct winspool_AsyncGetPrinter *)r;
1400 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1401 DEBUG(5,("function winspool_AsyncGetPrinter replied async\n"));
1402 }
1403 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1404 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetPrinter, NDR_OUT | NDR_SET_VALUES, r2);
1405 }
1406 if (dce_call->fault_code != 0) {
1407 DBG_WARNING("dcerpc_fault %s in winspool_AsyncGetPrinter\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1408 }
1409 break;
1410 }
1411 case 10: { /* winspool_AsyncStartDocPrinter */
1412 struct winspool_AsyncStartDocPrinter *r2 = (struct winspool_AsyncStartDocPrinter *)r;
1413 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1414 DEBUG(5,("function winspool_AsyncStartDocPrinter replied async\n"));
1415 }
1416 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1417 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncStartDocPrinter, NDR_OUT | NDR_SET_VALUES, r2);
1418 }
1419 if (dce_call->fault_code != 0) {
1420 DBG_WARNING("dcerpc_fault %s in winspool_AsyncStartDocPrinter\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1421 }
1422 break;
1423 }
1424 case 11: { /* winspool_AsyncStartPagePrinter */
1425 struct winspool_AsyncStartPagePrinter *r2 = (struct winspool_AsyncStartPagePrinter *)r;
1426 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1427 DEBUG(5,("function winspool_AsyncStartPagePrinter replied async\n"));
1428 }
1429 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1430 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncStartPagePrinter, NDR_OUT | NDR_SET_VALUES, r2);
1431 }
1432 if (dce_call->fault_code != 0) {
1433 DBG_WARNING("dcerpc_fault %s in winspool_AsyncStartPagePrinter\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1434 }
1435 break;
1436 }
1437 case 12: { /* winspool_AsyncWritePrinter */
1438 struct winspool_AsyncWritePrinter *r2 = (struct winspool_AsyncWritePrinter *)r;
1439 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1440 DEBUG(5,("function winspool_AsyncWritePrinter replied async\n"));
1441 }
1442 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1443 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncWritePrinter, NDR_OUT | NDR_SET_VALUES, r2);
1444 }
1445 if (dce_call->fault_code != 0) {
1446 DBG_WARNING("dcerpc_fault %s in winspool_AsyncWritePrinter\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1447 }
1448 break;
1449 }
1450 case 13: { /* winspool_AsyncEndPagePrinter */
1451 struct winspool_AsyncEndPagePrinter *r2 = (struct winspool_AsyncEndPagePrinter *)r;
1452 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1453 DEBUG(5,("function winspool_AsyncEndPagePrinter replied async\n"));
1454 }
1455 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1456 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEndPagePrinter, NDR_OUT | NDR_SET_VALUES, r2);
1457 }
1458 if (dce_call->fault_code != 0) {
1459 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEndPagePrinter\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1460 }
1461 break;
1462 }
1463 case 14: { /* winspool_AsyncEndDocPrinter */
1464 struct winspool_AsyncEndDocPrinter *r2 = (struct winspool_AsyncEndDocPrinter *)r;
1465 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1466 DEBUG(5,("function winspool_AsyncEndDocPrinter replied async\n"));
1467 }
1468 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1469 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEndDocPrinter, NDR_OUT | NDR_SET_VALUES, r2);
1470 }
1471 if (dce_call->fault_code != 0) {
1472 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEndDocPrinter\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1473 }
1474 break;
1475 }
1476 case 15: { /* winspool_AsyncAbortPrinter */
1477 struct winspool_AsyncAbortPrinter *r2 = (struct winspool_AsyncAbortPrinter *)r;
1478 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1479 DEBUG(5,("function winspool_AsyncAbortPrinter replied async\n"));
1480 }
1481 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1482 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAbortPrinter, NDR_OUT | NDR_SET_VALUES, r2);
1483 }
1484 if (dce_call->fault_code != 0) {
1485 DBG_WARNING("dcerpc_fault %s in winspool_AsyncAbortPrinter\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1486 }
1487 break;
1488 }
1489 case 16: { /* winspool_AsyncGetPrinterData */
1490 struct winspool_AsyncGetPrinterData *r2 = (struct winspool_AsyncGetPrinterData *)r;
1491 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1492 DEBUG(5,("function winspool_AsyncGetPrinterData replied async\n"));
1493 }
1494 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1495 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetPrinterData, NDR_OUT | NDR_SET_VALUES, r2);
1496 }
1497 if (dce_call->fault_code != 0) {
1498 DBG_WARNING("dcerpc_fault %s in winspool_AsyncGetPrinterData\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1499 }
1500 break;
1501 }
1502 case 17: { /* winspool_AsyncGetPrinterDataEx */
1503 struct winspool_AsyncGetPrinterDataEx *r2 = (struct winspool_AsyncGetPrinterDataEx *)r;
1504 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1505 DEBUG(5,("function winspool_AsyncGetPrinterDataEx replied async\n"));
1506 }
1507 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1508 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetPrinterDataEx, NDR_OUT | NDR_SET_VALUES, r2);
1509 }
1510 if (dce_call->fault_code != 0) {
1511 DBG_WARNING("dcerpc_fault %s in winspool_AsyncGetPrinterDataEx\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1512 }
1513 break;
1514 }
1515 case 18: { /* winspool_AsyncSetPrinterData */
1516 struct winspool_AsyncSetPrinterData *r2 = (struct winspool_AsyncSetPrinterData *)r;
1517 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1518 DEBUG(5,("function winspool_AsyncSetPrinterData replied async\n"));
1519 }
1520 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1521 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSetPrinterData, NDR_OUT | NDR_SET_VALUES, r2);
1522 }
1523 if (dce_call->fault_code != 0) {
1524 DBG_WARNING("dcerpc_fault %s in winspool_AsyncSetPrinterData\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1525 }
1526 break;
1527 }
1528 case 19: { /* winspool_AsyncSetPrinterDataEx */
1529 struct winspool_AsyncSetPrinterDataEx *r2 = (struct winspool_AsyncSetPrinterDataEx *)r;
1530 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1531 DEBUG(5,("function winspool_AsyncSetPrinterDataEx replied async\n"));
1532 }
1533 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1534 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSetPrinterDataEx, NDR_OUT | NDR_SET_VALUES, r2);
1535 }
1536 if (dce_call->fault_code != 0) {
1537 DBG_WARNING("dcerpc_fault %s in winspool_AsyncSetPrinterDataEx\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1538 }
1539 break;
1540 }
1541 case 20: { /* winspool_AsyncClosePrinter */
1542 struct winspool_AsyncClosePrinter *r2 = (struct winspool_AsyncClosePrinter *)r;
1543 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1544 DEBUG(5,("function winspool_AsyncClosePrinter replied async\n"));
1545 }
1546 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1547 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncClosePrinter, NDR_OUT | NDR_SET_VALUES, r2);
1548 }
1549 if (dce_call->fault_code != 0) {
1550 DBG_WARNING("dcerpc_fault %s in winspool_AsyncClosePrinter\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1551 }
1552 break;
1553 }
1554 case 21: { /* winspool_AsyncAddForm */
1555 struct winspool_AsyncAddForm *r2 = (struct winspool_AsyncAddForm *)r;
1556 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1557 DEBUG(5,("function winspool_AsyncAddForm replied async\n"));
1558 }
1559 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1560 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddForm, NDR_OUT | NDR_SET_VALUES, r2);
1561 }
1562 if (dce_call->fault_code != 0) {
1563 DBG_WARNING("dcerpc_fault %s in winspool_AsyncAddForm\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1564 }
1565 break;
1566 }
1567 case 22: { /* winspool_AsyncDeleteForm */
1568 struct winspool_AsyncDeleteForm *r2 = (struct winspool_AsyncDeleteForm *)r;
1569 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1570 DEBUG(5,("function winspool_AsyncDeleteForm replied async\n"));
1571 }
1572 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1573 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeleteForm, NDR_OUT | NDR_SET_VALUES, r2);
1574 }
1575 if (dce_call->fault_code != 0) {
1576 DBG_WARNING("dcerpc_fault %s in winspool_AsyncDeleteForm\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1577 }
1578 break;
1579 }
1580 case 23: { /* winspool_AsyncGetForm */
1581 struct winspool_AsyncGetForm *r2 = (struct winspool_AsyncGetForm *)r;
1582 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1583 DEBUG(5,("function winspool_AsyncGetForm replied async\n"));
1584 }
1585 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1586 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetForm, NDR_OUT | NDR_SET_VALUES, r2);
1587 }
1588 if (dce_call->fault_code != 0) {
1589 DBG_WARNING("dcerpc_fault %s in winspool_AsyncGetForm\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1590 }
1591 break;
1592 }
1593 case 24: { /* winspool_AsyncSetForm */
1594 struct winspool_AsyncSetForm *r2 = (struct winspool_AsyncSetForm *)r;
1595 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1596 DEBUG(5,("function winspool_AsyncSetForm replied async\n"));
1597 }
1598 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1599 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSetForm, NDR_OUT | NDR_SET_VALUES, r2);
1600 }
1601 if (dce_call->fault_code != 0) {
1602 DBG_WARNING("dcerpc_fault %s in winspool_AsyncSetForm\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1603 }
1604 break;
1605 }
1606 case 25: { /* winspool_AsyncEnumForms */
1607 struct winspool_AsyncEnumForms *r2 = (struct winspool_AsyncEnumForms *)r;
1608 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1609 DEBUG(5,("function winspool_AsyncEnumForms replied async\n"));
1610 }
1611 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1612 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumForms, NDR_OUT | NDR_SET_VALUES, r2);
1613 }
1614 if (dce_call->fault_code != 0) {
1615 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEnumForms\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1616 }
1617 break;
1618 }
1619 case 26: { /* winspool_AsyncGetPrinterDriver */
1620 struct winspool_AsyncGetPrinterDriver *r2 = (struct winspool_AsyncGetPrinterDriver *)r;
1621 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1622 DEBUG(5,("function winspool_AsyncGetPrinterDriver replied async\n"));
1623 }
1624 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1625 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetPrinterDriver, NDR_OUT | NDR_SET_VALUES, r2);
1626 }
1627 if (dce_call->fault_code != 0) {
1628 DBG_WARNING("dcerpc_fault %s in winspool_AsyncGetPrinterDriver\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1629 }
1630 break;
1631 }
1632 case 27: { /* winspool_AsyncEnumPrinterData */
1633 struct winspool_AsyncEnumPrinterData *r2 = (struct winspool_AsyncEnumPrinterData *)r;
1634 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1635 DEBUG(5,("function winspool_AsyncEnumPrinterData replied async\n"));
1636 }
1637 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1638 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPrinterData, NDR_OUT | NDR_SET_VALUES, r2);
1639 }
1640 if (dce_call->fault_code != 0) {
1641 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEnumPrinterData\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1642 }
1643 break;
1644 }
1645 case 28: { /* winspool_AsyncEnumPrinterDataEx */
1646 struct winspool_AsyncEnumPrinterDataEx *r2 = (struct winspool_AsyncEnumPrinterDataEx *)r;
1647 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1648 DEBUG(5,("function winspool_AsyncEnumPrinterDataEx replied async\n"));
1649 }
1650 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1651 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPrinterDataEx, NDR_OUT | NDR_SET_VALUES, r2);
1652 }
1653 if (dce_call->fault_code != 0) {
1654 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEnumPrinterDataEx\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1655 }
1656 break;
1657 }
1658 case 29: { /* winspool_AsyncEnumPrinterKey */
1659 struct winspool_AsyncEnumPrinterKey *r2 = (struct winspool_AsyncEnumPrinterKey *)r;
1660 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1661 DEBUG(5,("function winspool_AsyncEnumPrinterKey replied async\n"));
1662 }
1663 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1664 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPrinterKey, NDR_OUT | NDR_SET_VALUES, r2);
1665 }
1666 if (dce_call->fault_code != 0) {
1667 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEnumPrinterKey\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1668 }
1669 break;
1670 }
1671 case 30: { /* winspool_AsyncDeletePrinterData */
1672 struct winspool_AsyncDeletePrinterData *r2 = (struct winspool_AsyncDeletePrinterData *)r;
1673 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1674 DEBUG(5,("function winspool_AsyncDeletePrinterData replied async\n"));
1675 }
1676 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1677 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinterData, NDR_OUT | NDR_SET_VALUES, r2);
1678 }
1679 if (dce_call->fault_code != 0) {
1680 DBG_WARNING("dcerpc_fault %s in winspool_AsyncDeletePrinterData\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1681 }
1682 break;
1683 }
1684 case 31: { /* winspool_AsyncDeletePrinterDataEx */
1685 struct winspool_AsyncDeletePrinterDataEx *r2 = (struct winspool_AsyncDeletePrinterDataEx *)r;
1686 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1687 DEBUG(5,("function winspool_AsyncDeletePrinterDataEx replied async\n"));
1688 }
1689 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1690 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinterDataEx, NDR_OUT | NDR_SET_VALUES, r2);
1691 }
1692 if (dce_call->fault_code != 0) {
1693 DBG_WARNING("dcerpc_fault %s in winspool_AsyncDeletePrinterDataEx\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1694 }
1695 break;
1696 }
1697 case 32: { /* winspool_AsyncDeletePrinterKey */
1698 struct winspool_AsyncDeletePrinterKey *r2 = (struct winspool_AsyncDeletePrinterKey *)r;
1699 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1700 DEBUG(5,("function winspool_AsyncDeletePrinterKey replied async\n"));
1701 }
1702 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1703 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinterKey, NDR_OUT | NDR_SET_VALUES, r2);
1704 }
1705 if (dce_call->fault_code != 0) {
1706 DBG_WARNING("dcerpc_fault %s in winspool_AsyncDeletePrinterKey\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1707 }
1708 break;
1709 }
1710 case 33: { /* winspool_AsyncXcvData */
1711 struct winspool_AsyncXcvData *r2 = (struct winspool_AsyncXcvData *)r;
1712 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1713 DEBUG(5,("function winspool_AsyncXcvData replied async\n"));
1714 }
1715 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1716 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncXcvData, NDR_OUT | NDR_SET_VALUES, r2);
1717 }
1718 if (dce_call->fault_code != 0) {
1719 DBG_WARNING("dcerpc_fault %s in winspool_AsyncXcvData\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1720 }
1721 break;
1722 }
1723 case 34: { /* winspool_AsyncSendRecvBidiData */
1724 struct winspool_AsyncSendRecvBidiData *r2 = (struct winspool_AsyncSendRecvBidiData *)r;
1725 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1726 DEBUG(5,("function winspool_AsyncSendRecvBidiData replied async\n"));
1727 }
1728 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1729 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSendRecvBidiData, NDR_OUT | NDR_SET_VALUES, r2);
1730 }
1731 if (dce_call->fault_code != 0) {
1732 DBG_WARNING("dcerpc_fault %s in winspool_AsyncSendRecvBidiData\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1733 }
1734 break;
1735 }
1736 case 35: { /* winspool_AsyncCreatePrinterIC */
1737 struct winspool_AsyncCreatePrinterIC *r2 = (struct winspool_AsyncCreatePrinterIC *)r;
1738 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1739 DEBUG(5,("function winspool_AsyncCreatePrinterIC replied async\n"));
1740 }
1741 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1742 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncCreatePrinterIC, NDR_OUT | NDR_SET_VALUES, r2);
1743 }
1744 if (dce_call->fault_code != 0) {
1745 DBG_WARNING("dcerpc_fault %s in winspool_AsyncCreatePrinterIC\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1746 }
1747 break;
1748 }
1749 case 36: { /* winspool_AsyncPlayGdiScriptOnPrinterIC */
1750 struct winspool_AsyncPlayGdiScriptOnPrinterIC *r2 = (struct winspool_AsyncPlayGdiScriptOnPrinterIC *)r;
1751 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1752 DEBUG(5,("function winspool_AsyncPlayGdiScriptOnPrinterIC replied async\n"));
1753 }
1754 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1755 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncPlayGdiScriptOnPrinterIC, NDR_OUT | NDR_SET_VALUES, r2);
1756 }
1757 if (dce_call->fault_code != 0) {
1758 DBG_WARNING("dcerpc_fault %s in winspool_AsyncPlayGdiScriptOnPrinterIC\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1759 }
1760 break;
1761 }
1762 case 37: { /* winspool_AsyncDeletePrinterIC */
1763 struct winspool_AsyncDeletePrinterIC *r2 = (struct winspool_AsyncDeletePrinterIC *)r;
1764 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1765 DEBUG(5,("function winspool_AsyncDeletePrinterIC replied async\n"));
1766 }
1767 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1768 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinterIC, NDR_OUT | NDR_SET_VALUES, r2);
1769 }
1770 if (dce_call->fault_code != 0) {
1771 DBG_WARNING("dcerpc_fault %s in winspool_AsyncDeletePrinterIC\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1772 }
1773 break;
1774 }
1775 case 38: { /* winspool_AsyncEnumPrinters */
1776 struct winspool_AsyncEnumPrinters *r2 = (struct winspool_AsyncEnumPrinters *)r;
1777 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1778 DEBUG(5,("function winspool_AsyncEnumPrinters replied async\n"));
1779 }
1780 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1781 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPrinters, NDR_OUT | NDR_SET_VALUES, r2);
1782 }
1783 if (dce_call->fault_code != 0) {
1784 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEnumPrinters\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1785 }
1786 break;
1787 }
1788 case 39: { /* winspool_AsyncAddPrinterDriver */
1789 struct winspool_AsyncAddPrinterDriver *r2 = (struct winspool_AsyncAddPrinterDriver *)r;
1790 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1791 DEBUG(5,("function winspool_AsyncAddPrinterDriver replied async\n"));
1792 }
1793 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1794 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddPrinterDriver, NDR_OUT | NDR_SET_VALUES, r2);
1795 }
1796 if (dce_call->fault_code != 0) {
1797 DBG_WARNING("dcerpc_fault %s in winspool_AsyncAddPrinterDriver\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1798 }
1799 break;
1800 }
1801 case 40: { /* winspool_AsyncEnumPrinterDrivers */
1802 struct winspool_AsyncEnumPrinterDrivers *r2 = (struct winspool_AsyncEnumPrinterDrivers *)r;
1803 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1804 DEBUG(5,("function winspool_AsyncEnumPrinterDrivers replied async\n"));
1805 }
1806 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1807 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPrinterDrivers, NDR_OUT | NDR_SET_VALUES, r2);
1808 }
1809 if (dce_call->fault_code != 0) {
1810 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEnumPrinterDrivers\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1811 }
1812 break;
1813 }
1814 case 41: { /* winspool_AsyncGetPrinterDriverDirectory */
1815 struct winspool_AsyncGetPrinterDriverDirectory *r2 = (struct winspool_AsyncGetPrinterDriverDirectory *)r;
1816 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1817 DEBUG(5,("function winspool_AsyncGetPrinterDriverDirectory replied async\n"));
1818 }
1819 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1820 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetPrinterDriverDirectory, NDR_OUT | NDR_SET_VALUES, r2);
1821 }
1822 if (dce_call->fault_code != 0) {
1823 DBG_WARNING("dcerpc_fault %s in winspool_AsyncGetPrinterDriverDirectory\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1824 }
1825 break;
1826 }
1827 case 42: { /* winspool_AsyncDeletePrinterDriver */
1828 struct winspool_AsyncDeletePrinterDriver *r2 = (struct winspool_AsyncDeletePrinterDriver *)r;
1829 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1830 DEBUG(5,("function winspool_AsyncDeletePrinterDriver replied async\n"));
1831 }
1832 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1833 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinterDriver, NDR_OUT | NDR_SET_VALUES, r2);
1834 }
1835 if (dce_call->fault_code != 0) {
1836 DBG_WARNING("dcerpc_fault %s in winspool_AsyncDeletePrinterDriver\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1837 }
1838 break;
1839 }
1840 case 43: { /* winspool_AsyncDeletePrinterDriverEx */
1841 struct winspool_AsyncDeletePrinterDriverEx *r2 = (struct winspool_AsyncDeletePrinterDriverEx *)r;
1842 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1843 DEBUG(5,("function winspool_AsyncDeletePrinterDriverEx replied async\n"));
1844 }
1845 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1846 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinterDriverEx, NDR_OUT | NDR_SET_VALUES, r2);
1847 }
1848 if (dce_call->fault_code != 0) {
1849 DBG_WARNING("dcerpc_fault %s in winspool_AsyncDeletePrinterDriverEx\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1850 }
1851 break;
1852 }
1853 case 44: { /* winspool_AsyncAddPrintProcessor */
1854 struct winspool_AsyncAddPrintProcessor *r2 = (struct winspool_AsyncAddPrintProcessor *)r;
1855 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1856 DEBUG(5,("function winspool_AsyncAddPrintProcessor replied async\n"));
1857 }
1858 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1859 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddPrintProcessor, NDR_OUT | NDR_SET_VALUES, r2);
1860 }
1861 if (dce_call->fault_code != 0) {
1862 DBG_WARNING("dcerpc_fault %s in winspool_AsyncAddPrintProcessor\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1863 }
1864 break;
1865 }
1866 case 45: { /* winspool_AsyncEnumPrintProcessors */
1867 struct winspool_AsyncEnumPrintProcessors *r2 = (struct winspool_AsyncEnumPrintProcessors *)r;
1868 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1869 DEBUG(5,("function winspool_AsyncEnumPrintProcessors replied async\n"));
1870 }
1871 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1872 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPrintProcessors, NDR_OUT | NDR_SET_VALUES, r2);
1873 }
1874 if (dce_call->fault_code != 0) {
1875 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEnumPrintProcessors\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1876 }
1877 break;
1878 }
1879 case 46: { /* winspool_AsyncGetPrintProcessorDirectory */
1880 struct winspool_AsyncGetPrintProcessorDirectory *r2 = (struct winspool_AsyncGetPrintProcessorDirectory *)r;
1881 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1882 DEBUG(5,("function winspool_AsyncGetPrintProcessorDirectory replied async\n"));
1883 }
1884 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1885 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetPrintProcessorDirectory, NDR_OUT | NDR_SET_VALUES, r2);
1886 }
1887 if (dce_call->fault_code != 0) {
1888 DBG_WARNING("dcerpc_fault %s in winspool_AsyncGetPrintProcessorDirectory\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1889 }
1890 break;
1891 }
1892 case 47: { /* winspool_AsyncEnumPorts */
1893 struct winspool_AsyncEnumPorts *r2 = (struct winspool_AsyncEnumPorts *)r;
1894 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1895 DEBUG(5,("function winspool_AsyncEnumPorts replied async\n"));
1896 }
1897 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1898 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPorts, NDR_OUT | NDR_SET_VALUES, r2);
1899 }
1900 if (dce_call->fault_code != 0) {
1901 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEnumPorts\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1902 }
1903 break;
1904 }
1905 case 48: { /* winspool_AsyncEnumMonitors */
1906 struct winspool_AsyncEnumMonitors *r2 = (struct winspool_AsyncEnumMonitors *)r;
1907 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1908 DEBUG(5,("function winspool_AsyncEnumMonitors replied async\n"));
1909 }
1910 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1911 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumMonitors, NDR_OUT | NDR_SET_VALUES, r2);
1912 }
1913 if (dce_call->fault_code != 0) {
1914 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEnumMonitors\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1915 }
1916 break;
1917 }
1918 case 49: { /* winspool_AsyncAddPort */
1919 struct winspool_AsyncAddPort *r2 = (struct winspool_AsyncAddPort *)r;
1920 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1921 DEBUG(5,("function winspool_AsyncAddPort replied async\n"));
1922 }
1923 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1924 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddPort, NDR_OUT | NDR_SET_VALUES, r2);
1925 }
1926 if (dce_call->fault_code != 0) {
1927 DBG_WARNING("dcerpc_fault %s in winspool_AsyncAddPort\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1928 }
1929 break;
1930 }
1931 case 50: { /* winspool_AsyncSetPort */
1932 struct winspool_AsyncSetPort *r2 = (struct winspool_AsyncSetPort *)r;
1933 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1934 DEBUG(5,("function winspool_AsyncSetPort replied async\n"));
1935 }
1936 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1937 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSetPort, NDR_OUT | NDR_SET_VALUES, r2);
1938 }
1939 if (dce_call->fault_code != 0) {
1940 DBG_WARNING("dcerpc_fault %s in winspool_AsyncSetPort\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1941 }
1942 break;
1943 }
1944 case 51: { /* winspool_AsyncAddMonitor */
1945 struct winspool_AsyncAddMonitor *r2 = (struct winspool_AsyncAddMonitor *)r;
1946 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1947 DEBUG(5,("function winspool_AsyncAddMonitor replied async\n"));
1948 }
1949 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1950 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddMonitor, NDR_OUT | NDR_SET_VALUES, r2);
1951 }
1952 if (dce_call->fault_code != 0) {
1953 DBG_WARNING("dcerpc_fault %s in winspool_AsyncAddMonitor\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1954 }
1955 break;
1956 }
1957 case 52: { /* winspool_AsyncDeleteMonitor */
1958 struct winspool_AsyncDeleteMonitor *r2 = (struct winspool_AsyncDeleteMonitor *)r;
1959 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1960 DEBUG(5,("function winspool_AsyncDeleteMonitor replied async\n"));
1961 }
1962 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1963 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeleteMonitor, NDR_OUT | NDR_SET_VALUES, r2);
1964 }
1965 if (dce_call->fault_code != 0) {
1966 DBG_WARNING("dcerpc_fault %s in winspool_AsyncDeleteMonitor\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1967 }
1968 break;
1969 }
1970 case 53: { /* winspool_AsyncDeletePrintProcessor */
1971 struct winspool_AsyncDeletePrintProcessor *r2 = (struct winspool_AsyncDeletePrintProcessor *)r;
1972 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1973 DEBUG(5,("function winspool_AsyncDeletePrintProcessor replied async\n"));
1974 }
1975 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1976 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrintProcessor, NDR_OUT | NDR_SET_VALUES, r2);
1977 }
1978 if (dce_call->fault_code != 0) {
1979 DBG_WARNING("dcerpc_fault %s in winspool_AsyncDeletePrintProcessor\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1980 }
1981 break;
1982 }
1983 case 54: { /* winspool_AsyncEnumPrintProcessorDatatypes */
1984 struct winspool_AsyncEnumPrintProcessorDatatypes *r2 = (struct winspool_AsyncEnumPrintProcessorDatatypes *)r;
1985 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1986 DEBUG(5,("function winspool_AsyncEnumPrintProcessorDatatypes replied async\n"));
1987 }
1988 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1989 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPrintProcessorDatatypes, NDR_OUT | NDR_SET_VALUES, r2);
1990 }
1991 if (dce_call->fault_code != 0) {
1992 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEnumPrintProcessorDatatypes\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
1993 }
1994 break;
1995 }
1996 case 55: { /* winspool_AsyncAddPerMachineConnection */
1997 struct winspool_AsyncAddPerMachineConnection *r2 = (struct winspool_AsyncAddPerMachineConnection *)r;
1998 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1999 DEBUG(5,("function winspool_AsyncAddPerMachineConnection replied async\n"));
2000 }
2001 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2002 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncAddPerMachineConnection, NDR_OUT | NDR_SET_VALUES, r2);
2003 }
2004 if (dce_call->fault_code != 0) {
2005 DBG_WARNING("dcerpc_fault %s in winspool_AsyncAddPerMachineConnection\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2006 }
2007 break;
2008 }
2009 case 56: { /* winspool_AsyncDeletePerMachineConnection */
2010 struct winspool_AsyncDeletePerMachineConnection *r2 = (struct winspool_AsyncDeletePerMachineConnection *)r;
2011 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2012 DEBUG(5,("function winspool_AsyncDeletePerMachineConnection replied async\n"));
2013 }
2014 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2015 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePerMachineConnection, NDR_OUT | NDR_SET_VALUES, r2);
2016 }
2017 if (dce_call->fault_code != 0) {
2018 DBG_WARNING("dcerpc_fault %s in winspool_AsyncDeletePerMachineConnection\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2019 }
2020 break;
2021 }
2022 case 57: { /* winspool_AsyncEnumPerMachineConnections */
2023 struct winspool_AsyncEnumPerMachineConnections *r2 = (struct winspool_AsyncEnumPerMachineConnections *)r;
2024 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2025 DEBUG(5,("function winspool_AsyncEnumPerMachineConnections replied async\n"));
2026 }
2027 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2028 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumPerMachineConnections, NDR_OUT | NDR_SET_VALUES, r2);
2029 }
2030 if (dce_call->fault_code != 0) {
2031 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEnumPerMachineConnections\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2032 }
2033 break;
2034 }
2035 case 58: { /* winspool_SyncRegisterForRemoteNotifications */
2036 struct winspool_SyncRegisterForRemoteNotifications *r2 = (struct winspool_SyncRegisterForRemoteNotifications *)r;
2037 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2038 DEBUG(5,("function winspool_SyncRegisterForRemoteNotifications replied async\n"));
2039 }
2040 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2041 NDR_PRINT_FUNCTION_DEBUG(winspool_SyncRegisterForRemoteNotifications, NDR_OUT | NDR_SET_VALUES, r2);
2042 }
2043 if (dce_call->fault_code != 0) {
2044 DBG_WARNING("dcerpc_fault %s in winspool_SyncRegisterForRemoteNotifications\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2045 }
2046 break;
2047 }
2048 case 59: { /* winspool_SyncUnRegisterForRemoteNotifications */
2049 struct winspool_SyncUnRegisterForRemoteNotifications *r2 = (struct winspool_SyncUnRegisterForRemoteNotifications *)r;
2050 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2051 DEBUG(5,("function winspool_SyncUnRegisterForRemoteNotifications replied async\n"));
2052 }
2053 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2054 NDR_PRINT_FUNCTION_DEBUG(winspool_SyncUnRegisterForRemoteNotifications, NDR_OUT | NDR_SET_VALUES, r2);
2055 }
2056 if (dce_call->fault_code != 0) {
2057 DBG_WARNING("dcerpc_fault %s in winspool_SyncUnRegisterForRemoteNotifications\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2058 }
2059 break;
2060 }
2061 case 60: { /* winspool_SyncRefreshRemoteNotifications */
2062 struct winspool_SyncRefreshRemoteNotifications *r2 = (struct winspool_SyncRefreshRemoteNotifications *)r;
2063 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2064 DEBUG(5,("function winspool_SyncRefreshRemoteNotifications replied async\n"));
2065 }
2066 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2067 NDR_PRINT_FUNCTION_DEBUG(winspool_SyncRefreshRemoteNotifications, NDR_OUT | NDR_SET_VALUES, r2);
2068 }
2069 if (dce_call->fault_code != 0) {
2070 DBG_WARNING("dcerpc_fault %s in winspool_SyncRefreshRemoteNotifications\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2071 }
2072 break;
2073 }
2074 case 61: { /* winspool_AsyncGetRemoteNotifications */
2075 struct winspool_AsyncGetRemoteNotifications *r2 = (struct winspool_AsyncGetRemoteNotifications *)r;
2076 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2077 DEBUG(5,("function winspool_AsyncGetRemoteNotifications replied async\n"));
2078 }
2079 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2080 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetRemoteNotifications, NDR_OUT | NDR_SET_VALUES, r2);
2081 }
2082 if (dce_call->fault_code != 0) {
2083 DBG_WARNING("dcerpc_fault %s in winspool_AsyncGetRemoteNotifications\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2084 }
2085 break;
2086 }
2087 case 62: { /* winspool_AsyncInstallPrinterDriverFromPackage */
2088 struct winspool_AsyncInstallPrinterDriverFromPackage *r2 = (struct winspool_AsyncInstallPrinterDriverFromPackage *)r;
2089 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2090 DEBUG(5,("function winspool_AsyncInstallPrinterDriverFromPackage replied async\n"));
2091 }
2092 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2093 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncInstallPrinterDriverFromPackage, NDR_OUT | NDR_SET_VALUES, r2);
2094 }
2095 if (dce_call->fault_code != 0) {
2096 DBG_WARNING("dcerpc_fault %s in winspool_AsyncInstallPrinterDriverFromPackage\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2097 }
2098 break;
2099 }
2100 case 63: { /* winspool_AsyncUploadPrinterDriverPackage */
2101 struct winspool_AsyncUploadPrinterDriverPackage *r2 = (struct winspool_AsyncUploadPrinterDriverPackage *)r;
2102 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2103 DEBUG(5,("function winspool_AsyncUploadPrinterDriverPackage replied async\n"));
2104 }
2105 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2106 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncUploadPrinterDriverPackage, NDR_OUT | NDR_SET_VALUES, r2);
2107 }
2108 if (dce_call->fault_code != 0) {
2109 DBG_WARNING("dcerpc_fault %s in winspool_AsyncUploadPrinterDriverPackage\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2110 }
2111 break;
2112 }
2113 case 64: { /* winspool_AsyncGetCorePrinterDrivers */
2114 struct winspool_AsyncGetCorePrinterDrivers *r2 = (struct winspool_AsyncGetCorePrinterDrivers *)r;
2115 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2116 DEBUG(5,("function winspool_AsyncGetCorePrinterDrivers replied async\n"));
2117 }
2118 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2119 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetCorePrinterDrivers, NDR_OUT | NDR_SET_VALUES, r2);
2120 }
2121 if (dce_call->fault_code != 0) {
2122 DBG_WARNING("dcerpc_fault %s in winspool_AsyncGetCorePrinterDrivers\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2123 }
2124 break;
2125 }
2126 case 65: { /* winspool_AsyncCorePrinterDriverInstalled */
2127 struct winspool_AsyncCorePrinterDriverInstalled *r2 = (struct winspool_AsyncCorePrinterDriverInstalled *)r;
2128 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2129 DEBUG(5,("function winspool_AsyncCorePrinterDriverInstalled replied async\n"));
2130 }
2131 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2132 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncCorePrinterDriverInstalled, NDR_OUT | NDR_SET_VALUES, r2);
2133 }
2134 if (dce_call->fault_code != 0) {
2135 DBG_WARNING("dcerpc_fault %s in winspool_AsyncCorePrinterDriverInstalled\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2136 }
2137 break;
2138 }
2139 case 66: { /* winspool_AsyncGetPrinterDriverPackagePath */
2140 struct winspool_AsyncGetPrinterDriverPackagePath *r2 = (struct winspool_AsyncGetPrinterDriverPackagePath *)r;
2141 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2142 DEBUG(5,("function winspool_AsyncGetPrinterDriverPackagePath replied async\n"));
2143 }
2144 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2145 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetPrinterDriverPackagePath, NDR_OUT | NDR_SET_VALUES, r2);
2146 }
2147 if (dce_call->fault_code != 0) {
2148 DBG_WARNING("dcerpc_fault %s in winspool_AsyncGetPrinterDriverPackagePath\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2149 }
2150 break;
2151 }
2152 case 67: { /* winspool_AsyncDeletePrinterDriverPackage */
2153 struct winspool_AsyncDeletePrinterDriverPackage *r2 = (struct winspool_AsyncDeletePrinterDriverPackage *)r;
2154 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2155 DEBUG(5,("function winspool_AsyncDeletePrinterDriverPackage replied async\n"));
2156 }
2157 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2158 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeletePrinterDriverPackage, NDR_OUT | NDR_SET_VALUES, r2);
2159 }
2160 if (dce_call->fault_code != 0) {
2161 DBG_WARNING("dcerpc_fault %s in winspool_AsyncDeletePrinterDriverPackage\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2162 }
2163 break;
2164 }
2165 case 68: { /* winspool_AsyncReadPrinter */
2166 struct winspool_AsyncReadPrinter *r2 = (struct winspool_AsyncReadPrinter *)r;
2167 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2168 DEBUG(5,("function winspool_AsyncReadPrinter replied async\n"));
2169 }
2170 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2171 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncReadPrinter, NDR_OUT | NDR_SET_VALUES, r2);
2172 }
2173 if (dce_call->fault_code != 0) {
2174 DBG_WARNING("dcerpc_fault %s in winspool_AsyncReadPrinter\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2175 }
2176 break;
2177 }
2178 case 69: { /* winspool_AsyncResetPrinter */
2179 struct winspool_AsyncResetPrinter *r2 = (struct winspool_AsyncResetPrinter *)r;
2180 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2181 DEBUG(5,("function winspool_AsyncResetPrinter replied async\n"));
2182 }
2183 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2184 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncResetPrinter, NDR_OUT | NDR_SET_VALUES, r2);
2185 }
2186 if (dce_call->fault_code != 0) {
2187 DBG_WARNING("dcerpc_fault %s in winspool_AsyncResetPrinter\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2188 }
2189 break;
2190 }
2191 case 70: { /* winspool_AsyncGetJobNamedPropertyValue */
2192 struct winspool_AsyncGetJobNamedPropertyValue *r2 = (struct winspool_AsyncGetJobNamedPropertyValue *)r;
2193 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2194 DEBUG(5,("function winspool_AsyncGetJobNamedPropertyValue replied async\n"));
2195 }
2196 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2197 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncGetJobNamedPropertyValue, NDR_OUT | NDR_SET_VALUES, r2);
2198 }
2199 if (dce_call->fault_code != 0) {
2200 DBG_WARNING("dcerpc_fault %s in winspool_AsyncGetJobNamedPropertyValue\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2201 }
2202 break;
2203 }
2204 case 71: { /* winspool_AsyncSetJobNamedProperty */
2205 struct winspool_AsyncSetJobNamedProperty *r2 = (struct winspool_AsyncSetJobNamedProperty *)r;
2206 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2207 DEBUG(5,("function winspool_AsyncSetJobNamedProperty replied async\n"));
2208 }
2209 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2210 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncSetJobNamedProperty, NDR_OUT | NDR_SET_VALUES, r2);
2211 }
2212 if (dce_call->fault_code != 0) {
2213 DBG_WARNING("dcerpc_fault %s in winspool_AsyncSetJobNamedProperty\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2214 }
2215 break;
2216 }
2217 case 72: { /* winspool_AsyncDeleteJobNamedProperty */
2218 struct winspool_AsyncDeleteJobNamedProperty *r2 = (struct winspool_AsyncDeleteJobNamedProperty *)r;
2219 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2220 DEBUG(5,("function winspool_AsyncDeleteJobNamedProperty replied async\n"));
2221 }
2222 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2223 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncDeleteJobNamedProperty, NDR_OUT | NDR_SET_VALUES, r2);
2224 }
2225 if (dce_call->fault_code != 0) {
2226 DBG_WARNING("dcerpc_fault %s in winspool_AsyncDeleteJobNamedProperty\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2227 }
2228 break;
2229 }
2230 case 73: { /* winspool_AsyncEnumJobNamedProperties */
2231 struct winspool_AsyncEnumJobNamedProperties *r2 = (struct winspool_AsyncEnumJobNamedProperties *)r;
2232 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2233 DEBUG(5,("function winspool_AsyncEnumJobNamedProperties replied async\n"));
2234 }
2235 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2236 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncEnumJobNamedProperties, NDR_OUT | NDR_SET_VALUES, r2);
2237 }
2238 if (dce_call->fault_code != 0) {
2239 DBG_WARNING("dcerpc_fault %s in winspool_AsyncEnumJobNamedProperties\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2240 }
2241 break;
2242 }
2243 case 74: { /* winspool_AsyncLogJobInfoForBranchOffice */
2244 struct winspool_AsyncLogJobInfoForBranchOffice *r2 = (struct winspool_AsyncLogJobInfoForBranchOffice *)r;
2245 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
2246 DEBUG(5,("function winspool_AsyncLogJobInfoForBranchOffice replied async\n"));
2247 }
2248 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
2249 NDR_PRINT_FUNCTION_DEBUG(winspool_AsyncLogJobInfoForBranchOffice, NDR_OUT | NDR_SET_VALUES, r2);
2250 }
2251 if (dce_call->fault_code != 0) {
2252 DBG_WARNING("dcerpc_fault %s in winspool_AsyncLogJobInfoForBranchOffice\n", dcerpc_errstr(mem_ctx, dce_call->fault_code));
2253 }
2254 break;
2255 }
2256 default:
2257 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
2258 break;
2259 }
2260
2261 if (dce_call->fault_code != 0) {
2262 return NT_STATUS_NET_WRITE_FAULT;
2263 }
2264
2265 return NT_STATUS_OK;
2266 }
2267
2268 NTSTATUS iremotewinspool__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
2269 {
2270 enum ndr_err_code ndr_err;
2271 uint16_t opnum = dce_call->pkt.u.request.opnum;
2272
2273 if (forward_opnum_to_spoolss(opnum)) {
2274 return spoolss__op_ndr_push(dce_call, mem_ctx, push, r);
2275 }
2276
2277 ndr_err = ndr_table_iremotewinspool.calls[opnum].ndr_push(push, NDR_OUT, r);
2278 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2279 dce_call->fault_code = DCERPC_FAULT_NDR;
2280 return NT_STATUS_NET_WRITE_FAULT;
2281 }
2282
2283 return NT_STATUS_OK;
2284 }
2285
2286 NTSTATUS iremotewinspool__op_local(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
2287 {
2288 return iremotewinspool__op_dispatch_internal(dce_call, mem_ctx, r, true);
2289 }
2290
2291 static const struct dcesrv_interface dcesrv_iremotewinspool_interface = {
2292 .name = "iremotewinspool",
2293 .syntax_id = {{0x76f03f96,0xcdfd,0x44fc,{0xa2,0x2c},{0x64,0x95,0x0a,0x00,0x12,0x09}},1.0},
2294 .bind = iremotewinspool__op_bind,
2295 .unbind = iremotewinspool__op_unbind,
2296 .ndr_pull = iremotewinspool__op_ndr_pull,
2297 .dispatch = iremotewinspool__op_dispatch,
2298 .reply = iremotewinspool__op_reply,
2299 .ndr_push = iremotewinspool__op_ndr_push,
2300 .local = iremotewinspool__op_local,
2301 #ifdef DCESRV_INTERFACE_IREMOTEWINSPOOL_FLAGS
2302 .flags = DCESRV_INTERFACE_IREMOTEWINSPOOL_FLAGS
2303 #else
2304 .flags = 0
2305 #endif
2306 };
2307
2308 static NTSTATUS iremotewinspool__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
2309 {
2310 int i;
2311 NTSTATUS ret;
2312
2313 #ifdef DCESRV_INTERFACE_IREMOTEWINSPOOL_NCACN_NP_SECONDARY_ENDPOINT
2314 const char *ncacn_np_secondary_endpoint = DCESRV_INTERFACE_IREMOTEWINSPOOL_NCACN_NP_SECONDARY_ENDPOINT;
2315 #else
2316 const char *ncacn_np_secondary_endpoint = NULL;
2317 #endif
2318
2319 for (i=0;i<ndr_table_iremotewinspool.endpoints->count;i++) {
2320 const char *name = ndr_table_iremotewinspool.endpoints->names[i];
2321
2322 ret = dcesrv_interface_register(dce_ctx, name, ncacn_np_secondary_endpoint, &dcesrv_iremotewinspool_interface, NULL);
2323 if (!NT_STATUS_IS_OK(ret)) {
2324 DBG_ERR("Failed to register endpoint '%s'\n",name);
2325 return ret;
2326 }
2327 }
2328
2329 return NT_STATUS_OK;
2330 }
2331
2332 static NTSTATUS iremotewinspool__op_shutdown_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
2333 {
2334 return NT_STATUS_OK;
2335 }
2336
2337 static bool iremotewinspool__op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version)
2338 {
2339 if (dcesrv_iremotewinspool_interface.syntax_id.if_version == if_version && GUID_equal(&dcesrv_iremotewinspool_interface.syntax_id.uuid, uuid)) {
2340 memcpy(iface,&dcesrv_iremotewinspool_interface, sizeof(*iface));
2341 return true;
2342 }
2343
2344 return false;
2345 }
2346
2347 static bool iremotewinspool__op_interface_by_name(struct dcesrv_interface *iface, const char *name)
2348 {
2349 if (strcmp(dcesrv_iremotewinspool_interface.name, name)==0) {
2350 memcpy(iface, &dcesrv_iremotewinspool_interface, sizeof(*iface));
2351 return true;
2352 }
2353
2354 return false;
2355 }
2356
2357 static const struct dcesrv_endpoint_server iremotewinspool_ep_server = {
2358 /* fill in our name */
2359 .name = "iremotewinspool",
2360
2361 /* Initialization flag */
2362 .initialized = false,
2363
2364 /* fill in all the operations */
2365 #ifdef DCESRV_INTERFACE_IREMOTEWINSPOOL_INIT_SERVER
2366 .init_server = DCESRV_INTERFACE_IREMOTEWINSPOOL_INIT_SERVER,
2367 #else
2368 .init_server = iremotewinspool__op_init_server,
2369 #endif
2370 #ifdef DCESRV_INTERFACE_IREMOTEWINSPOOL_SHUTDOWN_SERVER
2371 .shutdown_server = DCESRV_INTERFACE_IREMOTEWINSPOOL_SHUTDOWN_SERVER,
2372 #else
2373 .shutdown_server = iremotewinspool__op_shutdown_server,
2374 #endif
2375 .interface_by_uuid = iremotewinspool__op_interface_by_uuid,
2376 .interface_by_name = iremotewinspool__op_interface_by_name
2377 };
2378
2379 const struct dcesrv_endpoint_server *iremotewinspool_get_ep_server(void)
2380 {
2381 return &iremotewinspool_ep_server;
2382 }
GSS-enabled samba4