source3/rpc_server/spoolss/srv_iremotewinspool.c

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