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