librpc/gen_ndr/cli_spoolss.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * client auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "../librpc/gen_ndr/cli_spoolss.h"
   8
   9 struct rpccli_spoolss_EnumPrinters_state {
  10         struct spoolss_EnumPrinters orig;
  11         struct spoolss_EnumPrinters tmp;
  12         TALLOC_CTX *out_mem_ctx;
  13         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
  14 };
  15
  16 static void rpccli_spoolss_EnumPrinters_done(struct tevent_req *subreq);
  17
  18 struct tevent_req *rpccli_spoolss_EnumPrinters_send(TALLOC_CTX *mem_ctx,
  19                                                     struct tevent_context *ev,
  20                                                     struct rpc_pipe_client *cli,
  21                                                     uint32_t _flags /* [in]  */,
  22                                                     const char *_server /* [in] [unique,charset(UTF16)] */,
  23                                                     uint32_t _level /* [in]  */,
  24                                                     DATA_BLOB *_buffer /* [in] [unique] */,
  25                                                     uint32_t _offered /* [in]  */,
  26                                                     uint32_t *_count /* [out] [ref] */,
  27                                                     union spoolss_PrinterInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
  28                                                     uint32_t *_needed /* [out] [ref] */)
  29 {
  30         struct tevent_req *req;
  31         struct rpccli_spoolss_EnumPrinters_state *state;
  32         struct tevent_req *subreq;
  33
  34         req = tevent_req_create(mem_ctx, &state,
  35                                 struct rpccli_spoolss_EnumPrinters_state);
  36         if (req == NULL) {
  37                 return NULL;
  38         }
  39         state->out_mem_ctx = NULL;
  40         state->dispatch_recv = cli->dispatch_recv;
  41
  42         /* In parameters */
  43         state->orig.in.flags = _flags;
  44         state->orig.in.server = _server;
  45         state->orig.in.level = _level;
  46         state->orig.in.buffer = _buffer;
  47         state->orig.in.offered = _offered;
  48
  49         /* Out parameters */
  50         state->orig.out.count = _count;
  51         state->orig.out.info = _info;
  52         state->orig.out.needed = _needed;
  53
  54         /* Result */
  55         ZERO_STRUCT(state->orig.out.result);
  56
  57         state->out_mem_ctx = talloc_named_const(state, 0,
  58                              "rpccli_spoolss_EnumPrinters_out_memory");
  59         if (tevent_req_nomem(state->out_mem_ctx, req)) {
  60                 return tevent_req_post(req, ev);
  61         }
  62
  63         /* make a temporary copy, that we pass to the dispatch function */
  64         state->tmp = state->orig;
  65
  66         subreq = cli->dispatch_send(state, ev, cli,
  67                                     &ndr_table_spoolss,
  68                                     NDR_SPOOLSS_ENUMPRINTERS,
  69                                     &state->tmp);
  70         if (tevent_req_nomem(subreq, req)) {
  71                 return tevent_req_post(req, ev);
  72         }
  73         tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinters_done, req);
  74         return req;
  75 }
  76
  77 static void rpccli_spoolss_EnumPrinters_done(struct tevent_req *subreq)
  78 {
  79         struct tevent_req *req = tevent_req_callback_data(
  80                 subreq, struct tevent_req);
  81         struct rpccli_spoolss_EnumPrinters_state *state = tevent_req_data(
  82                 req, struct rpccli_spoolss_EnumPrinters_state);
  83         NTSTATUS status;
  84         TALLOC_CTX *mem_ctx;
  85
  86         if (state->out_mem_ctx) {
  87                 mem_ctx = state->out_mem_ctx;
  88         } else {
  89                 mem_ctx = state;
  90         }
  91
  92         status = state->dispatch_recv(subreq, mem_ctx);
  93         TALLOC_FREE(subreq);
  94         if (!NT_STATUS_IS_OK(status)) {
  95                 tevent_req_nterror(req, status);
  96                 return;
  97         }
  98
  99         /* Copy out parameters */
 100         *state->orig.out.count = *state->tmp.out.count;
 101         *state->orig.out.info = *state->tmp.out.info;
 102         *state->orig.out.needed = *state->tmp.out.needed;
 103
 104         /* Copy result */
 105         state->orig.out.result = state->tmp.out.result;
 106
 107         /* Reset temporary structure */
 108         ZERO_STRUCT(state->tmp);
 109
 110         tevent_req_done(req);
 111 }
 112
 113 NTSTATUS rpccli_spoolss_EnumPrinters_recv(struct tevent_req *req,
 114                                           TALLOC_CTX *mem_ctx,
 115                                           WERROR *result)
 116 {
 117         struct rpccli_spoolss_EnumPrinters_state *state = tevent_req_data(
 118                 req, struct rpccli_spoolss_EnumPrinters_state);
 119         NTSTATUS status;
 120
 121         if (tevent_req_is_nterror(req, &status)) {
 122                 tevent_req_received(req);
 123                 return status;
 124         }
 125
 126         /* Steal possbile out parameters to the callers context */
 127         talloc_steal(mem_ctx, state->out_mem_ctx);
 128
 129         /* Return result */
 130         *result = state->orig.out.result;
 131
 132         tevent_req_received(req);
 133         return NT_STATUS_OK;
 134 }
 135
 136 NTSTATUS rpccli_spoolss_EnumPrinters(struct rpc_pipe_client *cli,
 137                                      TALLOC_CTX *mem_ctx,
 138                                      uint32_t flags /* [in]  */,
 139                                      const char *server /* [in] [unique,charset(UTF16)] */,
 140                                      uint32_t level /* [in]  */,
 141                                      DATA_BLOB *buffer /* [in] [unique] */,
 142                                      uint32_t offered /* [in]  */,
 143                                      uint32_t *count /* [out] [ref] */,
 144                                      union spoolss_PrinterInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
 145                                      uint32_t *needed /* [out] [ref] */,
 146                                      WERROR *werror)
 147 {
 148         struct spoolss_EnumPrinters r;
 149         NTSTATUS status;
 150
 151         /* In parameters */
 152         r.in.flags = flags;
 153         r.in.server = server;
 154         r.in.level = level;
 155         r.in.buffer = buffer;
 156         r.in.offered = offered;
 157
 158         status = cli->dispatch(cli,
 159                                 mem_ctx,
 160                                 &ndr_table_spoolss,
 161                                 NDR_SPOOLSS_ENUMPRINTERS,
 162                                 &r);
 163
 164         if (!NT_STATUS_IS_OK(status)) {
 165                 return status;
 166         }
 167
 168         if (NT_STATUS_IS_ERR(status)) {
 169                 return status;
 170         }
 171
 172         /* Return variables */
 173         *count = *r.out.count;
 174         *info = *r.out.info;
 175         *needed = *r.out.needed;
 176
 177         /* Return result */
 178         if (werror) {
 179                 *werror = r.out.result;
 180         }
 181
 182         return werror_to_ntstatus(r.out.result);
 183 }
 184
 185 struct rpccli_spoolss_OpenPrinter_state {
 186         struct spoolss_OpenPrinter orig;
 187         struct spoolss_OpenPrinter tmp;
 188         TALLOC_CTX *out_mem_ctx;
 189         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 190 };
 191
 192 static void rpccli_spoolss_OpenPrinter_done(struct tevent_req *subreq);
 193
 194 struct tevent_req *rpccli_spoolss_OpenPrinter_send(TALLOC_CTX *mem_ctx,
 195                                                    struct tevent_context *ev,
 196                                                    struct rpc_pipe_client *cli,
 197                                                    const char *_printername /* [in] [unique,charset(UTF16)] */,
 198                                                    const char *_datatype /* [in] [unique,charset(UTF16)] */,
 199                                                    struct spoolss_DevmodeContainer _devmode_ctr /* [in]  */,
 200                                                    uint32_t _access_mask /* [in]  */,
 201                                                    struct policy_handle *_handle /* [out] [ref] */)
 202 {
 203         struct tevent_req *req;
 204         struct rpccli_spoolss_OpenPrinter_state *state;
 205         struct tevent_req *subreq;
 206
 207         req = tevent_req_create(mem_ctx, &state,
 208                                 struct rpccli_spoolss_OpenPrinter_state);
 209         if (req == NULL) {
 210                 return NULL;
 211         }
 212         state->out_mem_ctx = NULL;
 213         state->dispatch_recv = cli->dispatch_recv;
 214
 215         /* In parameters */
 216         state->orig.in.printername = _printername;
 217         state->orig.in.datatype = _datatype;
 218         state->orig.in.devmode_ctr = _devmode_ctr;
 219         state->orig.in.access_mask = _access_mask;
 220
 221         /* Out parameters */
 222         state->orig.out.handle = _handle;
 223
 224         /* Result */
 225         ZERO_STRUCT(state->orig.out.result);
 226
 227         state->out_mem_ctx = talloc_named_const(state, 0,
 228                              "rpccli_spoolss_OpenPrinter_out_memory");
 229         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 230                 return tevent_req_post(req, ev);
 231         }
 232
 233         /* make a temporary copy, that we pass to the dispatch function */
 234         state->tmp = state->orig;
 235
 236         subreq = cli->dispatch_send(state, ev, cli,
 237                                     &ndr_table_spoolss,
 238                                     NDR_SPOOLSS_OPENPRINTER,
 239                                     &state->tmp);
 240         if (tevent_req_nomem(subreq, req)) {
 241                 return tevent_req_post(req, ev);
 242         }
 243         tevent_req_set_callback(subreq, rpccli_spoolss_OpenPrinter_done, req);
 244         return req;
 245 }
 246
 247 static void rpccli_spoolss_OpenPrinter_done(struct tevent_req *subreq)
 248 {
 249         struct tevent_req *req = tevent_req_callback_data(
 250                 subreq, struct tevent_req);
 251         struct rpccli_spoolss_OpenPrinter_state *state = tevent_req_data(
 252                 req, struct rpccli_spoolss_OpenPrinter_state);
 253         NTSTATUS status;
 254         TALLOC_CTX *mem_ctx;
 255
 256         if (state->out_mem_ctx) {
 257                 mem_ctx = state->out_mem_ctx;
 258         } else {
 259                 mem_ctx = state;
 260         }
 261
 262         status = state->dispatch_recv(subreq, mem_ctx);
 263         TALLOC_FREE(subreq);
 264         if (!NT_STATUS_IS_OK(status)) {
 265                 tevent_req_nterror(req, status);
 266                 return;
 267         }
 268
 269         /* Copy out parameters */
 270         *state->orig.out.handle = *state->tmp.out.handle;
 271
 272         /* Copy result */
 273         state->orig.out.result = state->tmp.out.result;
 274
 275         /* Reset temporary structure */
 276         ZERO_STRUCT(state->tmp);
 277
 278         tevent_req_done(req);
 279 }
 280
 281 NTSTATUS rpccli_spoolss_OpenPrinter_recv(struct tevent_req *req,
 282                                          TALLOC_CTX *mem_ctx,
 283                                          WERROR *result)
 284 {
 285         struct rpccli_spoolss_OpenPrinter_state *state = tevent_req_data(
 286                 req, struct rpccli_spoolss_OpenPrinter_state);
 287         NTSTATUS status;
 288
 289         if (tevent_req_is_nterror(req, &status)) {
 290                 tevent_req_received(req);
 291                 return status;
 292         }
 293
 294         /* Steal possbile out parameters to the callers context */
 295         talloc_steal(mem_ctx, state->out_mem_ctx);
 296
 297         /* Return result */
 298         *result = state->orig.out.result;
 299
 300         tevent_req_received(req);
 301         return NT_STATUS_OK;
 302 }
 303
 304 NTSTATUS rpccli_spoolss_OpenPrinter(struct rpc_pipe_client *cli,
 305                                     TALLOC_CTX *mem_ctx,
 306                                     const char *printername /* [in] [unique,charset(UTF16)] */,
 307                                     const char *datatype /* [in] [unique,charset(UTF16)] */,
 308                                     struct spoolss_DevmodeContainer devmode_ctr /* [in]  */,
 309                                     uint32_t access_mask /* [in]  */,
 310                                     struct policy_handle *handle /* [out] [ref] */,
 311                                     WERROR *werror)
 312 {
 313         struct spoolss_OpenPrinter r;
 314         NTSTATUS status;
 315
 316         /* In parameters */
 317         r.in.printername = printername;
 318         r.in.datatype = datatype;
 319         r.in.devmode_ctr = devmode_ctr;
 320         r.in.access_mask = access_mask;
 321
 322         status = cli->dispatch(cli,
 323                                 mem_ctx,
 324                                 &ndr_table_spoolss,
 325                                 NDR_SPOOLSS_OPENPRINTER,
 326                                 &r);
 327
 328         if (!NT_STATUS_IS_OK(status)) {
 329                 return status;
 330         }
 331
 332         if (NT_STATUS_IS_ERR(status)) {
 333                 return status;
 334         }
 335
 336         /* Return variables */
 337         *handle = *r.out.handle;
 338
 339         /* Return result */
 340         if (werror) {
 341                 *werror = r.out.result;
 342         }
 343
 344         return werror_to_ntstatus(r.out.result);
 345 }
 346
 347 struct rpccli_spoolss_SetJob_state {
 348         struct spoolss_SetJob orig;
 349         struct spoolss_SetJob tmp;
 350         TALLOC_CTX *out_mem_ctx;
 351         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 352 };
 353
 354 static void rpccli_spoolss_SetJob_done(struct tevent_req *subreq);
 355
 356 struct tevent_req *rpccli_spoolss_SetJob_send(TALLOC_CTX *mem_ctx,
 357                                               struct tevent_context *ev,
 358                                               struct rpc_pipe_client *cli,
 359                                               struct policy_handle *_handle /* [in] [ref] */,
 360                                               uint32_t _job_id /* [in]  */,
 361                                               struct spoolss_JobInfoContainer *_ctr /* [in] [unique] */,
 362                                               enum spoolss_JobControl _command /* [in]  */)
 363 {
 364         struct tevent_req *req;
 365         struct rpccli_spoolss_SetJob_state *state;
 366         struct tevent_req *subreq;
 367
 368         req = tevent_req_create(mem_ctx, &state,
 369                                 struct rpccli_spoolss_SetJob_state);
 370         if (req == NULL) {
 371                 return NULL;
 372         }
 373         state->out_mem_ctx = NULL;
 374         state->dispatch_recv = cli->dispatch_recv;
 375
 376         /* In parameters */
 377         state->orig.in.handle = _handle;
 378         state->orig.in.job_id = _job_id;
 379         state->orig.in.ctr = _ctr;
 380         state->orig.in.command = _command;
 381
 382         /* Out parameters */
 383
 384         /* Result */
 385         ZERO_STRUCT(state->orig.out.result);
 386
 387         /* make a temporary copy, that we pass to the dispatch function */
 388         state->tmp = state->orig;
 389
 390         subreq = cli->dispatch_send(state, ev, cli,
 391                                     &ndr_table_spoolss,
 392                                     NDR_SPOOLSS_SETJOB,
 393                                     &state->tmp);
 394         if (tevent_req_nomem(subreq, req)) {
 395                 return tevent_req_post(req, ev);
 396         }
 397         tevent_req_set_callback(subreq, rpccli_spoolss_SetJob_done, req);
 398         return req;
 399 }
 400
 401 static void rpccli_spoolss_SetJob_done(struct tevent_req *subreq)
 402 {
 403         struct tevent_req *req = tevent_req_callback_data(
 404                 subreq, struct tevent_req);
 405         struct rpccli_spoolss_SetJob_state *state = tevent_req_data(
 406                 req, struct rpccli_spoolss_SetJob_state);
 407         NTSTATUS status;
 408         TALLOC_CTX *mem_ctx;
 409
 410         if (state->out_mem_ctx) {
 411                 mem_ctx = state->out_mem_ctx;
 412         } else {
 413                 mem_ctx = state;
 414         }
 415
 416         status = state->dispatch_recv(subreq, mem_ctx);
 417         TALLOC_FREE(subreq);
 418         if (!NT_STATUS_IS_OK(status)) {
 419                 tevent_req_nterror(req, status);
 420                 return;
 421         }
 422
 423         /* Copy out parameters */
 424
 425         /* Copy result */
 426         state->orig.out.result = state->tmp.out.result;
 427
 428         /* Reset temporary structure */
 429         ZERO_STRUCT(state->tmp);
 430
 431         tevent_req_done(req);
 432 }
 433
 434 NTSTATUS rpccli_spoolss_SetJob_recv(struct tevent_req *req,
 435                                     TALLOC_CTX *mem_ctx,
 436                                     WERROR *result)
 437 {
 438         struct rpccli_spoolss_SetJob_state *state = tevent_req_data(
 439                 req, struct rpccli_spoolss_SetJob_state);
 440         NTSTATUS status;
 441
 442         if (tevent_req_is_nterror(req, &status)) {
 443                 tevent_req_received(req);
 444                 return status;
 445         }
 446
 447         /* Steal possbile out parameters to the callers context */
 448         talloc_steal(mem_ctx, state->out_mem_ctx);
 449
 450         /* Return result */
 451         *result = state->orig.out.result;
 452
 453         tevent_req_received(req);
 454         return NT_STATUS_OK;
 455 }
 456
 457 NTSTATUS rpccli_spoolss_SetJob(struct rpc_pipe_client *cli,
 458                                TALLOC_CTX *mem_ctx,
 459                                struct policy_handle *handle /* [in] [ref] */,
 460                                uint32_t job_id /* [in]  */,
 461                                struct spoolss_JobInfoContainer *ctr /* [in] [unique] */,
 462                                enum spoolss_JobControl command /* [in]  */,
 463                                WERROR *werror)
 464 {
 465         struct spoolss_SetJob r;
 466         NTSTATUS status;
 467
 468         /* In parameters */
 469         r.in.handle = handle;
 470         r.in.job_id = job_id;
 471         r.in.ctr = ctr;
 472         r.in.command = command;
 473
 474         status = cli->dispatch(cli,
 475                                 mem_ctx,
 476                                 &ndr_table_spoolss,
 477                                 NDR_SPOOLSS_SETJOB,
 478                                 &r);
 479
 480         if (!NT_STATUS_IS_OK(status)) {
 481                 return status;
 482         }
 483
 484         if (NT_STATUS_IS_ERR(status)) {
 485                 return status;
 486         }
 487
 488         /* Return variables */
 489
 490         /* Return result */
 491         if (werror) {
 492                 *werror = r.out.result;
 493         }
 494
 495         return werror_to_ntstatus(r.out.result);
 496 }
 497
 498 struct rpccli_spoolss_GetJob_state {
 499         struct spoolss_GetJob orig;
 500         struct spoolss_GetJob tmp;
 501         TALLOC_CTX *out_mem_ctx;
 502         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 503 };
 504
 505 static void rpccli_spoolss_GetJob_done(struct tevent_req *subreq);
 506
 507 struct tevent_req *rpccli_spoolss_GetJob_send(TALLOC_CTX *mem_ctx,
 508                                               struct tevent_context *ev,
 509                                               struct rpc_pipe_client *cli,
 510                                               struct policy_handle *_handle /* [in] [ref] */,
 511                                               uint32_t _job_id /* [in]  */,
 512                                               uint32_t _level /* [in]  */,
 513                                               DATA_BLOB *_buffer /* [in] [unique] */,
 514                                               uint32_t _offered /* [in]  */,
 515                                               union spoolss_JobInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
 516                                               uint32_t *_needed /* [out] [ref] */)
 517 {
 518         struct tevent_req *req;
 519         struct rpccli_spoolss_GetJob_state *state;
 520         struct tevent_req *subreq;
 521
 522         req = tevent_req_create(mem_ctx, &state,
 523                                 struct rpccli_spoolss_GetJob_state);
 524         if (req == NULL) {
 525                 return NULL;
 526         }
 527         state->out_mem_ctx = NULL;
 528         state->dispatch_recv = cli->dispatch_recv;
 529
 530         /* In parameters */
 531         state->orig.in.handle = _handle;
 532         state->orig.in.job_id = _job_id;
 533         state->orig.in.level = _level;
 534         state->orig.in.buffer = _buffer;
 535         state->orig.in.offered = _offered;
 536
 537         /* Out parameters */
 538         state->orig.out.info = _info;
 539         state->orig.out.needed = _needed;
 540
 541         /* Result */
 542         ZERO_STRUCT(state->orig.out.result);
 543
 544         state->out_mem_ctx = talloc_named_const(state, 0,
 545                              "rpccli_spoolss_GetJob_out_memory");
 546         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 547                 return tevent_req_post(req, ev);
 548         }
 549
 550         /* make a temporary copy, that we pass to the dispatch function */
 551         state->tmp = state->orig;
 552
 553         subreq = cli->dispatch_send(state, ev, cli,
 554                                     &ndr_table_spoolss,
 555                                     NDR_SPOOLSS_GETJOB,
 556                                     &state->tmp);
 557         if (tevent_req_nomem(subreq, req)) {
 558                 return tevent_req_post(req, ev);
 559         }
 560         tevent_req_set_callback(subreq, rpccli_spoolss_GetJob_done, req);
 561         return req;
 562 }
 563
 564 static void rpccli_spoolss_GetJob_done(struct tevent_req *subreq)
 565 {
 566         struct tevent_req *req = tevent_req_callback_data(
 567                 subreq, struct tevent_req);
 568         struct rpccli_spoolss_GetJob_state *state = tevent_req_data(
 569                 req, struct rpccli_spoolss_GetJob_state);
 570         NTSTATUS status;
 571         TALLOC_CTX *mem_ctx;
 572
 573         if (state->out_mem_ctx) {
 574                 mem_ctx = state->out_mem_ctx;
 575         } else {
 576                 mem_ctx = state;
 577         }
 578
 579         status = state->dispatch_recv(subreq, mem_ctx);
 580         TALLOC_FREE(subreq);
 581         if (!NT_STATUS_IS_OK(status)) {
 582                 tevent_req_nterror(req, status);
 583                 return;
 584         }
 585
 586         /* Copy out parameters */
 587         if (state->orig.out.info && state->tmp.out.info) {
 588                 *state->orig.out.info = *state->tmp.out.info;
 589         }
 590         *state->orig.out.needed = *state->tmp.out.needed;
 591
 592         /* Copy result */
 593         state->orig.out.result = state->tmp.out.result;
 594
 595         /* Reset temporary structure */
 596         ZERO_STRUCT(state->tmp);
 597
 598         tevent_req_done(req);
 599 }
 600
 601 NTSTATUS rpccli_spoolss_GetJob_recv(struct tevent_req *req,
 602                                     TALLOC_CTX *mem_ctx,
 603                                     WERROR *result)
 604 {
 605         struct rpccli_spoolss_GetJob_state *state = tevent_req_data(
 606                 req, struct rpccli_spoolss_GetJob_state);
 607         NTSTATUS status;
 608
 609         if (tevent_req_is_nterror(req, &status)) {
 610                 tevent_req_received(req);
 611                 return status;
 612         }
 613
 614         /* Steal possbile out parameters to the callers context */
 615         talloc_steal(mem_ctx, state->out_mem_ctx);
 616
 617         /* Return result */
 618         *result = state->orig.out.result;
 619
 620         tevent_req_received(req);
 621         return NT_STATUS_OK;
 622 }
 623
 624 NTSTATUS rpccli_spoolss_GetJob(struct rpc_pipe_client *cli,
 625                                TALLOC_CTX *mem_ctx,
 626                                struct policy_handle *handle /* [in] [ref] */,
 627                                uint32_t job_id /* [in]  */,
 628                                uint32_t level /* [in]  */,
 629                                DATA_BLOB *buffer /* [in] [unique] */,
 630                                uint32_t offered /* [in]  */,
 631                                union spoolss_JobInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
 632                                uint32_t *needed /* [out] [ref] */,
 633                                WERROR *werror)
 634 {
 635         struct spoolss_GetJob r;
 636         NTSTATUS status;
 637
 638         /* In parameters */
 639         r.in.handle = handle;
 640         r.in.job_id = job_id;
 641         r.in.level = level;
 642         r.in.buffer = buffer;
 643         r.in.offered = offered;
 644
 645         status = cli->dispatch(cli,
 646                                 mem_ctx,
 647                                 &ndr_table_spoolss,
 648                                 NDR_SPOOLSS_GETJOB,
 649                                 &r);
 650
 651         if (!NT_STATUS_IS_OK(status)) {
 652                 return status;
 653         }
 654
 655         if (NT_STATUS_IS_ERR(status)) {
 656                 return status;
 657         }
 658
 659         /* Return variables */
 660         if (info && r.out.info) {
 661                 *info = *r.out.info;
 662         }
 663         *needed = *r.out.needed;
 664
 665         /* Return result */
 666         if (werror) {
 667                 *werror = r.out.result;
 668         }
 669
 670         return werror_to_ntstatus(r.out.result);
 671 }
 672
 673 struct rpccli_spoolss_EnumJobs_state {
 674         struct spoolss_EnumJobs orig;
 675         struct spoolss_EnumJobs tmp;
 676         TALLOC_CTX *out_mem_ctx;
 677         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 678 };
 679
 680 static void rpccli_spoolss_EnumJobs_done(struct tevent_req *subreq);
 681
 682 struct tevent_req *rpccli_spoolss_EnumJobs_send(TALLOC_CTX *mem_ctx,
 683                                                 struct tevent_context *ev,
 684                                                 struct rpc_pipe_client *cli,
 685                                                 struct policy_handle *_handle /* [in] [ref] */,
 686                                                 uint32_t _firstjob /* [in]  */,
 687                                                 uint32_t _numjobs /* [in]  */,
 688                                                 uint32_t _level /* [in]  */,
 689                                                 DATA_BLOB *_buffer /* [in] [unique] */,
 690                                                 uint32_t _offered /* [in]  */,
 691                                                 uint32_t *_count /* [out] [ref] */,
 692                                                 union spoolss_JobInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
 693                                                 uint32_t *_needed /* [out] [ref] */)
 694 {
 695         struct tevent_req *req;
 696         struct rpccli_spoolss_EnumJobs_state *state;
 697         struct tevent_req *subreq;
 698
 699         req = tevent_req_create(mem_ctx, &state,
 700                                 struct rpccli_spoolss_EnumJobs_state);
 701         if (req == NULL) {
 702                 return NULL;
 703         }
 704         state->out_mem_ctx = NULL;
 705         state->dispatch_recv = cli->dispatch_recv;
 706
 707         /* In parameters */
 708         state->orig.in.handle = _handle;
 709         state->orig.in.firstjob = _firstjob;
 710         state->orig.in.numjobs = _numjobs;
 711         state->orig.in.level = _level;
 712         state->orig.in.buffer = _buffer;
 713         state->orig.in.offered = _offered;
 714
 715         /* Out parameters */
 716         state->orig.out.count = _count;
 717         state->orig.out.info = _info;
 718         state->orig.out.needed = _needed;
 719
 720         /* Result */
 721         ZERO_STRUCT(state->orig.out.result);
 722
 723         state->out_mem_ctx = talloc_named_const(state, 0,
 724                              "rpccli_spoolss_EnumJobs_out_memory");
 725         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 726                 return tevent_req_post(req, ev);
 727         }
 728
 729         /* make a temporary copy, that we pass to the dispatch function */
 730         state->tmp = state->orig;
 731
 732         subreq = cli->dispatch_send(state, ev, cli,
 733                                     &ndr_table_spoolss,
 734                                     NDR_SPOOLSS_ENUMJOBS,
 735                                     &state->tmp);
 736         if (tevent_req_nomem(subreq, req)) {
 737                 return tevent_req_post(req, ev);
 738         }
 739         tevent_req_set_callback(subreq, rpccli_spoolss_EnumJobs_done, req);
 740         return req;
 741 }
 742
 743 static void rpccli_spoolss_EnumJobs_done(struct tevent_req *subreq)
 744 {
 745         struct tevent_req *req = tevent_req_callback_data(
 746                 subreq, struct tevent_req);
 747         struct rpccli_spoolss_EnumJobs_state *state = tevent_req_data(
 748                 req, struct rpccli_spoolss_EnumJobs_state);
 749         NTSTATUS status;
 750         TALLOC_CTX *mem_ctx;
 751
 752         if (state->out_mem_ctx) {
 753                 mem_ctx = state->out_mem_ctx;
 754         } else {
 755                 mem_ctx = state;
 756         }
 757
 758         status = state->dispatch_recv(subreq, mem_ctx);
 759         TALLOC_FREE(subreq);
 760         if (!NT_STATUS_IS_OK(status)) {
 761                 tevent_req_nterror(req, status);
 762                 return;
 763         }
 764
 765         /* Copy out parameters */
 766         *state->orig.out.count = *state->tmp.out.count;
 767         *state->orig.out.info = *state->tmp.out.info;
 768         *state->orig.out.needed = *state->tmp.out.needed;
 769
 770         /* Copy result */
 771         state->orig.out.result = state->tmp.out.result;
 772
 773         /* Reset temporary structure */
 774         ZERO_STRUCT(state->tmp);
 775
 776         tevent_req_done(req);
 777 }
 778
 779 NTSTATUS rpccli_spoolss_EnumJobs_recv(struct tevent_req *req,
 780                                       TALLOC_CTX *mem_ctx,
 781                                       WERROR *result)
 782 {
 783         struct rpccli_spoolss_EnumJobs_state *state = tevent_req_data(
 784                 req, struct rpccli_spoolss_EnumJobs_state);
 785         NTSTATUS status;
 786
 787         if (tevent_req_is_nterror(req, &status)) {
 788                 tevent_req_received(req);
 789                 return status;
 790         }
 791
 792         /* Steal possbile out parameters to the callers context */
 793         talloc_steal(mem_ctx, state->out_mem_ctx);
 794
 795         /* Return result */
 796         *result = state->orig.out.result;
 797
 798         tevent_req_received(req);
 799         return NT_STATUS_OK;
 800 }
 801
 802 NTSTATUS rpccli_spoolss_EnumJobs(struct rpc_pipe_client *cli,
 803                                  TALLOC_CTX *mem_ctx,
 804                                  struct policy_handle *handle /* [in] [ref] */,
 805                                  uint32_t firstjob /* [in]  */,
 806                                  uint32_t numjobs /* [in]  */,
 807                                  uint32_t level /* [in]  */,
 808                                  DATA_BLOB *buffer /* [in] [unique] */,
 809                                  uint32_t offered /* [in]  */,
 810                                  uint32_t *count /* [out] [ref] */,
 811                                  union spoolss_JobInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
 812                                  uint32_t *needed /* [out] [ref] */,
 813                                  WERROR *werror)
 814 {
 815         struct spoolss_EnumJobs r;
 816         NTSTATUS status;
 817
 818         /* In parameters */
 819         r.in.handle = handle;
 820         r.in.firstjob = firstjob;
 821         r.in.numjobs = numjobs;
 822         r.in.level = level;
 823         r.in.buffer = buffer;
 824         r.in.offered = offered;
 825
 826         status = cli->dispatch(cli,
 827                                 mem_ctx,
 828                                 &ndr_table_spoolss,
 829                                 NDR_SPOOLSS_ENUMJOBS,
 830                                 &r);
 831
 832         if (!NT_STATUS_IS_OK(status)) {
 833                 return status;
 834         }
 835
 836         if (NT_STATUS_IS_ERR(status)) {
 837                 return status;
 838         }
 839
 840         /* Return variables */
 841         *count = *r.out.count;
 842         *info = *r.out.info;
 843         *needed = *r.out.needed;
 844
 845         /* Return result */
 846         if (werror) {
 847                 *werror = r.out.result;
 848         }
 849
 850         return werror_to_ntstatus(r.out.result);
 851 }
 852
 853 struct rpccli_spoolss_AddPrinter_state {
 854         struct spoolss_AddPrinter orig;
 855         struct spoolss_AddPrinter tmp;
 856         TALLOC_CTX *out_mem_ctx;
 857         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 858 };
 859
 860 static void rpccli_spoolss_AddPrinter_done(struct tevent_req *subreq);
 861
 862 struct tevent_req *rpccli_spoolss_AddPrinter_send(TALLOC_CTX *mem_ctx,
 863                                                   struct tevent_context *ev,
 864                                                   struct rpc_pipe_client *cli,
 865                                                   const char *_server /* [in] [unique,charset(UTF16)] */,
 866                                                   struct spoolss_SetPrinterInfoCtr *_info_ctr /* [in] [ref] */,
 867                                                   struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */,
 868                                                   struct sec_desc_buf *_secdesc_ctr /* [in] [ref] */,
 869                                                   struct policy_handle *_handle /* [out] [ref] */)
 870 {
 871         struct tevent_req *req;
 872         struct rpccli_spoolss_AddPrinter_state *state;
 873         struct tevent_req *subreq;
 874
 875         req = tevent_req_create(mem_ctx, &state,
 876                                 struct rpccli_spoolss_AddPrinter_state);
 877         if (req == NULL) {
 878                 return NULL;
 879         }
 880         state->out_mem_ctx = NULL;
 881         state->dispatch_recv = cli->dispatch_recv;
 882
 883         /* In parameters */
 884         state->orig.in.server = _server;
 885         state->orig.in.info_ctr = _info_ctr;
 886         state->orig.in.devmode_ctr = _devmode_ctr;
 887         state->orig.in.secdesc_ctr = _secdesc_ctr;
 888
 889         /* Out parameters */
 890         state->orig.out.handle = _handle;
 891
 892         /* Result */
 893         ZERO_STRUCT(state->orig.out.result);
 894
 895         state->out_mem_ctx = talloc_named_const(state, 0,
 896                              "rpccli_spoolss_AddPrinter_out_memory");
 897         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 898                 return tevent_req_post(req, ev);
 899         }
 900
 901         /* make a temporary copy, that we pass to the dispatch function */
 902         state->tmp = state->orig;
 903
 904         subreq = cli->dispatch_send(state, ev, cli,
 905                                     &ndr_table_spoolss,
 906                                     NDR_SPOOLSS_ADDPRINTER,
 907                                     &state->tmp);
 908         if (tevent_req_nomem(subreq, req)) {
 909                 return tevent_req_post(req, ev);
 910         }
 911         tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinter_done, req);
 912         return req;
 913 }
 914
 915 static void rpccli_spoolss_AddPrinter_done(struct tevent_req *subreq)
 916 {
 917         struct tevent_req *req = tevent_req_callback_data(
 918                 subreq, struct tevent_req);
 919         struct rpccli_spoolss_AddPrinter_state *state = tevent_req_data(
 920                 req, struct rpccli_spoolss_AddPrinter_state);
 921         NTSTATUS status;
 922         TALLOC_CTX *mem_ctx;
 923
 924         if (state->out_mem_ctx) {
 925                 mem_ctx = state->out_mem_ctx;
 926         } else {
 927                 mem_ctx = state;
 928         }
 929
 930         status = state->dispatch_recv(subreq, mem_ctx);
 931         TALLOC_FREE(subreq);
 932         if (!NT_STATUS_IS_OK(status)) {
 933                 tevent_req_nterror(req, status);
 934                 return;
 935         }
 936
 937         /* Copy out parameters */
 938         *state->orig.out.handle = *state->tmp.out.handle;
 939
 940         /* Copy result */
 941         state->orig.out.result = state->tmp.out.result;
 942
 943         /* Reset temporary structure */
 944         ZERO_STRUCT(state->tmp);
 945
 946         tevent_req_done(req);
 947 }
 948
 949 NTSTATUS rpccli_spoolss_AddPrinter_recv(struct tevent_req *req,
 950                                         TALLOC_CTX *mem_ctx,
 951                                         WERROR *result)
 952 {
 953         struct rpccli_spoolss_AddPrinter_state *state = tevent_req_data(
 954                 req, struct rpccli_spoolss_AddPrinter_state);
 955         NTSTATUS status;
 956
 957         if (tevent_req_is_nterror(req, &status)) {
 958                 tevent_req_received(req);
 959                 return status;
 960         }
 961
 962         /* Steal possbile out parameters to the callers context */
 963         talloc_steal(mem_ctx, state->out_mem_ctx);
 964
 965         /* Return result */
 966         *result = state->orig.out.result;
 967
 968         tevent_req_received(req);
 969         return NT_STATUS_OK;
 970 }
 971
 972 NTSTATUS rpccli_spoolss_AddPrinter(struct rpc_pipe_client *cli,
 973                                    TALLOC_CTX *mem_ctx,
 974                                    const char *server /* [in] [unique,charset(UTF16)] */,
 975                                    struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */,
 976                                    struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
 977                                    struct sec_desc_buf *secdesc_ctr /* [in] [ref] */,
 978                                    struct policy_handle *handle /* [out] [ref] */,
 979                                    WERROR *werror)
 980 {
 981         struct spoolss_AddPrinter r;
 982         NTSTATUS status;
 983
 984         /* In parameters */
 985         r.in.server = server;
 986         r.in.info_ctr = info_ctr;
 987         r.in.devmode_ctr = devmode_ctr;
 988         r.in.secdesc_ctr = secdesc_ctr;
 989
 990         status = cli->dispatch(cli,
 991                                 mem_ctx,
 992                                 &ndr_table_spoolss,
 993                                 NDR_SPOOLSS_ADDPRINTER,
 994                                 &r);
 995
 996         if (!NT_STATUS_IS_OK(status)) {
 997                 return status;
 998         }
 999
1000         if (NT_STATUS_IS_ERR(status)) {
1001                 return status;
1002         }
1003
1004         /* Return variables */
1005         *handle = *r.out.handle;
1006
1007         /* Return result */
1008         if (werror) {
1009                 *werror = r.out.result;
1010         }
1011
1012         return werror_to_ntstatus(r.out.result);
1013 }
1014
1015 struct rpccli_spoolss_DeletePrinter_state {
1016         struct spoolss_DeletePrinter orig;
1017         struct spoolss_DeletePrinter tmp;
1018         TALLOC_CTX *out_mem_ctx;
1019         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1020 };
1021
1022 static void rpccli_spoolss_DeletePrinter_done(struct tevent_req *subreq);
1023
1024 struct tevent_req *rpccli_spoolss_DeletePrinter_send(TALLOC_CTX *mem_ctx,
1025                                                      struct tevent_context *ev,
1026                                                      struct rpc_pipe_client *cli,
1027                                                      struct policy_handle *_handle /* [in] [ref] */)
1028 {
1029         struct tevent_req *req;
1030         struct rpccli_spoolss_DeletePrinter_state *state;
1031         struct tevent_req *subreq;
1032
1033         req = tevent_req_create(mem_ctx, &state,
1034                                 struct rpccli_spoolss_DeletePrinter_state);
1035         if (req == NULL) {
1036                 return NULL;
1037         }
1038         state->out_mem_ctx = NULL;
1039         state->dispatch_recv = cli->dispatch_recv;
1040
1041         /* In parameters */
1042         state->orig.in.handle = _handle;
1043
1044         /* Out parameters */
1045
1046         /* Result */
1047         ZERO_STRUCT(state->orig.out.result);
1048
1049         /* make a temporary copy, that we pass to the dispatch function */
1050         state->tmp = state->orig;
1051
1052         subreq = cli->dispatch_send(state, ev, cli,
1053                                     &ndr_table_spoolss,
1054                                     NDR_SPOOLSS_DELETEPRINTER,
1055                                     &state->tmp);
1056         if (tevent_req_nomem(subreq, req)) {
1057                 return tevent_req_post(req, ev);
1058         }
1059         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinter_done, req);
1060         return req;
1061 }
1062
1063 static void rpccli_spoolss_DeletePrinter_done(struct tevent_req *subreq)
1064 {
1065         struct tevent_req *req = tevent_req_callback_data(
1066                 subreq, struct tevent_req);
1067         struct rpccli_spoolss_DeletePrinter_state *state = tevent_req_data(
1068                 req, struct rpccli_spoolss_DeletePrinter_state);
1069         NTSTATUS status;
1070         TALLOC_CTX *mem_ctx;
1071
1072         if (state->out_mem_ctx) {
1073                 mem_ctx = state->out_mem_ctx;
1074         } else {
1075                 mem_ctx = state;
1076         }
1077
1078         status = state->dispatch_recv(subreq, mem_ctx);
1079         TALLOC_FREE(subreq);
1080         if (!NT_STATUS_IS_OK(status)) {
1081                 tevent_req_nterror(req, status);
1082                 return;
1083         }
1084
1085         /* Copy out parameters */
1086
1087         /* Copy result */
1088         state->orig.out.result = state->tmp.out.result;
1089
1090         /* Reset temporary structure */
1091         ZERO_STRUCT(state->tmp);
1092
1093         tevent_req_done(req);
1094 }
1095
1096 NTSTATUS rpccli_spoolss_DeletePrinter_recv(struct tevent_req *req,
1097                                            TALLOC_CTX *mem_ctx,
1098                                            WERROR *result)
1099 {
1100         struct rpccli_spoolss_DeletePrinter_state *state = tevent_req_data(
1101                 req, struct rpccli_spoolss_DeletePrinter_state);
1102         NTSTATUS status;
1103
1104         if (tevent_req_is_nterror(req, &status)) {
1105                 tevent_req_received(req);
1106                 return status;
1107         }
1108
1109         /* Steal possbile out parameters to the callers context */
1110         talloc_steal(mem_ctx, state->out_mem_ctx);
1111
1112         /* Return result */
1113         *result = state->orig.out.result;
1114
1115         tevent_req_received(req);
1116         return NT_STATUS_OK;
1117 }
1118
1119 NTSTATUS rpccli_spoolss_DeletePrinter(struct rpc_pipe_client *cli,
1120                                       TALLOC_CTX *mem_ctx,
1121                                       struct policy_handle *handle /* [in] [ref] */,
1122                                       WERROR *werror)
1123 {
1124         struct spoolss_DeletePrinter r;
1125         NTSTATUS status;
1126
1127         /* In parameters */
1128         r.in.handle = handle;
1129
1130         status = cli->dispatch(cli,
1131                                 mem_ctx,
1132                                 &ndr_table_spoolss,
1133                                 NDR_SPOOLSS_DELETEPRINTER,
1134                                 &r);
1135
1136         if (!NT_STATUS_IS_OK(status)) {
1137                 return status;
1138         }
1139
1140         if (NT_STATUS_IS_ERR(status)) {
1141                 return status;
1142         }
1143
1144         /* Return variables */
1145
1146         /* Return result */
1147         if (werror) {
1148                 *werror = r.out.result;
1149         }
1150
1151         return werror_to_ntstatus(r.out.result);
1152 }
1153
1154 struct rpccli_spoolss_SetPrinter_state {
1155         struct spoolss_SetPrinter orig;
1156         struct spoolss_SetPrinter tmp;
1157         TALLOC_CTX *out_mem_ctx;
1158         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1159 };
1160
1161 static void rpccli_spoolss_SetPrinter_done(struct tevent_req *subreq);
1162
1163 struct tevent_req *rpccli_spoolss_SetPrinter_send(TALLOC_CTX *mem_ctx,
1164                                                   struct tevent_context *ev,
1165                                                   struct rpc_pipe_client *cli,
1166                                                   struct policy_handle *_handle /* [in] [ref] */,
1167                                                   struct spoolss_SetPrinterInfoCtr *_info_ctr /* [in] [ref] */,
1168                                                   struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */,
1169                                                   struct sec_desc_buf *_secdesc_ctr /* [in] [ref] */,
1170                                                   enum spoolss_PrinterControl _command /* [in]  */)
1171 {
1172         struct tevent_req *req;
1173         struct rpccli_spoolss_SetPrinter_state *state;
1174         struct tevent_req *subreq;
1175
1176         req = tevent_req_create(mem_ctx, &state,
1177                                 struct rpccli_spoolss_SetPrinter_state);
1178         if (req == NULL) {
1179                 return NULL;
1180         }
1181         state->out_mem_ctx = NULL;
1182         state->dispatch_recv = cli->dispatch_recv;
1183
1184         /* In parameters */
1185         state->orig.in.handle = _handle;
1186         state->orig.in.info_ctr = _info_ctr;
1187         state->orig.in.devmode_ctr = _devmode_ctr;
1188         state->orig.in.secdesc_ctr = _secdesc_ctr;
1189         state->orig.in.command = _command;
1190
1191         /* Out parameters */
1192
1193         /* Result */
1194         ZERO_STRUCT(state->orig.out.result);
1195
1196         /* make a temporary copy, that we pass to the dispatch function */
1197         state->tmp = state->orig;
1198
1199         subreq = cli->dispatch_send(state, ev, cli,
1200                                     &ndr_table_spoolss,
1201                                     NDR_SPOOLSS_SETPRINTER,
1202                                     &state->tmp);
1203         if (tevent_req_nomem(subreq, req)) {
1204                 return tevent_req_post(req, ev);
1205         }
1206         tevent_req_set_callback(subreq, rpccli_spoolss_SetPrinter_done, req);
1207         return req;
1208 }
1209
1210 static void rpccli_spoolss_SetPrinter_done(struct tevent_req *subreq)
1211 {
1212         struct tevent_req *req = tevent_req_callback_data(
1213                 subreq, struct tevent_req);
1214         struct rpccli_spoolss_SetPrinter_state *state = tevent_req_data(
1215                 req, struct rpccli_spoolss_SetPrinter_state);
1216         NTSTATUS status;
1217         TALLOC_CTX *mem_ctx;
1218
1219         if (state->out_mem_ctx) {
1220                 mem_ctx = state->out_mem_ctx;
1221         } else {
1222                 mem_ctx = state;
1223         }
1224
1225         status = state->dispatch_recv(subreq, mem_ctx);
1226         TALLOC_FREE(subreq);
1227         if (!NT_STATUS_IS_OK(status)) {
1228                 tevent_req_nterror(req, status);
1229                 return;
1230         }
1231
1232         /* Copy out parameters */
1233
1234         /* Copy result */
1235         state->orig.out.result = state->tmp.out.result;
1236
1237         /* Reset temporary structure */
1238         ZERO_STRUCT(state->tmp);
1239
1240         tevent_req_done(req);
1241 }
1242
1243 NTSTATUS rpccli_spoolss_SetPrinter_recv(struct tevent_req *req,
1244                                         TALLOC_CTX *mem_ctx,
1245                                         WERROR *result)
1246 {
1247         struct rpccli_spoolss_SetPrinter_state *state = tevent_req_data(
1248                 req, struct rpccli_spoolss_SetPrinter_state);
1249         NTSTATUS status;
1250
1251         if (tevent_req_is_nterror(req, &status)) {
1252                 tevent_req_received(req);
1253                 return status;
1254         }
1255
1256         /* Steal possbile out parameters to the callers context */
1257         talloc_steal(mem_ctx, state->out_mem_ctx);
1258
1259         /* Return result */
1260         *result = state->orig.out.result;
1261
1262         tevent_req_received(req);
1263         return NT_STATUS_OK;
1264 }
1265
1266 NTSTATUS rpccli_spoolss_SetPrinter(struct rpc_pipe_client *cli,
1267                                    TALLOC_CTX *mem_ctx,
1268                                    struct policy_handle *handle /* [in] [ref] */,
1269                                    struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */,
1270                                    struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
1271                                    struct sec_desc_buf *secdesc_ctr /* [in] [ref] */,
1272                                    enum spoolss_PrinterControl command /* [in]  */,
1273                                    WERROR *werror)
1274 {
1275         struct spoolss_SetPrinter r;
1276         NTSTATUS status;
1277
1278         /* In parameters */
1279         r.in.handle = handle;
1280         r.in.info_ctr = info_ctr;
1281         r.in.devmode_ctr = devmode_ctr;
1282         r.in.secdesc_ctr = secdesc_ctr;
1283         r.in.command = command;
1284
1285         status = cli->dispatch(cli,
1286                                 mem_ctx,
1287                                 &ndr_table_spoolss,
1288                                 NDR_SPOOLSS_SETPRINTER,
1289                                 &r);
1290
1291         if (!NT_STATUS_IS_OK(status)) {
1292                 return status;
1293         }
1294
1295         if (NT_STATUS_IS_ERR(status)) {
1296                 return status;
1297         }
1298
1299         /* Return variables */
1300
1301         /* Return result */
1302         if (werror) {
1303                 *werror = r.out.result;
1304         }
1305
1306         return werror_to_ntstatus(r.out.result);
1307 }
1308
1309 struct rpccli_spoolss_GetPrinter_state {
1310         struct spoolss_GetPrinter orig;
1311         struct spoolss_GetPrinter tmp;
1312         TALLOC_CTX *out_mem_ctx;
1313         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1314 };
1315
1316 static void rpccli_spoolss_GetPrinter_done(struct tevent_req *subreq);
1317
1318 struct tevent_req *rpccli_spoolss_GetPrinter_send(TALLOC_CTX *mem_ctx,
1319                                                   struct tevent_context *ev,
1320                                                   struct rpc_pipe_client *cli,
1321                                                   struct policy_handle *_handle /* [in] [ref] */,
1322                                                   uint32_t _level /* [in]  */,
1323                                                   DATA_BLOB *_buffer /* [in] [unique] */,
1324                                                   uint32_t _offered /* [in]  */,
1325                                                   union spoolss_PrinterInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1326                                                   uint32_t *_needed /* [out] [ref] */)
1327 {
1328         struct tevent_req *req;
1329         struct rpccli_spoolss_GetPrinter_state *state;
1330         struct tevent_req *subreq;
1331
1332         req = tevent_req_create(mem_ctx, &state,
1333                                 struct rpccli_spoolss_GetPrinter_state);
1334         if (req == NULL) {
1335                 return NULL;
1336         }
1337         state->out_mem_ctx = NULL;
1338         state->dispatch_recv = cli->dispatch_recv;
1339
1340         /* In parameters */
1341         state->orig.in.handle = _handle;
1342         state->orig.in.level = _level;
1343         state->orig.in.buffer = _buffer;
1344         state->orig.in.offered = _offered;
1345
1346         /* Out parameters */
1347         state->orig.out.info = _info;
1348         state->orig.out.needed = _needed;
1349
1350         /* Result */
1351         ZERO_STRUCT(state->orig.out.result);
1352
1353         state->out_mem_ctx = talloc_named_const(state, 0,
1354                              "rpccli_spoolss_GetPrinter_out_memory");
1355         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1356                 return tevent_req_post(req, ev);
1357         }
1358
1359         /* make a temporary copy, that we pass to the dispatch function */
1360         state->tmp = state->orig;
1361
1362         subreq = cli->dispatch_send(state, ev, cli,
1363                                     &ndr_table_spoolss,
1364                                     NDR_SPOOLSS_GETPRINTER,
1365                                     &state->tmp);
1366         if (tevent_req_nomem(subreq, req)) {
1367                 return tevent_req_post(req, ev);
1368         }
1369         tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinter_done, req);
1370         return req;
1371 }
1372
1373 static void rpccli_spoolss_GetPrinter_done(struct tevent_req *subreq)
1374 {
1375         struct tevent_req *req = tevent_req_callback_data(
1376                 subreq, struct tevent_req);
1377         struct rpccli_spoolss_GetPrinter_state *state = tevent_req_data(
1378                 req, struct rpccli_spoolss_GetPrinter_state);
1379         NTSTATUS status;
1380         TALLOC_CTX *mem_ctx;
1381
1382         if (state->out_mem_ctx) {
1383                 mem_ctx = state->out_mem_ctx;
1384         } else {
1385                 mem_ctx = state;
1386         }
1387
1388         status = state->dispatch_recv(subreq, mem_ctx);
1389         TALLOC_FREE(subreq);
1390         if (!NT_STATUS_IS_OK(status)) {
1391                 tevent_req_nterror(req, status);
1392                 return;
1393         }
1394
1395         /* Copy out parameters */
1396         if (state->orig.out.info && state->tmp.out.info) {
1397                 *state->orig.out.info = *state->tmp.out.info;
1398         }
1399         *state->orig.out.needed = *state->tmp.out.needed;
1400
1401         /* Copy result */
1402         state->orig.out.result = state->tmp.out.result;
1403
1404         /* Reset temporary structure */
1405         ZERO_STRUCT(state->tmp);
1406
1407         tevent_req_done(req);
1408 }
1409
1410 NTSTATUS rpccli_spoolss_GetPrinter_recv(struct tevent_req *req,
1411                                         TALLOC_CTX *mem_ctx,
1412                                         WERROR *result)
1413 {
1414         struct rpccli_spoolss_GetPrinter_state *state = tevent_req_data(
1415                 req, struct rpccli_spoolss_GetPrinter_state);
1416         NTSTATUS status;
1417
1418         if (tevent_req_is_nterror(req, &status)) {
1419                 tevent_req_received(req);
1420                 return status;
1421         }
1422
1423         /* Steal possbile out parameters to the callers context */
1424         talloc_steal(mem_ctx, state->out_mem_ctx);
1425
1426         /* Return result */
1427         *result = state->orig.out.result;
1428
1429         tevent_req_received(req);
1430         return NT_STATUS_OK;
1431 }
1432
1433 NTSTATUS rpccli_spoolss_GetPrinter(struct rpc_pipe_client *cli,
1434                                    TALLOC_CTX *mem_ctx,
1435                                    struct policy_handle *handle /* [in] [ref] */,
1436                                    uint32_t level /* [in]  */,
1437                                    DATA_BLOB *buffer /* [in] [unique] */,
1438                                    uint32_t offered /* [in]  */,
1439                                    union spoolss_PrinterInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1440                                    uint32_t *needed /* [out] [ref] */,
1441                                    WERROR *werror)
1442 {
1443         struct spoolss_GetPrinter r;
1444         NTSTATUS status;
1445
1446         /* In parameters */
1447         r.in.handle = handle;
1448         r.in.level = level;
1449         r.in.buffer = buffer;
1450         r.in.offered = offered;
1451
1452         status = cli->dispatch(cli,
1453                                 mem_ctx,
1454                                 &ndr_table_spoolss,
1455                                 NDR_SPOOLSS_GETPRINTER,
1456                                 &r);
1457
1458         if (!NT_STATUS_IS_OK(status)) {
1459                 return status;
1460         }
1461
1462         if (NT_STATUS_IS_ERR(status)) {
1463                 return status;
1464         }
1465
1466         /* Return variables */
1467         if (info && r.out.info) {
1468                 *info = *r.out.info;
1469         }
1470         *needed = *r.out.needed;
1471
1472         /* Return result */
1473         if (werror) {
1474                 *werror = r.out.result;
1475         }
1476
1477         return werror_to_ntstatus(r.out.result);
1478 }
1479
1480 struct rpccli_spoolss_AddPrinterDriver_state {
1481         struct spoolss_AddPrinterDriver orig;
1482         struct spoolss_AddPrinterDriver tmp;
1483         TALLOC_CTX *out_mem_ctx;
1484         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1485 };
1486
1487 static void rpccli_spoolss_AddPrinterDriver_done(struct tevent_req *subreq);
1488
1489 struct tevent_req *rpccli_spoolss_AddPrinterDriver_send(TALLOC_CTX *mem_ctx,
1490                                                         struct tevent_context *ev,
1491                                                         struct rpc_pipe_client *cli,
1492                                                         const char *_servername /* [in] [unique,charset(UTF16)] */,
1493                                                         struct spoolss_AddDriverInfoCtr *_info_ctr /* [in] [ref] */)
1494 {
1495         struct tevent_req *req;
1496         struct rpccli_spoolss_AddPrinterDriver_state *state;
1497         struct tevent_req *subreq;
1498
1499         req = tevent_req_create(mem_ctx, &state,
1500                                 struct rpccli_spoolss_AddPrinterDriver_state);
1501         if (req == NULL) {
1502                 return NULL;
1503         }
1504         state->out_mem_ctx = NULL;
1505         state->dispatch_recv = cli->dispatch_recv;
1506
1507         /* In parameters */
1508         state->orig.in.servername = _servername;
1509         state->orig.in.info_ctr = _info_ctr;
1510
1511         /* Out parameters */
1512
1513         /* Result */
1514         ZERO_STRUCT(state->orig.out.result);
1515
1516         /* make a temporary copy, that we pass to the dispatch function */
1517         state->tmp = state->orig;
1518
1519         subreq = cli->dispatch_send(state, ev, cli,
1520                                     &ndr_table_spoolss,
1521                                     NDR_SPOOLSS_ADDPRINTERDRIVER,
1522                                     &state->tmp);
1523         if (tevent_req_nomem(subreq, req)) {
1524                 return tevent_req_post(req, ev);
1525         }
1526         tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterDriver_done, req);
1527         return req;
1528 }
1529
1530 static void rpccli_spoolss_AddPrinterDriver_done(struct tevent_req *subreq)
1531 {
1532         struct tevent_req *req = tevent_req_callback_data(
1533                 subreq, struct tevent_req);
1534         struct rpccli_spoolss_AddPrinterDriver_state *state = tevent_req_data(
1535                 req, struct rpccli_spoolss_AddPrinterDriver_state);
1536         NTSTATUS status;
1537         TALLOC_CTX *mem_ctx;
1538
1539         if (state->out_mem_ctx) {
1540                 mem_ctx = state->out_mem_ctx;
1541         } else {
1542                 mem_ctx = state;
1543         }
1544
1545         status = state->dispatch_recv(subreq, mem_ctx);
1546         TALLOC_FREE(subreq);
1547         if (!NT_STATUS_IS_OK(status)) {
1548                 tevent_req_nterror(req, status);
1549                 return;
1550         }
1551
1552         /* Copy out parameters */
1553
1554         /* Copy result */
1555         state->orig.out.result = state->tmp.out.result;
1556
1557         /* Reset temporary structure */
1558         ZERO_STRUCT(state->tmp);
1559
1560         tevent_req_done(req);
1561 }
1562
1563 NTSTATUS rpccli_spoolss_AddPrinterDriver_recv(struct tevent_req *req,
1564                                               TALLOC_CTX *mem_ctx,
1565                                               WERROR *result)
1566 {
1567         struct rpccli_spoolss_AddPrinterDriver_state *state = tevent_req_data(
1568                 req, struct rpccli_spoolss_AddPrinterDriver_state);
1569         NTSTATUS status;
1570
1571         if (tevent_req_is_nterror(req, &status)) {
1572                 tevent_req_received(req);
1573                 return status;
1574         }
1575
1576         /* Steal possbile out parameters to the callers context */
1577         talloc_steal(mem_ctx, state->out_mem_ctx);
1578
1579         /* Return result */
1580         *result = state->orig.out.result;
1581
1582         tevent_req_received(req);
1583         return NT_STATUS_OK;
1584 }
1585
1586 NTSTATUS rpccli_spoolss_AddPrinterDriver(struct rpc_pipe_client *cli,
1587                                          TALLOC_CTX *mem_ctx,
1588                                          const char *servername /* [in] [unique,charset(UTF16)] */,
1589                                          struct spoolss_AddDriverInfoCtr *info_ctr /* [in] [ref] */,
1590                                          WERROR *werror)
1591 {
1592         struct spoolss_AddPrinterDriver r;
1593         NTSTATUS status;
1594
1595         /* In parameters */
1596         r.in.servername = servername;
1597         r.in.info_ctr = info_ctr;
1598
1599         status = cli->dispatch(cli,
1600                                 mem_ctx,
1601                                 &ndr_table_spoolss,
1602                                 NDR_SPOOLSS_ADDPRINTERDRIVER,
1603                                 &r);
1604
1605         if (!NT_STATUS_IS_OK(status)) {
1606                 return status;
1607         }
1608
1609         if (NT_STATUS_IS_ERR(status)) {
1610                 return status;
1611         }
1612
1613         /* Return variables */
1614
1615         /* Return result */
1616         if (werror) {
1617                 *werror = r.out.result;
1618         }
1619
1620         return werror_to_ntstatus(r.out.result);
1621 }
1622
1623 struct rpccli_spoolss_EnumPrinterDrivers_state {
1624         struct spoolss_EnumPrinterDrivers orig;
1625         struct spoolss_EnumPrinterDrivers tmp;
1626         TALLOC_CTX *out_mem_ctx;
1627         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1628 };
1629
1630 static void rpccli_spoolss_EnumPrinterDrivers_done(struct tevent_req *subreq);
1631
1632 struct tevent_req *rpccli_spoolss_EnumPrinterDrivers_send(TALLOC_CTX *mem_ctx,
1633                                                           struct tevent_context *ev,
1634                                                           struct rpc_pipe_client *cli,
1635                                                           const char *_server /* [in] [unique,charset(UTF16)] */,
1636                                                           const char *_environment /* [in] [unique,charset(UTF16)] */,
1637                                                           uint32_t _level /* [in]  */,
1638                                                           DATA_BLOB *_buffer /* [in] [unique] */,
1639                                                           uint32_t _offered /* [in]  */,
1640                                                           uint32_t *_count /* [out] [ref] */,
1641                                                           union spoolss_DriverInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
1642                                                           uint32_t *_needed /* [out] [ref] */)
1643 {
1644         struct tevent_req *req;
1645         struct rpccli_spoolss_EnumPrinterDrivers_state *state;
1646         struct tevent_req *subreq;
1647
1648         req = tevent_req_create(mem_ctx, &state,
1649                                 struct rpccli_spoolss_EnumPrinterDrivers_state);
1650         if (req == NULL) {
1651                 return NULL;
1652         }
1653         state->out_mem_ctx = NULL;
1654         state->dispatch_recv = cli->dispatch_recv;
1655
1656         /* In parameters */
1657         state->orig.in.server = _server;
1658         state->orig.in.environment = _environment;
1659         state->orig.in.level = _level;
1660         state->orig.in.buffer = _buffer;
1661         state->orig.in.offered = _offered;
1662
1663         /* Out parameters */
1664         state->orig.out.count = _count;
1665         state->orig.out.info = _info;
1666         state->orig.out.needed = _needed;
1667
1668         /* Result */
1669         ZERO_STRUCT(state->orig.out.result);
1670
1671         state->out_mem_ctx = talloc_named_const(state, 0,
1672                              "rpccli_spoolss_EnumPrinterDrivers_out_memory");
1673         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1674                 return tevent_req_post(req, ev);
1675         }
1676
1677         /* make a temporary copy, that we pass to the dispatch function */
1678         state->tmp = state->orig;
1679
1680         subreq = cli->dispatch_send(state, ev, cli,
1681                                     &ndr_table_spoolss,
1682                                     NDR_SPOOLSS_ENUMPRINTERDRIVERS,
1683                                     &state->tmp);
1684         if (tevent_req_nomem(subreq, req)) {
1685                 return tevent_req_post(req, ev);
1686         }
1687         tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinterDrivers_done, req);
1688         return req;
1689 }
1690
1691 static void rpccli_spoolss_EnumPrinterDrivers_done(struct tevent_req *subreq)
1692 {
1693         struct tevent_req *req = tevent_req_callback_data(
1694                 subreq, struct tevent_req);
1695         struct rpccli_spoolss_EnumPrinterDrivers_state *state = tevent_req_data(
1696                 req, struct rpccli_spoolss_EnumPrinterDrivers_state);
1697         NTSTATUS status;
1698         TALLOC_CTX *mem_ctx;
1699
1700         if (state->out_mem_ctx) {
1701                 mem_ctx = state->out_mem_ctx;
1702         } else {
1703                 mem_ctx = state;
1704         }
1705
1706         status = state->dispatch_recv(subreq, mem_ctx);
1707         TALLOC_FREE(subreq);
1708         if (!NT_STATUS_IS_OK(status)) {
1709                 tevent_req_nterror(req, status);
1710                 return;
1711         }
1712
1713         /* Copy out parameters */
1714         *state->orig.out.count = *state->tmp.out.count;
1715         *state->orig.out.info = *state->tmp.out.info;
1716         *state->orig.out.needed = *state->tmp.out.needed;
1717
1718         /* Copy result */
1719         state->orig.out.result = state->tmp.out.result;
1720
1721         /* Reset temporary structure */
1722         ZERO_STRUCT(state->tmp);
1723
1724         tevent_req_done(req);
1725 }
1726
1727 NTSTATUS rpccli_spoolss_EnumPrinterDrivers_recv(struct tevent_req *req,
1728                                                 TALLOC_CTX *mem_ctx,
1729                                                 WERROR *result)
1730 {
1731         struct rpccli_spoolss_EnumPrinterDrivers_state *state = tevent_req_data(
1732                 req, struct rpccli_spoolss_EnumPrinterDrivers_state);
1733         NTSTATUS status;
1734
1735         if (tevent_req_is_nterror(req, &status)) {
1736                 tevent_req_received(req);
1737                 return status;
1738         }
1739
1740         /* Steal possbile out parameters to the callers context */
1741         talloc_steal(mem_ctx, state->out_mem_ctx);
1742
1743         /* Return result */
1744         *result = state->orig.out.result;
1745
1746         tevent_req_received(req);
1747         return NT_STATUS_OK;
1748 }
1749
1750 NTSTATUS rpccli_spoolss_EnumPrinterDrivers(struct rpc_pipe_client *cli,
1751                                            TALLOC_CTX *mem_ctx,
1752                                            const char *server /* [in] [unique,charset(UTF16)] */,
1753                                            const char *environment /* [in] [unique,charset(UTF16)] */,
1754                                            uint32_t level /* [in]  */,
1755                                            DATA_BLOB *buffer /* [in] [unique] */,
1756                                            uint32_t offered /* [in]  */,
1757                                            uint32_t *count /* [out] [ref] */,
1758                                            union spoolss_DriverInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
1759                                            uint32_t *needed /* [out] [ref] */,
1760                                            WERROR *werror)
1761 {
1762         struct spoolss_EnumPrinterDrivers r;
1763         NTSTATUS status;
1764
1765         /* In parameters */
1766         r.in.server = server;
1767         r.in.environment = environment;
1768         r.in.level = level;
1769         r.in.buffer = buffer;
1770         r.in.offered = offered;
1771
1772         status = cli->dispatch(cli,
1773                                 mem_ctx,
1774                                 &ndr_table_spoolss,
1775                                 NDR_SPOOLSS_ENUMPRINTERDRIVERS,
1776                                 &r);
1777
1778         if (!NT_STATUS_IS_OK(status)) {
1779                 return status;
1780         }
1781
1782         if (NT_STATUS_IS_ERR(status)) {
1783                 return status;
1784         }
1785
1786         /* Return variables */
1787         *count = *r.out.count;
1788         *info = *r.out.info;
1789         *needed = *r.out.needed;
1790
1791         /* Return result */
1792         if (werror) {
1793                 *werror = r.out.result;
1794         }
1795
1796         return werror_to_ntstatus(r.out.result);
1797 }
1798
1799 struct rpccli_spoolss_GetPrinterDriver_state {
1800         struct spoolss_GetPrinterDriver orig;
1801         struct spoolss_GetPrinterDriver tmp;
1802         TALLOC_CTX *out_mem_ctx;
1803         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1804 };
1805
1806 static void rpccli_spoolss_GetPrinterDriver_done(struct tevent_req *subreq);
1807
1808 struct tevent_req *rpccli_spoolss_GetPrinterDriver_send(TALLOC_CTX *mem_ctx,
1809                                                         struct tevent_context *ev,
1810                                                         struct rpc_pipe_client *cli,
1811                                                         struct policy_handle *_handle /* [in] [ref] */,
1812                                                         const char *_architecture /* [in] [unique,charset(UTF16)] */,
1813                                                         uint32_t _level /* [in]  */,
1814                                                         DATA_BLOB *_buffer /* [in] [unique] */,
1815                                                         uint32_t _offered /* [in]  */,
1816                                                         union spoolss_DriverInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1817                                                         uint32_t *_needed /* [out] [ref] */)
1818 {
1819         struct tevent_req *req;
1820         struct rpccli_spoolss_GetPrinterDriver_state *state;
1821         struct tevent_req *subreq;
1822
1823         req = tevent_req_create(mem_ctx, &state,
1824                                 struct rpccli_spoolss_GetPrinterDriver_state);
1825         if (req == NULL) {
1826                 return NULL;
1827         }
1828         state->out_mem_ctx = NULL;
1829         state->dispatch_recv = cli->dispatch_recv;
1830
1831         /* In parameters */
1832         state->orig.in.handle = _handle;
1833         state->orig.in.architecture = _architecture;
1834         state->orig.in.level = _level;
1835         state->orig.in.buffer = _buffer;
1836         state->orig.in.offered = _offered;
1837
1838         /* Out parameters */
1839         state->orig.out.info = _info;
1840         state->orig.out.needed = _needed;
1841
1842         /* Result */
1843         ZERO_STRUCT(state->orig.out.result);
1844
1845         state->out_mem_ctx = talloc_named_const(state, 0,
1846                              "rpccli_spoolss_GetPrinterDriver_out_memory");
1847         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1848                 return tevent_req_post(req, ev);
1849         }
1850
1851         /* make a temporary copy, that we pass to the dispatch function */
1852         state->tmp = state->orig;
1853
1854         subreq = cli->dispatch_send(state, ev, cli,
1855                                     &ndr_table_spoolss,
1856                                     NDR_SPOOLSS_GETPRINTERDRIVER,
1857                                     &state->tmp);
1858         if (tevent_req_nomem(subreq, req)) {
1859                 return tevent_req_post(req, ev);
1860         }
1861         tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriver_done, req);
1862         return req;
1863 }
1864
1865 static void rpccli_spoolss_GetPrinterDriver_done(struct tevent_req *subreq)
1866 {
1867         struct tevent_req *req = tevent_req_callback_data(
1868                 subreq, struct tevent_req);
1869         struct rpccli_spoolss_GetPrinterDriver_state *state = tevent_req_data(
1870                 req, struct rpccli_spoolss_GetPrinterDriver_state);
1871         NTSTATUS status;
1872         TALLOC_CTX *mem_ctx;
1873
1874         if (state->out_mem_ctx) {
1875                 mem_ctx = state->out_mem_ctx;
1876         } else {
1877                 mem_ctx = state;
1878         }
1879
1880         status = state->dispatch_recv(subreq, mem_ctx);
1881         TALLOC_FREE(subreq);
1882         if (!NT_STATUS_IS_OK(status)) {
1883                 tevent_req_nterror(req, status);
1884                 return;
1885         }
1886
1887         /* Copy out parameters */
1888         if (state->orig.out.info && state->tmp.out.info) {
1889                 *state->orig.out.info = *state->tmp.out.info;
1890         }
1891         *state->orig.out.needed = *state->tmp.out.needed;
1892
1893         /* Copy result */
1894         state->orig.out.result = state->tmp.out.result;
1895
1896         /* Reset temporary structure */
1897         ZERO_STRUCT(state->tmp);
1898
1899         tevent_req_done(req);
1900 }
1901
1902 NTSTATUS rpccli_spoolss_GetPrinterDriver_recv(struct tevent_req *req,
1903                                               TALLOC_CTX *mem_ctx,
1904                                               WERROR *result)
1905 {
1906         struct rpccli_spoolss_GetPrinterDriver_state *state = tevent_req_data(
1907                 req, struct rpccli_spoolss_GetPrinterDriver_state);
1908         NTSTATUS status;
1909
1910         if (tevent_req_is_nterror(req, &status)) {
1911                 tevent_req_received(req);
1912                 return status;
1913         }
1914
1915         /* Steal possbile out parameters to the callers context */
1916         talloc_steal(mem_ctx, state->out_mem_ctx);
1917
1918         /* Return result */
1919         *result = state->orig.out.result;
1920
1921         tevent_req_received(req);
1922         return NT_STATUS_OK;
1923 }
1924
1925 NTSTATUS rpccli_spoolss_GetPrinterDriver(struct rpc_pipe_client *cli,
1926                                          TALLOC_CTX *mem_ctx,
1927                                          struct policy_handle *handle /* [in] [ref] */,
1928                                          const char *architecture /* [in] [unique,charset(UTF16)] */,
1929                                          uint32_t level /* [in]  */,
1930                                          DATA_BLOB *buffer /* [in] [unique] */,
1931                                          uint32_t offered /* [in]  */,
1932                                          union spoolss_DriverInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1933                                          uint32_t *needed /* [out] [ref] */,
1934                                          WERROR *werror)
1935 {
1936         struct spoolss_GetPrinterDriver r;
1937         NTSTATUS status;
1938
1939         /* In parameters */
1940         r.in.handle = handle;
1941         r.in.architecture = architecture;
1942         r.in.level = level;
1943         r.in.buffer = buffer;
1944         r.in.offered = offered;
1945
1946         status = cli->dispatch(cli,
1947                                 mem_ctx,
1948                                 &ndr_table_spoolss,
1949                                 NDR_SPOOLSS_GETPRINTERDRIVER,
1950                                 &r);
1951
1952         if (!NT_STATUS_IS_OK(status)) {
1953                 return status;
1954         }
1955
1956         if (NT_STATUS_IS_ERR(status)) {
1957                 return status;
1958         }
1959
1960         /* Return variables */
1961         if (info && r.out.info) {
1962                 *info = *r.out.info;
1963         }
1964         *needed = *r.out.needed;
1965
1966         /* Return result */
1967         if (werror) {
1968                 *werror = r.out.result;
1969         }
1970
1971         return werror_to_ntstatus(r.out.result);
1972 }
1973
1974 struct rpccli_spoolss_GetPrinterDriverDirectory_state {
1975         struct spoolss_GetPrinterDriverDirectory orig;
1976         struct spoolss_GetPrinterDriverDirectory tmp;
1977         TALLOC_CTX *out_mem_ctx;
1978         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1979 };
1980
1981 static void rpccli_spoolss_GetPrinterDriverDirectory_done(struct tevent_req *subreq);
1982
1983 struct tevent_req *rpccli_spoolss_GetPrinterDriverDirectory_send(TALLOC_CTX *mem_ctx,
1984                                                                  struct tevent_context *ev,
1985                                                                  struct rpc_pipe_client *cli,
1986                                                                  const char *_server /* [in] [unique,charset(UTF16)] */,
1987                                                                  const char *_environment /* [in] [unique,charset(UTF16)] */,
1988                                                                  uint32_t _level /* [in]  */,
1989                                                                  DATA_BLOB *_buffer /* [in] [unique] */,
1990                                                                  uint32_t _offered /* [in]  */,
1991                                                                  union spoolss_DriverDirectoryInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1992                                                                  uint32_t *_needed /* [out] [ref] */)
1993 {
1994         struct tevent_req *req;
1995         struct rpccli_spoolss_GetPrinterDriverDirectory_state *state;
1996         struct tevent_req *subreq;
1997
1998         req = tevent_req_create(mem_ctx, &state,
1999                                 struct rpccli_spoolss_GetPrinterDriverDirectory_state);
2000         if (req == NULL) {
2001                 return NULL;
2002         }
2003         state->out_mem_ctx = NULL;
2004         state->dispatch_recv = cli->dispatch_recv;
2005
2006         /* In parameters */
2007         state->orig.in.server = _server;
2008         state->orig.in.environment = _environment;
2009         state->orig.in.level = _level;
2010         state->orig.in.buffer = _buffer;
2011         state->orig.in.offered = _offered;
2012
2013         /* Out parameters */
2014         state->orig.out.info = _info;
2015         state->orig.out.needed = _needed;
2016
2017         /* Result */
2018         ZERO_STRUCT(state->orig.out.result);
2019
2020         state->out_mem_ctx = talloc_named_const(state, 0,
2021                              "rpccli_spoolss_GetPrinterDriverDirectory_out_memory");
2022         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2023                 return tevent_req_post(req, ev);
2024         }
2025
2026         /* make a temporary copy, that we pass to the dispatch function */
2027         state->tmp = state->orig;
2028
2029         subreq = cli->dispatch_send(state, ev, cli,
2030                                     &ndr_table_spoolss,
2031                                     NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY,
2032                                     &state->tmp);
2033         if (tevent_req_nomem(subreq, req)) {
2034                 return tevent_req_post(req, ev);
2035         }
2036         tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriverDirectory_done, req);
2037         return req;
2038 }
2039
2040 static void rpccli_spoolss_GetPrinterDriverDirectory_done(struct tevent_req *subreq)
2041 {
2042         struct tevent_req *req = tevent_req_callback_data(
2043                 subreq, struct tevent_req);
2044         struct rpccli_spoolss_GetPrinterDriverDirectory_state *state = tevent_req_data(
2045                 req, struct rpccli_spoolss_GetPrinterDriverDirectory_state);
2046         NTSTATUS status;
2047         TALLOC_CTX *mem_ctx;
2048
2049         if (state->out_mem_ctx) {
2050                 mem_ctx = state->out_mem_ctx;
2051         } else {
2052                 mem_ctx = state;
2053         }
2054
2055         status = state->dispatch_recv(subreq, mem_ctx);
2056         TALLOC_FREE(subreq);
2057         if (!NT_STATUS_IS_OK(status)) {
2058                 tevent_req_nterror(req, status);
2059                 return;
2060         }
2061
2062         /* Copy out parameters */
2063         if (state->orig.out.info && state->tmp.out.info) {
2064                 *state->orig.out.info = *state->tmp.out.info;
2065         }
2066         *state->orig.out.needed = *state->tmp.out.needed;
2067
2068         /* Copy result */
2069         state->orig.out.result = state->tmp.out.result;
2070
2071         /* Reset temporary structure */
2072         ZERO_STRUCT(state->tmp);
2073
2074         tevent_req_done(req);
2075 }
2076
2077 NTSTATUS rpccli_spoolss_GetPrinterDriverDirectory_recv(struct tevent_req *req,
2078                                                        TALLOC_CTX *mem_ctx,
2079                                                        WERROR *result)
2080 {
2081         struct rpccli_spoolss_GetPrinterDriverDirectory_state *state = tevent_req_data(
2082                 req, struct rpccli_spoolss_GetPrinterDriverDirectory_state);
2083         NTSTATUS status;
2084
2085         if (tevent_req_is_nterror(req, &status)) {
2086                 tevent_req_received(req);
2087                 return status;
2088         }
2089
2090         /* Steal possbile out parameters to the callers context */
2091         talloc_steal(mem_ctx, state->out_mem_ctx);
2092
2093         /* Return result */
2094         *result = state->orig.out.result;
2095
2096         tevent_req_received(req);
2097         return NT_STATUS_OK;
2098 }
2099
2100 NTSTATUS rpccli_spoolss_GetPrinterDriverDirectory(struct rpc_pipe_client *cli,
2101                                                   TALLOC_CTX *mem_ctx,
2102                                                   const char *server /* [in] [unique,charset(UTF16)] */,
2103                                                   const char *environment /* [in] [unique,charset(UTF16)] */,
2104                                                   uint32_t level /* [in]  */,
2105                                                   DATA_BLOB *buffer /* [in] [unique] */,
2106                                                   uint32_t offered /* [in]  */,
2107                                                   union spoolss_DriverDirectoryInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
2108                                                   uint32_t *needed /* [out] [ref] */,
2109                                                   WERROR *werror)
2110 {
2111         struct spoolss_GetPrinterDriverDirectory r;
2112         NTSTATUS status;
2113
2114         /* In parameters */
2115         r.in.server = server;
2116         r.in.environment = environment;
2117         r.in.level = level;
2118         r.in.buffer = buffer;
2119         r.in.offered = offered;
2120
2121         status = cli->dispatch(cli,
2122                                 mem_ctx,
2123                                 &ndr_table_spoolss,
2124                                 NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY,
2125                                 &r);
2126
2127         if (!NT_STATUS_IS_OK(status)) {
2128                 return status;
2129         }
2130
2131         if (NT_STATUS_IS_ERR(status)) {
2132                 return status;
2133         }
2134
2135         /* Return variables */
2136         if (info && r.out.info) {
2137                 *info = *r.out.info;
2138         }
2139         *needed = *r.out.needed;
2140
2141         /* Return result */
2142         if (werror) {
2143                 *werror = r.out.result;
2144         }
2145
2146         return werror_to_ntstatus(r.out.result);
2147 }
2148
2149 struct rpccli_spoolss_DeletePrinterDriver_state {
2150         struct spoolss_DeletePrinterDriver orig;
2151         struct spoolss_DeletePrinterDriver tmp;
2152         TALLOC_CTX *out_mem_ctx;
2153         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2154 };
2155
2156 static void rpccli_spoolss_DeletePrinterDriver_done(struct tevent_req *subreq);
2157
2158 struct tevent_req *rpccli_spoolss_DeletePrinterDriver_send(TALLOC_CTX *mem_ctx,
2159                                                            struct tevent_context *ev,
2160                                                            struct rpc_pipe_client *cli,
2161                                                            const char *_server /* [in] [unique,charset(UTF16)] */,
2162                                                            const char *_architecture /* [in] [charset(UTF16)] */,
2163                                                            const char *_driver /* [in] [charset(UTF16)] */)
2164 {
2165         struct tevent_req *req;
2166         struct rpccli_spoolss_DeletePrinterDriver_state *state;
2167         struct tevent_req *subreq;
2168
2169         req = tevent_req_create(mem_ctx, &state,
2170                                 struct rpccli_spoolss_DeletePrinterDriver_state);
2171         if (req == NULL) {
2172                 return NULL;
2173         }
2174         state->out_mem_ctx = NULL;
2175         state->dispatch_recv = cli->dispatch_recv;
2176
2177         /* In parameters */
2178         state->orig.in.server = _server;
2179         state->orig.in.architecture = _architecture;
2180         state->orig.in.driver = _driver;
2181
2182         /* Out parameters */
2183
2184         /* Result */
2185         ZERO_STRUCT(state->orig.out.result);
2186
2187         /* make a temporary copy, that we pass to the dispatch function */
2188         state->tmp = state->orig;
2189
2190         subreq = cli->dispatch_send(state, ev, cli,
2191                                     &ndr_table_spoolss,
2192                                     NDR_SPOOLSS_DELETEPRINTERDRIVER,
2193                                     &state->tmp);
2194         if (tevent_req_nomem(subreq, req)) {
2195                 return tevent_req_post(req, ev);
2196         }
2197         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterDriver_done, req);
2198         return req;
2199 }
2200
2201 static void rpccli_spoolss_DeletePrinterDriver_done(struct tevent_req *subreq)
2202 {
2203         struct tevent_req *req = tevent_req_callback_data(
2204                 subreq, struct tevent_req);
2205         struct rpccli_spoolss_DeletePrinterDriver_state *state = tevent_req_data(
2206                 req, struct rpccli_spoolss_DeletePrinterDriver_state);
2207         NTSTATUS status;
2208         TALLOC_CTX *mem_ctx;
2209
2210         if (state->out_mem_ctx) {
2211                 mem_ctx = state->out_mem_ctx;
2212         } else {
2213                 mem_ctx = state;
2214         }
2215
2216         status = state->dispatch_recv(subreq, mem_ctx);
2217         TALLOC_FREE(subreq);
2218         if (!NT_STATUS_IS_OK(status)) {
2219                 tevent_req_nterror(req, status);
2220                 return;
2221         }
2222
2223         /* Copy out parameters */
2224
2225         /* Copy result */
2226         state->orig.out.result = state->tmp.out.result;
2227
2228         /* Reset temporary structure */
2229         ZERO_STRUCT(state->tmp);
2230
2231         tevent_req_done(req);
2232 }
2233
2234 NTSTATUS rpccli_spoolss_DeletePrinterDriver_recv(struct tevent_req *req,
2235                                                  TALLOC_CTX *mem_ctx,
2236                                                  WERROR *result)
2237 {
2238         struct rpccli_spoolss_DeletePrinterDriver_state *state = tevent_req_data(
2239                 req, struct rpccli_spoolss_DeletePrinterDriver_state);
2240         NTSTATUS status;
2241
2242         if (tevent_req_is_nterror(req, &status)) {
2243                 tevent_req_received(req);
2244                 return status;
2245         }
2246
2247         /* Steal possbile out parameters to the callers context */
2248         talloc_steal(mem_ctx, state->out_mem_ctx);
2249
2250         /* Return result */
2251         *result = state->orig.out.result;
2252
2253         tevent_req_received(req);
2254         return NT_STATUS_OK;
2255 }
2256
2257 NTSTATUS rpccli_spoolss_DeletePrinterDriver(struct rpc_pipe_client *cli,
2258                                             TALLOC_CTX *mem_ctx,
2259                                             const char *server /* [in] [unique,charset(UTF16)] */,
2260                                             const char *architecture /* [in] [charset(UTF16)] */,
2261                                             const char *driver /* [in] [charset(UTF16)] */,
2262                                             WERROR *werror)
2263 {
2264         struct spoolss_DeletePrinterDriver r;
2265         NTSTATUS status;
2266
2267         /* In parameters */
2268         r.in.server = server;
2269         r.in.architecture = architecture;
2270         r.in.driver = driver;
2271
2272         status = cli->dispatch(cli,
2273                                 mem_ctx,
2274                                 &ndr_table_spoolss,
2275                                 NDR_SPOOLSS_DELETEPRINTERDRIVER,
2276                                 &r);
2277
2278         if (!NT_STATUS_IS_OK(status)) {
2279                 return status;
2280         }
2281
2282         if (NT_STATUS_IS_ERR(status)) {
2283                 return status;
2284         }
2285
2286         /* Return variables */
2287
2288         /* Return result */
2289         if (werror) {
2290                 *werror = r.out.result;
2291         }
2292
2293         return werror_to_ntstatus(r.out.result);
2294 }
2295
2296 struct rpccli_spoolss_AddPrintProcessor_state {
2297         struct spoolss_AddPrintProcessor orig;
2298         struct spoolss_AddPrintProcessor tmp;
2299         TALLOC_CTX *out_mem_ctx;
2300         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2301 };
2302
2303 static void rpccli_spoolss_AddPrintProcessor_done(struct tevent_req *subreq);
2304
2305 struct tevent_req *rpccli_spoolss_AddPrintProcessor_send(TALLOC_CTX *mem_ctx,
2306                                                          struct tevent_context *ev,
2307                                                          struct rpc_pipe_client *cli,
2308                                                          const char *_server /* [in] [unique,charset(UTF16)] */,
2309                                                          const char *_architecture /* [in] [charset(UTF16)] */,
2310                                                          const char *_path_name /* [in] [charset(UTF16)] */,
2311                                                          const char *_print_processor_name /* [in] [charset(UTF16)] */)
2312 {
2313         struct tevent_req *req;
2314         struct rpccli_spoolss_AddPrintProcessor_state *state;
2315         struct tevent_req *subreq;
2316
2317         req = tevent_req_create(mem_ctx, &state,
2318                                 struct rpccli_spoolss_AddPrintProcessor_state);
2319         if (req == NULL) {
2320                 return NULL;
2321         }
2322         state->out_mem_ctx = NULL;
2323         state->dispatch_recv = cli->dispatch_recv;
2324
2325         /* In parameters */
2326         state->orig.in.server = _server;
2327         state->orig.in.architecture = _architecture;
2328         state->orig.in.path_name = _path_name;
2329         state->orig.in.print_processor_name = _print_processor_name;
2330
2331         /* Out parameters */
2332
2333         /* Result */
2334         ZERO_STRUCT(state->orig.out.result);
2335
2336         /* make a temporary copy, that we pass to the dispatch function */
2337         state->tmp = state->orig;
2338
2339         subreq = cli->dispatch_send(state, ev, cli,
2340                                     &ndr_table_spoolss,
2341                                     NDR_SPOOLSS_ADDPRINTPROCESSOR,
2342                                     &state->tmp);
2343         if (tevent_req_nomem(subreq, req)) {
2344                 return tevent_req_post(req, ev);
2345         }
2346         tevent_req_set_callback(subreq, rpccli_spoolss_AddPrintProcessor_done, req);
2347         return req;
2348 }
2349
2350 static void rpccli_spoolss_AddPrintProcessor_done(struct tevent_req *subreq)
2351 {
2352         struct tevent_req *req = tevent_req_callback_data(
2353                 subreq, struct tevent_req);
2354         struct rpccli_spoolss_AddPrintProcessor_state *state = tevent_req_data(
2355                 req, struct rpccli_spoolss_AddPrintProcessor_state);
2356         NTSTATUS status;
2357         TALLOC_CTX *mem_ctx;
2358
2359         if (state->out_mem_ctx) {
2360                 mem_ctx = state->out_mem_ctx;
2361         } else {
2362                 mem_ctx = state;
2363         }
2364
2365         status = state->dispatch_recv(subreq, mem_ctx);
2366         TALLOC_FREE(subreq);
2367         if (!NT_STATUS_IS_OK(status)) {
2368                 tevent_req_nterror(req, status);
2369                 return;
2370         }
2371
2372         /* Copy out parameters */
2373
2374         /* Copy result */
2375         state->orig.out.result = state->tmp.out.result;
2376
2377         /* Reset temporary structure */
2378         ZERO_STRUCT(state->tmp);
2379
2380         tevent_req_done(req);
2381 }
2382
2383 NTSTATUS rpccli_spoolss_AddPrintProcessor_recv(struct tevent_req *req,
2384                                                TALLOC_CTX *mem_ctx,
2385                                                WERROR *result)
2386 {
2387         struct rpccli_spoolss_AddPrintProcessor_state *state = tevent_req_data(
2388                 req, struct rpccli_spoolss_AddPrintProcessor_state);
2389         NTSTATUS status;
2390
2391         if (tevent_req_is_nterror(req, &status)) {
2392                 tevent_req_received(req);
2393                 return status;
2394         }
2395
2396         /* Steal possbile out parameters to the callers context */
2397         talloc_steal(mem_ctx, state->out_mem_ctx);
2398
2399         /* Return result */
2400         *result = state->orig.out.result;
2401
2402         tevent_req_received(req);
2403         return NT_STATUS_OK;
2404 }
2405
2406 NTSTATUS rpccli_spoolss_AddPrintProcessor(struct rpc_pipe_client *cli,
2407                                           TALLOC_CTX *mem_ctx,
2408                                           const char *server /* [in] [unique,charset(UTF16)] */,
2409                                           const char *architecture /* [in] [charset(UTF16)] */,
2410                                           const char *path_name /* [in] [charset(UTF16)] */,
2411                                           const char *print_processor_name /* [in] [charset(UTF16)] */,
2412                                           WERROR *werror)
2413 {
2414         struct spoolss_AddPrintProcessor r;
2415         NTSTATUS status;
2416
2417         /* In parameters */
2418         r.in.server = server;
2419         r.in.architecture = architecture;
2420         r.in.path_name = path_name;
2421         r.in.print_processor_name = print_processor_name;
2422
2423         status = cli->dispatch(cli,
2424                                 mem_ctx,
2425                                 &ndr_table_spoolss,
2426                                 NDR_SPOOLSS_ADDPRINTPROCESSOR,
2427                                 &r);
2428
2429         if (!NT_STATUS_IS_OK(status)) {
2430                 return status;
2431         }
2432
2433         if (NT_STATUS_IS_ERR(status)) {
2434                 return status;
2435         }
2436
2437         /* Return variables */
2438
2439         /* Return result */
2440         if (werror) {
2441                 *werror = r.out.result;
2442         }
2443
2444         return werror_to_ntstatus(r.out.result);
2445 }
2446
2447 struct rpccli_spoolss_EnumPrintProcessors_state {
2448         struct spoolss_EnumPrintProcessors orig;
2449         struct spoolss_EnumPrintProcessors tmp;
2450         TALLOC_CTX *out_mem_ctx;
2451         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2452 };
2453
2454 static void rpccli_spoolss_EnumPrintProcessors_done(struct tevent_req *subreq);
2455
2456 struct tevent_req *rpccli_spoolss_EnumPrintProcessors_send(TALLOC_CTX *mem_ctx,
2457                                                            struct tevent_context *ev,
2458                                                            struct rpc_pipe_client *cli,
2459                                                            const char *_servername /* [in] [unique,charset(UTF16)] */,
2460                                                            const char *_environment /* [in] [unique,charset(UTF16)] */,
2461                                                            uint32_t _level /* [in]  */,
2462                                                            DATA_BLOB *_buffer /* [in] [unique] */,
2463                                                            uint32_t _offered /* [in]  */,
2464                                                            uint32_t *_count /* [out] [ref] */,
2465                                                            union spoolss_PrintProcessorInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
2466                                                            uint32_t *_needed /* [out] [ref] */)
2467 {
2468         struct tevent_req *req;
2469         struct rpccli_spoolss_EnumPrintProcessors_state *state;
2470         struct tevent_req *subreq;
2471
2472         req = tevent_req_create(mem_ctx, &state,
2473                                 struct rpccli_spoolss_EnumPrintProcessors_state);
2474         if (req == NULL) {
2475                 return NULL;
2476         }
2477         state->out_mem_ctx = NULL;
2478         state->dispatch_recv = cli->dispatch_recv;
2479
2480         /* In parameters */
2481         state->orig.in.servername = _servername;
2482         state->orig.in.environment = _environment;
2483         state->orig.in.level = _level;
2484         state->orig.in.buffer = _buffer;
2485         state->orig.in.offered = _offered;
2486
2487         /* Out parameters */
2488         state->orig.out.count = _count;
2489         state->orig.out.info = _info;
2490         state->orig.out.needed = _needed;
2491
2492         /* Result */
2493         ZERO_STRUCT(state->orig.out.result);
2494
2495         state->out_mem_ctx = talloc_named_const(state, 0,
2496                              "rpccli_spoolss_EnumPrintProcessors_out_memory");
2497         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2498                 return tevent_req_post(req, ev);
2499         }
2500
2501         /* make a temporary copy, that we pass to the dispatch function */
2502         state->tmp = state->orig;
2503
2504         subreq = cli->dispatch_send(state, ev, cli,
2505                                     &ndr_table_spoolss,
2506                                     NDR_SPOOLSS_ENUMPRINTPROCESSORS,
2507                                     &state->tmp);
2508         if (tevent_req_nomem(subreq, req)) {
2509                 return tevent_req_post(req, ev);
2510         }
2511         tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrintProcessors_done, req);
2512         return req;
2513 }
2514
2515 static void rpccli_spoolss_EnumPrintProcessors_done(struct tevent_req *subreq)
2516 {
2517         struct tevent_req *req = tevent_req_callback_data(
2518                 subreq, struct tevent_req);
2519         struct rpccli_spoolss_EnumPrintProcessors_state *state = tevent_req_data(
2520                 req, struct rpccli_spoolss_EnumPrintProcessors_state);
2521         NTSTATUS status;
2522         TALLOC_CTX *mem_ctx;
2523
2524         if (state->out_mem_ctx) {
2525                 mem_ctx = state->out_mem_ctx;
2526         } else {
2527                 mem_ctx = state;
2528         }
2529
2530         status = state->dispatch_recv(subreq, mem_ctx);
2531         TALLOC_FREE(subreq);
2532         if (!NT_STATUS_IS_OK(status)) {
2533                 tevent_req_nterror(req, status);
2534                 return;
2535         }
2536
2537         /* Copy out parameters */
2538         *state->orig.out.count = *state->tmp.out.count;
2539         *state->orig.out.info = *state->tmp.out.info;
2540         *state->orig.out.needed = *state->tmp.out.needed;
2541
2542         /* Copy result */
2543         state->orig.out.result = state->tmp.out.result;
2544
2545         /* Reset temporary structure */
2546         ZERO_STRUCT(state->tmp);
2547
2548         tevent_req_done(req);
2549 }
2550
2551 NTSTATUS rpccli_spoolss_EnumPrintProcessors_recv(struct tevent_req *req,
2552                                                  TALLOC_CTX *mem_ctx,
2553                                                  WERROR *result)
2554 {
2555         struct rpccli_spoolss_EnumPrintProcessors_state *state = tevent_req_data(
2556                 req, struct rpccli_spoolss_EnumPrintProcessors_state);
2557         NTSTATUS status;
2558
2559         if (tevent_req_is_nterror(req, &status)) {
2560                 tevent_req_received(req);
2561                 return status;
2562         }
2563
2564         /* Steal possbile out parameters to the callers context */
2565         talloc_steal(mem_ctx, state->out_mem_ctx);
2566
2567         /* Return result */
2568         *result = state->orig.out.result;
2569
2570         tevent_req_received(req);
2571         return NT_STATUS_OK;
2572 }
2573
2574 NTSTATUS rpccli_spoolss_EnumPrintProcessors(struct rpc_pipe_client *cli,
2575                                             TALLOC_CTX *mem_ctx,
2576                                             const char *servername /* [in] [unique,charset(UTF16)] */,
2577                                             const char *environment /* [in] [unique,charset(UTF16)] */,
2578                                             uint32_t level /* [in]  */,
2579                                             DATA_BLOB *buffer /* [in] [unique] */,
2580                                             uint32_t offered /* [in]  */,
2581                                             uint32_t *count /* [out] [ref] */,
2582                                             union spoolss_PrintProcessorInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
2583                                             uint32_t *needed /* [out] [ref] */,
2584                                             WERROR *werror)
2585 {
2586         struct spoolss_EnumPrintProcessors r;
2587         NTSTATUS status;
2588
2589         /* In parameters */
2590         r.in.servername = servername;
2591         r.in.environment = environment;
2592         r.in.level = level;
2593         r.in.buffer = buffer;
2594         r.in.offered = offered;
2595
2596         status = cli->dispatch(cli,
2597                                 mem_ctx,
2598                                 &ndr_table_spoolss,
2599                                 NDR_SPOOLSS_ENUMPRINTPROCESSORS,
2600                                 &r);
2601
2602         if (!NT_STATUS_IS_OK(status)) {
2603                 return status;
2604         }
2605
2606         if (NT_STATUS_IS_ERR(status)) {
2607                 return status;
2608         }
2609
2610         /* Return variables */
2611         *count = *r.out.count;
2612         *info = *r.out.info;
2613         *needed = *r.out.needed;
2614
2615         /* Return result */
2616         if (werror) {
2617                 *werror = r.out.result;
2618         }
2619
2620         return werror_to_ntstatus(r.out.result);
2621 }
2622
2623 struct rpccli_spoolss_GetPrintProcessorDirectory_state {
2624         struct spoolss_GetPrintProcessorDirectory orig;
2625         struct spoolss_GetPrintProcessorDirectory tmp;
2626         TALLOC_CTX *out_mem_ctx;
2627         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2628 };
2629
2630 static void rpccli_spoolss_GetPrintProcessorDirectory_done(struct tevent_req *subreq);
2631
2632 struct tevent_req *rpccli_spoolss_GetPrintProcessorDirectory_send(TALLOC_CTX *mem_ctx,
2633                                                                   struct tevent_context *ev,
2634                                                                   struct rpc_pipe_client *cli,
2635                                                                   const char *_server /* [in] [unique,charset(UTF16)] */,
2636                                                                   const char *_environment /* [in] [unique,charset(UTF16)] */,
2637                                                                   uint32_t _level /* [in]  */,
2638                                                                   DATA_BLOB *_buffer /* [in] [unique] */,
2639                                                                   uint32_t _offered /* [in]  */,
2640                                                                   union spoolss_PrintProcessorDirectoryInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
2641                                                                   uint32_t *_needed /* [out] [ref] */)
2642 {
2643         struct tevent_req *req;
2644         struct rpccli_spoolss_GetPrintProcessorDirectory_state *state;
2645         struct tevent_req *subreq;
2646
2647         req = tevent_req_create(mem_ctx, &state,
2648                                 struct rpccli_spoolss_GetPrintProcessorDirectory_state);
2649         if (req == NULL) {
2650                 return NULL;
2651         }
2652         state->out_mem_ctx = NULL;
2653         state->dispatch_recv = cli->dispatch_recv;
2654
2655         /* In parameters */
2656         state->orig.in.server = _server;
2657         state->orig.in.environment = _environment;
2658         state->orig.in.level = _level;
2659         state->orig.in.buffer = _buffer;
2660         state->orig.in.offered = _offered;
2661
2662         /* Out parameters */
2663         state->orig.out.info = _info;
2664         state->orig.out.needed = _needed;
2665
2666         /* Result */
2667         ZERO_STRUCT(state->orig.out.result);
2668
2669         state->out_mem_ctx = talloc_named_const(state, 0,
2670                              "rpccli_spoolss_GetPrintProcessorDirectory_out_memory");
2671         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2672                 return tevent_req_post(req, ev);
2673         }
2674
2675         /* make a temporary copy, that we pass to the dispatch function */
2676         state->tmp = state->orig;
2677
2678         subreq = cli->dispatch_send(state, ev, cli,
2679                                     &ndr_table_spoolss,
2680                                     NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY,
2681                                     &state->tmp);
2682         if (tevent_req_nomem(subreq, req)) {
2683                 return tevent_req_post(req, ev);
2684         }
2685         tevent_req_set_callback(subreq, rpccli_spoolss_GetPrintProcessorDirectory_done, req);
2686         return req;
2687 }
2688
2689 static void rpccli_spoolss_GetPrintProcessorDirectory_done(struct tevent_req *subreq)
2690 {
2691         struct tevent_req *req = tevent_req_callback_data(
2692                 subreq, struct tevent_req);
2693         struct rpccli_spoolss_GetPrintProcessorDirectory_state *state = tevent_req_data(
2694                 req, struct rpccli_spoolss_GetPrintProcessorDirectory_state);
2695         NTSTATUS status;
2696         TALLOC_CTX *mem_ctx;
2697
2698         if (state->out_mem_ctx) {
2699                 mem_ctx = state->out_mem_ctx;
2700         } else {
2701                 mem_ctx = state;
2702         }
2703
2704         status = state->dispatch_recv(subreq, mem_ctx);
2705         TALLOC_FREE(subreq);
2706         if (!NT_STATUS_IS_OK(status)) {
2707                 tevent_req_nterror(req, status);
2708                 return;
2709         }
2710
2711         /* Copy out parameters */
2712         if (state->orig.out.info && state->tmp.out.info) {
2713                 *state->orig.out.info = *state->tmp.out.info;
2714         }
2715         *state->orig.out.needed = *state->tmp.out.needed;
2716
2717         /* Copy result */
2718         state->orig.out.result = state->tmp.out.result;
2719
2720         /* Reset temporary structure */
2721         ZERO_STRUCT(state->tmp);
2722
2723         tevent_req_done(req);
2724 }
2725
2726 NTSTATUS rpccli_spoolss_GetPrintProcessorDirectory_recv(struct tevent_req *req,
2727                                                         TALLOC_CTX *mem_ctx,
2728                                                         WERROR *result)
2729 {
2730         struct rpccli_spoolss_GetPrintProcessorDirectory_state *state = tevent_req_data(
2731                 req, struct rpccli_spoolss_GetPrintProcessorDirectory_state);
2732         NTSTATUS status;
2733
2734         if (tevent_req_is_nterror(req, &status)) {
2735                 tevent_req_received(req);
2736                 return status;
2737         }
2738
2739         /* Steal possbile out parameters to the callers context */
2740         talloc_steal(mem_ctx, state->out_mem_ctx);
2741
2742         /* Return result */
2743         *result = state->orig.out.result;
2744
2745         tevent_req_received(req);
2746         return NT_STATUS_OK;
2747 }
2748
2749 NTSTATUS rpccli_spoolss_GetPrintProcessorDirectory(struct rpc_pipe_client *cli,
2750                                                    TALLOC_CTX *mem_ctx,
2751                                                    const char *server /* [in] [unique,charset(UTF16)] */,
2752                                                    const char *environment /* [in] [unique,charset(UTF16)] */,
2753                                                    uint32_t level /* [in]  */,
2754                                                    DATA_BLOB *buffer /* [in] [unique] */,
2755                                                    uint32_t offered /* [in]  */,
2756                                                    union spoolss_PrintProcessorDirectoryInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
2757                                                    uint32_t *needed /* [out] [ref] */,
2758                                                    WERROR *werror)
2759 {
2760         struct spoolss_GetPrintProcessorDirectory r;
2761         NTSTATUS status;
2762
2763         /* In parameters */
2764         r.in.server = server;
2765         r.in.environment = environment;
2766         r.in.level = level;
2767         r.in.buffer = buffer;
2768         r.in.offered = offered;
2769
2770         status = cli->dispatch(cli,
2771                                 mem_ctx,
2772                                 &ndr_table_spoolss,
2773                                 NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY,
2774                                 &r);
2775
2776         if (!NT_STATUS_IS_OK(status)) {
2777                 return status;
2778         }
2779
2780         if (NT_STATUS_IS_ERR(status)) {
2781                 return status;
2782         }
2783
2784         /* Return variables */
2785         if (info && r.out.info) {
2786                 *info = *r.out.info;
2787         }
2788         *needed = *r.out.needed;
2789
2790         /* Return result */
2791         if (werror) {
2792                 *werror = r.out.result;
2793         }
2794
2795         return werror_to_ntstatus(r.out.result);
2796 }
2797
2798 struct rpccli_spoolss_StartDocPrinter_state {
2799         struct spoolss_StartDocPrinter orig;
2800         struct spoolss_StartDocPrinter tmp;
2801         TALLOC_CTX *out_mem_ctx;
2802         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2803 };
2804
2805 static void rpccli_spoolss_StartDocPrinter_done(struct tevent_req *subreq);
2806
2807 struct tevent_req *rpccli_spoolss_StartDocPrinter_send(TALLOC_CTX *mem_ctx,
2808                                                        struct tevent_context *ev,
2809                                                        struct rpc_pipe_client *cli,
2810                                                        struct policy_handle *_handle /* [in] [ref] */,
2811                                                        uint32_t _level /* [in]  */,
2812                                                        union spoolss_DocumentInfo _info /* [in] [switch_is(level)] */,
2813                                                        uint32_t *_job_id /* [out] [ref] */)
2814 {
2815         struct tevent_req *req;
2816         struct rpccli_spoolss_StartDocPrinter_state *state;
2817         struct tevent_req *subreq;
2818
2819         req = tevent_req_create(mem_ctx, &state,
2820                                 struct rpccli_spoolss_StartDocPrinter_state);
2821         if (req == NULL) {
2822                 return NULL;
2823         }
2824         state->out_mem_ctx = NULL;
2825         state->dispatch_recv = cli->dispatch_recv;
2826
2827         /* In parameters */
2828         state->orig.in.handle = _handle;
2829         state->orig.in.level = _level;
2830         state->orig.in.info = _info;
2831
2832         /* Out parameters */
2833         state->orig.out.job_id = _job_id;
2834
2835         /* Result */
2836         ZERO_STRUCT(state->orig.out.result);
2837
2838         state->out_mem_ctx = talloc_named_const(state, 0,
2839                              "rpccli_spoolss_StartDocPrinter_out_memory");
2840         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2841                 return tevent_req_post(req, ev);
2842         }
2843
2844         /* make a temporary copy, that we pass to the dispatch function */
2845         state->tmp = state->orig;
2846
2847         subreq = cli->dispatch_send(state, ev, cli,
2848                                     &ndr_table_spoolss,
2849                                     NDR_SPOOLSS_STARTDOCPRINTER,
2850                                     &state->tmp);
2851         if (tevent_req_nomem(subreq, req)) {
2852                 return tevent_req_post(req, ev);
2853         }
2854         tevent_req_set_callback(subreq, rpccli_spoolss_StartDocPrinter_done, req);
2855         return req;
2856 }
2857
2858 static void rpccli_spoolss_StartDocPrinter_done(struct tevent_req *subreq)
2859 {
2860         struct tevent_req *req = tevent_req_callback_data(
2861                 subreq, struct tevent_req);
2862         struct rpccli_spoolss_StartDocPrinter_state *state = tevent_req_data(
2863                 req, struct rpccli_spoolss_StartDocPrinter_state);
2864         NTSTATUS status;
2865         TALLOC_CTX *mem_ctx;
2866
2867         if (state->out_mem_ctx) {
2868                 mem_ctx = state->out_mem_ctx;
2869         } else {
2870                 mem_ctx = state;
2871         }
2872
2873         status = state->dispatch_recv(subreq, mem_ctx);
2874         TALLOC_FREE(subreq);
2875         if (!NT_STATUS_IS_OK(status)) {
2876                 tevent_req_nterror(req, status);
2877                 return;
2878         }
2879
2880         /* Copy out parameters */
2881         *state->orig.out.job_id = *state->tmp.out.job_id;
2882
2883         /* Copy result */
2884         state->orig.out.result = state->tmp.out.result;
2885
2886         /* Reset temporary structure */
2887         ZERO_STRUCT(state->tmp);
2888
2889         tevent_req_done(req);
2890 }
2891
2892 NTSTATUS rpccli_spoolss_StartDocPrinter_recv(struct tevent_req *req,
2893                                              TALLOC_CTX *mem_ctx,
2894                                              WERROR *result)
2895 {
2896         struct rpccli_spoolss_StartDocPrinter_state *state = tevent_req_data(
2897                 req, struct rpccli_spoolss_StartDocPrinter_state);
2898         NTSTATUS status;
2899
2900         if (tevent_req_is_nterror(req, &status)) {
2901                 tevent_req_received(req);
2902                 return status;
2903         }
2904
2905         /* Steal possbile out parameters to the callers context */
2906         talloc_steal(mem_ctx, state->out_mem_ctx);
2907
2908         /* Return result */
2909         *result = state->orig.out.result;
2910
2911         tevent_req_received(req);
2912         return NT_STATUS_OK;
2913 }
2914
2915 NTSTATUS rpccli_spoolss_StartDocPrinter(struct rpc_pipe_client *cli,
2916                                         TALLOC_CTX *mem_ctx,
2917                                         struct policy_handle *handle /* [in] [ref] */,
2918                                         uint32_t level /* [in]  */,
2919                                         union spoolss_DocumentInfo info /* [in] [switch_is(level)] */,
2920                                         uint32_t *job_id /* [out] [ref] */,
2921                                         WERROR *werror)
2922 {
2923         struct spoolss_StartDocPrinter r;
2924         NTSTATUS status;
2925
2926         /* In parameters */
2927         r.in.handle = handle;
2928         r.in.level = level;
2929         r.in.info = info;
2930
2931         status = cli->dispatch(cli,
2932                                 mem_ctx,
2933                                 &ndr_table_spoolss,
2934                                 NDR_SPOOLSS_STARTDOCPRINTER,
2935                                 &r);
2936
2937         if (!NT_STATUS_IS_OK(status)) {
2938                 return status;
2939         }
2940
2941         if (NT_STATUS_IS_ERR(status)) {
2942                 return status;
2943         }
2944
2945         /* Return variables */
2946         *job_id = *r.out.job_id;
2947
2948         /* Return result */
2949         if (werror) {
2950                 *werror = r.out.result;
2951         }
2952
2953         return werror_to_ntstatus(r.out.result);
2954 }
2955
2956 struct rpccli_spoolss_StartPagePrinter_state {
2957         struct spoolss_StartPagePrinter orig;
2958         struct spoolss_StartPagePrinter tmp;
2959         TALLOC_CTX *out_mem_ctx;
2960         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2961 };
2962
2963 static void rpccli_spoolss_StartPagePrinter_done(struct tevent_req *subreq);
2964
2965 struct tevent_req *rpccli_spoolss_StartPagePrinter_send(TALLOC_CTX *mem_ctx,
2966                                                         struct tevent_context *ev,
2967                                                         struct rpc_pipe_client *cli,
2968                                                         struct policy_handle *_handle /* [in] [ref] */)
2969 {
2970         struct tevent_req *req;
2971         struct rpccli_spoolss_StartPagePrinter_state *state;
2972         struct tevent_req *subreq;
2973
2974         req = tevent_req_create(mem_ctx, &state,
2975                                 struct rpccli_spoolss_StartPagePrinter_state);
2976         if (req == NULL) {
2977                 return NULL;
2978         }
2979         state->out_mem_ctx = NULL;
2980         state->dispatch_recv = cli->dispatch_recv;
2981
2982         /* In parameters */
2983         state->orig.in.handle = _handle;
2984
2985         /* Out parameters */
2986
2987         /* Result */
2988         ZERO_STRUCT(state->orig.out.result);
2989
2990         /* make a temporary copy, that we pass to the dispatch function */
2991         state->tmp = state->orig;
2992
2993         subreq = cli->dispatch_send(state, ev, cli,
2994                                     &ndr_table_spoolss,
2995                                     NDR_SPOOLSS_STARTPAGEPRINTER,
2996                                     &state->tmp);
2997         if (tevent_req_nomem(subreq, req)) {
2998                 return tevent_req_post(req, ev);
2999         }
3000         tevent_req_set_callback(subreq, rpccli_spoolss_StartPagePrinter_done, req);
3001         return req;
3002 }
3003
3004 static void rpccli_spoolss_StartPagePrinter_done(struct tevent_req *subreq)
3005 {
3006         struct tevent_req *req = tevent_req_callback_data(
3007                 subreq, struct tevent_req);
3008         struct rpccli_spoolss_StartPagePrinter_state *state = tevent_req_data(
3009                 req, struct rpccli_spoolss_StartPagePrinter_state);
3010         NTSTATUS status;
3011         TALLOC_CTX *mem_ctx;
3012
3013         if (state->out_mem_ctx) {
3014                 mem_ctx = state->out_mem_ctx;
3015         } else {
3016                 mem_ctx = state;
3017         }
3018
3019         status = state->dispatch_recv(subreq, mem_ctx);
3020         TALLOC_FREE(subreq);
3021         if (!NT_STATUS_IS_OK(status)) {
3022                 tevent_req_nterror(req, status);
3023                 return;
3024         }
3025
3026         /* Copy out parameters */
3027
3028         /* Copy result */
3029         state->orig.out.result = state->tmp.out.result;
3030
3031         /* Reset temporary structure */
3032         ZERO_STRUCT(state->tmp);
3033
3034         tevent_req_done(req);
3035 }
3036
3037 NTSTATUS rpccli_spoolss_StartPagePrinter_recv(struct tevent_req *req,
3038                                               TALLOC_CTX *mem_ctx,
3039                                               WERROR *result)
3040 {
3041         struct rpccli_spoolss_StartPagePrinter_state *state = tevent_req_data(
3042                 req, struct rpccli_spoolss_StartPagePrinter_state);
3043         NTSTATUS status;
3044
3045         if (tevent_req_is_nterror(req, &status)) {
3046                 tevent_req_received(req);
3047                 return status;
3048         }
3049
3050         /* Steal possbile out parameters to the callers context */
3051         talloc_steal(mem_ctx, state->out_mem_ctx);
3052
3053         /* Return result */
3054         *result = state->orig.out.result;
3055
3056         tevent_req_received(req);
3057         return NT_STATUS_OK;
3058 }
3059
3060 NTSTATUS rpccli_spoolss_StartPagePrinter(struct rpc_pipe_client *cli,
3061                                          TALLOC_CTX *mem_ctx,
3062                                          struct policy_handle *handle /* [in] [ref] */,
3063                                          WERROR *werror)
3064 {
3065         struct spoolss_StartPagePrinter r;
3066         NTSTATUS status;
3067
3068         /* In parameters */
3069         r.in.handle = handle;
3070
3071         status = cli->dispatch(cli,
3072                                 mem_ctx,
3073                                 &ndr_table_spoolss,
3074                                 NDR_SPOOLSS_STARTPAGEPRINTER,
3075                                 &r);
3076
3077         if (!NT_STATUS_IS_OK(status)) {
3078                 return status;
3079         }
3080
3081         if (NT_STATUS_IS_ERR(status)) {
3082                 return status;
3083         }
3084
3085         /* Return variables */
3086
3087         /* Return result */
3088         if (werror) {
3089                 *werror = r.out.result;
3090         }
3091
3092         return werror_to_ntstatus(r.out.result);
3093 }
3094
3095 struct rpccli_spoolss_WritePrinter_state {
3096         struct spoolss_WritePrinter orig;
3097         struct spoolss_WritePrinter tmp;
3098         TALLOC_CTX *out_mem_ctx;
3099         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3100 };
3101
3102 static void rpccli_spoolss_WritePrinter_done(struct tevent_req *subreq);
3103
3104 struct tevent_req *rpccli_spoolss_WritePrinter_send(TALLOC_CTX *mem_ctx,
3105                                                     struct tevent_context *ev,
3106                                                     struct rpc_pipe_client *cli,
3107                                                     struct policy_handle *_handle /* [in] [ref] */,
3108                                                     DATA_BLOB _data /* [in]  */,
3109                                                     uint32_t __data_size /* [in] [value(r->in.data.length)] */,
3110                                                     uint32_t *_num_written /* [out] [ref] */)
3111 {
3112         struct tevent_req *req;
3113         struct rpccli_spoolss_WritePrinter_state *state;
3114         struct tevent_req *subreq;
3115
3116         req = tevent_req_create(mem_ctx, &state,
3117                                 struct rpccli_spoolss_WritePrinter_state);
3118         if (req == NULL) {
3119                 return NULL;
3120         }
3121         state->out_mem_ctx = NULL;
3122         state->dispatch_recv = cli->dispatch_recv;
3123
3124         /* In parameters */
3125         state->orig.in.handle = _handle;
3126         state->orig.in.data = _data;
3127         state->orig.in._data_size = __data_size;
3128
3129         /* Out parameters */
3130         state->orig.out.num_written = _num_written;
3131
3132         /* Result */
3133         ZERO_STRUCT(state->orig.out.result);
3134
3135         state->out_mem_ctx = talloc_named_const(state, 0,
3136                              "rpccli_spoolss_WritePrinter_out_memory");
3137         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3138                 return tevent_req_post(req, ev);
3139         }
3140
3141         /* make a temporary copy, that we pass to the dispatch function */
3142         state->tmp = state->orig;
3143
3144         subreq = cli->dispatch_send(state, ev, cli,
3145                                     &ndr_table_spoolss,
3146                                     NDR_SPOOLSS_WRITEPRINTER,
3147                                     &state->tmp);
3148         if (tevent_req_nomem(subreq, req)) {
3149                 return tevent_req_post(req, ev);
3150         }
3151         tevent_req_set_callback(subreq, rpccli_spoolss_WritePrinter_done, req);
3152         return req;
3153 }
3154
3155 static void rpccli_spoolss_WritePrinter_done(struct tevent_req *subreq)
3156 {
3157         struct tevent_req *req = tevent_req_callback_data(
3158                 subreq, struct tevent_req);
3159         struct rpccli_spoolss_WritePrinter_state *state = tevent_req_data(
3160                 req, struct rpccli_spoolss_WritePrinter_state);
3161         NTSTATUS status;
3162         TALLOC_CTX *mem_ctx;
3163
3164         if (state->out_mem_ctx) {
3165                 mem_ctx = state->out_mem_ctx;
3166         } else {
3167                 mem_ctx = state;
3168         }
3169
3170         status = state->dispatch_recv(subreq, mem_ctx);
3171         TALLOC_FREE(subreq);
3172         if (!NT_STATUS_IS_OK(status)) {
3173                 tevent_req_nterror(req, status);
3174                 return;
3175         }
3176
3177         /* Copy out parameters */
3178         *state->orig.out.num_written = *state->tmp.out.num_written;
3179
3180         /* Copy result */
3181         state->orig.out.result = state->tmp.out.result;
3182
3183         /* Reset temporary structure */
3184         ZERO_STRUCT(state->tmp);
3185
3186         tevent_req_done(req);
3187 }
3188
3189 NTSTATUS rpccli_spoolss_WritePrinter_recv(struct tevent_req *req,
3190                                           TALLOC_CTX *mem_ctx,
3191                                           WERROR *result)
3192 {
3193         struct rpccli_spoolss_WritePrinter_state *state = tevent_req_data(
3194                 req, struct rpccli_spoolss_WritePrinter_state);
3195         NTSTATUS status;
3196
3197         if (tevent_req_is_nterror(req, &status)) {
3198                 tevent_req_received(req);
3199                 return status;
3200         }
3201
3202         /* Steal possbile out parameters to the callers context */
3203         talloc_steal(mem_ctx, state->out_mem_ctx);
3204
3205         /* Return result */
3206         *result = state->orig.out.result;
3207
3208         tevent_req_received(req);
3209         return NT_STATUS_OK;
3210 }
3211
3212 NTSTATUS rpccli_spoolss_WritePrinter(struct rpc_pipe_client *cli,
3213                                      TALLOC_CTX *mem_ctx,
3214                                      struct policy_handle *handle /* [in] [ref] */,
3215                                      DATA_BLOB data /* [in]  */,
3216                                      uint32_t _data_size /* [in] [value(r->in.data.length)] */,
3217                                      uint32_t *num_written /* [out] [ref] */,
3218                                      WERROR *werror)
3219 {
3220         struct spoolss_WritePrinter r;
3221         NTSTATUS status;
3222
3223         /* In parameters */
3224         r.in.handle = handle;
3225         r.in.data = data;
3226         r.in._data_size = _data_size;
3227
3228         status = cli->dispatch(cli,
3229                                 mem_ctx,
3230                                 &ndr_table_spoolss,
3231                                 NDR_SPOOLSS_WRITEPRINTER,
3232                                 &r);
3233
3234         if (!NT_STATUS_IS_OK(status)) {
3235                 return status;
3236         }
3237
3238         if (NT_STATUS_IS_ERR(status)) {
3239                 return status;
3240         }
3241
3242         /* Return variables */
3243         *num_written = *r.out.num_written;
3244
3245         /* Return result */
3246         if (werror) {
3247                 *werror = r.out.result;
3248         }
3249
3250         return werror_to_ntstatus(r.out.result);
3251 }
3252
3253 struct rpccli_spoolss_EndPagePrinter_state {
3254         struct spoolss_EndPagePrinter orig;
3255         struct spoolss_EndPagePrinter tmp;
3256         TALLOC_CTX *out_mem_ctx;
3257         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3258 };
3259
3260 static void rpccli_spoolss_EndPagePrinter_done(struct tevent_req *subreq);
3261
3262 struct tevent_req *rpccli_spoolss_EndPagePrinter_send(TALLOC_CTX *mem_ctx,
3263                                                       struct tevent_context *ev,
3264                                                       struct rpc_pipe_client *cli,
3265                                                       struct policy_handle *_handle /* [in] [ref] */)
3266 {
3267         struct tevent_req *req;
3268         struct rpccli_spoolss_EndPagePrinter_state *state;
3269         struct tevent_req *subreq;
3270
3271         req = tevent_req_create(mem_ctx, &state,
3272                                 struct rpccli_spoolss_EndPagePrinter_state);
3273         if (req == NULL) {
3274                 return NULL;
3275         }
3276         state->out_mem_ctx = NULL;
3277         state->dispatch_recv = cli->dispatch_recv;
3278
3279         /* In parameters */
3280         state->orig.in.handle = _handle;
3281
3282         /* Out parameters */
3283
3284         /* Result */
3285         ZERO_STRUCT(state->orig.out.result);
3286
3287         /* make a temporary copy, that we pass to the dispatch function */
3288         state->tmp = state->orig;
3289
3290         subreq = cli->dispatch_send(state, ev, cli,
3291                                     &ndr_table_spoolss,
3292                                     NDR_SPOOLSS_ENDPAGEPRINTER,
3293                                     &state->tmp);
3294         if (tevent_req_nomem(subreq, req)) {
3295                 return tevent_req_post(req, ev);
3296         }
3297         tevent_req_set_callback(subreq, rpccli_spoolss_EndPagePrinter_done, req);
3298         return req;
3299 }
3300
3301 static void rpccli_spoolss_EndPagePrinter_done(struct tevent_req *subreq)
3302 {
3303         struct tevent_req *req = tevent_req_callback_data(
3304                 subreq, struct tevent_req);
3305         struct rpccli_spoolss_EndPagePrinter_state *state = tevent_req_data(
3306                 req, struct rpccli_spoolss_EndPagePrinter_state);
3307         NTSTATUS status;
3308         TALLOC_CTX *mem_ctx;
3309
3310         if (state->out_mem_ctx) {
3311                 mem_ctx = state->out_mem_ctx;
3312         } else {
3313                 mem_ctx = state;
3314         }
3315
3316         status = state->dispatch_recv(subreq, mem_ctx);
3317         TALLOC_FREE(subreq);
3318         if (!NT_STATUS_IS_OK(status)) {
3319                 tevent_req_nterror(req, status);
3320                 return;
3321         }
3322
3323         /* Copy out parameters */
3324
3325         /* Copy result */
3326         state->orig.out.result = state->tmp.out.result;
3327
3328         /* Reset temporary structure */
3329         ZERO_STRUCT(state->tmp);
3330
3331         tevent_req_done(req);
3332 }
3333
3334 NTSTATUS rpccli_spoolss_EndPagePrinter_recv(struct tevent_req *req,
3335                                             TALLOC_CTX *mem_ctx,
3336                                             WERROR *result)
3337 {
3338         struct rpccli_spoolss_EndPagePrinter_state *state = tevent_req_data(
3339                 req, struct rpccli_spoolss_EndPagePrinter_state);
3340         NTSTATUS status;
3341
3342         if (tevent_req_is_nterror(req, &status)) {
3343                 tevent_req_received(req);
3344                 return status;
3345         }
3346
3347         /* Steal possbile out parameters to the callers context */
3348         talloc_steal(mem_ctx, state->out_mem_ctx);
3349
3350         /* Return result */
3351         *result = state->orig.out.result;
3352
3353         tevent_req_received(req);
3354         return NT_STATUS_OK;
3355 }
3356
3357 NTSTATUS rpccli_spoolss_EndPagePrinter(struct rpc_pipe_client *cli,
3358                                        TALLOC_CTX *mem_ctx,
3359                                        struct policy_handle *handle /* [in] [ref] */,
3360                                        WERROR *werror)
3361 {
3362         struct spoolss_EndPagePrinter r;
3363         NTSTATUS status;
3364
3365         /* In parameters */
3366         r.in.handle = handle;
3367
3368         status = cli->dispatch(cli,
3369                                 mem_ctx,
3370                                 &ndr_table_spoolss,
3371                                 NDR_SPOOLSS_ENDPAGEPRINTER,
3372                                 &r);
3373
3374         if (!NT_STATUS_IS_OK(status)) {
3375                 return status;
3376         }
3377
3378         if (NT_STATUS_IS_ERR(status)) {
3379                 return status;
3380         }
3381
3382         /* Return variables */
3383
3384         /* Return result */
3385         if (werror) {
3386                 *werror = r.out.result;
3387         }
3388
3389         return werror_to_ntstatus(r.out.result);
3390 }
3391
3392 struct rpccli_spoolss_AbortPrinter_state {
3393         struct spoolss_AbortPrinter orig;
3394         struct spoolss_AbortPrinter tmp;
3395         TALLOC_CTX *out_mem_ctx;
3396         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3397 };
3398
3399 static void rpccli_spoolss_AbortPrinter_done(struct tevent_req *subreq);
3400
3401 struct tevent_req *rpccli_spoolss_AbortPrinter_send(TALLOC_CTX *mem_ctx,
3402                                                     struct tevent_context *ev,
3403                                                     struct rpc_pipe_client *cli,
3404                                                     struct policy_handle *_handle /* [in] [ref] */)
3405 {
3406         struct tevent_req *req;
3407         struct rpccli_spoolss_AbortPrinter_state *state;
3408         struct tevent_req *subreq;
3409
3410         req = tevent_req_create(mem_ctx, &state,
3411                                 struct rpccli_spoolss_AbortPrinter_state);
3412         if (req == NULL) {
3413                 return NULL;
3414         }
3415         state->out_mem_ctx = NULL;
3416         state->dispatch_recv = cli->dispatch_recv;
3417
3418         /* In parameters */
3419         state->orig.in.handle = _handle;
3420
3421         /* Out parameters */
3422
3423         /* Result */
3424         ZERO_STRUCT(state->orig.out.result);
3425
3426         /* make a temporary copy, that we pass to the dispatch function */
3427         state->tmp = state->orig;
3428
3429         subreq = cli->dispatch_send(state, ev, cli,
3430                                     &ndr_table_spoolss,
3431                                     NDR_SPOOLSS_ABORTPRINTER,
3432                                     &state->tmp);
3433         if (tevent_req_nomem(subreq, req)) {
3434                 return tevent_req_post(req, ev);
3435         }
3436         tevent_req_set_callback(subreq, rpccli_spoolss_AbortPrinter_done, req);
3437         return req;
3438 }
3439
3440 static void rpccli_spoolss_AbortPrinter_done(struct tevent_req *subreq)
3441 {
3442         struct tevent_req *req = tevent_req_callback_data(
3443                 subreq, struct tevent_req);
3444         struct rpccli_spoolss_AbortPrinter_state *state = tevent_req_data(
3445                 req, struct rpccli_spoolss_AbortPrinter_state);
3446         NTSTATUS status;
3447         TALLOC_CTX *mem_ctx;
3448
3449         if (state->out_mem_ctx) {
3450                 mem_ctx = state->out_mem_ctx;
3451         } else {
3452                 mem_ctx = state;
3453         }
3454
3455         status = state->dispatch_recv(subreq, mem_ctx);
3456         TALLOC_FREE(subreq);
3457         if (!NT_STATUS_IS_OK(status)) {
3458                 tevent_req_nterror(req, status);
3459                 return;
3460         }
3461
3462         /* Copy out parameters */
3463
3464         /* Copy result */
3465         state->orig.out.result = state->tmp.out.result;
3466
3467         /* Reset temporary structure */
3468         ZERO_STRUCT(state->tmp);
3469
3470         tevent_req_done(req);
3471 }
3472
3473 NTSTATUS rpccli_spoolss_AbortPrinter_recv(struct tevent_req *req,
3474                                           TALLOC_CTX *mem_ctx,
3475                                           WERROR *result)
3476 {
3477         struct rpccli_spoolss_AbortPrinter_state *state = tevent_req_data(
3478                 req, struct rpccli_spoolss_AbortPrinter_state);
3479         NTSTATUS status;
3480
3481         if (tevent_req_is_nterror(req, &status)) {
3482                 tevent_req_received(req);
3483                 return status;
3484         }
3485
3486         /* Steal possbile out parameters to the callers context */
3487         talloc_steal(mem_ctx, state->out_mem_ctx);
3488
3489         /* Return result */
3490         *result = state->orig.out.result;
3491
3492         tevent_req_received(req);
3493         return NT_STATUS_OK;
3494 }
3495
3496 NTSTATUS rpccli_spoolss_AbortPrinter(struct rpc_pipe_client *cli,
3497                                      TALLOC_CTX *mem_ctx,
3498                                      struct policy_handle *handle /* [in] [ref] */,
3499                                      WERROR *werror)
3500 {
3501         struct spoolss_AbortPrinter r;
3502         NTSTATUS status;
3503
3504         /* In parameters */
3505         r.in.handle = handle;
3506
3507         status = cli->dispatch(cli,
3508                                 mem_ctx,
3509                                 &ndr_table_spoolss,
3510                                 NDR_SPOOLSS_ABORTPRINTER,
3511                                 &r);
3512
3513         if (!NT_STATUS_IS_OK(status)) {
3514                 return status;
3515         }
3516
3517         if (NT_STATUS_IS_ERR(status)) {
3518                 return status;
3519         }
3520
3521         /* Return variables */
3522
3523         /* Return result */
3524         if (werror) {
3525                 *werror = r.out.result;
3526         }
3527
3528         return werror_to_ntstatus(r.out.result);
3529 }
3530
3531 struct rpccli_spoolss_ReadPrinter_state {
3532         struct spoolss_ReadPrinter orig;
3533         struct spoolss_ReadPrinter tmp;
3534         TALLOC_CTX *out_mem_ctx;
3535         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3536 };
3537
3538 static void rpccli_spoolss_ReadPrinter_done(struct tevent_req *subreq);
3539
3540 struct tevent_req *rpccli_spoolss_ReadPrinter_send(TALLOC_CTX *mem_ctx,
3541                                                    struct tevent_context *ev,
3542                                                    struct rpc_pipe_client *cli,
3543                                                    struct policy_handle *_handle /* [in] [ref] */,
3544                                                    uint8_t *_data /* [out] [ref,size_is(data_size)] */,
3545                                                    uint32_t _data_size /* [in]  */,
3546                                                    uint32_t *__data_size /* [out] [ref] */)
3547 {
3548         struct tevent_req *req;
3549         struct rpccli_spoolss_ReadPrinter_state *state;
3550         struct tevent_req *subreq;
3551
3552         req = tevent_req_create(mem_ctx, &state,
3553                                 struct rpccli_spoolss_ReadPrinter_state);
3554         if (req == NULL) {
3555                 return NULL;
3556         }
3557         state->out_mem_ctx = NULL;
3558         state->dispatch_recv = cli->dispatch_recv;
3559
3560         /* In parameters */
3561         state->orig.in.handle = _handle;
3562         state->orig.in.data_size = _data_size;
3563
3564         /* Out parameters */
3565         state->orig.out.data = _data;
3566         state->orig.out._data_size = __data_size;
3567
3568         /* Result */
3569         ZERO_STRUCT(state->orig.out.result);
3570
3571         state->out_mem_ctx = talloc_named_const(state, 0,
3572                              "rpccli_spoolss_ReadPrinter_out_memory");
3573         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3574                 return tevent_req_post(req, ev);
3575         }
3576
3577         /* make a temporary copy, that we pass to the dispatch function */
3578         state->tmp = state->orig;
3579
3580         subreq = cli->dispatch_send(state, ev, cli,
3581                                     &ndr_table_spoolss,
3582                                     NDR_SPOOLSS_READPRINTER,
3583                                     &state->tmp);
3584         if (tevent_req_nomem(subreq, req)) {
3585                 return tevent_req_post(req, ev);
3586         }
3587         tevent_req_set_callback(subreq, rpccli_spoolss_ReadPrinter_done, req);
3588         return req;
3589 }
3590
3591 static void rpccli_spoolss_ReadPrinter_done(struct tevent_req *subreq)
3592 {
3593         struct tevent_req *req = tevent_req_callback_data(
3594                 subreq, struct tevent_req);
3595         struct rpccli_spoolss_ReadPrinter_state *state = tevent_req_data(
3596                 req, struct rpccli_spoolss_ReadPrinter_state);
3597         NTSTATUS status;
3598         TALLOC_CTX *mem_ctx;
3599
3600         if (state->out_mem_ctx) {
3601                 mem_ctx = state->out_mem_ctx;
3602         } else {
3603                 mem_ctx = state;
3604         }
3605
3606         status = state->dispatch_recv(subreq, mem_ctx);
3607         TALLOC_FREE(subreq);
3608         if (!NT_STATUS_IS_OK(status)) {
3609                 tevent_req_nterror(req, status);
3610                 return;
3611         }
3612
3613         /* Copy out parameters */
3614         memcpy(state->orig.out.data, state->tmp.out.data, (state->tmp.in.data_size) * sizeof(*state->orig.out.data));
3615         *state->orig.out._data_size = *state->tmp.out._data_size;
3616
3617         /* Copy result */
3618         state->orig.out.result = state->tmp.out.result;
3619
3620         /* Reset temporary structure */
3621         ZERO_STRUCT(state->tmp);
3622
3623         tevent_req_done(req);
3624 }
3625
3626 NTSTATUS rpccli_spoolss_ReadPrinter_recv(struct tevent_req *req,
3627                                          TALLOC_CTX *mem_ctx,
3628                                          WERROR *result)
3629 {
3630         struct rpccli_spoolss_ReadPrinter_state *state = tevent_req_data(
3631                 req, struct rpccli_spoolss_ReadPrinter_state);
3632         NTSTATUS status;
3633
3634         if (tevent_req_is_nterror(req, &status)) {
3635                 tevent_req_received(req);
3636                 return status;
3637         }
3638
3639         /* Steal possbile out parameters to the callers context */
3640         talloc_steal(mem_ctx, state->out_mem_ctx);
3641
3642         /* Return result */
3643         *result = state->orig.out.result;
3644
3645         tevent_req_received(req);
3646         return NT_STATUS_OK;
3647 }
3648
3649 NTSTATUS rpccli_spoolss_ReadPrinter(struct rpc_pipe_client *cli,
3650                                     TALLOC_CTX *mem_ctx,
3651                                     struct policy_handle *handle /* [in] [ref] */,
3652                                     uint8_t *data /* [out] [ref,size_is(data_size)] */,
3653                                     uint32_t data_size /* [in]  */,
3654                                     uint32_t *_data_size /* [out] [ref] */,
3655                                     WERROR *werror)
3656 {
3657         struct spoolss_ReadPrinter r;
3658         NTSTATUS status;
3659
3660         /* In parameters */
3661         r.in.handle = handle;
3662         r.in.data_size = data_size;
3663
3664         status = cli->dispatch(cli,
3665                                 mem_ctx,
3666                                 &ndr_table_spoolss,
3667                                 NDR_SPOOLSS_READPRINTER,
3668                                 &r);
3669
3670         if (!NT_STATUS_IS_OK(status)) {
3671                 return status;
3672         }
3673
3674         if (NT_STATUS_IS_ERR(status)) {
3675                 return status;
3676         }
3677
3678         /* Return variables */
3679         memcpy(data, r.out.data, (r.in.data_size) * sizeof(*data));
3680         *_data_size = *r.out._data_size;
3681
3682         /* Return result */
3683         if (werror) {
3684                 *werror = r.out.result;
3685         }
3686
3687         return werror_to_ntstatus(r.out.result);
3688 }
3689
3690 struct rpccli_spoolss_EndDocPrinter_state {
3691         struct spoolss_EndDocPrinter orig;
3692         struct spoolss_EndDocPrinter tmp;
3693         TALLOC_CTX *out_mem_ctx;
3694         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3695 };
3696
3697 static void rpccli_spoolss_EndDocPrinter_done(struct tevent_req *subreq);
3698
3699 struct tevent_req *rpccli_spoolss_EndDocPrinter_send(TALLOC_CTX *mem_ctx,
3700                                                      struct tevent_context *ev,
3701                                                      struct rpc_pipe_client *cli,
3702                                                      struct policy_handle *_handle /* [in] [ref] */)
3703 {
3704         struct tevent_req *req;
3705         struct rpccli_spoolss_EndDocPrinter_state *state;
3706         struct tevent_req *subreq;
3707
3708         req = tevent_req_create(mem_ctx, &state,
3709                                 struct rpccli_spoolss_EndDocPrinter_state);
3710         if (req == NULL) {
3711                 return NULL;
3712         }
3713         state->out_mem_ctx = NULL;
3714         state->dispatch_recv = cli->dispatch_recv;
3715
3716         /* In parameters */
3717         state->orig.in.handle = _handle;
3718
3719         /* Out parameters */
3720
3721         /* Result */
3722         ZERO_STRUCT(state->orig.out.result);
3723
3724         /* make a temporary copy, that we pass to the dispatch function */
3725         state->tmp = state->orig;
3726
3727         subreq = cli->dispatch_send(state, ev, cli,
3728                                     &ndr_table_spoolss,
3729                                     NDR_SPOOLSS_ENDDOCPRINTER,
3730                                     &state->tmp);
3731         if (tevent_req_nomem(subreq, req)) {
3732                 return tevent_req_post(req, ev);
3733         }
3734         tevent_req_set_callback(subreq, rpccli_spoolss_EndDocPrinter_done, req);
3735         return req;
3736 }
3737
3738 static void rpccli_spoolss_EndDocPrinter_done(struct tevent_req *subreq)
3739 {
3740         struct tevent_req *req = tevent_req_callback_data(
3741                 subreq, struct tevent_req);
3742         struct rpccli_spoolss_EndDocPrinter_state *state = tevent_req_data(
3743                 req, struct rpccli_spoolss_EndDocPrinter_state);
3744         NTSTATUS status;
3745         TALLOC_CTX *mem_ctx;
3746
3747         if (state->out_mem_ctx) {
3748                 mem_ctx = state->out_mem_ctx;
3749         } else {
3750                 mem_ctx = state;
3751         }
3752
3753         status = state->dispatch_recv(subreq, mem_ctx);
3754         TALLOC_FREE(subreq);
3755         if (!NT_STATUS_IS_OK(status)) {
3756                 tevent_req_nterror(req, status);
3757                 return;
3758         }
3759
3760         /* Copy out parameters */
3761
3762         /* Copy result */
3763         state->orig.out.result = state->tmp.out.result;
3764
3765         /* Reset temporary structure */
3766         ZERO_STRUCT(state->tmp);
3767
3768         tevent_req_done(req);
3769 }
3770
3771 NTSTATUS rpccli_spoolss_EndDocPrinter_recv(struct tevent_req *req,
3772                                            TALLOC_CTX *mem_ctx,
3773                                            WERROR *result)
3774 {
3775         struct rpccli_spoolss_EndDocPrinter_state *state = tevent_req_data(
3776                 req, struct rpccli_spoolss_EndDocPrinter_state);
3777         NTSTATUS status;
3778
3779         if (tevent_req_is_nterror(req, &status)) {
3780                 tevent_req_received(req);
3781                 return status;
3782         }
3783
3784         /* Steal possbile out parameters to the callers context */
3785         talloc_steal(mem_ctx, state->out_mem_ctx);
3786
3787         /* Return result */
3788         *result = state->orig.out.result;
3789
3790         tevent_req_received(req);
3791         return NT_STATUS_OK;
3792 }
3793
3794 NTSTATUS rpccli_spoolss_EndDocPrinter(struct rpc_pipe_client *cli,
3795                                       TALLOC_CTX *mem_ctx,
3796                                       struct policy_handle *handle /* [in] [ref] */,
3797                                       WERROR *werror)
3798 {
3799         struct spoolss_EndDocPrinter r;
3800         NTSTATUS status;
3801
3802         /* In parameters */
3803         r.in.handle = handle;
3804
3805         status = cli->dispatch(cli,
3806                                 mem_ctx,
3807                                 &ndr_table_spoolss,
3808                                 NDR_SPOOLSS_ENDDOCPRINTER,
3809                                 &r);
3810
3811         if (!NT_STATUS_IS_OK(status)) {
3812                 return status;
3813         }
3814
3815         if (NT_STATUS_IS_ERR(status)) {
3816                 return status;
3817         }
3818
3819         /* Return variables */
3820
3821         /* Return result */
3822         if (werror) {
3823                 *werror = r.out.result;
3824         }
3825
3826         return werror_to_ntstatus(r.out.result);
3827 }
3828
3829 struct rpccli_spoolss_AddJob_state {
3830         struct spoolss_AddJob orig;
3831         struct spoolss_AddJob tmp;
3832         TALLOC_CTX *out_mem_ctx;
3833         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3834 };
3835
3836 static void rpccli_spoolss_AddJob_done(struct tevent_req *subreq);
3837
3838 struct tevent_req *rpccli_spoolss_AddJob_send(TALLOC_CTX *mem_ctx,
3839                                               struct tevent_context *ev,
3840                                               struct rpc_pipe_client *cli,
3841                                               struct policy_handle *_handle /* [in] [ref] */,
3842                                               uint32_t _level /* [in]  */,
3843                                               uint8_t *_buffer /* [in,out] [unique,size_is(offered)] */,
3844                                               uint32_t _offered /* [in]  */,
3845                                               uint32_t *_needed /* [out] [ref] */)
3846 {
3847         struct tevent_req *req;
3848         struct rpccli_spoolss_AddJob_state *state;
3849         struct tevent_req *subreq;
3850
3851         req = tevent_req_create(mem_ctx, &state,
3852                                 struct rpccli_spoolss_AddJob_state);
3853         if (req == NULL) {
3854                 return NULL;
3855         }
3856         state->out_mem_ctx = NULL;
3857         state->dispatch_recv = cli->dispatch_recv;
3858
3859         /* In parameters */
3860         state->orig.in.handle = _handle;
3861         state->orig.in.level = _level;
3862         state->orig.in.buffer = _buffer;
3863         state->orig.in.offered = _offered;
3864
3865         /* Out parameters */
3866         state->orig.out.buffer = _buffer;
3867         state->orig.out.needed = _needed;
3868
3869         /* Result */
3870         ZERO_STRUCT(state->orig.out.result);
3871
3872         state->out_mem_ctx = talloc_named_const(state, 0,
3873                              "rpccli_spoolss_AddJob_out_memory");
3874         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3875                 return tevent_req_post(req, ev);
3876         }
3877
3878         /* make a temporary copy, that we pass to the dispatch function */
3879         state->tmp = state->orig;
3880
3881         subreq = cli->dispatch_send(state, ev, cli,
3882                                     &ndr_table_spoolss,
3883                                     NDR_SPOOLSS_ADDJOB,
3884                                     &state->tmp);
3885         if (tevent_req_nomem(subreq, req)) {
3886                 return tevent_req_post(req, ev);
3887         }
3888         tevent_req_set_callback(subreq, rpccli_spoolss_AddJob_done, req);
3889         return req;
3890 }
3891
3892 static void rpccli_spoolss_AddJob_done(struct tevent_req *subreq)
3893 {
3894         struct tevent_req *req = tevent_req_callback_data(
3895                 subreq, struct tevent_req);
3896         struct rpccli_spoolss_AddJob_state *state = tevent_req_data(
3897                 req, struct rpccli_spoolss_AddJob_state);
3898         NTSTATUS status;
3899         TALLOC_CTX *mem_ctx;
3900
3901         if (state->out_mem_ctx) {
3902                 mem_ctx = state->out_mem_ctx;
3903         } else {
3904                 mem_ctx = state;
3905         }
3906
3907         status = state->dispatch_recv(subreq, mem_ctx);
3908         TALLOC_FREE(subreq);
3909         if (!NT_STATUS_IS_OK(status)) {
3910                 tevent_req_nterror(req, status);
3911                 return;
3912         }
3913
3914         /* Copy out parameters */
3915         if (state->orig.out.buffer && state->tmp.out.buffer) {
3916                 memcpy(state->orig.out.buffer, state->tmp.out.buffer, (state->tmp.in.offered) * sizeof(*state->orig.out.buffer));
3917         }
3918         *state->orig.out.needed = *state->tmp.out.needed;
3919
3920         /* Copy result */
3921         state->orig.out.result = state->tmp.out.result;
3922
3923         /* Reset temporary structure */
3924         ZERO_STRUCT(state->tmp);
3925
3926         tevent_req_done(req);
3927 }
3928
3929 NTSTATUS rpccli_spoolss_AddJob_recv(struct tevent_req *req,
3930                                     TALLOC_CTX *mem_ctx,
3931                                     WERROR *result)
3932 {
3933         struct rpccli_spoolss_AddJob_state *state = tevent_req_data(
3934                 req, struct rpccli_spoolss_AddJob_state);
3935         NTSTATUS status;
3936
3937         if (tevent_req_is_nterror(req, &status)) {
3938                 tevent_req_received(req);
3939                 return status;
3940         }
3941
3942         /* Steal possbile out parameters to the callers context */
3943         talloc_steal(mem_ctx, state->out_mem_ctx);
3944
3945         /* Return result */
3946         *result = state->orig.out.result;
3947
3948         tevent_req_received(req);
3949         return NT_STATUS_OK;
3950 }
3951
3952 NTSTATUS rpccli_spoolss_AddJob(struct rpc_pipe_client *cli,
3953                                TALLOC_CTX *mem_ctx,
3954                                struct policy_handle *handle /* [in] [ref] */,
3955                                uint32_t level /* [in]  */,
3956                                uint8_t *buffer /* [in,out] [unique,size_is(offered)] */,
3957                                uint32_t offered /* [in]  */,
3958                                uint32_t *needed /* [out] [ref] */,
3959                                WERROR *werror)
3960 {
3961         struct spoolss_AddJob r;
3962         NTSTATUS status;
3963
3964         /* In parameters */
3965         r.in.handle = handle;
3966         r.in.level = level;
3967         r.in.buffer = buffer;
3968         r.in.offered = offered;
3969
3970         status = cli->dispatch(cli,
3971                                 mem_ctx,
3972                                 &ndr_table_spoolss,
3973                                 NDR_SPOOLSS_ADDJOB,
3974                                 &r);
3975
3976         if (!NT_STATUS_IS_OK(status)) {
3977                 return status;
3978         }
3979
3980         if (NT_STATUS_IS_ERR(status)) {
3981                 return status;
3982         }
3983
3984         /* Return variables */
3985         if (buffer && r.out.buffer) {
3986                 memcpy(buffer, r.out.buffer, (r.in.offered) * sizeof(*buffer));
3987         }
3988         *needed = *r.out.needed;
3989
3990         /* Return result */
3991         if (werror) {
3992                 *werror = r.out.result;
3993         }
3994
3995         return werror_to_ntstatus(r.out.result);
3996 }
3997
3998 struct rpccli_spoolss_ScheduleJob_state {
3999         struct spoolss_ScheduleJob orig;
4000         struct spoolss_ScheduleJob tmp;
4001         TALLOC_CTX *out_mem_ctx;
4002         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4003 };
4004
4005 static void rpccli_spoolss_ScheduleJob_done(struct tevent_req *subreq);
4006
4007 struct tevent_req *rpccli_spoolss_ScheduleJob_send(TALLOC_CTX *mem_ctx,
4008                                                    struct tevent_context *ev,
4009                                                    struct rpc_pipe_client *cli,
4010                                                    struct policy_handle *_handle /* [in] [ref] */,
4011                                                    uint32_t _jobid /* [in]  */)
4012 {
4013         struct tevent_req *req;
4014         struct rpccli_spoolss_ScheduleJob_state *state;
4015         struct tevent_req *subreq;
4016
4017         req = tevent_req_create(mem_ctx, &state,
4018                                 struct rpccli_spoolss_ScheduleJob_state);
4019         if (req == NULL) {
4020                 return NULL;
4021         }
4022         state->out_mem_ctx = NULL;
4023         state->dispatch_recv = cli->dispatch_recv;
4024
4025         /* In parameters */
4026         state->orig.in.handle = _handle;
4027         state->orig.in.jobid = _jobid;
4028
4029         /* Out parameters */
4030
4031         /* Result */
4032         ZERO_STRUCT(state->orig.out.result);
4033
4034         /* make a temporary copy, that we pass to the dispatch function */
4035         state->tmp = state->orig;
4036
4037         subreq = cli->dispatch_send(state, ev, cli,
4038                                     &ndr_table_spoolss,
4039                                     NDR_SPOOLSS_SCHEDULEJOB,
4040                                     &state->tmp);
4041         if (tevent_req_nomem(subreq, req)) {
4042                 return tevent_req_post(req, ev);
4043         }
4044         tevent_req_set_callback(subreq, rpccli_spoolss_ScheduleJob_done, req);
4045         return req;
4046 }
4047
4048 static void rpccli_spoolss_ScheduleJob_done(struct tevent_req *subreq)
4049 {
4050         struct tevent_req *req = tevent_req_callback_data(
4051                 subreq, struct tevent_req);
4052         struct rpccli_spoolss_ScheduleJob_state *state = tevent_req_data(
4053                 req, struct rpccli_spoolss_ScheduleJob_state);
4054         NTSTATUS status;
4055         TALLOC_CTX *mem_ctx;
4056
4057         if (state->out_mem_ctx) {
4058                 mem_ctx = state->out_mem_ctx;
4059         } else {
4060                 mem_ctx = state;
4061         }
4062
4063         status = state->dispatch_recv(subreq, mem_ctx);
4064         TALLOC_FREE(subreq);
4065         if (!NT_STATUS_IS_OK(status)) {
4066                 tevent_req_nterror(req, status);
4067                 return;
4068         }
4069
4070         /* Copy out parameters */
4071
4072         /* Copy result */
4073         state->orig.out.result = state->tmp.out.result;
4074
4075         /* Reset temporary structure */
4076         ZERO_STRUCT(state->tmp);
4077
4078         tevent_req_done(req);
4079 }
4080
4081 NTSTATUS rpccli_spoolss_ScheduleJob_recv(struct tevent_req *req,
4082                                          TALLOC_CTX *mem_ctx,
4083                                          WERROR *result)
4084 {
4085         struct rpccli_spoolss_ScheduleJob_state *state = tevent_req_data(
4086                 req, struct rpccli_spoolss_ScheduleJob_state);
4087         NTSTATUS status;
4088
4089         if (tevent_req_is_nterror(req, &status)) {
4090                 tevent_req_received(req);
4091                 return status;
4092         }
4093
4094         /* Steal possbile out parameters to the callers context */
4095         talloc_steal(mem_ctx, state->out_mem_ctx);
4096
4097         /* Return result */
4098         *result = state->orig.out.result;
4099
4100         tevent_req_received(req);
4101         return NT_STATUS_OK;
4102 }
4103
4104 NTSTATUS rpccli_spoolss_ScheduleJob(struct rpc_pipe_client *cli,
4105                                     TALLOC_CTX *mem_ctx,
4106                                     struct policy_handle *handle /* [in] [ref] */,
4107                                     uint32_t jobid /* [in]  */,
4108                                     WERROR *werror)
4109 {
4110         struct spoolss_ScheduleJob r;
4111         NTSTATUS status;
4112
4113         /* In parameters */
4114         r.in.handle = handle;
4115         r.in.jobid = jobid;
4116
4117         status = cli->dispatch(cli,
4118                                 mem_ctx,
4119                                 &ndr_table_spoolss,
4120                                 NDR_SPOOLSS_SCHEDULEJOB,
4121                                 &r);
4122
4123         if (!NT_STATUS_IS_OK(status)) {
4124                 return status;
4125         }
4126
4127         if (NT_STATUS_IS_ERR(status)) {
4128                 return status;
4129         }
4130
4131         /* Return variables */
4132
4133         /* Return result */
4134         if (werror) {
4135                 *werror = r.out.result;
4136         }
4137
4138         return werror_to_ntstatus(r.out.result);
4139 }
4140
4141 struct rpccli_spoolss_GetPrinterData_state {
4142         struct spoolss_GetPrinterData orig;
4143         struct spoolss_GetPrinterData tmp;
4144         TALLOC_CTX *out_mem_ctx;
4145         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4146 };
4147
4148 static void rpccli_spoolss_GetPrinterData_done(struct tevent_req *subreq);
4149
4150 struct tevent_req *rpccli_spoolss_GetPrinterData_send(TALLOC_CTX *mem_ctx,
4151                                                       struct tevent_context *ev,
4152                                                       struct rpc_pipe_client *cli,
4153                                                       struct policy_handle *_handle /* [in] [ref] */,
4154                                                       const char *_value_name /* [in] [charset(UTF16)] */,
4155                                                       enum winreg_Type *_type /* [out] [ref] */,
4156                                                       uint8_t *_data /* [out] [ref,size_is(offered)] */,
4157                                                       uint32_t _offered /* [in]  */,
4158                                                       uint32_t *_needed /* [out] [ref] */)
4159 {
4160         struct tevent_req *req;
4161         struct rpccli_spoolss_GetPrinterData_state *state;
4162         struct tevent_req *subreq;
4163
4164         req = tevent_req_create(mem_ctx, &state,
4165                                 struct rpccli_spoolss_GetPrinterData_state);
4166         if (req == NULL) {
4167                 return NULL;
4168         }
4169         state->out_mem_ctx = NULL;
4170         state->dispatch_recv = cli->dispatch_recv;
4171
4172         /* In parameters */
4173         state->orig.in.handle = _handle;
4174         state->orig.in.value_name = _value_name;
4175         state->orig.in.offered = _offered;
4176
4177         /* Out parameters */
4178         state->orig.out.type = _type;
4179         state->orig.out.data = _data;
4180         state->orig.out.needed = _needed;
4181
4182         /* Result */
4183         ZERO_STRUCT(state->orig.out.result);
4184
4185         state->out_mem_ctx = talloc_named_const(state, 0,
4186                              "rpccli_spoolss_GetPrinterData_out_memory");
4187         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4188                 return tevent_req_post(req, ev);
4189         }
4190
4191         /* make a temporary copy, that we pass to the dispatch function */
4192         state->tmp = state->orig;
4193
4194         subreq = cli->dispatch_send(state, ev, cli,
4195                                     &ndr_table_spoolss,
4196                                     NDR_SPOOLSS_GETPRINTERDATA,
4197                                     &state->tmp);
4198         if (tevent_req_nomem(subreq, req)) {
4199                 return tevent_req_post(req, ev);
4200         }
4201         tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterData_done, req);
4202         return req;
4203 }
4204
4205 static void rpccli_spoolss_GetPrinterData_done(struct tevent_req *subreq)
4206 {
4207         struct tevent_req *req = tevent_req_callback_data(
4208                 subreq, struct tevent_req);
4209         struct rpccli_spoolss_GetPrinterData_state *state = tevent_req_data(
4210                 req, struct rpccli_spoolss_GetPrinterData_state);
4211         NTSTATUS status;
4212         TALLOC_CTX *mem_ctx;
4213
4214         if (state->out_mem_ctx) {
4215                 mem_ctx = state->out_mem_ctx;
4216         } else {
4217                 mem_ctx = state;
4218         }
4219
4220         status = state->dispatch_recv(subreq, mem_ctx);
4221         TALLOC_FREE(subreq);
4222         if (!NT_STATUS_IS_OK(status)) {
4223                 tevent_req_nterror(req, status);
4224                 return;
4225         }
4226
4227         /* Copy out parameters */
4228         *state->orig.out.type = *state->tmp.out.type;
4229         memcpy(state->orig.out.data, state->tmp.out.data, (state->tmp.in.offered) * sizeof(*state->orig.out.data));
4230         *state->orig.out.needed = *state->tmp.out.needed;
4231
4232         /* Copy result */
4233         state->orig.out.result = state->tmp.out.result;
4234
4235         /* Reset temporary structure */
4236         ZERO_STRUCT(state->tmp);
4237
4238         tevent_req_done(req);
4239 }
4240
4241 NTSTATUS rpccli_spoolss_GetPrinterData_recv(struct tevent_req *req,
4242                                             TALLOC_CTX *mem_ctx,
4243                                             WERROR *result)
4244 {
4245         struct rpccli_spoolss_GetPrinterData_state *state = tevent_req_data(
4246                 req, struct rpccli_spoolss_GetPrinterData_state);
4247         NTSTATUS status;
4248
4249         if (tevent_req_is_nterror(req, &status)) {
4250                 tevent_req_received(req);
4251                 return status;
4252         }
4253
4254         /* Steal possbile out parameters to the callers context */
4255         talloc_steal(mem_ctx, state->out_mem_ctx);
4256
4257         /* Return result */
4258         *result = state->orig.out.result;
4259
4260         tevent_req_received(req);
4261         return NT_STATUS_OK;
4262 }
4263
4264 NTSTATUS rpccli_spoolss_GetPrinterData(struct rpc_pipe_client *cli,
4265                                        TALLOC_CTX *mem_ctx,
4266                                        struct policy_handle *handle /* [in] [ref] */,
4267                                        const char *value_name /* [in] [charset(UTF16)] */,
4268                                        enum winreg_Type *type /* [out] [ref] */,
4269                                        uint8_t *data /* [out] [ref,size_is(offered)] */,
4270                                        uint32_t offered /* [in]  */,
4271                                        uint32_t *needed /* [out] [ref] */,
4272                                        WERROR *werror)
4273 {
4274         struct spoolss_GetPrinterData r;
4275         NTSTATUS status;
4276
4277         /* In parameters */
4278         r.in.handle = handle;
4279         r.in.value_name = value_name;
4280         r.in.offered = offered;
4281
4282         status = cli->dispatch(cli,
4283                                 mem_ctx,
4284                                 &ndr_table_spoolss,
4285                                 NDR_SPOOLSS_GETPRINTERDATA,
4286                                 &r);
4287
4288         if (!NT_STATUS_IS_OK(status)) {
4289                 return status;
4290         }
4291
4292         if (NT_STATUS_IS_ERR(status)) {
4293                 return status;
4294         }
4295
4296         /* Return variables */
4297         *type = *r.out.type;
4298         memcpy(data, r.out.data, (r.in.offered) * sizeof(*data));
4299         *needed = *r.out.needed;
4300
4301         /* Return result */
4302         if (werror) {
4303                 *werror = r.out.result;
4304         }
4305
4306         return werror_to_ntstatus(r.out.result);
4307 }
4308
4309 struct rpccli_spoolss_SetPrinterData_state {
4310         struct spoolss_SetPrinterData orig;
4311         struct spoolss_SetPrinterData tmp;
4312         TALLOC_CTX *out_mem_ctx;
4313         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4314 };
4315
4316 static void rpccli_spoolss_SetPrinterData_done(struct tevent_req *subreq);
4317
4318 struct tevent_req *rpccli_spoolss_SetPrinterData_send(TALLOC_CTX *mem_ctx,
4319                                                       struct tevent_context *ev,
4320                                                       struct rpc_pipe_client *cli,
4321                                                       struct policy_handle *_handle /* [in] [ref] */,
4322                                                       const char *_value_name /* [in] [charset(UTF16)] */,
4323                                                       enum winreg_Type _type /* [in]  */,
4324                                                       uint8_t *_data /* [in] [ref,size_is(offered)] */,
4325                                                       uint32_t _offered /* [in]  */)
4326 {
4327         struct tevent_req *req;
4328         struct rpccli_spoolss_SetPrinterData_state *state;
4329         struct tevent_req *subreq;
4330
4331         req = tevent_req_create(mem_ctx, &state,
4332                                 struct rpccli_spoolss_SetPrinterData_state);
4333         if (req == NULL) {
4334                 return NULL;
4335         }
4336         state->out_mem_ctx = NULL;
4337         state->dispatch_recv = cli->dispatch_recv;
4338
4339         /* In parameters */
4340         state->orig.in.handle = _handle;
4341         state->orig.in.value_name = _value_name;
4342         state->orig.in.type = _type;
4343         state->orig.in.data = _data;
4344         state->orig.in.offered = _offered;
4345
4346         /* Out parameters */
4347
4348         /* Result */
4349         ZERO_STRUCT(state->orig.out.result);
4350
4351         /* make a temporary copy, that we pass to the dispatch function */
4352         state->tmp = state->orig;
4353
4354         subreq = cli->dispatch_send(state, ev, cli,
4355                                     &ndr_table_spoolss,
4356                                     NDR_SPOOLSS_SETPRINTERDATA,
4357                                     &state->tmp);
4358         if (tevent_req_nomem(subreq, req)) {
4359                 return tevent_req_post(req, ev);
4360         }
4361         tevent_req_set_callback(subreq, rpccli_spoolss_SetPrinterData_done, req);
4362         return req;
4363 }
4364
4365 static void rpccli_spoolss_SetPrinterData_done(struct tevent_req *subreq)
4366 {
4367         struct tevent_req *req = tevent_req_callback_data(
4368                 subreq, struct tevent_req);
4369         struct rpccli_spoolss_SetPrinterData_state *state = tevent_req_data(
4370                 req, struct rpccli_spoolss_SetPrinterData_state);
4371         NTSTATUS status;
4372         TALLOC_CTX *mem_ctx;
4373
4374         if (state->out_mem_ctx) {
4375                 mem_ctx = state->out_mem_ctx;
4376         } else {
4377                 mem_ctx = state;
4378         }
4379
4380         status = state->dispatch_recv(subreq, mem_ctx);
4381         TALLOC_FREE(subreq);
4382         if (!NT_STATUS_IS_OK(status)) {
4383                 tevent_req_nterror(req, status);
4384                 return;
4385         }
4386
4387         /* Copy out parameters */
4388
4389         /* Copy result */
4390         state->orig.out.result = state->tmp.out.result;
4391
4392         /* Reset temporary structure */
4393         ZERO_STRUCT(state->tmp);
4394
4395         tevent_req_done(req);
4396 }
4397
4398 NTSTATUS rpccli_spoolss_SetPrinterData_recv(struct tevent_req *req,
4399                                             TALLOC_CTX *mem_ctx,
4400                                             WERROR *result)
4401 {
4402         struct rpccli_spoolss_SetPrinterData_state *state = tevent_req_data(
4403                 req, struct rpccli_spoolss_SetPrinterData_state);
4404         NTSTATUS status;
4405
4406         if (tevent_req_is_nterror(req, &status)) {
4407                 tevent_req_received(req);
4408                 return status;
4409         }
4410
4411         /* Steal possbile out parameters to the callers context */
4412         talloc_steal(mem_ctx, state->out_mem_ctx);
4413
4414         /* Return result */
4415         *result = state->orig.out.result;
4416
4417         tevent_req_received(req);
4418         return NT_STATUS_OK;
4419 }
4420
4421 NTSTATUS rpccli_spoolss_SetPrinterData(struct rpc_pipe_client *cli,
4422                                        TALLOC_CTX *mem_ctx,
4423                                        struct policy_handle *handle /* [in] [ref] */,
4424                                        const char *value_name /* [in] [charset(UTF16)] */,
4425                                        enum winreg_Type type /* [in]  */,
4426                                        uint8_t *data /* [in] [ref,size_is(offered)] */,
4427                                        uint32_t offered /* [in]  */,
4428                                        WERROR *werror)
4429 {
4430         struct spoolss_SetPrinterData r;
4431         NTSTATUS status;
4432
4433         /* In parameters */
4434         r.in.handle = handle;
4435         r.in.value_name = value_name;
4436         r.in.type = type;
4437         r.in.data = data;
4438         r.in.offered = offered;
4439
4440         status = cli->dispatch(cli,
4441                                 mem_ctx,
4442                                 &ndr_table_spoolss,
4443                                 NDR_SPOOLSS_SETPRINTERDATA,
4444                                 &r);
4445
4446         if (!NT_STATUS_IS_OK(status)) {
4447                 return status;
4448         }
4449
4450         if (NT_STATUS_IS_ERR(status)) {
4451                 return status;
4452         }
4453
4454         /* Return variables */
4455
4456         /* Return result */
4457         if (werror) {
4458                 *werror = r.out.result;
4459         }
4460
4461         return werror_to_ntstatus(r.out.result);
4462 }
4463
4464 struct rpccli_spoolss_WaitForPrinterChange_state {
4465         struct spoolss_WaitForPrinterChange orig;
4466         struct spoolss_WaitForPrinterChange tmp;
4467         TALLOC_CTX *out_mem_ctx;
4468         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4469 };
4470
4471 static void rpccli_spoolss_WaitForPrinterChange_done(struct tevent_req *subreq);
4472
4473 struct tevent_req *rpccli_spoolss_WaitForPrinterChange_send(TALLOC_CTX *mem_ctx,
4474                                                             struct tevent_context *ev,
4475                                                             struct rpc_pipe_client *cli)
4476 {
4477         struct tevent_req *req;
4478         struct rpccli_spoolss_WaitForPrinterChange_state *state;
4479         struct tevent_req *subreq;
4480
4481         req = tevent_req_create(mem_ctx, &state,
4482                                 struct rpccli_spoolss_WaitForPrinterChange_state);
4483         if (req == NULL) {
4484                 return NULL;
4485         }
4486         state->out_mem_ctx = NULL;
4487         state->dispatch_recv = cli->dispatch_recv;
4488
4489         /* In parameters */
4490
4491         /* Out parameters */
4492
4493         /* Result */
4494         ZERO_STRUCT(state->orig.out.result);
4495
4496         /* make a temporary copy, that we pass to the dispatch function */
4497         state->tmp = state->orig;
4498
4499         subreq = cli->dispatch_send(state, ev, cli,
4500                                     &ndr_table_spoolss,
4501                                     NDR_SPOOLSS_WAITFORPRINTERCHANGE,
4502                                     &state->tmp);
4503         if (tevent_req_nomem(subreq, req)) {
4504                 return tevent_req_post(req, ev);
4505         }
4506         tevent_req_set_callback(subreq, rpccli_spoolss_WaitForPrinterChange_done, req);
4507         return req;
4508 }
4509
4510 static void rpccli_spoolss_WaitForPrinterChange_done(struct tevent_req *subreq)
4511 {
4512         struct tevent_req *req = tevent_req_callback_data(
4513                 subreq, struct tevent_req);
4514         struct rpccli_spoolss_WaitForPrinterChange_state *state = tevent_req_data(
4515                 req, struct rpccli_spoolss_WaitForPrinterChange_state);
4516         NTSTATUS status;
4517         TALLOC_CTX *mem_ctx;
4518
4519         if (state->out_mem_ctx) {
4520                 mem_ctx = state->out_mem_ctx;
4521         } else {
4522                 mem_ctx = state;
4523         }
4524
4525         status = state->dispatch_recv(subreq, mem_ctx);
4526         TALLOC_FREE(subreq);
4527         if (!NT_STATUS_IS_OK(status)) {
4528                 tevent_req_nterror(req, status);
4529                 return;
4530         }
4531
4532         /* Copy out parameters */
4533
4534         /* Copy result */
4535         state->orig.out.result = state->tmp.out.result;
4536
4537         /* Reset temporary structure */
4538         ZERO_STRUCT(state->tmp);
4539
4540         tevent_req_done(req);
4541 }
4542
4543 NTSTATUS rpccli_spoolss_WaitForPrinterChange_recv(struct tevent_req *req,
4544                                                   TALLOC_CTX *mem_ctx,
4545                                                   WERROR *result)
4546 {
4547         struct rpccli_spoolss_WaitForPrinterChange_state *state = tevent_req_data(
4548                 req, struct rpccli_spoolss_WaitForPrinterChange_state);
4549         NTSTATUS status;
4550
4551         if (tevent_req_is_nterror(req, &status)) {
4552                 tevent_req_received(req);
4553                 return status;
4554         }
4555
4556         /* Steal possbile out parameters to the callers context */
4557         talloc_steal(mem_ctx, state->out_mem_ctx);
4558
4559         /* Return result */
4560         *result = state->orig.out.result;
4561
4562         tevent_req_received(req);
4563         return NT_STATUS_OK;
4564 }
4565
4566 NTSTATUS rpccli_spoolss_WaitForPrinterChange(struct rpc_pipe_client *cli,
4567                                              TALLOC_CTX *mem_ctx,
4568                                              WERROR *werror)
4569 {
4570         struct spoolss_WaitForPrinterChange r;
4571         NTSTATUS status;
4572
4573         /* In parameters */
4574
4575         status = cli->dispatch(cli,
4576                                 mem_ctx,
4577                                 &ndr_table_spoolss,
4578                                 NDR_SPOOLSS_WAITFORPRINTERCHANGE,
4579                                 &r);
4580
4581         if (!NT_STATUS_IS_OK(status)) {
4582                 return status;
4583         }
4584
4585         if (NT_STATUS_IS_ERR(status)) {
4586                 return status;
4587         }
4588
4589         /* Return variables */
4590
4591         /* Return result */
4592         if (werror) {
4593                 *werror = r.out.result;
4594         }
4595
4596         return werror_to_ntstatus(r.out.result);
4597 }
4598
4599 struct rpccli_spoolss_ClosePrinter_state {
4600         struct spoolss_ClosePrinter orig;
4601         struct spoolss_ClosePrinter tmp;
4602         TALLOC_CTX *out_mem_ctx;
4603         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4604 };
4605
4606 static void rpccli_spoolss_ClosePrinter_done(struct tevent_req *subreq);
4607
4608 struct tevent_req *rpccli_spoolss_ClosePrinter_send(TALLOC_CTX *mem_ctx,
4609                                                     struct tevent_context *ev,
4610                                                     struct rpc_pipe_client *cli,
4611                                                     struct policy_handle *_handle /* [in,out] [ref] */)
4612 {
4613         struct tevent_req *req;
4614         struct rpccli_spoolss_ClosePrinter_state *state;
4615         struct tevent_req *subreq;
4616
4617         req = tevent_req_create(mem_ctx, &state,
4618                                 struct rpccli_spoolss_ClosePrinter_state);
4619         if (req == NULL) {
4620                 return NULL;
4621         }
4622         state->out_mem_ctx = NULL;
4623         state->dispatch_recv = cli->dispatch_recv;
4624
4625         /* In parameters */
4626         state->orig.in.handle = _handle;
4627
4628         /* Out parameters */
4629         state->orig.out.handle = _handle;
4630
4631         /* Result */
4632         ZERO_STRUCT(state->orig.out.result);
4633
4634         state->out_mem_ctx = talloc_named_const(state, 0,
4635                              "rpccli_spoolss_ClosePrinter_out_memory");
4636         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4637                 return tevent_req_post(req, ev);
4638         }
4639
4640         /* make a temporary copy, that we pass to the dispatch function */
4641         state->tmp = state->orig;
4642
4643         subreq = cli->dispatch_send(state, ev, cli,
4644                                     &ndr_table_spoolss,
4645                                     NDR_SPOOLSS_CLOSEPRINTER,
4646                                     &state->tmp);
4647         if (tevent_req_nomem(subreq, req)) {
4648                 return tevent_req_post(req, ev);
4649         }
4650         tevent_req_set_callback(subreq, rpccli_spoolss_ClosePrinter_done, req);
4651         return req;
4652 }
4653
4654 static void rpccli_spoolss_ClosePrinter_done(struct tevent_req *subreq)
4655 {
4656         struct tevent_req *req = tevent_req_callback_data(
4657                 subreq, struct tevent_req);
4658         struct rpccli_spoolss_ClosePrinter_state *state = tevent_req_data(
4659                 req, struct rpccli_spoolss_ClosePrinter_state);
4660         NTSTATUS status;
4661         TALLOC_CTX *mem_ctx;
4662
4663         if (state->out_mem_ctx) {
4664                 mem_ctx = state->out_mem_ctx;
4665         } else {
4666                 mem_ctx = state;
4667         }
4668
4669         status = state->dispatch_recv(subreq, mem_ctx);
4670         TALLOC_FREE(subreq);
4671         if (!NT_STATUS_IS_OK(status)) {
4672                 tevent_req_nterror(req, status);
4673                 return;
4674         }
4675
4676         /* Copy out parameters */
4677         *state->orig.out.handle = *state->tmp.out.handle;
4678
4679         /* Copy result */
4680         state->orig.out.result = state->tmp.out.result;
4681
4682         /* Reset temporary structure */
4683         ZERO_STRUCT(state->tmp);
4684
4685         tevent_req_done(req);
4686 }
4687
4688 NTSTATUS rpccli_spoolss_ClosePrinter_recv(struct tevent_req *req,
4689                                           TALLOC_CTX *mem_ctx,
4690                                           WERROR *result)
4691 {
4692         struct rpccli_spoolss_ClosePrinter_state *state = tevent_req_data(
4693                 req, struct rpccli_spoolss_ClosePrinter_state);
4694         NTSTATUS status;
4695
4696         if (tevent_req_is_nterror(req, &status)) {
4697                 tevent_req_received(req);
4698                 return status;
4699         }
4700
4701         /* Steal possbile out parameters to the callers context */
4702         talloc_steal(mem_ctx, state->out_mem_ctx);
4703
4704         /* Return result */
4705         *result = state->orig.out.result;
4706
4707         tevent_req_received(req);
4708         return NT_STATUS_OK;
4709 }
4710
4711 NTSTATUS rpccli_spoolss_ClosePrinter(struct rpc_pipe_client *cli,
4712                                      TALLOC_CTX *mem_ctx,
4713                                      struct policy_handle *handle /* [in,out] [ref] */,
4714                                      WERROR *werror)
4715 {
4716         struct spoolss_ClosePrinter r;
4717         NTSTATUS status;
4718
4719         /* In parameters */
4720         r.in.handle = handle;
4721
4722         status = cli->dispatch(cli,
4723                                 mem_ctx,
4724                                 &ndr_table_spoolss,
4725                                 NDR_SPOOLSS_CLOSEPRINTER,
4726                                 &r);
4727
4728         if (!NT_STATUS_IS_OK(status)) {
4729                 return status;
4730         }
4731
4732         if (NT_STATUS_IS_ERR(status)) {
4733                 return status;
4734         }
4735
4736         /* Return variables */
4737         *handle = *r.out.handle;
4738
4739         /* Return result */
4740         if (werror) {
4741                 *werror = r.out.result;
4742         }
4743
4744         return werror_to_ntstatus(r.out.result);
4745 }
4746
4747 struct rpccli_spoolss_AddForm_state {
4748         struct spoolss_AddForm orig;
4749         struct spoolss_AddForm tmp;
4750         TALLOC_CTX *out_mem_ctx;
4751         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4752 };
4753
4754 static void rpccli_spoolss_AddForm_done(struct tevent_req *subreq);
4755
4756 struct tevent_req *rpccli_spoolss_AddForm_send(TALLOC_CTX *mem_ctx,
4757                                                struct tevent_context *ev,
4758                                                struct rpc_pipe_client *cli,
4759                                                struct policy_handle *_handle /* [in] [ref] */,
4760                                                uint32_t _level /* [in]  */,
4761                                                union spoolss_AddFormInfo _info /* [in] [switch_is(level)] */)
4762 {
4763         struct tevent_req *req;
4764         struct rpccli_spoolss_AddForm_state *state;
4765         struct tevent_req *subreq;
4766
4767         req = tevent_req_create(mem_ctx, &state,
4768                                 struct rpccli_spoolss_AddForm_state);
4769         if (req == NULL) {
4770                 return NULL;
4771         }
4772         state->out_mem_ctx = NULL;
4773         state->dispatch_recv = cli->dispatch_recv;
4774
4775         /* In parameters */
4776         state->orig.in.handle = _handle;
4777         state->orig.in.level = _level;
4778         state->orig.in.info = _info;
4779
4780         /* Out parameters */
4781
4782         /* Result */
4783         ZERO_STRUCT(state->orig.out.result);
4784
4785         /* make a temporary copy, that we pass to the dispatch function */
4786         state->tmp = state->orig;
4787
4788         subreq = cli->dispatch_send(state, ev, cli,
4789                                     &ndr_table_spoolss,
4790                                     NDR_SPOOLSS_ADDFORM,
4791                                     &state->tmp);
4792         if (tevent_req_nomem(subreq, req)) {
4793                 return tevent_req_post(req, ev);
4794         }
4795         tevent_req_set_callback(subreq, rpccli_spoolss_AddForm_done, req);
4796         return req;
4797 }
4798
4799 static void rpccli_spoolss_AddForm_done(struct tevent_req *subreq)
4800 {
4801         struct tevent_req *req = tevent_req_callback_data(
4802                 subreq, struct tevent_req);
4803         struct rpccli_spoolss_AddForm_state *state = tevent_req_data(
4804                 req, struct rpccli_spoolss_AddForm_state);
4805         NTSTATUS status;
4806         TALLOC_CTX *mem_ctx;
4807
4808         if (state->out_mem_ctx) {
4809                 mem_ctx = state->out_mem_ctx;
4810         } else {
4811                 mem_ctx = state;
4812         }
4813
4814         status = state->dispatch_recv(subreq, mem_ctx);
4815         TALLOC_FREE(subreq);
4816         if (!NT_STATUS_IS_OK(status)) {
4817                 tevent_req_nterror(req, status);
4818                 return;
4819         }
4820
4821         /* Copy out parameters */
4822
4823         /* Copy result */
4824         state->orig.out.result = state->tmp.out.result;
4825
4826         /* Reset temporary structure */
4827         ZERO_STRUCT(state->tmp);
4828
4829         tevent_req_done(req);
4830 }
4831
4832 NTSTATUS rpccli_spoolss_AddForm_recv(struct tevent_req *req,
4833                                      TALLOC_CTX *mem_ctx,
4834                                      WERROR *result)
4835 {
4836         struct rpccli_spoolss_AddForm_state *state = tevent_req_data(
4837                 req, struct rpccli_spoolss_AddForm_state);
4838         NTSTATUS status;
4839
4840         if (tevent_req_is_nterror(req, &status)) {
4841                 tevent_req_received(req);
4842                 return status;
4843         }
4844
4845         /* Steal possbile out parameters to the callers context */
4846         talloc_steal(mem_ctx, state->out_mem_ctx);
4847
4848         /* Return result */
4849         *result = state->orig.out.result;
4850
4851         tevent_req_received(req);
4852         return NT_STATUS_OK;
4853 }
4854
4855 NTSTATUS rpccli_spoolss_AddForm(struct rpc_pipe_client *cli,
4856                                 TALLOC_CTX *mem_ctx,
4857                                 struct policy_handle *handle /* [in] [ref] */,
4858                                 uint32_t level /* [in]  */,
4859                                 union spoolss_AddFormInfo info /* [in] [switch_is(level)] */,
4860                                 WERROR *werror)
4861 {
4862         struct spoolss_AddForm r;
4863         NTSTATUS status;
4864
4865         /* In parameters */
4866         r.in.handle = handle;
4867         r.in.level = level;
4868         r.in.info = info;
4869
4870         status = cli->dispatch(cli,
4871                                 mem_ctx,
4872                                 &ndr_table_spoolss,
4873                                 NDR_SPOOLSS_ADDFORM,
4874                                 &r);
4875
4876         if (!NT_STATUS_IS_OK(status)) {
4877                 return status;
4878         }
4879
4880         if (NT_STATUS_IS_ERR(status)) {
4881                 return status;
4882         }
4883
4884         /* Return variables */
4885
4886         /* Return result */
4887         if (werror) {
4888                 *werror = r.out.result;
4889         }
4890
4891         return werror_to_ntstatus(r.out.result);
4892 }
4893
4894 struct rpccli_spoolss_DeleteForm_state {
4895         struct spoolss_DeleteForm orig;
4896         struct spoolss_DeleteForm tmp;
4897         TALLOC_CTX *out_mem_ctx;
4898         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4899 };
4900
4901 static void rpccli_spoolss_DeleteForm_done(struct tevent_req *subreq);
4902
4903 struct tevent_req *rpccli_spoolss_DeleteForm_send(TALLOC_CTX *mem_ctx,
4904                                                   struct tevent_context *ev,
4905                                                   struct rpc_pipe_client *cli,
4906                                                   struct policy_handle *_handle /* [in] [ref] */,
4907                                                   const char *_form_name /* [in] [charset(UTF16)] */)
4908 {
4909         struct tevent_req *req;
4910         struct rpccli_spoolss_DeleteForm_state *state;
4911         struct tevent_req *subreq;
4912
4913         req = tevent_req_create(mem_ctx, &state,
4914                                 struct rpccli_spoolss_DeleteForm_state);
4915         if (req == NULL) {
4916                 return NULL;
4917         }
4918         state->out_mem_ctx = NULL;
4919         state->dispatch_recv = cli->dispatch_recv;
4920
4921         /* In parameters */
4922         state->orig.in.handle = _handle;
4923         state->orig.in.form_name = _form_name;
4924
4925         /* Out parameters */
4926
4927         /* Result */
4928         ZERO_STRUCT(state->orig.out.result);
4929
4930         /* make a temporary copy, that we pass to the dispatch function */
4931         state->tmp = state->orig;
4932
4933         subreq = cli->dispatch_send(state, ev, cli,
4934                                     &ndr_table_spoolss,
4935                                     NDR_SPOOLSS_DELETEFORM,
4936                                     &state->tmp);
4937         if (tevent_req_nomem(subreq, req)) {
4938                 return tevent_req_post(req, ev);
4939         }
4940         tevent_req_set_callback(subreq, rpccli_spoolss_DeleteForm_done, req);
4941         return req;
4942 }
4943
4944 static void rpccli_spoolss_DeleteForm_done(struct tevent_req *subreq)
4945 {
4946         struct tevent_req *req = tevent_req_callback_data(
4947                 subreq, struct tevent_req);
4948         struct rpccli_spoolss_DeleteForm_state *state = tevent_req_data(
4949                 req, struct rpccli_spoolss_DeleteForm_state);
4950         NTSTATUS status;
4951         TALLOC_CTX *mem_ctx;
4952
4953         if (state->out_mem_ctx) {
4954                 mem_ctx = state->out_mem_ctx;
4955         } else {
4956                 mem_ctx = state;
4957         }
4958
4959         status = state->dispatch_recv(subreq, mem_ctx);
4960         TALLOC_FREE(subreq);
4961         if (!NT_STATUS_IS_OK(status)) {
4962                 tevent_req_nterror(req, status);
4963                 return;
4964         }
4965
4966         /* Copy out parameters */
4967
4968         /* Copy result */
4969         state->orig.out.result = state->tmp.out.result;
4970
4971         /* Reset temporary structure */
4972         ZERO_STRUCT(state->tmp);
4973
4974         tevent_req_done(req);
4975 }
4976
4977 NTSTATUS rpccli_spoolss_DeleteForm_recv(struct tevent_req *req,
4978                                         TALLOC_CTX *mem_ctx,
4979                                         WERROR *result)
4980 {
4981         struct rpccli_spoolss_DeleteForm_state *state = tevent_req_data(
4982                 req, struct rpccli_spoolss_DeleteForm_state);
4983         NTSTATUS status;
4984
4985         if (tevent_req_is_nterror(req, &status)) {
4986                 tevent_req_received(req);
4987                 return status;
4988         }
4989
4990         /* Steal possbile out parameters to the callers context */
4991         talloc_steal(mem_ctx, state->out_mem_ctx);
4992
4993         /* Return result */
4994         *result = state->orig.out.result;
4995
4996         tevent_req_received(req);
4997         return NT_STATUS_OK;
4998 }
4999
5000 NTSTATUS rpccli_spoolss_DeleteForm(struct rpc_pipe_client *cli,
5001                                    TALLOC_CTX *mem_ctx,
5002                                    struct policy_handle *handle /* [in] [ref] */,
5003                                    const char *form_name /* [in] [charset(UTF16)] */,
5004                                    WERROR *werror)
5005 {
5006         struct spoolss_DeleteForm r;
5007         NTSTATUS status;
5008
5009         /* In parameters */
5010         r.in.handle = handle;
5011         r.in.form_name = form_name;
5012
5013         status = cli->dispatch(cli,
5014                                 mem_ctx,
5015                                 &ndr_table_spoolss,
5016                                 NDR_SPOOLSS_DELETEFORM,
5017                                 &r);
5018
5019         if (!NT_STATUS_IS_OK(status)) {
5020                 return status;
5021         }
5022
5023         if (NT_STATUS_IS_ERR(status)) {
5024                 return status;
5025         }
5026
5027         /* Return variables */
5028
5029         /* Return result */
5030         if (werror) {
5031                 *werror = r.out.result;
5032         }
5033
5034         return werror_to_ntstatus(r.out.result);
5035 }
5036
5037 struct rpccli_spoolss_GetForm_state {
5038         struct spoolss_GetForm orig;
5039         struct spoolss_GetForm tmp;
5040         TALLOC_CTX *out_mem_ctx;
5041         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5042 };
5043
5044 static void rpccli_spoolss_GetForm_done(struct tevent_req *subreq);
5045
5046 struct tevent_req *rpccli_spoolss_GetForm_send(TALLOC_CTX *mem_ctx,
5047                                                struct tevent_context *ev,
5048                                                struct rpc_pipe_client *cli,
5049                                                struct policy_handle *_handle /* [in] [ref] */,
5050                                                const char *_form_name /* [in] [charset(UTF16)] */,
5051                                                uint32_t _level /* [in]  */,
5052                                                DATA_BLOB *_buffer /* [in] [unique] */,
5053                                                uint32_t _offered /* [in]  */,
5054                                                union spoolss_FormInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
5055                                                uint32_t *_needed /* [out] [ref] */)
5056 {
5057         struct tevent_req *req;
5058         struct rpccli_spoolss_GetForm_state *state;
5059         struct tevent_req *subreq;
5060
5061         req = tevent_req_create(mem_ctx, &state,
5062                                 struct rpccli_spoolss_GetForm_state);
5063         if (req == NULL) {
5064                 return NULL;
5065         }
5066         state->out_mem_ctx = NULL;
5067         state->dispatch_recv = cli->dispatch_recv;
5068
5069         /* In parameters */
5070         state->orig.in.handle = _handle;
5071         state->orig.in.form_name = _form_name;
5072         state->orig.in.level = _level;
5073         state->orig.in.buffer = _buffer;
5074         state->orig.in.offered = _offered;
5075
5076         /* Out parameters */
5077         state->orig.out.info = _info;
5078         state->orig.out.needed = _needed;
5079
5080         /* Result */
5081         ZERO_STRUCT(state->orig.out.result);
5082
5083         state->out_mem_ctx = talloc_named_const(state, 0,
5084                              "rpccli_spoolss_GetForm_out_memory");
5085         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5086                 return tevent_req_post(req, ev);
5087         }
5088
5089         /* make a temporary copy, that we pass to the dispatch function */
5090         state->tmp = state->orig;
5091
5092         subreq = cli->dispatch_send(state, ev, cli,
5093                                     &ndr_table_spoolss,
5094                                     NDR_SPOOLSS_GETFORM,
5095                                     &state->tmp);
5096         if (tevent_req_nomem(subreq, req)) {
5097                 return tevent_req_post(req, ev);
5098         }
5099         tevent_req_set_callback(subreq, rpccli_spoolss_GetForm_done, req);
5100         return req;
5101 }
5102
5103 static void rpccli_spoolss_GetForm_done(struct tevent_req *subreq)
5104 {
5105         struct tevent_req *req = tevent_req_callback_data(
5106                 subreq, struct tevent_req);
5107         struct rpccli_spoolss_GetForm_state *state = tevent_req_data(
5108                 req, struct rpccli_spoolss_GetForm_state);
5109         NTSTATUS status;
5110         TALLOC_CTX *mem_ctx;
5111
5112         if (state->out_mem_ctx) {
5113                 mem_ctx = state->out_mem_ctx;
5114         } else {
5115                 mem_ctx = state;
5116         }
5117
5118         status = state->dispatch_recv(subreq, mem_ctx);
5119         TALLOC_FREE(subreq);
5120         if (!NT_STATUS_IS_OK(status)) {
5121                 tevent_req_nterror(req, status);
5122                 return;
5123         }
5124
5125         /* Copy out parameters */
5126         if (state->orig.out.info && state->tmp.out.info) {
5127                 *state->orig.out.info = *state->tmp.out.info;
5128         }
5129         *state->orig.out.needed = *state->tmp.out.needed;
5130
5131         /* Copy result */
5132         state->orig.out.result = state->tmp.out.result;
5133
5134         /* Reset temporary structure */
5135         ZERO_STRUCT(state->tmp);
5136
5137         tevent_req_done(req);
5138 }
5139
5140 NTSTATUS rpccli_spoolss_GetForm_recv(struct tevent_req *req,
5141                                      TALLOC_CTX *mem_ctx,
5142                                      WERROR *result)
5143 {
5144         struct rpccli_spoolss_GetForm_state *state = tevent_req_data(
5145                 req, struct rpccli_spoolss_GetForm_state);
5146         NTSTATUS status;
5147
5148         if (tevent_req_is_nterror(req, &status)) {
5149                 tevent_req_received(req);
5150                 return status;
5151         }
5152
5153         /* Steal possbile out parameters to the callers context */
5154         talloc_steal(mem_ctx, state->out_mem_ctx);
5155
5156         /* Return result */
5157         *result = state->orig.out.result;
5158
5159         tevent_req_received(req);
5160         return NT_STATUS_OK;
5161 }
5162
5163 NTSTATUS rpccli_spoolss_GetForm(struct rpc_pipe_client *cli,
5164                                 TALLOC_CTX *mem_ctx,
5165                                 struct policy_handle *handle /* [in] [ref] */,
5166                                 const char *form_name /* [in] [charset(UTF16)] */,
5167                                 uint32_t level /* [in]  */,
5168                                 DATA_BLOB *buffer /* [in] [unique] */,
5169                                 uint32_t offered /* [in]  */,
5170                                 union spoolss_FormInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
5171                                 uint32_t *needed /* [out] [ref] */,
5172                                 WERROR *werror)
5173 {
5174         struct spoolss_GetForm r;
5175         NTSTATUS status;
5176
5177         /* In parameters */
5178         r.in.handle = handle;
5179         r.in.form_name = form_name;
5180         r.in.level = level;
5181         r.in.buffer = buffer;
5182         r.in.offered = offered;
5183
5184         status = cli->dispatch(cli,
5185                                 mem_ctx,
5186                                 &ndr_table_spoolss,
5187                                 NDR_SPOOLSS_GETFORM,
5188                                 &r);
5189
5190         if (!NT_STATUS_IS_OK(status)) {
5191                 return status;
5192         }
5193
5194         if (NT_STATUS_IS_ERR(status)) {
5195                 return status;
5196         }
5197
5198         /* Return variables */
5199         if (info && r.out.info) {
5200                 *info = *r.out.info;
5201         }
5202         *needed = *r.out.needed;
5203
5204         /* Return result */
5205         if (werror) {
5206                 *werror = r.out.result;
5207         }
5208
5209         return werror_to_ntstatus(r.out.result);
5210 }
5211
5212 struct rpccli_spoolss_SetForm_state {
5213         struct spoolss_SetForm orig;
5214         struct spoolss_SetForm tmp;
5215         TALLOC_CTX *out_mem_ctx;
5216         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5217 };
5218
5219 static void rpccli_spoolss_SetForm_done(struct tevent_req *subreq);
5220
5221 struct tevent_req *rpccli_spoolss_SetForm_send(TALLOC_CTX *mem_ctx,
5222                                                struct tevent_context *ev,
5223                                                struct rpc_pipe_client *cli,
5224                                                struct policy_handle *_handle /* [in] [ref] */,
5225                                                const char *_form_name /* [in] [charset(UTF16)] */,
5226                                                uint32_t _level /* [in]  */,
5227                                                union spoolss_AddFormInfo _info /* [in] [switch_is(level)] */)
5228 {
5229         struct tevent_req *req;
5230         struct rpccli_spoolss_SetForm_state *state;
5231         struct tevent_req *subreq;
5232
5233         req = tevent_req_create(mem_ctx, &state,
5234                                 struct rpccli_spoolss_SetForm_state);
5235         if (req == NULL) {
5236                 return NULL;
5237         }
5238         state->out_mem_ctx = NULL;
5239         state->dispatch_recv = cli->dispatch_recv;
5240
5241         /* In parameters */
5242         state->orig.in.handle = _handle;
5243         state->orig.in.form_name = _form_name;
5244         state->orig.in.level = _level;
5245         state->orig.in.info = _info;
5246
5247         /* Out parameters */
5248
5249         /* Result */
5250         ZERO_STRUCT(state->orig.out.result);
5251
5252         /* make a temporary copy, that we pass to the dispatch function */
5253         state->tmp = state->orig;
5254
5255         subreq = cli->dispatch_send(state, ev, cli,
5256                                     &ndr_table_spoolss,
5257                                     NDR_SPOOLSS_SETFORM,
5258                                     &state->tmp);
5259         if (tevent_req_nomem(subreq, req)) {
5260                 return tevent_req_post(req, ev);
5261         }
5262         tevent_req_set_callback(subreq, rpccli_spoolss_SetForm_done, req);
5263         return req;
5264 }
5265
5266 static void rpccli_spoolss_SetForm_done(struct tevent_req *subreq)
5267 {
5268         struct tevent_req *req = tevent_req_callback_data(
5269                 subreq, struct tevent_req);
5270         struct rpccli_spoolss_SetForm_state *state = tevent_req_data(
5271                 req, struct rpccli_spoolss_SetForm_state);
5272         NTSTATUS status;
5273         TALLOC_CTX *mem_ctx;
5274
5275         if (state->out_mem_ctx) {
5276                 mem_ctx = state->out_mem_ctx;
5277         } else {
5278                 mem_ctx = state;
5279         }
5280
5281         status = state->dispatch_recv(subreq, mem_ctx);
5282         TALLOC_FREE(subreq);
5283         if (!NT_STATUS_IS_OK(status)) {
5284                 tevent_req_nterror(req, status);
5285                 return;
5286         }
5287
5288         /* Copy out parameters */
5289
5290         /* Copy result */
5291         state->orig.out.result = state->tmp.out.result;
5292
5293         /* Reset temporary structure */
5294         ZERO_STRUCT(state->tmp);
5295
5296         tevent_req_done(req);
5297 }
5298
5299 NTSTATUS rpccli_spoolss_SetForm_recv(struct tevent_req *req,
5300                                      TALLOC_CTX *mem_ctx,
5301                                      WERROR *result)
5302 {
5303         struct rpccli_spoolss_SetForm_state *state = tevent_req_data(
5304                 req, struct rpccli_spoolss_SetForm_state);
5305         NTSTATUS status;
5306
5307         if (tevent_req_is_nterror(req, &status)) {
5308                 tevent_req_received(req);
5309                 return status;
5310         }
5311
5312         /* Steal possbile out parameters to the callers context */
5313         talloc_steal(mem_ctx, state->out_mem_ctx);
5314
5315         /* Return result */
5316         *result = state->orig.out.result;
5317
5318         tevent_req_received(req);
5319         return NT_STATUS_OK;
5320 }
5321
5322 NTSTATUS rpccli_spoolss_SetForm(struct rpc_pipe_client *cli,
5323                                 TALLOC_CTX *mem_ctx,
5324                                 struct policy_handle *handle /* [in] [ref] */,
5325                                 const char *form_name /* [in] [charset(UTF16)] */,
5326                                 uint32_t level /* [in]  */,
5327                                 union spoolss_AddFormInfo info /* [in] [switch_is(level)] */,
5328                                 WERROR *werror)
5329 {
5330         struct spoolss_SetForm r;
5331         NTSTATUS status;
5332
5333         /* In parameters */
5334         r.in.handle = handle;
5335         r.in.form_name = form_name;
5336         r.in.level = level;
5337         r.in.info = info;
5338
5339         status = cli->dispatch(cli,
5340                                 mem_ctx,
5341                                 &ndr_table_spoolss,
5342                                 NDR_SPOOLSS_SETFORM,
5343                                 &r);
5344
5345         if (!NT_STATUS_IS_OK(status)) {
5346                 return status;
5347         }
5348
5349         if (NT_STATUS_IS_ERR(status)) {
5350                 return status;
5351         }
5352
5353         /* Return variables */
5354
5355         /* Return result */
5356         if (werror) {
5357                 *werror = r.out.result;
5358         }
5359
5360         return werror_to_ntstatus(r.out.result);
5361 }
5362
5363 struct rpccli_spoolss_EnumForms_state {
5364         struct spoolss_EnumForms orig;
5365         struct spoolss_EnumForms tmp;
5366         TALLOC_CTX *out_mem_ctx;
5367         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5368 };
5369
5370 static void rpccli_spoolss_EnumForms_done(struct tevent_req *subreq);
5371
5372 struct tevent_req *rpccli_spoolss_EnumForms_send(TALLOC_CTX *mem_ctx,
5373                                                  struct tevent_context *ev,
5374                                                  struct rpc_pipe_client *cli,
5375                                                  struct policy_handle *_handle /* [in] [ref] */,
5376                                                  uint32_t _level /* [in]  */,
5377                                                  DATA_BLOB *_buffer /* [in] [unique] */,
5378                                                  uint32_t _offered /* [in]  */,
5379                                                  uint32_t *_count /* [out] [ref] */,
5380                                                  union spoolss_FormInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5381                                                  uint32_t *_needed /* [out] [ref] */)
5382 {
5383         struct tevent_req *req;
5384         struct rpccli_spoolss_EnumForms_state *state;
5385         struct tevent_req *subreq;
5386
5387         req = tevent_req_create(mem_ctx, &state,
5388                                 struct rpccli_spoolss_EnumForms_state);
5389         if (req == NULL) {
5390                 return NULL;
5391         }
5392         state->out_mem_ctx = NULL;
5393         state->dispatch_recv = cli->dispatch_recv;
5394
5395         /* In parameters */
5396         state->orig.in.handle = _handle;
5397         state->orig.in.level = _level;
5398         state->orig.in.buffer = _buffer;
5399         state->orig.in.offered = _offered;
5400
5401         /* Out parameters */
5402         state->orig.out.count = _count;
5403         state->orig.out.info = _info;
5404         state->orig.out.needed = _needed;
5405
5406         /* Result */
5407         ZERO_STRUCT(state->orig.out.result);
5408
5409         state->out_mem_ctx = talloc_named_const(state, 0,
5410                              "rpccli_spoolss_EnumForms_out_memory");
5411         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5412                 return tevent_req_post(req, ev);
5413         }
5414
5415         /* make a temporary copy, that we pass to the dispatch function */
5416         state->tmp = state->orig;
5417
5418         subreq = cli->dispatch_send(state, ev, cli,
5419                                     &ndr_table_spoolss,
5420                                     NDR_SPOOLSS_ENUMFORMS,
5421                                     &state->tmp);
5422         if (tevent_req_nomem(subreq, req)) {
5423                 return tevent_req_post(req, ev);
5424         }
5425         tevent_req_set_callback(subreq, rpccli_spoolss_EnumForms_done, req);
5426         return req;
5427 }
5428
5429 static void rpccli_spoolss_EnumForms_done(struct tevent_req *subreq)
5430 {
5431         struct tevent_req *req = tevent_req_callback_data(
5432                 subreq, struct tevent_req);
5433         struct rpccli_spoolss_EnumForms_state *state = tevent_req_data(
5434                 req, struct rpccli_spoolss_EnumForms_state);
5435         NTSTATUS status;
5436         TALLOC_CTX *mem_ctx;
5437
5438         if (state->out_mem_ctx) {
5439                 mem_ctx = state->out_mem_ctx;
5440         } else {
5441                 mem_ctx = state;
5442         }
5443
5444         status = state->dispatch_recv(subreq, mem_ctx);
5445         TALLOC_FREE(subreq);
5446         if (!NT_STATUS_IS_OK(status)) {
5447                 tevent_req_nterror(req, status);
5448                 return;
5449         }
5450
5451         /* Copy out parameters */
5452         *state->orig.out.count = *state->tmp.out.count;
5453         *state->orig.out.info = *state->tmp.out.info;
5454         *state->orig.out.needed = *state->tmp.out.needed;
5455
5456         /* Copy result */
5457         state->orig.out.result = state->tmp.out.result;
5458
5459         /* Reset temporary structure */
5460         ZERO_STRUCT(state->tmp);
5461
5462         tevent_req_done(req);
5463 }
5464
5465 NTSTATUS rpccli_spoolss_EnumForms_recv(struct tevent_req *req,
5466                                        TALLOC_CTX *mem_ctx,
5467                                        WERROR *result)
5468 {
5469         struct rpccli_spoolss_EnumForms_state *state = tevent_req_data(
5470                 req, struct rpccli_spoolss_EnumForms_state);
5471         NTSTATUS status;
5472
5473         if (tevent_req_is_nterror(req, &status)) {
5474                 tevent_req_received(req);
5475                 return status;
5476         }
5477
5478         /* Steal possbile out parameters to the callers context */
5479         talloc_steal(mem_ctx, state->out_mem_ctx);
5480
5481         /* Return result */
5482         *result = state->orig.out.result;
5483
5484         tevent_req_received(req);
5485         return NT_STATUS_OK;
5486 }
5487
5488 NTSTATUS rpccli_spoolss_EnumForms(struct rpc_pipe_client *cli,
5489                                   TALLOC_CTX *mem_ctx,
5490                                   struct policy_handle *handle /* [in] [ref] */,
5491                                   uint32_t level /* [in]  */,
5492                                   DATA_BLOB *buffer /* [in] [unique] */,
5493                                   uint32_t offered /* [in]  */,
5494                                   uint32_t *count /* [out] [ref] */,
5495                                   union spoolss_FormInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5496                                   uint32_t *needed /* [out] [ref] */,
5497                                   WERROR *werror)
5498 {
5499         struct spoolss_EnumForms r;
5500         NTSTATUS status;
5501
5502         /* In parameters */
5503         r.in.handle = handle;
5504         r.in.level = level;
5505         r.in.buffer = buffer;
5506         r.in.offered = offered;
5507
5508         status = cli->dispatch(cli,
5509                                 mem_ctx,
5510                                 &ndr_table_spoolss,
5511                                 NDR_SPOOLSS_ENUMFORMS,
5512                                 &r);
5513
5514         if (!NT_STATUS_IS_OK(status)) {
5515                 return status;
5516         }
5517
5518         if (NT_STATUS_IS_ERR(status)) {
5519                 return status;
5520         }
5521
5522         /* Return variables */
5523         *count = *r.out.count;
5524         *info = *r.out.info;
5525         *needed = *r.out.needed;
5526
5527         /* Return result */
5528         if (werror) {
5529                 *werror = r.out.result;
5530         }
5531
5532         return werror_to_ntstatus(r.out.result);
5533 }
5534
5535 struct rpccli_spoolss_EnumPorts_state {
5536         struct spoolss_EnumPorts orig;
5537         struct spoolss_EnumPorts tmp;
5538         TALLOC_CTX *out_mem_ctx;
5539         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5540 };
5541
5542 static void rpccli_spoolss_EnumPorts_done(struct tevent_req *subreq);
5543
5544 struct tevent_req *rpccli_spoolss_EnumPorts_send(TALLOC_CTX *mem_ctx,
5545                                                  struct tevent_context *ev,
5546                                                  struct rpc_pipe_client *cli,
5547                                                  const char *_servername /* [in] [unique,charset(UTF16)] */,
5548                                                  uint32_t _level /* [in]  */,
5549                                                  DATA_BLOB *_buffer /* [in] [unique] */,
5550                                                  uint32_t _offered /* [in]  */,
5551                                                  uint32_t *_count /* [out] [ref] */,
5552                                                  union spoolss_PortInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5553                                                  uint32_t *_needed /* [out] [ref] */)
5554 {
5555         struct tevent_req *req;
5556         struct rpccli_spoolss_EnumPorts_state *state;
5557         struct tevent_req *subreq;
5558
5559         req = tevent_req_create(mem_ctx, &state,
5560                                 struct rpccli_spoolss_EnumPorts_state);
5561         if (req == NULL) {
5562                 return NULL;
5563         }
5564         state->out_mem_ctx = NULL;
5565         state->dispatch_recv = cli->dispatch_recv;
5566
5567         /* In parameters */
5568         state->orig.in.servername = _servername;
5569         state->orig.in.level = _level;
5570         state->orig.in.buffer = _buffer;
5571         state->orig.in.offered = _offered;
5572
5573         /* Out parameters */
5574         state->orig.out.count = _count;
5575         state->orig.out.info = _info;
5576         state->orig.out.needed = _needed;
5577
5578         /* Result */
5579         ZERO_STRUCT(state->orig.out.result);
5580
5581         state->out_mem_ctx = talloc_named_const(state, 0,
5582                              "rpccli_spoolss_EnumPorts_out_memory");
5583         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5584                 return tevent_req_post(req, ev);
5585         }
5586
5587         /* make a temporary copy, that we pass to the dispatch function */
5588         state->tmp = state->orig;
5589
5590         subreq = cli->dispatch_send(state, ev, cli,
5591                                     &ndr_table_spoolss,
5592                                     NDR_SPOOLSS_ENUMPORTS,
5593                                     &state->tmp);
5594         if (tevent_req_nomem(subreq, req)) {
5595                 return tevent_req_post(req, ev);
5596         }
5597         tevent_req_set_callback(subreq, rpccli_spoolss_EnumPorts_done, req);
5598         return req;
5599 }
5600
5601 static void rpccli_spoolss_EnumPorts_done(struct tevent_req *subreq)
5602 {
5603         struct tevent_req *req = tevent_req_callback_data(
5604                 subreq, struct tevent_req);
5605         struct rpccli_spoolss_EnumPorts_state *state = tevent_req_data(
5606                 req, struct rpccli_spoolss_EnumPorts_state);
5607         NTSTATUS status;
5608         TALLOC_CTX *mem_ctx;
5609
5610         if (state->out_mem_ctx) {
5611                 mem_ctx = state->out_mem_ctx;
5612         } else {
5613                 mem_ctx = state;
5614         }
5615
5616         status = state->dispatch_recv(subreq, mem_ctx);
5617         TALLOC_FREE(subreq);
5618         if (!NT_STATUS_IS_OK(status)) {
5619                 tevent_req_nterror(req, status);
5620                 return;
5621         }
5622
5623         /* Copy out parameters */
5624         *state->orig.out.count = *state->tmp.out.count;
5625         *state->orig.out.info = *state->tmp.out.info;
5626         *state->orig.out.needed = *state->tmp.out.needed;
5627
5628         /* Copy result */
5629         state->orig.out.result = state->tmp.out.result;
5630
5631         /* Reset temporary structure */
5632         ZERO_STRUCT(state->tmp);
5633
5634         tevent_req_done(req);
5635 }
5636
5637 NTSTATUS rpccli_spoolss_EnumPorts_recv(struct tevent_req *req,
5638                                        TALLOC_CTX *mem_ctx,
5639                                        WERROR *result)
5640 {
5641         struct rpccli_spoolss_EnumPorts_state *state = tevent_req_data(
5642                 req, struct rpccli_spoolss_EnumPorts_state);
5643         NTSTATUS status;
5644
5645         if (tevent_req_is_nterror(req, &status)) {
5646                 tevent_req_received(req);
5647                 return status;
5648         }
5649
5650         /* Steal possbile out parameters to the callers context */
5651         talloc_steal(mem_ctx, state->out_mem_ctx);
5652
5653         /* Return result */
5654         *result = state->orig.out.result;
5655
5656         tevent_req_received(req);
5657         return NT_STATUS_OK;
5658 }
5659
5660 NTSTATUS rpccli_spoolss_EnumPorts(struct rpc_pipe_client *cli,
5661                                   TALLOC_CTX *mem_ctx,
5662                                   const char *servername /* [in] [unique,charset(UTF16)] */,
5663                                   uint32_t level /* [in]  */,
5664                                   DATA_BLOB *buffer /* [in] [unique] */,
5665                                   uint32_t offered /* [in]  */,
5666                                   uint32_t *count /* [out] [ref] */,
5667                                   union spoolss_PortInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5668                                   uint32_t *needed /* [out] [ref] */,
5669                                   WERROR *werror)
5670 {
5671         struct spoolss_EnumPorts r;
5672         NTSTATUS status;
5673
5674         /* In parameters */
5675         r.in.servername = servername;
5676         r.in.level = level;
5677         r.in.buffer = buffer;
5678         r.in.offered = offered;
5679
5680         status = cli->dispatch(cli,
5681                                 mem_ctx,
5682                                 &ndr_table_spoolss,
5683                                 NDR_SPOOLSS_ENUMPORTS,
5684                                 &r);
5685
5686         if (!NT_STATUS_IS_OK(status)) {
5687                 return status;
5688         }
5689
5690         if (NT_STATUS_IS_ERR(status)) {
5691                 return status;
5692         }
5693
5694         /* Return variables */
5695         *count = *r.out.count;
5696         *info = *r.out.info;
5697         *needed = *r.out.needed;
5698
5699         /* Return result */
5700         if (werror) {
5701                 *werror = r.out.result;
5702         }
5703
5704         return werror_to_ntstatus(r.out.result);
5705 }
5706
5707 struct rpccli_spoolss_EnumMonitors_state {
5708         struct spoolss_EnumMonitors orig;
5709         struct spoolss_EnumMonitors tmp;
5710         TALLOC_CTX *out_mem_ctx;
5711         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5712 };
5713
5714 static void rpccli_spoolss_EnumMonitors_done(struct tevent_req *subreq);
5715
5716 struct tevent_req *rpccli_spoolss_EnumMonitors_send(TALLOC_CTX *mem_ctx,
5717                                                     struct tevent_context *ev,
5718                                                     struct rpc_pipe_client *cli,
5719                                                     const char *_servername /* [in] [unique,charset(UTF16)] */,
5720                                                     uint32_t _level /* [in]  */,
5721                                                     DATA_BLOB *_buffer /* [in] [unique] */,
5722                                                     uint32_t _offered /* [in]  */,
5723                                                     uint32_t *_count /* [out] [ref] */,
5724                                                     union spoolss_MonitorInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5725                                                     uint32_t *_needed /* [out] [ref] */)
5726 {
5727         struct tevent_req *req;
5728         struct rpccli_spoolss_EnumMonitors_state *state;
5729         struct tevent_req *subreq;
5730
5731         req = tevent_req_create(mem_ctx, &state,
5732                                 struct rpccli_spoolss_EnumMonitors_state);
5733         if (req == NULL) {
5734                 return NULL;
5735         }
5736         state->out_mem_ctx = NULL;
5737         state->dispatch_recv = cli->dispatch_recv;
5738
5739         /* In parameters */
5740         state->orig.in.servername = _servername;
5741         state->orig.in.level = _level;
5742         state->orig.in.buffer = _buffer;
5743         state->orig.in.offered = _offered;
5744
5745         /* Out parameters */
5746         state->orig.out.count = _count;
5747         state->orig.out.info = _info;
5748         state->orig.out.needed = _needed;
5749
5750         /* Result */
5751         ZERO_STRUCT(state->orig.out.result);
5752
5753         state->out_mem_ctx = talloc_named_const(state, 0,
5754                              "rpccli_spoolss_EnumMonitors_out_memory");
5755         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5756                 return tevent_req_post(req, ev);
5757         }
5758
5759         /* make a temporary copy, that we pass to the dispatch function */
5760         state->tmp = state->orig;
5761
5762         subreq = cli->dispatch_send(state, ev, cli,
5763                                     &ndr_table_spoolss,
5764                                     NDR_SPOOLSS_ENUMMONITORS,
5765                                     &state->tmp);
5766         if (tevent_req_nomem(subreq, req)) {
5767                 return tevent_req_post(req, ev);
5768         }
5769         tevent_req_set_callback(subreq, rpccli_spoolss_EnumMonitors_done, req);
5770         return req;
5771 }
5772
5773 static void rpccli_spoolss_EnumMonitors_done(struct tevent_req *subreq)
5774 {
5775         struct tevent_req *req = tevent_req_callback_data(
5776                 subreq, struct tevent_req);
5777         struct rpccli_spoolss_EnumMonitors_state *state = tevent_req_data(
5778                 req, struct rpccli_spoolss_EnumMonitors_state);
5779         NTSTATUS status;
5780         TALLOC_CTX *mem_ctx;
5781
5782         if (state->out_mem_ctx) {
5783                 mem_ctx = state->out_mem_ctx;
5784         } else {
5785                 mem_ctx = state;
5786         }
5787
5788         status = state->dispatch_recv(subreq, mem_ctx);
5789         TALLOC_FREE(subreq);
5790         if (!NT_STATUS_IS_OK(status)) {
5791                 tevent_req_nterror(req, status);
5792                 return;
5793         }
5794
5795         /* Copy out parameters */
5796         *state->orig.out.count = *state->tmp.out.count;
5797         *state->orig.out.info = *state->tmp.out.info;
5798         *state->orig.out.needed = *state->tmp.out.needed;
5799
5800         /* Copy result */
5801         state->orig.out.result = state->tmp.out.result;
5802
5803         /* Reset temporary structure */
5804         ZERO_STRUCT(state->tmp);
5805
5806         tevent_req_done(req);
5807 }
5808
5809 NTSTATUS rpccli_spoolss_EnumMonitors_recv(struct tevent_req *req,
5810                                           TALLOC_CTX *mem_ctx,
5811                                           WERROR *result)
5812 {
5813         struct rpccli_spoolss_EnumMonitors_state *state = tevent_req_data(
5814                 req, struct rpccli_spoolss_EnumMonitors_state);
5815         NTSTATUS status;
5816
5817         if (tevent_req_is_nterror(req, &status)) {
5818                 tevent_req_received(req);
5819                 return status;
5820         }
5821
5822         /* Steal possbile out parameters to the callers context */
5823         talloc_steal(mem_ctx, state->out_mem_ctx);
5824
5825         /* Return result */
5826         *result = state->orig.out.result;
5827
5828         tevent_req_received(req);
5829         return NT_STATUS_OK;
5830 }
5831
5832 NTSTATUS rpccli_spoolss_EnumMonitors(struct rpc_pipe_client *cli,
5833                                      TALLOC_CTX *mem_ctx,
5834                                      const char *servername /* [in] [unique,charset(UTF16)] */,
5835                                      uint32_t level /* [in]  */,
5836                                      DATA_BLOB *buffer /* [in] [unique] */,
5837                                      uint32_t offered /* [in]  */,
5838                                      uint32_t *count /* [out] [ref] */,
5839                                      union spoolss_MonitorInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5840                                      uint32_t *needed /* [out] [ref] */,
5841                                      WERROR *werror)
5842 {
5843         struct spoolss_EnumMonitors r;
5844         NTSTATUS status;
5845
5846         /* In parameters */
5847         r.in.servername = servername;
5848         r.in.level = level;
5849         r.in.buffer = buffer;
5850         r.in.offered = offered;
5851
5852         status = cli->dispatch(cli,
5853                                 mem_ctx,
5854                                 &ndr_table_spoolss,
5855                                 NDR_SPOOLSS_ENUMMONITORS,
5856                                 &r);
5857
5858         if (!NT_STATUS_IS_OK(status)) {
5859                 return status;
5860         }
5861
5862         if (NT_STATUS_IS_ERR(status)) {
5863                 return status;
5864         }
5865
5866         /* Return variables */
5867         *count = *r.out.count;
5868         *info = *r.out.info;
5869         *needed = *r.out.needed;
5870
5871         /* Return result */
5872         if (werror) {
5873                 *werror = r.out.result;
5874         }
5875
5876         return werror_to_ntstatus(r.out.result);
5877 }
5878
5879 struct rpccli_spoolss_AddPort_state {
5880         struct spoolss_AddPort orig;
5881         struct spoolss_AddPort tmp;
5882         TALLOC_CTX *out_mem_ctx;
5883         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5884 };
5885
5886 static void rpccli_spoolss_AddPort_done(struct tevent_req *subreq);
5887
5888 struct tevent_req *rpccli_spoolss_AddPort_send(TALLOC_CTX *mem_ctx,
5889                                                struct tevent_context *ev,
5890                                                struct rpc_pipe_client *cli,
5891                                                const char *_server_name /* [in] [unique,charset(UTF16)] */,
5892                                                uint32_t _unknown /* [in]  */,
5893                                                const char *_monitor_name /* [in] [charset(UTF16)] */)
5894 {
5895         struct tevent_req *req;
5896         struct rpccli_spoolss_AddPort_state *state;
5897         struct tevent_req *subreq;
5898
5899         req = tevent_req_create(mem_ctx, &state,
5900                                 struct rpccli_spoolss_AddPort_state);
5901         if (req == NULL) {
5902                 return NULL;
5903         }
5904         state->out_mem_ctx = NULL;
5905         state->dispatch_recv = cli->dispatch_recv;
5906
5907         /* In parameters */
5908         state->orig.in.server_name = _server_name;
5909         state->orig.in.unknown = _unknown;
5910         state->orig.in.monitor_name = _monitor_name;
5911
5912         /* Out parameters */
5913
5914         /* Result */
5915         ZERO_STRUCT(state->orig.out.result);
5916
5917         /* make a temporary copy, that we pass to the dispatch function */
5918         state->tmp = state->orig;
5919
5920         subreq = cli->dispatch_send(state, ev, cli,
5921                                     &ndr_table_spoolss,
5922                                     NDR_SPOOLSS_ADDPORT,
5923                                     &state->tmp);
5924         if (tevent_req_nomem(subreq, req)) {
5925                 return tevent_req_post(req, ev);
5926         }
5927         tevent_req_set_callback(subreq, rpccli_spoolss_AddPort_done, req);
5928         return req;
5929 }
5930
5931 static void rpccli_spoolss_AddPort_done(struct tevent_req *subreq)
5932 {
5933         struct tevent_req *req = tevent_req_callback_data(
5934                 subreq, struct tevent_req);
5935         struct rpccli_spoolss_AddPort_state *state = tevent_req_data(
5936                 req, struct rpccli_spoolss_AddPort_state);
5937         NTSTATUS status;
5938         TALLOC_CTX *mem_ctx;
5939
5940         if (state->out_mem_ctx) {
5941                 mem_ctx = state->out_mem_ctx;
5942         } else {
5943                 mem_ctx = state;
5944         }
5945
5946         status = state->dispatch_recv(subreq, mem_ctx);
5947         TALLOC_FREE(subreq);
5948         if (!NT_STATUS_IS_OK(status)) {
5949                 tevent_req_nterror(req, status);
5950                 return;
5951         }
5952
5953         /* Copy out parameters */
5954
5955         /* Copy result */
5956         state->orig.out.result = state->tmp.out.result;
5957
5958         /* Reset temporary structure */
5959         ZERO_STRUCT(state->tmp);
5960
5961         tevent_req_done(req);
5962 }
5963
5964 NTSTATUS rpccli_spoolss_AddPort_recv(struct tevent_req *req,
5965                                      TALLOC_CTX *mem_ctx,
5966                                      WERROR *result)
5967 {
5968         struct rpccli_spoolss_AddPort_state *state = tevent_req_data(
5969                 req, struct rpccli_spoolss_AddPort_state);
5970         NTSTATUS status;
5971
5972         if (tevent_req_is_nterror(req, &status)) {
5973                 tevent_req_received(req);
5974                 return status;
5975         }
5976
5977         /* Steal possbile out parameters to the callers context */
5978         talloc_steal(mem_ctx, state->out_mem_ctx);
5979
5980         /* Return result */
5981         *result = state->orig.out.result;
5982
5983         tevent_req_received(req);
5984         return NT_STATUS_OK;
5985 }
5986
5987 NTSTATUS rpccli_spoolss_AddPort(struct rpc_pipe_client *cli,
5988                                 TALLOC_CTX *mem_ctx,
5989                                 const char *server_name /* [in] [unique,charset(UTF16)] */,
5990                                 uint32_t unknown /* [in]  */,
5991                                 const char *monitor_name /* [in] [charset(UTF16)] */,
5992                                 WERROR *werror)
5993 {
5994         struct spoolss_AddPort r;
5995         NTSTATUS status;
5996
5997         /* In parameters */
5998         r.in.server_name = server_name;
5999         r.in.unknown = unknown;
6000         r.in.monitor_name = monitor_name;
6001
6002         status = cli->dispatch(cli,
6003                                 mem_ctx,
6004                                 &ndr_table_spoolss,
6005                                 NDR_SPOOLSS_ADDPORT,
6006                                 &r);
6007
6008         if (!NT_STATUS_IS_OK(status)) {
6009                 return status;
6010         }
6011
6012         if (NT_STATUS_IS_ERR(status)) {
6013                 return status;
6014         }
6015
6016         /* Return variables */
6017
6018         /* Return result */
6019         if (werror) {
6020                 *werror = r.out.result;
6021         }
6022
6023         return werror_to_ntstatus(r.out.result);
6024 }
6025
6026 struct rpccli_spoolss_ConfigurePort_state {
6027         struct spoolss_ConfigurePort orig;
6028         struct spoolss_ConfigurePort tmp;
6029         TALLOC_CTX *out_mem_ctx;
6030         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6031 };
6032
6033 static void rpccli_spoolss_ConfigurePort_done(struct tevent_req *subreq);
6034
6035 struct tevent_req *rpccli_spoolss_ConfigurePort_send(TALLOC_CTX *mem_ctx,
6036                                                      struct tevent_context *ev,
6037                                                      struct rpc_pipe_client *cli)
6038 {
6039         struct tevent_req *req;
6040         struct rpccli_spoolss_ConfigurePort_state *state;
6041         struct tevent_req *subreq;
6042
6043         req = tevent_req_create(mem_ctx, &state,
6044                                 struct rpccli_spoolss_ConfigurePort_state);
6045         if (req == NULL) {
6046                 return NULL;
6047         }
6048         state->out_mem_ctx = NULL;
6049         state->dispatch_recv = cli->dispatch_recv;
6050
6051         /* In parameters */
6052
6053         /* Out parameters */
6054
6055         /* Result */
6056         ZERO_STRUCT(state->orig.out.result);
6057
6058         /* make a temporary copy, that we pass to the dispatch function */
6059         state->tmp = state->orig;
6060
6061         subreq = cli->dispatch_send(state, ev, cli,
6062                                     &ndr_table_spoolss,
6063                                     NDR_SPOOLSS_CONFIGUREPORT,
6064                                     &state->tmp);
6065         if (tevent_req_nomem(subreq, req)) {
6066                 return tevent_req_post(req, ev);
6067         }
6068         tevent_req_set_callback(subreq, rpccli_spoolss_ConfigurePort_done, req);
6069         return req;
6070 }
6071
6072 static void rpccli_spoolss_ConfigurePort_done(struct tevent_req *subreq)
6073 {
6074         struct tevent_req *req = tevent_req_callback_data(
6075                 subreq, struct tevent_req);
6076         struct rpccli_spoolss_ConfigurePort_state *state = tevent_req_data(
6077                 req, struct rpccli_spoolss_ConfigurePort_state);
6078         NTSTATUS status;
6079         TALLOC_CTX *mem_ctx;
6080
6081         if (state->out_mem_ctx) {
6082                 mem_ctx = state->out_mem_ctx;
6083         } else {
6084                 mem_ctx = state;
6085         }
6086
6087         status = state->dispatch_recv(subreq, mem_ctx);
6088         TALLOC_FREE(subreq);
6089         if (!NT_STATUS_IS_OK(status)) {
6090                 tevent_req_nterror(req, status);
6091                 return;
6092         }
6093
6094         /* Copy out parameters */
6095
6096         /* Copy result */
6097         state->orig.out.result = state->tmp.out.result;
6098
6099         /* Reset temporary structure */
6100         ZERO_STRUCT(state->tmp);
6101
6102         tevent_req_done(req);
6103 }
6104
6105 NTSTATUS rpccli_spoolss_ConfigurePort_recv(struct tevent_req *req,
6106                                            TALLOC_CTX *mem_ctx,
6107                                            WERROR *result)
6108 {
6109         struct rpccli_spoolss_ConfigurePort_state *state = tevent_req_data(
6110                 req, struct rpccli_spoolss_ConfigurePort_state);
6111         NTSTATUS status;
6112
6113         if (tevent_req_is_nterror(req, &status)) {
6114                 tevent_req_received(req);
6115                 return status;
6116         }
6117
6118         /* Steal possbile out parameters to the callers context */
6119         talloc_steal(mem_ctx, state->out_mem_ctx);
6120
6121         /* Return result */
6122         *result = state->orig.out.result;
6123
6124         tevent_req_received(req);
6125         return NT_STATUS_OK;
6126 }
6127
6128 NTSTATUS rpccli_spoolss_ConfigurePort(struct rpc_pipe_client *cli,
6129                                       TALLOC_CTX *mem_ctx,
6130                                       WERROR *werror)
6131 {
6132         struct spoolss_ConfigurePort r;
6133         NTSTATUS status;
6134
6135         /* In parameters */
6136
6137         status = cli->dispatch(cli,
6138                                 mem_ctx,
6139                                 &ndr_table_spoolss,
6140                                 NDR_SPOOLSS_CONFIGUREPORT,
6141                                 &r);
6142
6143         if (!NT_STATUS_IS_OK(status)) {
6144                 return status;
6145         }
6146
6147         if (NT_STATUS_IS_ERR(status)) {
6148                 return status;
6149         }
6150
6151         /* Return variables */
6152
6153         /* Return result */
6154         if (werror) {
6155                 *werror = r.out.result;
6156         }
6157
6158         return werror_to_ntstatus(r.out.result);
6159 }
6160
6161 struct rpccli_spoolss_DeletePort_state {
6162         struct spoolss_DeletePort orig;
6163         struct spoolss_DeletePort tmp;
6164         TALLOC_CTX *out_mem_ctx;
6165         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6166 };
6167
6168 static void rpccli_spoolss_DeletePort_done(struct tevent_req *subreq);
6169
6170 struct tevent_req *rpccli_spoolss_DeletePort_send(TALLOC_CTX *mem_ctx,
6171                                                   struct tevent_context *ev,
6172                                                   struct rpc_pipe_client *cli)
6173 {
6174         struct tevent_req *req;
6175         struct rpccli_spoolss_DeletePort_state *state;
6176         struct tevent_req *subreq;
6177
6178         req = tevent_req_create(mem_ctx, &state,
6179                                 struct rpccli_spoolss_DeletePort_state);
6180         if (req == NULL) {
6181                 return NULL;
6182         }
6183         state->out_mem_ctx = NULL;
6184         state->dispatch_recv = cli->dispatch_recv;
6185
6186         /* In parameters */
6187
6188         /* Out parameters */
6189
6190         /* Result */
6191         ZERO_STRUCT(state->orig.out.result);
6192
6193         /* make a temporary copy, that we pass to the dispatch function */
6194         state->tmp = state->orig;
6195
6196         subreq = cli->dispatch_send(state, ev, cli,
6197                                     &ndr_table_spoolss,
6198                                     NDR_SPOOLSS_DELETEPORT,
6199                                     &state->tmp);
6200         if (tevent_req_nomem(subreq, req)) {
6201                 return tevent_req_post(req, ev);
6202         }
6203         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePort_done, req);
6204         return req;
6205 }
6206
6207 static void rpccli_spoolss_DeletePort_done(struct tevent_req *subreq)
6208 {
6209         struct tevent_req *req = tevent_req_callback_data(
6210                 subreq, struct tevent_req);
6211         struct rpccli_spoolss_DeletePort_state *state = tevent_req_data(
6212                 req, struct rpccli_spoolss_DeletePort_state);
6213         NTSTATUS status;
6214         TALLOC_CTX *mem_ctx;
6215
6216         if (state->out_mem_ctx) {
6217                 mem_ctx = state->out_mem_ctx;
6218         } else {
6219                 mem_ctx = state;
6220         }
6221
6222         status = state->dispatch_recv(subreq, mem_ctx);
6223         TALLOC_FREE(subreq);
6224         if (!NT_STATUS_IS_OK(status)) {
6225                 tevent_req_nterror(req, status);
6226                 return;
6227         }
6228
6229         /* Copy out parameters */
6230
6231         /* Copy result */
6232         state->orig.out.result = state->tmp.out.result;
6233
6234         /* Reset temporary structure */
6235         ZERO_STRUCT(state->tmp);
6236
6237         tevent_req_done(req);
6238 }
6239
6240 NTSTATUS rpccli_spoolss_DeletePort_recv(struct tevent_req *req,
6241                                         TALLOC_CTX *mem_ctx,
6242                                         WERROR *result)
6243 {
6244         struct rpccli_spoolss_DeletePort_state *state = tevent_req_data(
6245                 req, struct rpccli_spoolss_DeletePort_state);
6246         NTSTATUS status;
6247
6248         if (tevent_req_is_nterror(req, &status)) {
6249                 tevent_req_received(req);
6250                 return status;
6251         }
6252
6253         /* Steal possbile out parameters to the callers context */
6254         talloc_steal(mem_ctx, state->out_mem_ctx);
6255
6256         /* Return result */
6257         *result = state->orig.out.result;
6258
6259         tevent_req_received(req);
6260         return NT_STATUS_OK;
6261 }
6262
6263 NTSTATUS rpccli_spoolss_DeletePort(struct rpc_pipe_client *cli,
6264                                    TALLOC_CTX *mem_ctx,
6265                                    WERROR *werror)
6266 {
6267         struct spoolss_DeletePort r;
6268         NTSTATUS status;
6269
6270         /* In parameters */
6271
6272         status = cli->dispatch(cli,
6273                                 mem_ctx,
6274                                 &ndr_table_spoolss,
6275                                 NDR_SPOOLSS_DELETEPORT,
6276                                 &r);
6277
6278         if (!NT_STATUS_IS_OK(status)) {
6279                 return status;
6280         }
6281
6282         if (NT_STATUS_IS_ERR(status)) {
6283                 return status;
6284         }
6285
6286         /* Return variables */
6287
6288         /* Return result */
6289         if (werror) {
6290                 *werror = r.out.result;
6291         }
6292
6293         return werror_to_ntstatus(r.out.result);
6294 }
6295
6296 struct rpccli_spoolss_CreatePrinterIC_state {
6297         struct spoolss_CreatePrinterIC orig;
6298         struct spoolss_CreatePrinterIC tmp;
6299         TALLOC_CTX *out_mem_ctx;
6300         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6301 };
6302
6303 static void rpccli_spoolss_CreatePrinterIC_done(struct tevent_req *subreq);
6304
6305 struct tevent_req *rpccli_spoolss_CreatePrinterIC_send(TALLOC_CTX *mem_ctx,
6306                                                        struct tevent_context *ev,
6307                                                        struct rpc_pipe_client *cli,
6308                                                        struct policy_handle *_handle /* [in] [ref] */,
6309                                                        struct policy_handle *_gdi_handle /* [out] [ref] */,
6310                                                        struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */)
6311 {
6312         struct tevent_req *req;
6313         struct rpccli_spoolss_CreatePrinterIC_state *state;
6314         struct tevent_req *subreq;
6315
6316         req = tevent_req_create(mem_ctx, &state,
6317                                 struct rpccli_spoolss_CreatePrinterIC_state);
6318         if (req == NULL) {
6319                 return NULL;
6320         }
6321         state->out_mem_ctx = NULL;
6322         state->dispatch_recv = cli->dispatch_recv;
6323
6324         /* In parameters */
6325         state->orig.in.handle = _handle;
6326         state->orig.in.devmode_ctr = _devmode_ctr;
6327
6328         /* Out parameters */
6329         state->orig.out.gdi_handle = _gdi_handle;
6330
6331         /* Result */
6332         ZERO_STRUCT(state->orig.out.result);
6333
6334         state->out_mem_ctx = talloc_named_const(state, 0,
6335                              "rpccli_spoolss_CreatePrinterIC_out_memory");
6336         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6337                 return tevent_req_post(req, ev);
6338         }
6339
6340         /* make a temporary copy, that we pass to the dispatch function */
6341         state->tmp = state->orig;
6342
6343         subreq = cli->dispatch_send(state, ev, cli,
6344                                     &ndr_table_spoolss,
6345                                     NDR_SPOOLSS_CREATEPRINTERIC,
6346                                     &state->tmp);
6347         if (tevent_req_nomem(subreq, req)) {
6348                 return tevent_req_post(req, ev);
6349         }
6350         tevent_req_set_callback(subreq, rpccli_spoolss_CreatePrinterIC_done, req);
6351         return req;
6352 }
6353
6354 static void rpccli_spoolss_CreatePrinterIC_done(struct tevent_req *subreq)
6355 {
6356         struct tevent_req *req = tevent_req_callback_data(
6357                 subreq, struct tevent_req);
6358         struct rpccli_spoolss_CreatePrinterIC_state *state = tevent_req_data(
6359                 req, struct rpccli_spoolss_CreatePrinterIC_state);
6360         NTSTATUS status;
6361         TALLOC_CTX *mem_ctx;
6362
6363         if (state->out_mem_ctx) {
6364                 mem_ctx = state->out_mem_ctx;
6365         } else {
6366                 mem_ctx = state;
6367         }
6368
6369         status = state->dispatch_recv(subreq, mem_ctx);
6370         TALLOC_FREE(subreq);
6371         if (!NT_STATUS_IS_OK(status)) {
6372                 tevent_req_nterror(req, status);
6373                 return;
6374         }
6375
6376         /* Copy out parameters */
6377         *state->orig.out.gdi_handle = *state->tmp.out.gdi_handle;
6378
6379         /* Copy result */
6380         state->orig.out.result = state->tmp.out.result;
6381
6382         /* Reset temporary structure */
6383         ZERO_STRUCT(state->tmp);
6384
6385         tevent_req_done(req);
6386 }
6387
6388 NTSTATUS rpccli_spoolss_CreatePrinterIC_recv(struct tevent_req *req,
6389                                              TALLOC_CTX *mem_ctx,
6390                                              WERROR *result)
6391 {
6392         struct rpccli_spoolss_CreatePrinterIC_state *state = tevent_req_data(
6393                 req, struct rpccli_spoolss_CreatePrinterIC_state);
6394         NTSTATUS status;
6395
6396         if (tevent_req_is_nterror(req, &status)) {
6397                 tevent_req_received(req);
6398                 return status;
6399         }
6400
6401         /* Steal possbile out parameters to the callers context */
6402         talloc_steal(mem_ctx, state->out_mem_ctx);
6403
6404         /* Return result */
6405         *result = state->orig.out.result;
6406
6407         tevent_req_received(req);
6408         return NT_STATUS_OK;
6409 }
6410
6411 NTSTATUS rpccli_spoolss_CreatePrinterIC(struct rpc_pipe_client *cli,
6412                                         TALLOC_CTX *mem_ctx,
6413                                         struct policy_handle *handle /* [in] [ref] */,
6414                                         struct policy_handle *gdi_handle /* [out] [ref] */,
6415                                         struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
6416                                         WERROR *werror)
6417 {
6418         struct spoolss_CreatePrinterIC r;
6419         NTSTATUS status;
6420
6421         /* In parameters */
6422         r.in.handle = handle;
6423         r.in.devmode_ctr = devmode_ctr;
6424
6425         status = cli->dispatch(cli,
6426                                 mem_ctx,
6427                                 &ndr_table_spoolss,
6428                                 NDR_SPOOLSS_CREATEPRINTERIC,
6429                                 &r);
6430
6431         if (!NT_STATUS_IS_OK(status)) {
6432                 return status;
6433         }
6434
6435         if (NT_STATUS_IS_ERR(status)) {
6436                 return status;
6437         }
6438
6439         /* Return variables */
6440         *gdi_handle = *r.out.gdi_handle;
6441
6442         /* Return result */
6443         if (werror) {
6444                 *werror = r.out.result;
6445         }
6446
6447         return werror_to_ntstatus(r.out.result);
6448 }
6449
6450 struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state {
6451         struct spoolss_PlayGDIScriptOnPrinterIC orig;
6452         struct spoolss_PlayGDIScriptOnPrinterIC tmp;
6453         TALLOC_CTX *out_mem_ctx;
6454         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6455 };
6456
6457 static void rpccli_spoolss_PlayGDIScriptOnPrinterIC_done(struct tevent_req *subreq);
6458
6459 struct tevent_req *rpccli_spoolss_PlayGDIScriptOnPrinterIC_send(TALLOC_CTX *mem_ctx,
6460                                                                 struct tevent_context *ev,
6461                                                                 struct rpc_pipe_client *cli)
6462 {
6463         struct tevent_req *req;
6464         struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state *state;
6465         struct tevent_req *subreq;
6466
6467         req = tevent_req_create(mem_ctx, &state,
6468                                 struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state);
6469         if (req == NULL) {
6470                 return NULL;
6471         }
6472         state->out_mem_ctx = NULL;
6473         state->dispatch_recv = cli->dispatch_recv;
6474
6475         /* In parameters */
6476
6477         /* Out parameters */
6478
6479         /* Result */
6480         ZERO_STRUCT(state->orig.out.result);
6481
6482         /* make a temporary copy, that we pass to the dispatch function */
6483         state->tmp = state->orig;
6484
6485         subreq = cli->dispatch_send(state, ev, cli,
6486                                     &ndr_table_spoolss,
6487                                     NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC,
6488                                     &state->tmp);
6489         if (tevent_req_nomem(subreq, req)) {
6490                 return tevent_req_post(req, ev);
6491         }
6492         tevent_req_set_callback(subreq, rpccli_spoolss_PlayGDIScriptOnPrinterIC_done, req);
6493         return req;
6494 }
6495
6496 static void rpccli_spoolss_PlayGDIScriptOnPrinterIC_done(struct tevent_req *subreq)
6497 {
6498         struct tevent_req *req = tevent_req_callback_data(
6499                 subreq, struct tevent_req);
6500         struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state *state = tevent_req_data(
6501                 req, struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state);
6502         NTSTATUS status;
6503         TALLOC_CTX *mem_ctx;
6504
6505         if (state->out_mem_ctx) {
6506                 mem_ctx = state->out_mem_ctx;
6507         } else {
6508                 mem_ctx = state;
6509         }
6510
6511         status = state->dispatch_recv(subreq, mem_ctx);
6512         TALLOC_FREE(subreq);
6513         if (!NT_STATUS_IS_OK(status)) {
6514                 tevent_req_nterror(req, status);
6515                 return;
6516         }
6517
6518         /* Copy out parameters */
6519
6520         /* Copy result */
6521         state->orig.out.result = state->tmp.out.result;
6522
6523         /* Reset temporary structure */
6524         ZERO_STRUCT(state->tmp);
6525
6526         tevent_req_done(req);
6527 }
6528
6529 NTSTATUS rpccli_spoolss_PlayGDIScriptOnPrinterIC_recv(struct tevent_req *req,
6530                                                       TALLOC_CTX *mem_ctx,
6531                                                       WERROR *result)
6532 {
6533         struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state *state = tevent_req_data(
6534                 req, struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state);
6535         NTSTATUS status;
6536
6537         if (tevent_req_is_nterror(req, &status)) {
6538                 tevent_req_received(req);
6539                 return status;
6540         }
6541
6542         /* Steal possbile out parameters to the callers context */
6543         talloc_steal(mem_ctx, state->out_mem_ctx);
6544
6545         /* Return result */
6546         *result = state->orig.out.result;
6547
6548         tevent_req_received(req);
6549         return NT_STATUS_OK;
6550 }
6551
6552 NTSTATUS rpccli_spoolss_PlayGDIScriptOnPrinterIC(struct rpc_pipe_client *cli,
6553                                                  TALLOC_CTX *mem_ctx,
6554                                                  WERROR *werror)
6555 {
6556         struct spoolss_PlayGDIScriptOnPrinterIC r;
6557         NTSTATUS status;
6558
6559         /* In parameters */
6560
6561         status = cli->dispatch(cli,
6562                                 mem_ctx,
6563                                 &ndr_table_spoolss,
6564                                 NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC,
6565                                 &r);
6566
6567         if (!NT_STATUS_IS_OK(status)) {
6568                 return status;
6569         }
6570
6571         if (NT_STATUS_IS_ERR(status)) {
6572                 return status;
6573         }
6574
6575         /* Return variables */
6576
6577         /* Return result */
6578         if (werror) {
6579                 *werror = r.out.result;
6580         }
6581
6582         return werror_to_ntstatus(r.out.result);
6583 }
6584
6585 struct rpccli_spoolss_DeletePrinterIC_state {
6586         struct spoolss_DeletePrinterIC orig;
6587         struct spoolss_DeletePrinterIC tmp;
6588         TALLOC_CTX *out_mem_ctx;
6589         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6590 };
6591
6592 static void rpccli_spoolss_DeletePrinterIC_done(struct tevent_req *subreq);
6593
6594 struct tevent_req *rpccli_spoolss_DeletePrinterIC_send(TALLOC_CTX *mem_ctx,
6595                                                        struct tevent_context *ev,
6596                                                        struct rpc_pipe_client *cli,
6597                                                        struct policy_handle *_gdi_handle /* [in,out] [ref] */)
6598 {
6599         struct tevent_req *req;
6600         struct rpccli_spoolss_DeletePrinterIC_state *state;
6601         struct tevent_req *subreq;
6602
6603         req = tevent_req_create(mem_ctx, &state,
6604                                 struct rpccli_spoolss_DeletePrinterIC_state);
6605         if (req == NULL) {
6606                 return NULL;
6607         }
6608         state->out_mem_ctx = NULL;
6609         state->dispatch_recv = cli->dispatch_recv;
6610
6611         /* In parameters */
6612         state->orig.in.gdi_handle = _gdi_handle;
6613
6614         /* Out parameters */
6615         state->orig.out.gdi_handle = _gdi_handle;
6616
6617         /* Result */
6618         ZERO_STRUCT(state->orig.out.result);
6619
6620         state->out_mem_ctx = talloc_named_const(state, 0,
6621                              "rpccli_spoolss_DeletePrinterIC_out_memory");
6622         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6623                 return tevent_req_post(req, ev);
6624         }
6625
6626         /* make a temporary copy, that we pass to the dispatch function */
6627         state->tmp = state->orig;
6628
6629         subreq = cli->dispatch_send(state, ev, cli,
6630                                     &ndr_table_spoolss,
6631                                     NDR_SPOOLSS_DELETEPRINTERIC,
6632                                     &state->tmp);
6633         if (tevent_req_nomem(subreq, req)) {
6634                 return tevent_req_post(req, ev);
6635         }
6636         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterIC_done, req);
6637         return req;
6638 }
6639
6640 static void rpccli_spoolss_DeletePrinterIC_done(struct tevent_req *subreq)
6641 {
6642         struct tevent_req *req = tevent_req_callback_data(
6643                 subreq, struct tevent_req);
6644         struct rpccli_spoolss_DeletePrinterIC_state *state = tevent_req_data(
6645                 req, struct rpccli_spoolss_DeletePrinterIC_state);
6646         NTSTATUS status;
6647         TALLOC_CTX *mem_ctx;
6648
6649         if (state->out_mem_ctx) {
6650                 mem_ctx = state->out_mem_ctx;
6651         } else {
6652                 mem_ctx = state;
6653         }
6654
6655         status = state->dispatch_recv(subreq, mem_ctx);
6656         TALLOC_FREE(subreq);
6657         if (!NT_STATUS_IS_OK(status)) {
6658                 tevent_req_nterror(req, status);
6659                 return;
6660         }
6661
6662         /* Copy out parameters */
6663         *state->orig.out.gdi_handle = *state->tmp.out.gdi_handle;
6664
6665         /* Copy result */
6666         state->orig.out.result = state->tmp.out.result;
6667
6668         /* Reset temporary structure */
6669         ZERO_STRUCT(state->tmp);
6670
6671         tevent_req_done(req);
6672 }
6673
6674 NTSTATUS rpccli_spoolss_DeletePrinterIC_recv(struct tevent_req *req,
6675                                              TALLOC_CTX *mem_ctx,
6676                                              WERROR *result)
6677 {
6678         struct rpccli_spoolss_DeletePrinterIC_state *state = tevent_req_data(
6679                 req, struct rpccli_spoolss_DeletePrinterIC_state);
6680         NTSTATUS status;
6681
6682         if (tevent_req_is_nterror(req, &status)) {
6683                 tevent_req_received(req);
6684                 return status;
6685         }
6686
6687         /* Steal possbile out parameters to the callers context */
6688         talloc_steal(mem_ctx, state->out_mem_ctx);
6689
6690         /* Return result */
6691         *result = state->orig.out.result;
6692
6693         tevent_req_received(req);
6694         return NT_STATUS_OK;
6695 }
6696
6697 NTSTATUS rpccli_spoolss_DeletePrinterIC(struct rpc_pipe_client *cli,
6698                                         TALLOC_CTX *mem_ctx,
6699                                         struct policy_handle *gdi_handle /* [in,out] [ref] */,
6700                                         WERROR *werror)
6701 {
6702         struct spoolss_DeletePrinterIC r;
6703         NTSTATUS status;
6704
6705         /* In parameters */
6706         r.in.gdi_handle = gdi_handle;
6707
6708         status = cli->dispatch(cli,
6709                                 mem_ctx,
6710                                 &ndr_table_spoolss,
6711                                 NDR_SPOOLSS_DELETEPRINTERIC,
6712                                 &r);
6713
6714         if (!NT_STATUS_IS_OK(status)) {
6715                 return status;
6716         }
6717
6718         if (NT_STATUS_IS_ERR(status)) {
6719                 return status;
6720         }
6721
6722         /* Return variables */
6723         *gdi_handle = *r.out.gdi_handle;
6724
6725         /* Return result */
6726         if (werror) {
6727                 *werror = r.out.result;
6728         }
6729
6730         return werror_to_ntstatus(r.out.result);
6731 }
6732
6733 struct rpccli_spoolss_AddPrinterConnection_state {
6734         struct spoolss_AddPrinterConnection orig;
6735         struct spoolss_AddPrinterConnection tmp;
6736         TALLOC_CTX *out_mem_ctx;
6737         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6738 };
6739
6740 static void rpccli_spoolss_AddPrinterConnection_done(struct tevent_req *subreq);
6741
6742 struct tevent_req *rpccli_spoolss_AddPrinterConnection_send(TALLOC_CTX *mem_ctx,
6743                                                             struct tevent_context *ev,
6744                                                             struct rpc_pipe_client *cli)
6745 {
6746         struct tevent_req *req;
6747         struct rpccli_spoolss_AddPrinterConnection_state *state;
6748         struct tevent_req *subreq;
6749
6750         req = tevent_req_create(mem_ctx, &state,
6751                                 struct rpccli_spoolss_AddPrinterConnection_state);
6752         if (req == NULL) {
6753                 return NULL;
6754         }
6755         state->out_mem_ctx = NULL;
6756         state->dispatch_recv = cli->dispatch_recv;
6757
6758         /* In parameters */
6759
6760         /* Out parameters */
6761
6762         /* Result */
6763         ZERO_STRUCT(state->orig.out.result);
6764
6765         /* make a temporary copy, that we pass to the dispatch function */
6766         state->tmp = state->orig;
6767
6768         subreq = cli->dispatch_send(state, ev, cli,
6769                                     &ndr_table_spoolss,
6770                                     NDR_SPOOLSS_ADDPRINTERCONNECTION,
6771                                     &state->tmp);
6772         if (tevent_req_nomem(subreq, req)) {
6773                 return tevent_req_post(req, ev);
6774         }
6775         tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterConnection_done, req);
6776         return req;
6777 }
6778
6779 static void rpccli_spoolss_AddPrinterConnection_done(struct tevent_req *subreq)
6780 {
6781         struct tevent_req *req = tevent_req_callback_data(
6782                 subreq, struct tevent_req);
6783         struct rpccli_spoolss_AddPrinterConnection_state *state = tevent_req_data(
6784                 req, struct rpccli_spoolss_AddPrinterConnection_state);
6785         NTSTATUS status;
6786         TALLOC_CTX *mem_ctx;
6787
6788         if (state->out_mem_ctx) {
6789                 mem_ctx = state->out_mem_ctx;
6790         } else {
6791                 mem_ctx = state;
6792         }
6793
6794         status = state->dispatch_recv(subreq, mem_ctx);
6795         TALLOC_FREE(subreq);
6796         if (!NT_STATUS_IS_OK(status)) {
6797                 tevent_req_nterror(req, status);
6798                 return;
6799         }
6800
6801         /* Copy out parameters */
6802
6803         /* Copy result */
6804         state->orig.out.result = state->tmp.out.result;
6805
6806         /* Reset temporary structure */
6807         ZERO_STRUCT(state->tmp);
6808
6809         tevent_req_done(req);
6810 }
6811
6812 NTSTATUS rpccli_spoolss_AddPrinterConnection_recv(struct tevent_req *req,
6813                                                   TALLOC_CTX *mem_ctx,
6814                                                   WERROR *result)
6815 {
6816         struct rpccli_spoolss_AddPrinterConnection_state *state = tevent_req_data(
6817                 req, struct rpccli_spoolss_AddPrinterConnection_state);
6818         NTSTATUS status;
6819
6820         if (tevent_req_is_nterror(req, &status)) {
6821                 tevent_req_received(req);
6822                 return status;
6823         }
6824
6825         /* Steal possbile out parameters to the callers context */
6826         talloc_steal(mem_ctx, state->out_mem_ctx);
6827
6828         /* Return result */
6829         *result = state->orig.out.result;
6830
6831         tevent_req_received(req);
6832         return NT_STATUS_OK;
6833 }
6834
6835 NTSTATUS rpccli_spoolss_AddPrinterConnection(struct rpc_pipe_client *cli,
6836                                              TALLOC_CTX *mem_ctx,
6837                                              WERROR *werror)
6838 {
6839         struct spoolss_AddPrinterConnection r;
6840         NTSTATUS status;
6841
6842         /* In parameters */
6843
6844         status = cli->dispatch(cli,
6845                                 mem_ctx,
6846                                 &ndr_table_spoolss,
6847                                 NDR_SPOOLSS_ADDPRINTERCONNECTION,
6848                                 &r);
6849
6850         if (!NT_STATUS_IS_OK(status)) {
6851                 return status;
6852         }
6853
6854         if (NT_STATUS_IS_ERR(status)) {
6855                 return status;
6856         }
6857
6858         /* Return variables */
6859
6860         /* Return result */
6861         if (werror) {
6862                 *werror = r.out.result;
6863         }
6864
6865         return werror_to_ntstatus(r.out.result);
6866 }
6867
6868 struct rpccli_spoolss_DeletePrinterConnection_state {
6869         struct spoolss_DeletePrinterConnection orig;
6870         struct spoolss_DeletePrinterConnection tmp;
6871         TALLOC_CTX *out_mem_ctx;
6872         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6873 };
6874
6875 static void rpccli_spoolss_DeletePrinterConnection_done(struct tevent_req *subreq);
6876
6877 struct tevent_req *rpccli_spoolss_DeletePrinterConnection_send(TALLOC_CTX *mem_ctx,
6878                                                                struct tevent_context *ev,
6879                                                                struct rpc_pipe_client *cli)
6880 {
6881         struct tevent_req *req;
6882         struct rpccli_spoolss_DeletePrinterConnection_state *state;
6883         struct tevent_req *subreq;
6884
6885         req = tevent_req_create(mem_ctx, &state,
6886                                 struct rpccli_spoolss_DeletePrinterConnection_state);
6887         if (req == NULL) {
6888                 return NULL;
6889         }
6890         state->out_mem_ctx = NULL;
6891         state->dispatch_recv = cli->dispatch_recv;
6892
6893         /* In parameters */
6894
6895         /* Out parameters */
6896
6897         /* Result */
6898         ZERO_STRUCT(state->orig.out.result);
6899
6900         /* make a temporary copy, that we pass to the dispatch function */
6901         state->tmp = state->orig;
6902
6903         subreq = cli->dispatch_send(state, ev, cli,
6904                                     &ndr_table_spoolss,
6905                                     NDR_SPOOLSS_DELETEPRINTERCONNECTION,
6906                                     &state->tmp);
6907         if (tevent_req_nomem(subreq, req)) {
6908                 return tevent_req_post(req, ev);
6909         }
6910         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterConnection_done, req);
6911         return req;
6912 }
6913
6914 static void rpccli_spoolss_DeletePrinterConnection_done(struct tevent_req *subreq)
6915 {
6916         struct tevent_req *req = tevent_req_callback_data(
6917                 subreq, struct tevent_req);
6918         struct rpccli_spoolss_DeletePrinterConnection_state *state = tevent_req_data(
6919                 req, struct rpccli_spoolss_DeletePrinterConnection_state);
6920         NTSTATUS status;
6921         TALLOC_CTX *mem_ctx;
6922
6923         if (state->out_mem_ctx) {
6924                 mem_ctx = state->out_mem_ctx;
6925         } else {
6926                 mem_ctx = state;
6927         }
6928
6929         status = state->dispatch_recv(subreq, mem_ctx);
6930         TALLOC_FREE(subreq);
6931         if (!NT_STATUS_IS_OK(status)) {
6932                 tevent_req_nterror(req, status);
6933                 return;
6934         }
6935
6936         /* Copy out parameters */
6937
6938         /* Copy result */
6939         state->orig.out.result = state->tmp.out.result;
6940
6941         /* Reset temporary structure */
6942         ZERO_STRUCT(state->tmp);
6943
6944         tevent_req_done(req);
6945 }
6946
6947 NTSTATUS rpccli_spoolss_DeletePrinterConnection_recv(struct tevent_req *req,
6948                                                      TALLOC_CTX *mem_ctx,
6949                                                      WERROR *result)
6950 {
6951         struct rpccli_spoolss_DeletePrinterConnection_state *state = tevent_req_data(
6952                 req, struct rpccli_spoolss_DeletePrinterConnection_state);
6953         NTSTATUS status;
6954
6955         if (tevent_req_is_nterror(req, &status)) {
6956                 tevent_req_received(req);
6957                 return status;
6958         }
6959
6960         /* Steal possbile out parameters to the callers context */
6961         talloc_steal(mem_ctx, state->out_mem_ctx);
6962
6963         /* Return result */
6964         *result = state->orig.out.result;
6965
6966         tevent_req_received(req);
6967         return NT_STATUS_OK;
6968 }
6969
6970 NTSTATUS rpccli_spoolss_DeletePrinterConnection(struct rpc_pipe_client *cli,
6971                                                 TALLOC_CTX *mem_ctx,
6972                                                 WERROR *werror)
6973 {
6974         struct spoolss_DeletePrinterConnection r;
6975         NTSTATUS status;
6976
6977         /* In parameters */
6978
6979         status = cli->dispatch(cli,
6980                                 mem_ctx,
6981                                 &ndr_table_spoolss,
6982                                 NDR_SPOOLSS_DELETEPRINTERCONNECTION,
6983                                 &r);
6984
6985         if (!NT_STATUS_IS_OK(status)) {
6986                 return status;
6987         }
6988
6989         if (NT_STATUS_IS_ERR(status)) {
6990                 return status;
6991         }
6992
6993         /* Return variables */
6994
6995         /* Return result */
6996         if (werror) {
6997                 *werror = r.out.result;
6998         }
6999
7000         return werror_to_ntstatus(r.out.result);
7001 }
7002
7003 struct rpccli_spoolss_PrinterMessageBox_state {
7004         struct spoolss_PrinterMessageBox orig;
7005         struct spoolss_PrinterMessageBox tmp;
7006         TALLOC_CTX *out_mem_ctx;
7007         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7008 };
7009
7010 static void rpccli_spoolss_PrinterMessageBox_done(struct tevent_req *subreq);
7011
7012 struct tevent_req *rpccli_spoolss_PrinterMessageBox_send(TALLOC_CTX *mem_ctx,
7013                                                          struct tevent_context *ev,
7014                                                          struct rpc_pipe_client *cli)
7015 {
7016         struct tevent_req *req;
7017         struct rpccli_spoolss_PrinterMessageBox_state *state;
7018         struct tevent_req *subreq;
7019
7020         req = tevent_req_create(mem_ctx, &state,
7021                                 struct rpccli_spoolss_PrinterMessageBox_state);
7022         if (req == NULL) {
7023                 return NULL;
7024         }
7025         state->out_mem_ctx = NULL;
7026         state->dispatch_recv = cli->dispatch_recv;
7027
7028         /* In parameters */
7029
7030         /* Out parameters */
7031
7032         /* Result */
7033         ZERO_STRUCT(state->orig.out.result);
7034
7035         /* make a temporary copy, that we pass to the dispatch function */
7036         state->tmp = state->orig;
7037
7038         subreq = cli->dispatch_send(state, ev, cli,
7039                                     &ndr_table_spoolss,
7040                                     NDR_SPOOLSS_PRINTERMESSAGEBOX,
7041                                     &state->tmp);
7042         if (tevent_req_nomem(subreq, req)) {
7043                 return tevent_req_post(req, ev);
7044         }
7045         tevent_req_set_callback(subreq, rpccli_spoolss_PrinterMessageBox_done, req);
7046         return req;
7047 }
7048
7049 static void rpccli_spoolss_PrinterMessageBox_done(struct tevent_req *subreq)
7050 {
7051         struct tevent_req *req = tevent_req_callback_data(
7052                 subreq, struct tevent_req);
7053         struct rpccli_spoolss_PrinterMessageBox_state *state = tevent_req_data(
7054                 req, struct rpccli_spoolss_PrinterMessageBox_state);
7055         NTSTATUS status;
7056         TALLOC_CTX *mem_ctx;
7057
7058         if (state->out_mem_ctx) {
7059                 mem_ctx = state->out_mem_ctx;
7060         } else {
7061                 mem_ctx = state;
7062         }
7063
7064         status = state->dispatch_recv(subreq, mem_ctx);
7065         TALLOC_FREE(subreq);
7066         if (!NT_STATUS_IS_OK(status)) {
7067                 tevent_req_nterror(req, status);
7068                 return;
7069         }
7070
7071         /* Copy out parameters */
7072
7073         /* Copy result */
7074         state->orig.out.result = state->tmp.out.result;
7075
7076         /* Reset temporary structure */
7077         ZERO_STRUCT(state->tmp);
7078
7079         tevent_req_done(req);
7080 }
7081
7082 NTSTATUS rpccli_spoolss_PrinterMessageBox_recv(struct tevent_req *req,
7083                                                TALLOC_CTX *mem_ctx,
7084                                                WERROR *result)
7085 {
7086         struct rpccli_spoolss_PrinterMessageBox_state *state = tevent_req_data(
7087                 req, struct rpccli_spoolss_PrinterMessageBox_state);
7088         NTSTATUS status;
7089
7090         if (tevent_req_is_nterror(req, &status)) {
7091                 tevent_req_received(req);
7092                 return status;
7093         }
7094
7095         /* Steal possbile out parameters to the callers context */
7096         talloc_steal(mem_ctx, state->out_mem_ctx);
7097
7098         /* Return result */
7099         *result = state->orig.out.result;
7100
7101         tevent_req_received(req);
7102         return NT_STATUS_OK;
7103 }
7104
7105 NTSTATUS rpccli_spoolss_PrinterMessageBox(struct rpc_pipe_client *cli,
7106                                           TALLOC_CTX *mem_ctx,
7107                                           WERROR *werror)
7108 {
7109         struct spoolss_PrinterMessageBox r;
7110         NTSTATUS status;
7111
7112         /* In parameters */
7113
7114         status = cli->dispatch(cli,
7115                                 mem_ctx,
7116                                 &ndr_table_spoolss,
7117                                 NDR_SPOOLSS_PRINTERMESSAGEBOX,
7118                                 &r);
7119
7120         if (!NT_STATUS_IS_OK(status)) {
7121                 return status;
7122         }
7123
7124         if (NT_STATUS_IS_ERR(status)) {
7125                 return status;
7126         }
7127
7128         /* Return variables */
7129
7130         /* Return result */
7131         if (werror) {
7132                 *werror = r.out.result;
7133         }
7134
7135         return werror_to_ntstatus(r.out.result);
7136 }
7137
7138 struct rpccli_spoolss_AddMonitor_state {
7139         struct spoolss_AddMonitor orig;
7140         struct spoolss_AddMonitor tmp;
7141         TALLOC_CTX *out_mem_ctx;
7142         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7143 };
7144
7145 static void rpccli_spoolss_AddMonitor_done(struct tevent_req *subreq);
7146
7147 struct tevent_req *rpccli_spoolss_AddMonitor_send(TALLOC_CTX *mem_ctx,
7148                                                   struct tevent_context *ev,
7149                                                   struct rpc_pipe_client *cli)
7150 {
7151         struct tevent_req *req;
7152         struct rpccli_spoolss_AddMonitor_state *state;
7153         struct tevent_req *subreq;
7154
7155         req = tevent_req_create(mem_ctx, &state,
7156                                 struct rpccli_spoolss_AddMonitor_state);
7157         if (req == NULL) {
7158                 return NULL;
7159         }
7160         state->out_mem_ctx = NULL;
7161         state->dispatch_recv = cli->dispatch_recv;
7162
7163         /* In parameters */
7164
7165         /* Out parameters */
7166
7167         /* Result */
7168         ZERO_STRUCT(state->orig.out.result);
7169
7170         /* make a temporary copy, that we pass to the dispatch function */
7171         state->tmp = state->orig;
7172
7173         subreq = cli->dispatch_send(state, ev, cli,
7174                                     &ndr_table_spoolss,
7175                                     NDR_SPOOLSS_ADDMONITOR,
7176                                     &state->tmp);
7177         if (tevent_req_nomem(subreq, req)) {
7178                 return tevent_req_post(req, ev);
7179         }
7180         tevent_req_set_callback(subreq, rpccli_spoolss_AddMonitor_done, req);
7181         return req;
7182 }
7183
7184 static void rpccli_spoolss_AddMonitor_done(struct tevent_req *subreq)
7185 {
7186         struct tevent_req *req = tevent_req_callback_data(
7187                 subreq, struct tevent_req);
7188         struct rpccli_spoolss_AddMonitor_state *state = tevent_req_data(
7189                 req, struct rpccli_spoolss_AddMonitor_state);
7190         NTSTATUS status;
7191         TALLOC_CTX *mem_ctx;
7192
7193         if (state->out_mem_ctx) {
7194                 mem_ctx = state->out_mem_ctx;
7195         } else {
7196                 mem_ctx = state;
7197         }
7198
7199         status = state->dispatch_recv(subreq, mem_ctx);
7200         TALLOC_FREE(subreq);
7201         if (!NT_STATUS_IS_OK(status)) {
7202                 tevent_req_nterror(req, status);
7203                 return;
7204         }
7205
7206         /* Copy out parameters */
7207
7208         /* Copy result */
7209         state->orig.out.result = state->tmp.out.result;
7210
7211         /* Reset temporary structure */
7212         ZERO_STRUCT(state->tmp);
7213
7214         tevent_req_done(req);
7215 }
7216
7217 NTSTATUS rpccli_spoolss_AddMonitor_recv(struct tevent_req *req,
7218                                         TALLOC_CTX *mem_ctx,
7219                                         WERROR *result)
7220 {
7221         struct rpccli_spoolss_AddMonitor_state *state = tevent_req_data(
7222                 req, struct rpccli_spoolss_AddMonitor_state);
7223         NTSTATUS status;
7224
7225         if (tevent_req_is_nterror(req, &status)) {
7226                 tevent_req_received(req);
7227                 return status;
7228         }
7229
7230         /* Steal possbile out parameters to the callers context */
7231         talloc_steal(mem_ctx, state->out_mem_ctx);
7232
7233         /* Return result */
7234         *result = state->orig.out.result;
7235
7236         tevent_req_received(req);
7237         return NT_STATUS_OK;
7238 }
7239
7240 NTSTATUS rpccli_spoolss_AddMonitor(struct rpc_pipe_client *cli,
7241                                    TALLOC_CTX *mem_ctx,
7242                                    WERROR *werror)
7243 {
7244         struct spoolss_AddMonitor r;
7245         NTSTATUS status;
7246
7247         /* In parameters */
7248
7249         status = cli->dispatch(cli,
7250                                 mem_ctx,
7251                                 &ndr_table_spoolss,
7252                                 NDR_SPOOLSS_ADDMONITOR,
7253                                 &r);
7254
7255         if (!NT_STATUS_IS_OK(status)) {
7256                 return status;
7257         }
7258
7259         if (NT_STATUS_IS_ERR(status)) {
7260                 return status;
7261         }
7262
7263         /* Return variables */
7264
7265         /* Return result */
7266         if (werror) {
7267                 *werror = r.out.result;
7268         }
7269
7270         return werror_to_ntstatus(r.out.result);
7271 }
7272
7273 struct rpccli_spoolss_DeleteMonitor_state {
7274         struct spoolss_DeleteMonitor orig;
7275         struct spoolss_DeleteMonitor tmp;
7276         TALLOC_CTX *out_mem_ctx;
7277         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7278 };
7279
7280 static void rpccli_spoolss_DeleteMonitor_done(struct tevent_req *subreq);
7281
7282 struct tevent_req *rpccli_spoolss_DeleteMonitor_send(TALLOC_CTX *mem_ctx,
7283                                                      struct tevent_context *ev,
7284                                                      struct rpc_pipe_client *cli)
7285 {
7286         struct tevent_req *req;
7287         struct rpccli_spoolss_DeleteMonitor_state *state;
7288         struct tevent_req *subreq;
7289
7290         req = tevent_req_create(mem_ctx, &state,
7291                                 struct rpccli_spoolss_DeleteMonitor_state);
7292         if (req == NULL) {
7293                 return NULL;
7294         }
7295         state->out_mem_ctx = NULL;
7296         state->dispatch_recv = cli->dispatch_recv;
7297
7298         /* In parameters */
7299
7300         /* Out parameters */
7301
7302         /* Result */
7303         ZERO_STRUCT(state->orig.out.result);
7304
7305         /* make a temporary copy, that we pass to the dispatch function */
7306         state->tmp = state->orig;
7307
7308         subreq = cli->dispatch_send(state, ev, cli,
7309                                     &ndr_table_spoolss,
7310                                     NDR_SPOOLSS_DELETEMONITOR,
7311                                     &state->tmp);
7312         if (tevent_req_nomem(subreq, req)) {
7313                 return tevent_req_post(req, ev);
7314         }
7315         tevent_req_set_callback(subreq, rpccli_spoolss_DeleteMonitor_done, req);
7316         return req;
7317 }
7318
7319 static void rpccli_spoolss_DeleteMonitor_done(struct tevent_req *subreq)
7320 {
7321         struct tevent_req *req = tevent_req_callback_data(
7322                 subreq, struct tevent_req);
7323         struct rpccli_spoolss_DeleteMonitor_state *state = tevent_req_data(
7324                 req, struct rpccli_spoolss_DeleteMonitor_state);
7325         NTSTATUS status;
7326         TALLOC_CTX *mem_ctx;
7327
7328         if (state->out_mem_ctx) {
7329                 mem_ctx = state->out_mem_ctx;
7330         } else {
7331                 mem_ctx = state;
7332         }
7333
7334         status = state->dispatch_recv(subreq, mem_ctx);
7335         TALLOC_FREE(subreq);
7336         if (!NT_STATUS_IS_OK(status)) {
7337                 tevent_req_nterror(req, status);
7338                 return;
7339         }
7340
7341         /* Copy out parameters */
7342
7343         /* Copy result */
7344         state->orig.out.result = state->tmp.out.result;
7345
7346         /* Reset temporary structure */
7347         ZERO_STRUCT(state->tmp);
7348
7349         tevent_req_done(req);
7350 }
7351
7352 NTSTATUS rpccli_spoolss_DeleteMonitor_recv(struct tevent_req *req,
7353                                            TALLOC_CTX *mem_ctx,
7354                                            WERROR *result)
7355 {
7356         struct rpccli_spoolss_DeleteMonitor_state *state = tevent_req_data(
7357                 req, struct rpccli_spoolss_DeleteMonitor_state);
7358         NTSTATUS status;
7359
7360         if (tevent_req_is_nterror(req, &status)) {
7361                 tevent_req_received(req);
7362                 return status;
7363         }
7364
7365         /* Steal possbile out parameters to the callers context */
7366         talloc_steal(mem_ctx, state->out_mem_ctx);
7367
7368         /* Return result */
7369         *result = state->orig.out.result;
7370
7371         tevent_req_received(req);
7372         return NT_STATUS_OK;
7373 }
7374
7375 NTSTATUS rpccli_spoolss_DeleteMonitor(struct rpc_pipe_client *cli,
7376                                       TALLOC_CTX *mem_ctx,
7377                                       WERROR *werror)
7378 {
7379         struct spoolss_DeleteMonitor r;
7380         NTSTATUS status;
7381
7382         /* In parameters */
7383
7384         status = cli->dispatch(cli,
7385                                 mem_ctx,
7386                                 &ndr_table_spoolss,
7387                                 NDR_SPOOLSS_DELETEMONITOR,
7388                                 &r);
7389
7390         if (!NT_STATUS_IS_OK(status)) {
7391                 return status;
7392         }
7393
7394         if (NT_STATUS_IS_ERR(status)) {
7395                 return status;
7396         }
7397
7398         /* Return variables */
7399
7400         /* Return result */
7401         if (werror) {
7402                 *werror = r.out.result;
7403         }
7404
7405         return werror_to_ntstatus(r.out.result);
7406 }
7407
7408 struct rpccli_spoolss_DeletePrintProcessor_state {
7409         struct spoolss_DeletePrintProcessor orig;
7410         struct spoolss_DeletePrintProcessor tmp;
7411         TALLOC_CTX *out_mem_ctx;
7412         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7413 };
7414
7415 static void rpccli_spoolss_DeletePrintProcessor_done(struct tevent_req *subreq);
7416
7417 struct tevent_req *rpccli_spoolss_DeletePrintProcessor_send(TALLOC_CTX *mem_ctx,
7418                                                             struct tevent_context *ev,
7419                                                             struct rpc_pipe_client *cli)
7420 {
7421         struct tevent_req *req;
7422         struct rpccli_spoolss_DeletePrintProcessor_state *state;
7423         struct tevent_req *subreq;
7424
7425         req = tevent_req_create(mem_ctx, &state,
7426                                 struct rpccli_spoolss_DeletePrintProcessor_state);
7427         if (req == NULL) {
7428                 return NULL;
7429         }
7430         state->out_mem_ctx = NULL;
7431         state->dispatch_recv = cli->dispatch_recv;
7432
7433         /* In parameters */
7434
7435         /* Out parameters */
7436
7437         /* Result */
7438         ZERO_STRUCT(state->orig.out.result);
7439
7440         /* make a temporary copy, that we pass to the dispatch function */
7441         state->tmp = state->orig;
7442
7443         subreq = cli->dispatch_send(state, ev, cli,
7444                                     &ndr_table_spoolss,
7445                                     NDR_SPOOLSS_DELETEPRINTPROCESSOR,
7446                                     &state->tmp);
7447         if (tevent_req_nomem(subreq, req)) {
7448                 return tevent_req_post(req, ev);
7449         }
7450         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrintProcessor_done, req);
7451         return req;
7452 }
7453
7454 static void rpccli_spoolss_DeletePrintProcessor_done(struct tevent_req *subreq)
7455 {
7456         struct tevent_req *req = tevent_req_callback_data(
7457                 subreq, struct tevent_req);
7458         struct rpccli_spoolss_DeletePrintProcessor_state *state = tevent_req_data(
7459                 req, struct rpccli_spoolss_DeletePrintProcessor_state);
7460         NTSTATUS status;
7461         TALLOC_CTX *mem_ctx;
7462
7463         if (state->out_mem_ctx) {
7464                 mem_ctx = state->out_mem_ctx;
7465         } else {
7466                 mem_ctx = state;
7467         }
7468
7469         status = state->dispatch_recv(subreq, mem_ctx);
7470         TALLOC_FREE(subreq);
7471         if (!NT_STATUS_IS_OK(status)) {
7472                 tevent_req_nterror(req, status);
7473                 return;
7474         }
7475
7476         /* Copy out parameters */
7477
7478         /* Copy result */
7479         state->orig.out.result = state->tmp.out.result;
7480
7481         /* Reset temporary structure */
7482         ZERO_STRUCT(state->tmp);
7483
7484         tevent_req_done(req);
7485 }
7486
7487 NTSTATUS rpccli_spoolss_DeletePrintProcessor_recv(struct tevent_req *req,
7488                                                   TALLOC_CTX *mem_ctx,
7489                                                   WERROR *result)
7490 {
7491         struct rpccli_spoolss_DeletePrintProcessor_state *state = tevent_req_data(
7492                 req, struct rpccli_spoolss_DeletePrintProcessor_state);
7493         NTSTATUS status;
7494
7495         if (tevent_req_is_nterror(req, &status)) {
7496                 tevent_req_received(req);
7497                 return status;
7498         }
7499
7500         /* Steal possbile out parameters to the callers context */
7501         talloc_steal(mem_ctx, state->out_mem_ctx);
7502
7503         /* Return result */
7504         *result = state->orig.out.result;
7505
7506         tevent_req_received(req);
7507         return NT_STATUS_OK;
7508 }
7509
7510 NTSTATUS rpccli_spoolss_DeletePrintProcessor(struct rpc_pipe_client *cli,
7511                                              TALLOC_CTX *mem_ctx,
7512                                              WERROR *werror)
7513 {
7514         struct spoolss_DeletePrintProcessor r;
7515         NTSTATUS status;
7516
7517         /* In parameters */
7518
7519         status = cli->dispatch(cli,
7520                                 mem_ctx,
7521                                 &ndr_table_spoolss,
7522                                 NDR_SPOOLSS_DELETEPRINTPROCESSOR,
7523                                 &r);
7524
7525         if (!NT_STATUS_IS_OK(status)) {
7526                 return status;
7527         }
7528
7529         if (NT_STATUS_IS_ERR(status)) {
7530                 return status;
7531         }
7532
7533         /* Return variables */
7534
7535         /* Return result */
7536         if (werror) {
7537                 *werror = r.out.result;
7538         }
7539
7540         return werror_to_ntstatus(r.out.result);
7541 }
7542
7543 struct rpccli_spoolss_AddPrintProvidor_state {
7544         struct spoolss_AddPrintProvidor orig;
7545         struct spoolss_AddPrintProvidor tmp;
7546         TALLOC_CTX *out_mem_ctx;
7547         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7548 };
7549
7550 static void rpccli_spoolss_AddPrintProvidor_done(struct tevent_req *subreq);
7551
7552 struct tevent_req *rpccli_spoolss_AddPrintProvidor_send(TALLOC_CTX *mem_ctx,
7553                                                         struct tevent_context *ev,
7554                                                         struct rpc_pipe_client *cli)
7555 {
7556         struct tevent_req *req;
7557         struct rpccli_spoolss_AddPrintProvidor_state *state;
7558         struct tevent_req *subreq;
7559
7560         req = tevent_req_create(mem_ctx, &state,
7561                                 struct rpccli_spoolss_AddPrintProvidor_state);
7562         if (req == NULL) {
7563                 return NULL;
7564         }
7565         state->out_mem_ctx = NULL;
7566         state->dispatch_recv = cli->dispatch_recv;
7567
7568         /* In parameters */
7569
7570         /* Out parameters */
7571
7572         /* Result */
7573         ZERO_STRUCT(state->orig.out.result);
7574
7575         /* make a temporary copy, that we pass to the dispatch function */
7576         state->tmp = state->orig;
7577
7578         subreq = cli->dispatch_send(state, ev, cli,
7579                                     &ndr_table_spoolss,
7580                                     NDR_SPOOLSS_ADDPRINTPROVIDOR,
7581                                     &state->tmp);
7582         if (tevent_req_nomem(subreq, req)) {
7583                 return tevent_req_post(req, ev);
7584         }
7585         tevent_req_set_callback(subreq, rpccli_spoolss_AddPrintProvidor_done, req);
7586         return req;
7587 }
7588
7589 static void rpccli_spoolss_AddPrintProvidor_done(struct tevent_req *subreq)
7590 {
7591         struct tevent_req *req = tevent_req_callback_data(
7592                 subreq, struct tevent_req);
7593         struct rpccli_spoolss_AddPrintProvidor_state *state = tevent_req_data(
7594                 req, struct rpccli_spoolss_AddPrintProvidor_state);
7595         NTSTATUS status;
7596         TALLOC_CTX *mem_ctx;
7597
7598         if (state->out_mem_ctx) {
7599                 mem_ctx = state->out_mem_ctx;
7600         } else {
7601                 mem_ctx = state;
7602         }
7603
7604         status = state->dispatch_recv(subreq, mem_ctx);
7605         TALLOC_FREE(subreq);
7606         if (!NT_STATUS_IS_OK(status)) {
7607                 tevent_req_nterror(req, status);
7608                 return;
7609         }
7610
7611         /* Copy out parameters */
7612
7613         /* Copy result */
7614         state->orig.out.result = state->tmp.out.result;
7615
7616         /* Reset temporary structure */
7617         ZERO_STRUCT(state->tmp);
7618
7619         tevent_req_done(req);
7620 }
7621
7622 NTSTATUS rpccli_spoolss_AddPrintProvidor_recv(struct tevent_req *req,
7623                                               TALLOC_CTX *mem_ctx,
7624                                               WERROR *result)
7625 {
7626         struct rpccli_spoolss_AddPrintProvidor_state *state = tevent_req_data(
7627                 req, struct rpccli_spoolss_AddPrintProvidor_state);
7628         NTSTATUS status;
7629
7630         if (tevent_req_is_nterror(req, &status)) {
7631                 tevent_req_received(req);
7632                 return status;
7633         }
7634
7635         /* Steal possbile out parameters to the callers context */
7636         talloc_steal(mem_ctx, state->out_mem_ctx);
7637
7638         /* Return result */
7639         *result = state->orig.out.result;
7640
7641         tevent_req_received(req);
7642         return NT_STATUS_OK;
7643 }
7644
7645 NTSTATUS rpccli_spoolss_AddPrintProvidor(struct rpc_pipe_client *cli,
7646                                          TALLOC_CTX *mem_ctx,
7647                                          WERROR *werror)
7648 {
7649         struct spoolss_AddPrintProvidor r;
7650         NTSTATUS status;
7651
7652         /* In parameters */
7653
7654         status = cli->dispatch(cli,
7655                                 mem_ctx,
7656                                 &ndr_table_spoolss,
7657                                 NDR_SPOOLSS_ADDPRINTPROVIDOR,
7658                                 &r);
7659
7660         if (!NT_STATUS_IS_OK(status)) {
7661                 return status;
7662         }
7663
7664         if (NT_STATUS_IS_ERR(status)) {
7665                 return status;
7666         }
7667
7668         /* Return variables */
7669
7670         /* Return result */
7671         if (werror) {
7672                 *werror = r.out.result;
7673         }
7674
7675         return werror_to_ntstatus(r.out.result);
7676 }
7677
7678 struct rpccli_spoolss_DeletePrintProvidor_state {
7679         struct spoolss_DeletePrintProvidor orig;
7680         struct spoolss_DeletePrintProvidor tmp;
7681         TALLOC_CTX *out_mem_ctx;
7682         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7683 };
7684
7685 static void rpccli_spoolss_DeletePrintProvidor_done(struct tevent_req *subreq);
7686
7687 struct tevent_req *rpccli_spoolss_DeletePrintProvidor_send(TALLOC_CTX *mem_ctx,
7688                                                            struct tevent_context *ev,
7689                                                            struct rpc_pipe_client *cli)
7690 {
7691         struct tevent_req *req;
7692         struct rpccli_spoolss_DeletePrintProvidor_state *state;
7693         struct tevent_req *subreq;
7694
7695         req = tevent_req_create(mem_ctx, &state,
7696                                 struct rpccli_spoolss_DeletePrintProvidor_state);
7697         if (req == NULL) {
7698                 return NULL;
7699         }
7700         state->out_mem_ctx = NULL;
7701         state->dispatch_recv = cli->dispatch_recv;
7702
7703         /* In parameters */
7704
7705         /* Out parameters */
7706
7707         /* Result */
7708         ZERO_STRUCT(state->orig.out.result);
7709
7710         /* make a temporary copy, that we pass to the dispatch function */
7711         state->tmp = state->orig;
7712
7713         subreq = cli->dispatch_send(state, ev, cli,
7714                                     &ndr_table_spoolss,
7715                                     NDR_SPOOLSS_DELETEPRINTPROVIDOR,
7716                                     &state->tmp);
7717         if (tevent_req_nomem(subreq, req)) {
7718                 return tevent_req_post(req, ev);
7719         }
7720         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrintProvidor_done, req);
7721         return req;
7722 }
7723
7724 static void rpccli_spoolss_DeletePrintProvidor_done(struct tevent_req *subreq)
7725 {
7726         struct tevent_req *req = tevent_req_callback_data(
7727                 subreq, struct tevent_req);
7728         struct rpccli_spoolss_DeletePrintProvidor_state *state = tevent_req_data(
7729                 req, struct rpccli_spoolss_DeletePrintProvidor_state);
7730         NTSTATUS status;
7731         TALLOC_CTX *mem_ctx;
7732
7733         if (state->out_mem_ctx) {
7734                 mem_ctx = state->out_mem_ctx;
7735         } else {
7736                 mem_ctx = state;
7737         }
7738
7739         status = state->dispatch_recv(subreq, mem_ctx);
7740         TALLOC_FREE(subreq);
7741         if (!NT_STATUS_IS_OK(status)) {
7742                 tevent_req_nterror(req, status);
7743                 return;
7744         }
7745
7746         /* Copy out parameters */
7747
7748         /* Copy result */
7749         state->orig.out.result = state->tmp.out.result;
7750
7751         /* Reset temporary structure */
7752         ZERO_STRUCT(state->tmp);
7753
7754         tevent_req_done(req);
7755 }
7756
7757 NTSTATUS rpccli_spoolss_DeletePrintProvidor_recv(struct tevent_req *req,
7758                                                  TALLOC_CTX *mem_ctx,
7759                                                  WERROR *result)
7760 {
7761         struct rpccli_spoolss_DeletePrintProvidor_state *state = tevent_req_data(
7762                 req, struct rpccli_spoolss_DeletePrintProvidor_state);
7763         NTSTATUS status;
7764
7765         if (tevent_req_is_nterror(req, &status)) {
7766                 tevent_req_received(req);
7767                 return status;
7768         }
7769
7770         /* Steal possbile out parameters to the callers context */
7771         talloc_steal(mem_ctx, state->out_mem_ctx);
7772
7773         /* Return result */
7774         *result = state->orig.out.result;
7775
7776         tevent_req_received(req);
7777         return NT_STATUS_OK;
7778 }
7779
7780 NTSTATUS rpccli_spoolss_DeletePrintProvidor(struct rpc_pipe_client *cli,
7781                                             TALLOC_CTX *mem_ctx,
7782                                             WERROR *werror)
7783 {
7784         struct spoolss_DeletePrintProvidor r;
7785         NTSTATUS status;
7786
7787         /* In parameters */
7788
7789         status = cli->dispatch(cli,
7790                                 mem_ctx,
7791                                 &ndr_table_spoolss,
7792                                 NDR_SPOOLSS_DELETEPRINTPROVIDOR,
7793                                 &r);
7794
7795         if (!NT_STATUS_IS_OK(status)) {
7796                 return status;
7797         }
7798
7799         if (NT_STATUS_IS_ERR(status)) {
7800                 return status;
7801         }
7802
7803         /* Return variables */
7804
7805         /* Return result */
7806         if (werror) {
7807                 *werror = r.out.result;
7808         }
7809
7810         return werror_to_ntstatus(r.out.result);
7811 }
7812
7813 struct rpccli_spoolss_EnumPrintProcDataTypes_state {
7814         struct spoolss_EnumPrintProcDataTypes orig;
7815         struct spoolss_EnumPrintProcDataTypes tmp;
7816         TALLOC_CTX *out_mem_ctx;
7817         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7818 };
7819
7820 static void rpccli_spoolss_EnumPrintProcDataTypes_done(struct tevent_req *subreq);
7821
7822 struct tevent_req *rpccli_spoolss_EnumPrintProcDataTypes_send(TALLOC_CTX *mem_ctx,
7823                                                               struct tevent_context *ev,
7824                                                               struct rpc_pipe_client *cli,
7825                                                               const char *_servername /* [in] [unique,charset(UTF16)] */,
7826                                                               const char *_print_processor_name /* [in] [unique,charset(UTF16)] */,
7827                                                               uint32_t _level /* [in]  */,
7828                                                               DATA_BLOB *_buffer /* [in] [unique] */,
7829                                                               uint32_t _offered /* [in]  */,
7830                                                               uint32_t *_count /* [out] [ref] */,
7831                                                               union spoolss_PrintProcDataTypesInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
7832                                                               uint32_t *_needed /* [out] [ref] */)
7833 {
7834         struct tevent_req *req;
7835         struct rpccli_spoolss_EnumPrintProcDataTypes_state *state;
7836         struct tevent_req *subreq;
7837
7838         req = tevent_req_create(mem_ctx, &state,
7839                                 struct rpccli_spoolss_EnumPrintProcDataTypes_state);
7840         if (req == NULL) {
7841                 return NULL;
7842         }
7843         state->out_mem_ctx = NULL;
7844         state->dispatch_recv = cli->dispatch_recv;
7845
7846         /* In parameters */
7847         state->orig.in.servername = _servername;
7848         state->orig.in.print_processor_name = _print_processor_name;
7849         state->orig.in.level = _level;
7850         state->orig.in.buffer = _buffer;
7851         state->orig.in.offered = _offered;
7852
7853         /* Out parameters */
7854         state->orig.out.count = _count;
7855         state->orig.out.info = _info;
7856         state->orig.out.needed = _needed;
7857
7858         /* Result */
7859         ZERO_STRUCT(state->orig.out.result);
7860
7861         state->out_mem_ctx = talloc_named_const(state, 0,
7862                              "rpccli_spoolss_EnumPrintProcDataTypes_out_memory");
7863         if (tevent_req_nomem(state->out_mem_ctx, req)) {
7864                 return tevent_req_post(req, ev);
7865         }
7866
7867         /* make a temporary copy, that we pass to the dispatch function */
7868         state->tmp = state->orig;
7869
7870         subreq = cli->dispatch_send(state, ev, cli,
7871                                     &ndr_table_spoolss,
7872                                     NDR_SPOOLSS_ENUMPRINTPROCDATATYPES,
7873                                     &state->tmp);
7874         if (tevent_req_nomem(subreq, req)) {
7875                 return tevent_req_post(req, ev);
7876         }
7877         tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrintProcDataTypes_done, req);
7878         return req;
7879 }
7880
7881 static void rpccli_spoolss_EnumPrintProcDataTypes_done(struct tevent_req *subreq)
7882 {
7883         struct tevent_req *req = tevent_req_callback_data(
7884                 subreq, struct tevent_req);
7885         struct rpccli_spoolss_EnumPrintProcDataTypes_state *state = tevent_req_data(
7886                 req, struct rpccli_spoolss_EnumPrintProcDataTypes_state);
7887         NTSTATUS status;
7888         TALLOC_CTX *mem_ctx;
7889
7890         if (state->out_mem_ctx) {
7891                 mem_ctx = state->out_mem_ctx;
7892         } else {
7893                 mem_ctx = state;
7894         }
7895
7896         status = state->dispatch_recv(subreq, mem_ctx);
7897         TALLOC_FREE(subreq);
7898         if (!NT_STATUS_IS_OK(status)) {
7899                 tevent_req_nterror(req, status);
7900                 return;
7901         }
7902
7903         /* Copy out parameters */
7904         *state->orig.out.count = *state->tmp.out.count;
7905         *state->orig.out.info = *state->tmp.out.info;
7906         *state->orig.out.needed = *state->tmp.out.needed;
7907
7908         /* Copy result */
7909         state->orig.out.result = state->tmp.out.result;
7910
7911         /* Reset temporary structure */
7912         ZERO_STRUCT(state->tmp);
7913
7914         tevent_req_done(req);
7915 }
7916
7917 NTSTATUS rpccli_spoolss_EnumPrintProcDataTypes_recv(struct tevent_req *req,
7918                                                     TALLOC_CTX *mem_ctx,
7919                                                     WERROR *result)
7920 {
7921         struct rpccli_spoolss_EnumPrintProcDataTypes_state *state = tevent_req_data(
7922                 req, struct rpccli_spoolss_EnumPrintProcDataTypes_state);
7923         NTSTATUS status;
7924
7925         if (tevent_req_is_nterror(req, &status)) {
7926                 tevent_req_received(req);
7927                 return status;
7928         }
7929
7930         /* Steal possbile out parameters to the callers context */
7931         talloc_steal(mem_ctx, state->out_mem_ctx);
7932
7933         /* Return result */
7934         *result = state->orig.out.result;
7935
7936         tevent_req_received(req);
7937         return NT_STATUS_OK;
7938 }
7939
7940 NTSTATUS rpccli_spoolss_EnumPrintProcDataTypes(struct rpc_pipe_client *cli,
7941                                                TALLOC_CTX *mem_ctx,
7942                                                const char *servername /* [in] [unique,charset(UTF16)] */,
7943                                                const char *print_processor_name /* [in] [unique,charset(UTF16)] */,
7944                                                uint32_t level /* [in]  */,
7945                                                DATA_BLOB *buffer /* [in] [unique] */,
7946                                                uint32_t offered /* [in]  */,
7947                                                uint32_t *count /* [out] [ref] */,
7948                                                union spoolss_PrintProcDataTypesInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
7949                                                uint32_t *needed /* [out] [ref] */,
7950                                                WERROR *werror)
7951 {
7952         struct spoolss_EnumPrintProcDataTypes r;
7953         NTSTATUS status;
7954
7955         /* In parameters */
7956         r.in.servername = servername;
7957         r.in.print_processor_name = print_processor_name;
7958         r.in.level = level;
7959         r.in.buffer = buffer;
7960         r.in.offered = offered;
7961
7962         status = cli->dispatch(cli,
7963                                 mem_ctx,
7964                                 &ndr_table_spoolss,
7965                                 NDR_SPOOLSS_ENUMPRINTPROCDATATYPES,
7966                                 &r);
7967
7968         if (!NT_STATUS_IS_OK(status)) {
7969                 return status;
7970         }
7971
7972         if (NT_STATUS_IS_ERR(status)) {
7973                 return status;
7974         }
7975
7976         /* Return variables */
7977         *count = *r.out.count;
7978         *info = *r.out.info;
7979         *needed = *r.out.needed;
7980
7981         /* Return result */
7982         if (werror) {
7983                 *werror = r.out.result;
7984         }
7985
7986         return werror_to_ntstatus(r.out.result);
7987 }
7988
7989 struct rpccli_spoolss_ResetPrinter_state {
7990         struct spoolss_ResetPrinter orig;
7991         struct spoolss_ResetPrinter tmp;
7992         TALLOC_CTX *out_mem_ctx;
7993         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7994 };
7995
7996 static void rpccli_spoolss_ResetPrinter_done(struct tevent_req *subreq);
7997
7998 struct tevent_req *rpccli_spoolss_ResetPrinter_send(TALLOC_CTX *mem_ctx,
7999                                                     struct tevent_context *ev,
8000                                                     struct rpc_pipe_client *cli,
8001                                                     struct policy_handle *_handle /* [in] [ref] */,
8002                                                     const char *_data_type /* [in] [unique,charset(UTF16)] */,
8003                                                     struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */)
8004 {
8005         struct tevent_req *req;
8006         struct rpccli_spoolss_ResetPrinter_state *state;
8007         struct tevent_req *subreq;
8008
8009         req = tevent_req_create(mem_ctx, &state,
8010                                 struct rpccli_spoolss_ResetPrinter_state);
8011         if (req == NULL) {
8012                 return NULL;
8013         }
8014         state->out_mem_ctx = NULL;
8015         state->dispatch_recv = cli->dispatch_recv;
8016
8017         /* In parameters */
8018         state->orig.in.handle = _handle;
8019         state->orig.in.data_type = _data_type;
8020         state->orig.in.devmode_ctr = _devmode_ctr;
8021
8022         /* Out parameters */
8023
8024         /* Result */
8025         ZERO_STRUCT(state->orig.out.result);
8026
8027         /* make a temporary copy, that we pass to the dispatch function */
8028         state->tmp = state->orig;
8029
8030         subreq = cli->dispatch_send(state, ev, cli,
8031                                     &ndr_table_spoolss,
8032                                     NDR_SPOOLSS_RESETPRINTER,
8033                                     &state->tmp);
8034         if (tevent_req_nomem(subreq, req)) {
8035                 return tevent_req_post(req, ev);
8036         }
8037         tevent_req_set_callback(subreq, rpccli_spoolss_ResetPrinter_done, req);
8038         return req;
8039 }
8040
8041 static void rpccli_spoolss_ResetPrinter_done(struct tevent_req *subreq)
8042 {
8043         struct tevent_req *req = tevent_req_callback_data(
8044                 subreq, struct tevent_req);
8045         struct rpccli_spoolss_ResetPrinter_state *state = tevent_req_data(
8046                 req, struct rpccli_spoolss_ResetPrinter_state);
8047         NTSTATUS status;
8048         TALLOC_CTX *mem_ctx;
8049
8050         if (state->out_mem_ctx) {
8051                 mem_ctx = state->out_mem_ctx;
8052         } else {
8053                 mem_ctx = state;
8054         }
8055
8056         status = state->dispatch_recv(subreq, mem_ctx);
8057         TALLOC_FREE(subreq);
8058         if (!NT_STATUS_IS_OK(status)) {
8059                 tevent_req_nterror(req, status);
8060                 return;
8061         }
8062
8063         /* Copy out parameters */
8064
8065         /* Copy result */
8066         state->orig.out.result = state->tmp.out.result;
8067
8068         /* Reset temporary structure */
8069         ZERO_STRUCT(state->tmp);
8070
8071         tevent_req_done(req);
8072 }
8073
8074 NTSTATUS rpccli_spoolss_ResetPrinter_recv(struct tevent_req *req,
8075                                           TALLOC_CTX *mem_ctx,
8076                                           WERROR *result)
8077 {
8078         struct rpccli_spoolss_ResetPrinter_state *state = tevent_req_data(
8079                 req, struct rpccli_spoolss_ResetPrinter_state);
8080         NTSTATUS status;
8081
8082         if (tevent_req_is_nterror(req, &status)) {
8083                 tevent_req_received(req);
8084                 return status;
8085         }
8086
8087         /* Steal possbile out parameters to the callers context */
8088         talloc_steal(mem_ctx, state->out_mem_ctx);
8089
8090         /* Return result */
8091         *result = state->orig.out.result;
8092
8093         tevent_req_received(req);
8094         return NT_STATUS_OK;
8095 }
8096
8097 NTSTATUS rpccli_spoolss_ResetPrinter(struct rpc_pipe_client *cli,
8098                                      TALLOC_CTX *mem_ctx,
8099                                      struct policy_handle *handle /* [in] [ref] */,
8100                                      const char *data_type /* [in] [unique,charset(UTF16)] */,
8101                                      struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
8102                                      WERROR *werror)
8103 {
8104         struct spoolss_ResetPrinter r;
8105         NTSTATUS status;
8106
8107         /* In parameters */
8108         r.in.handle = handle;
8109         r.in.data_type = data_type;
8110         r.in.devmode_ctr = devmode_ctr;
8111
8112         status = cli->dispatch(cli,
8113                                 mem_ctx,
8114                                 &ndr_table_spoolss,
8115                                 NDR_SPOOLSS_RESETPRINTER,
8116                                 &r);
8117
8118         if (!NT_STATUS_IS_OK(status)) {
8119                 return status;
8120         }
8121
8122         if (NT_STATUS_IS_ERR(status)) {
8123                 return status;
8124         }
8125
8126         /* Return variables */
8127
8128         /* Return result */
8129         if (werror) {
8130                 *werror = r.out.result;
8131         }
8132
8133         return werror_to_ntstatus(r.out.result);
8134 }
8135
8136 struct rpccli_spoolss_GetPrinterDriver2_state {
8137         struct spoolss_GetPrinterDriver2 orig;
8138         struct spoolss_GetPrinterDriver2 tmp;
8139         TALLOC_CTX *out_mem_ctx;
8140         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8141 };
8142
8143 static void rpccli_spoolss_GetPrinterDriver2_done(struct tevent_req *subreq);
8144
8145 struct tevent_req *rpccli_spoolss_GetPrinterDriver2_send(TALLOC_CTX *mem_ctx,
8146                                                          struct tevent_context *ev,
8147                                                          struct rpc_pipe_client *cli,
8148                                                          struct policy_handle *_handle /* [in] [ref] */,
8149                                                          const char *_architecture /* [in] [unique,charset(UTF16)] */,
8150                                                          uint32_t _level /* [in]  */,
8151                                                          DATA_BLOB *_buffer /* [in] [unique] */,
8152                                                          uint32_t _offered /* [in]  */,
8153                                                          uint32_t _client_major_version /* [in]  */,
8154                                                          uint32_t _client_minor_version /* [in]  */,
8155                                                          union spoolss_DriverInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
8156                                                          uint32_t *_needed /* [out] [ref] */,
8157                                                          uint32_t *_server_major_version /* [out] [ref] */,
8158                                                          uint32_t *_server_minor_version /* [out] [ref] */)
8159 {
8160         struct tevent_req *req;
8161         struct rpccli_spoolss_GetPrinterDriver2_state *state;
8162         struct tevent_req *subreq;
8163
8164         req = tevent_req_create(mem_ctx, &state,
8165                                 struct rpccli_spoolss_GetPrinterDriver2_state);
8166         if (req == NULL) {
8167                 return NULL;
8168         }
8169         state->out_mem_ctx = NULL;
8170         state->dispatch_recv = cli->dispatch_recv;
8171
8172         /* In parameters */
8173         state->orig.in.handle = _handle;
8174         state->orig.in.architecture = _architecture;
8175         state->orig.in.level = _level;
8176         state->orig.in.buffer = _buffer;
8177         state->orig.in.offered = _offered;
8178         state->orig.in.client_major_version = _client_major_version;
8179         state->orig.in.client_minor_version = _client_minor_version;
8180
8181         /* Out parameters */
8182         state->orig.out.info = _info;
8183         state->orig.out.needed = _needed;
8184         state->orig.out.server_major_version = _server_major_version;
8185         state->orig.out.server_minor_version = _server_minor_version;
8186
8187         /* Result */
8188         ZERO_STRUCT(state->orig.out.result);
8189
8190         state->out_mem_ctx = talloc_named_const(state, 0,
8191                              "rpccli_spoolss_GetPrinterDriver2_out_memory");
8192         if (tevent_req_nomem(state->out_mem_ctx, req)) {
8193                 return tevent_req_post(req, ev);
8194         }
8195
8196         /* make a temporary copy, that we pass to the dispatch function */
8197         state->tmp = state->orig;
8198
8199         subreq = cli->dispatch_send(state, ev, cli,
8200                                     &ndr_table_spoolss,
8201                                     NDR_SPOOLSS_GETPRINTERDRIVER2,
8202                                     &state->tmp);
8203         if (tevent_req_nomem(subreq, req)) {
8204                 return tevent_req_post(req, ev);
8205         }
8206         tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriver2_done, req);
8207         return req;
8208 }
8209
8210 static void rpccli_spoolss_GetPrinterDriver2_done(struct tevent_req *subreq)
8211 {
8212         struct tevent_req *req = tevent_req_callback_data(
8213                 subreq, struct tevent_req);
8214         struct rpccli_spoolss_GetPrinterDriver2_state *state = tevent_req_data(
8215                 req, struct rpccli_spoolss_GetPrinterDriver2_state);
8216         NTSTATUS status;
8217         TALLOC_CTX *mem_ctx;
8218
8219         if (state->out_mem_ctx) {
8220                 mem_ctx = state->out_mem_ctx;
8221         } else {
8222                 mem_ctx = state;
8223         }
8224
8225         status = state->dispatch_recv(subreq, mem_ctx);
8226         TALLOC_FREE(subreq);
8227         if (!NT_STATUS_IS_OK(status)) {
8228                 tevent_req_nterror(req, status);
8229                 return;
8230         }
8231
8232         /* Copy out parameters */
8233         if (state->orig.out.info && state->tmp.out.info) {
8234                 *state->orig.out.info = *state->tmp.out.info;
8235         }
8236         *state->orig.out.needed = *state->tmp.out.needed;
8237         *state->orig.out.server_major_version = *state->tmp.out.server_major_version;
8238         *state->orig.out.server_minor_version = *state->tmp.out.server_minor_version;
8239
8240         /* Copy result */
8241         state->orig.out.result = state->tmp.out.result;
8242
8243         /* Reset temporary structure */
8244         ZERO_STRUCT(state->tmp);
8245
8246         tevent_req_done(req);
8247 }
8248
8249 NTSTATUS rpccli_spoolss_GetPrinterDriver2_recv(struct tevent_req *req,
8250                                                TALLOC_CTX *mem_ctx,
8251                                                WERROR *result)
8252 {
8253         struct rpccli_spoolss_GetPrinterDriver2_state *state = tevent_req_data(
8254                 req, struct rpccli_spoolss_GetPrinterDriver2_state);
8255         NTSTATUS status;
8256
8257         if (tevent_req_is_nterror(req, &status)) {
8258                 tevent_req_received(req);
8259                 return status;
8260         }
8261
8262         /* Steal possbile out parameters to the callers context */
8263         talloc_steal(mem_ctx, state->out_mem_ctx);
8264
8265         /* Return result */
8266         *result = state->orig.out.result;
8267
8268         tevent_req_received(req);
8269         return NT_STATUS_OK;
8270 }
8271
8272 NTSTATUS rpccli_spoolss_GetPrinterDriver2(struct rpc_pipe_client *cli,
8273                                           TALLOC_CTX *mem_ctx,
8274                                           struct policy_handle *handle /* [in] [ref] */,
8275                                           const char *architecture /* [in] [unique,charset(UTF16)] */,
8276                                           uint32_t level /* [in]  */,
8277                                           DATA_BLOB *buffer /* [in] [unique] */,
8278                                           uint32_t offered /* [in]  */,
8279                                           uint32_t client_major_version /* [in]  */,
8280                                           uint32_t client_minor_version /* [in]  */,
8281                                           union spoolss_DriverInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
8282                                           uint32_t *needed /* [out] [ref] */,
8283                                           uint32_t *server_major_version /* [out] [ref] */,
8284                                           uint32_t *server_minor_version /* [out] [ref] */,
8285                                           WERROR *werror)
8286 {
8287         struct spoolss_GetPrinterDriver2 r;
8288         NTSTATUS status;
8289
8290         /* In parameters */
8291         r.in.handle = handle;
8292         r.in.architecture = architecture;
8293         r.in.level = level;
8294         r.in.buffer = buffer;
8295         r.in.offered = offered;
8296         r.in.client_major_version = client_major_version;
8297         r.in.client_minor_version = client_minor_version;
8298
8299         status = cli->dispatch(cli,
8300                                 mem_ctx,
8301                                 &ndr_table_spoolss,
8302                                 NDR_SPOOLSS_GETPRINTERDRIVER2,
8303                                 &r);
8304
8305         if (!NT_STATUS_IS_OK(status)) {
8306                 return status;
8307         }
8308
8309         if (NT_STATUS_IS_ERR(status)) {
8310                 return status;
8311         }
8312
8313         /* Return variables */
8314         if (info && r.out.info) {
8315                 *info = *r.out.info;
8316         }
8317         *needed = *r.out.needed;
8318         *server_major_version = *r.out.server_major_version;
8319         *server_minor_version = *r.out.server_minor_version;
8320
8321         /* Return result */
8322         if (werror) {
8323                 *werror = r.out.result;
8324         }
8325
8326         return werror_to_ntstatus(r.out.result);
8327 }
8328
8329 struct rpccli_spoolss_FindFirstPrinterChangeNotification_state {
8330         struct spoolss_FindFirstPrinterChangeNotification orig;
8331         struct spoolss_FindFirstPrinterChangeNotification tmp;
8332         TALLOC_CTX *out_mem_ctx;
8333         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8334 };
8335
8336 static void rpccli_spoolss_FindFirstPrinterChangeNotification_done(struct tevent_req *subreq);
8337
8338 struct tevent_req *rpccli_spoolss_FindFirstPrinterChangeNotification_send(TALLOC_CTX *mem_ctx,
8339                                                                           struct tevent_context *ev,
8340                                                                           struct rpc_pipe_client *cli)
8341 {
8342         struct tevent_req *req;
8343         struct rpccli_spoolss_FindFirstPrinterChangeNotification_state *state;
8344         struct tevent_req *subreq;
8345
8346         req = tevent_req_create(mem_ctx, &state,
8347                                 struct rpccli_spoolss_FindFirstPrinterChangeNotification_state);
8348         if (req == NULL) {
8349                 return NULL;
8350         }
8351         state->out_mem_ctx = NULL;
8352         state->dispatch_recv = cli->dispatch_recv;
8353
8354         /* In parameters */
8355
8356         /* Out parameters */
8357
8358         /* Result */
8359         ZERO_STRUCT(state->orig.out.result);
8360
8361         /* make a temporary copy, that we pass to the dispatch function */
8362         state->tmp = state->orig;
8363
8364         subreq = cli->dispatch_send(state, ev, cli,
8365                                     &ndr_table_spoolss,
8366                                     NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION,
8367                                     &state->tmp);
8368         if (tevent_req_nomem(subreq, req)) {
8369                 return tevent_req_post(req, ev);
8370         }
8371         tevent_req_set_callback(subreq, rpccli_spoolss_FindFirstPrinterChangeNotification_done, req);
8372         return req;
8373 }
8374
8375 static void rpccli_spoolss_FindFirstPrinterChangeNotification_done(struct tevent_req *subreq)
8376 {
8377         struct tevent_req *req = tevent_req_callback_data(
8378                 subreq, struct tevent_req);
8379         struct rpccli_spoolss_FindFirstPrinterChangeNotification_state *state = tevent_req_data(
8380                 req, struct rpccli_spoolss_FindFirstPrinterChangeNotification_state);
8381         NTSTATUS status;
8382         TALLOC_CTX *mem_ctx;
8383
8384         if (state->out_mem_ctx) {
8385                 mem_ctx = state->out_mem_ctx;
8386         } else {
8387                 mem_ctx = state;
8388         }
8389
8390         status = state->dispatch_recv(subreq, mem_ctx);
8391         TALLOC_FREE(subreq);
8392         if (!NT_STATUS_IS_OK(status)) {
8393                 tevent_req_nterror(req, status);
8394                 return;
8395         }
8396
8397         /* Copy out parameters */
8398
8399         /* Copy result */
8400         state->orig.out.result = state->tmp.out.result;
8401
8402         /* Reset temporary structure */
8403         ZERO_STRUCT(state->tmp);
8404
8405         tevent_req_done(req);
8406 }
8407
8408 NTSTATUS rpccli_spoolss_FindFirstPrinterChangeNotification_recv(struct tevent_req *req,
8409                                                                 TALLOC_CTX *mem_ctx,
8410                                                                 WERROR *result)
8411 {
8412         struct rpccli_spoolss_FindFirstPrinterChangeNotification_state *state = tevent_req_data(
8413                 req, struct rpccli_spoolss_FindFirstPrinterChangeNotification_state);
8414         NTSTATUS status;
8415
8416         if (tevent_req_is_nterror(req, &status)) {
8417                 tevent_req_received(req);
8418                 return status;
8419         }
8420
8421         /* Steal possbile out parameters to the callers context */
8422         talloc_steal(mem_ctx, state->out_mem_ctx);
8423
8424         /* Return result */
8425         *result = state->orig.out.result;
8426
8427         tevent_req_received(req);
8428         return NT_STATUS_OK;
8429 }
8430
8431 NTSTATUS rpccli_spoolss_FindFirstPrinterChangeNotification(struct rpc_pipe_client *cli,
8432                                                            TALLOC_CTX *mem_ctx,
8433                                                            WERROR *werror)
8434 {
8435         struct spoolss_FindFirstPrinterChangeNotification r;
8436         NTSTATUS status;
8437
8438         /* In parameters */
8439
8440         status = cli->dispatch(cli,
8441                                 mem_ctx,
8442                                 &ndr_table_spoolss,
8443                                 NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION,
8444                                 &r);
8445
8446         if (!NT_STATUS_IS_OK(status)) {
8447                 return status;
8448         }
8449
8450         if (NT_STATUS_IS_ERR(status)) {
8451                 return status;
8452         }
8453
8454         /* Return variables */
8455
8456         /* Return result */
8457         if (werror) {
8458                 *werror = r.out.result;
8459         }
8460
8461         return werror_to_ntstatus(r.out.result);
8462 }
8463
8464 struct rpccli_spoolss_FindNextPrinterChangeNotification_state {
8465         struct spoolss_FindNextPrinterChangeNotification orig;
8466         struct spoolss_FindNextPrinterChangeNotification tmp;
8467         TALLOC_CTX *out_mem_ctx;
8468         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8469 };
8470
8471 static void rpccli_spoolss_FindNextPrinterChangeNotification_done(struct tevent_req *subreq);
8472
8473 struct tevent_req *rpccli_spoolss_FindNextPrinterChangeNotification_send(TALLOC_CTX *mem_ctx,
8474                                                                          struct tevent_context *ev,
8475                                                                          struct rpc_pipe_client *cli)
8476 {
8477         struct tevent_req *req;
8478         struct rpccli_spoolss_FindNextPrinterChangeNotification_state *state;
8479         struct tevent_req *subreq;
8480
8481         req = tevent_req_create(mem_ctx, &state,
8482                                 struct rpccli_spoolss_FindNextPrinterChangeNotification_state);
8483         if (req == NULL) {
8484                 return NULL;
8485         }
8486         state->out_mem_ctx = NULL;
8487         state->dispatch_recv = cli->dispatch_recv;
8488
8489         /* In parameters */
8490
8491         /* Out parameters */
8492
8493         /* Result */
8494         ZERO_STRUCT(state->orig.out.result);
8495
8496         /* make a temporary copy, that we pass to the dispatch function */
8497         state->tmp = state->orig;
8498
8499         subreq = cli->dispatch_send(state, ev, cli,
8500                                     &ndr_table_spoolss,
8501                                     NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION,
8502                                     &state->tmp);
8503         if (tevent_req_nomem(subreq, req)) {
8504                 return tevent_req_post(req, ev);
8505         }
8506         tevent_req_set_callback(subreq, rpccli_spoolss_FindNextPrinterChangeNotification_done, req);
8507         return req;
8508 }
8509
8510 static void rpccli_spoolss_FindNextPrinterChangeNotification_done(struct tevent_req *subreq)
8511 {
8512         struct tevent_req *req = tevent_req_callback_data(
8513                 subreq, struct tevent_req);
8514         struct rpccli_spoolss_FindNextPrinterChangeNotification_state *state = tevent_req_data(
8515                 req, struct rpccli_spoolss_FindNextPrinterChangeNotification_state);
8516         NTSTATUS status;
8517         TALLOC_CTX *mem_ctx;
8518
8519         if (state->out_mem_ctx) {
8520                 mem_ctx = state->out_mem_ctx;
8521         } else {
8522                 mem_ctx = state;
8523         }
8524
8525         status = state->dispatch_recv(subreq, mem_ctx);
8526         TALLOC_FREE(subreq);
8527         if (!NT_STATUS_IS_OK(status)) {
8528                 tevent_req_nterror(req, status);
8529                 return;
8530         }
8531
8532         /* Copy out parameters */
8533
8534         /* Copy result */
8535         state->orig.out.result = state->tmp.out.result;
8536
8537         /* Reset temporary structure */
8538         ZERO_STRUCT(state->tmp);
8539
8540         tevent_req_done(req);
8541 }
8542
8543 NTSTATUS rpccli_spoolss_FindNextPrinterChangeNotification_recv(struct tevent_req *req,
8544                                                                TALLOC_CTX *mem_ctx,
8545                                                                WERROR *result)
8546 {
8547         struct rpccli_spoolss_FindNextPrinterChangeNotification_state *state = tevent_req_data(
8548                 req, struct rpccli_spoolss_FindNextPrinterChangeNotification_state);
8549         NTSTATUS status;
8550
8551         if (tevent_req_is_nterror(req, &status)) {
8552                 tevent_req_received(req);
8553                 return status;
8554         }
8555
8556         /* Steal possbile out parameters to the callers context */
8557         talloc_steal(mem_ctx, state->out_mem_ctx);
8558
8559         /* Return result */
8560         *result = state->orig.out.result;
8561
8562         tevent_req_received(req);
8563         return NT_STATUS_OK;
8564 }
8565
8566 NTSTATUS rpccli_spoolss_FindNextPrinterChangeNotification(struct rpc_pipe_client *cli,
8567                                                           TALLOC_CTX *mem_ctx,
8568                                                           WERROR *werror)
8569 {
8570         struct spoolss_FindNextPrinterChangeNotification r;
8571         NTSTATUS status;
8572
8573         /* In parameters */
8574
8575         status = cli->dispatch(cli,
8576                                 mem_ctx,
8577                                 &ndr_table_spoolss,
8578                                 NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION,
8579                                 &r);
8580
8581         if (!NT_STATUS_IS_OK(status)) {
8582                 return status;
8583         }
8584
8585         if (NT_STATUS_IS_ERR(status)) {
8586                 return status;
8587         }
8588
8589         /* Return variables */
8590
8591         /* Return result */
8592         if (werror) {
8593                 *werror = r.out.result;
8594         }
8595
8596         return werror_to_ntstatus(r.out.result);
8597 }
8598
8599 struct rpccli_spoolss_FindClosePrinterNotify_state {
8600         struct spoolss_FindClosePrinterNotify orig;
8601         struct spoolss_FindClosePrinterNotify tmp;
8602         TALLOC_CTX *out_mem_ctx;
8603         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8604 };
8605
8606 static void rpccli_spoolss_FindClosePrinterNotify_done(struct tevent_req *subreq);
8607
8608 struct tevent_req *rpccli_spoolss_FindClosePrinterNotify_send(TALLOC_CTX *mem_ctx,
8609                                                               struct tevent_context *ev,
8610                                                               struct rpc_pipe_client *cli,
8611                                                               struct policy_handle *_handle /* [in] [ref] */)
8612 {
8613         struct tevent_req *req;
8614         struct rpccli_spoolss_FindClosePrinterNotify_state *state;
8615         struct tevent_req *subreq;
8616
8617         req = tevent_req_create(mem_ctx, &state,
8618                                 struct rpccli_spoolss_FindClosePrinterNotify_state);
8619         if (req == NULL) {
8620                 return NULL;
8621         }
8622         state->out_mem_ctx = NULL;
8623         state->dispatch_recv = cli->dispatch_recv;
8624
8625         /* In parameters */
8626         state->orig.in.handle = _handle;
8627
8628         /* Out parameters */
8629
8630         /* Result */
8631         ZERO_STRUCT(state->orig.out.result);
8632
8633         /* make a temporary copy, that we pass to the dispatch function */
8634         state->tmp = state->orig;
8635
8636         subreq = cli->dispatch_send(state, ev, cli,
8637                                     &ndr_table_spoolss,
8638                                     NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY,
8639                                     &state->tmp);
8640         if (tevent_req_nomem(subreq, req)) {
8641                 return tevent_req_post(req, ev);
8642         }
8643         tevent_req_set_callback(subreq, rpccli_spoolss_FindClosePrinterNotify_done, req);
8644         return req;
8645 }
8646
8647 static void rpccli_spoolss_FindClosePrinterNotify_done(struct tevent_req *subreq)
8648 {
8649         struct tevent_req *req = tevent_req_callback_data(
8650                 subreq, struct tevent_req);
8651         struct rpccli_spoolss_FindClosePrinterNotify_state *state = tevent_req_data(
8652                 req, struct rpccli_spoolss_FindClosePrinterNotify_state);
8653         NTSTATUS status;
8654         TALLOC_CTX *mem_ctx;
8655
8656         if (state->out_mem_ctx) {
8657                 mem_ctx = state->out_mem_ctx;
8658         } else {
8659                 mem_ctx = state;
8660         }
8661
8662         status = state->dispatch_recv(subreq, mem_ctx);
8663         TALLOC_FREE(subreq);
8664         if (!NT_STATUS_IS_OK(status)) {
8665                 tevent_req_nterror(req, status);
8666                 return;
8667         }
8668
8669         /* Copy out parameters */
8670
8671         /* Copy result */
8672         state->orig.out.result = state->tmp.out.result;
8673
8674         /* Reset temporary structure */
8675         ZERO_STRUCT(state->tmp);
8676
8677         tevent_req_done(req);
8678 }
8679
8680 NTSTATUS rpccli_spoolss_FindClosePrinterNotify_recv(struct tevent_req *req,
8681                                                     TALLOC_CTX *mem_ctx,
8682                                                     WERROR *result)
8683 {
8684         struct rpccli_spoolss_FindClosePrinterNotify_state *state = tevent_req_data(
8685                 req, struct rpccli_spoolss_FindClosePrinterNotify_state);
8686         NTSTATUS status;
8687
8688         if (tevent_req_is_nterror(req, &status)) {
8689                 tevent_req_received(req);
8690                 return status;
8691         }
8692
8693         /* Steal possbile out parameters to the callers context */
8694         talloc_steal(mem_ctx, state->out_mem_ctx);
8695
8696         /* Return result */
8697         *result = state->orig.out.result;
8698
8699         tevent_req_received(req);
8700         return NT_STATUS_OK;
8701 }
8702
8703 NTSTATUS rpccli_spoolss_FindClosePrinterNotify(struct rpc_pipe_client *cli,
8704                                                TALLOC_CTX *mem_ctx,
8705                                                struct policy_handle *handle /* [in] [ref] */,
8706                                                WERROR *werror)
8707 {
8708         struct spoolss_FindClosePrinterNotify r;
8709         NTSTATUS status;
8710
8711         /* In parameters */
8712         r.in.handle = handle;
8713
8714         status = cli->dispatch(cli,
8715                                 mem_ctx,
8716                                 &ndr_table_spoolss,
8717                                 NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY,
8718                                 &r);
8719
8720         if (!NT_STATUS_IS_OK(status)) {
8721                 return status;
8722         }
8723
8724         if (NT_STATUS_IS_ERR(status)) {
8725                 return status;
8726         }
8727
8728         /* Return variables */
8729
8730         /* Return result */
8731         if (werror) {
8732                 *werror = r.out.result;
8733         }
8734
8735         return werror_to_ntstatus(r.out.result);
8736 }
8737
8738 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state {
8739         struct spoolss_RouterFindFirstPrinterChangeNotificationOld orig;
8740         struct spoolss_RouterFindFirstPrinterChangeNotificationOld tmp;
8741         TALLOC_CTX *out_mem_ctx;
8742         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8743 };
8744
8745 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_done(struct tevent_req *subreq);
8746
8747 struct tevent_req *rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_send(TALLOC_CTX *mem_ctx,
8748                                                                                    struct tevent_context *ev,
8749                                                                                    struct rpc_pipe_client *cli)
8750 {
8751         struct tevent_req *req;
8752         struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state *state;
8753         struct tevent_req *subreq;
8754
8755         req = tevent_req_create(mem_ctx, &state,
8756                                 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state);
8757         if (req == NULL) {
8758                 return NULL;
8759         }
8760         state->out_mem_ctx = NULL;
8761         state->dispatch_recv = cli->dispatch_recv;
8762
8763         /* In parameters */
8764
8765         /* Out parameters */
8766
8767         /* Result */
8768         ZERO_STRUCT(state->orig.out.result);
8769
8770         /* make a temporary copy, that we pass to the dispatch function */
8771         state->tmp = state->orig;
8772
8773         subreq = cli->dispatch_send(state, ev, cli,
8774                                     &ndr_table_spoolss,
8775                                     NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD,
8776                                     &state->tmp);
8777         if (tevent_req_nomem(subreq, req)) {
8778                 return tevent_req_post(req, ev);
8779         }
8780         tevent_req_set_callback(subreq, rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_done, req);
8781         return req;
8782 }
8783
8784 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_done(struct tevent_req *subreq)
8785 {
8786         struct tevent_req *req = tevent_req_callback_data(
8787                 subreq, struct tevent_req);
8788         struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state *state = tevent_req_data(
8789                 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state);
8790         NTSTATUS status;
8791         TALLOC_CTX *mem_ctx;
8792
8793         if (state->out_mem_ctx) {
8794                 mem_ctx = state->out_mem_ctx;
8795         } else {
8796                 mem_ctx = state;
8797         }
8798
8799         status = state->dispatch_recv(subreq, mem_ctx);
8800         TALLOC_FREE(subreq);
8801         if (!NT_STATUS_IS_OK(status)) {
8802                 tevent_req_nterror(req, status);
8803                 return;
8804         }
8805
8806         /* Copy out parameters */
8807
8808         /* Copy result */
8809         state->orig.out.result = state->tmp.out.result;
8810
8811         /* Reset temporary structure */
8812         ZERO_STRUCT(state->tmp);
8813
8814         tevent_req_done(req);
8815 }
8816
8817 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_recv(struct tevent_req *req,
8818                                                                          TALLOC_CTX *mem_ctx,
8819                                                                          WERROR *result)
8820 {
8821         struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state *state = tevent_req_data(
8822                 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state);
8823         NTSTATUS status;
8824
8825         if (tevent_req_is_nterror(req, &status)) {
8826                 tevent_req_received(req);
8827                 return status;
8828         }
8829
8830         /* Steal possbile out parameters to the callers context */
8831         talloc_steal(mem_ctx, state->out_mem_ctx);
8832
8833         /* Return result */
8834         *result = state->orig.out.result;
8835
8836         tevent_req_received(req);
8837         return NT_STATUS_OK;
8838 }
8839
8840 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct rpc_pipe_client *cli,
8841                                                                     TALLOC_CTX *mem_ctx,
8842                                                                     WERROR *werror)
8843 {
8844         struct spoolss_RouterFindFirstPrinterChangeNotificationOld r;
8845         NTSTATUS status;
8846
8847         /* In parameters */
8848
8849         status = cli->dispatch(cli,
8850                                 mem_ctx,
8851                                 &ndr_table_spoolss,
8852                                 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD,
8853                                 &r);
8854
8855         if (!NT_STATUS_IS_OK(status)) {
8856                 return status;
8857         }
8858
8859         if (NT_STATUS_IS_ERR(status)) {
8860                 return status;
8861         }
8862
8863         /* Return variables */
8864
8865         /* Return result */
8866         if (werror) {
8867                 *werror = r.out.result;
8868         }
8869
8870         return werror_to_ntstatus(r.out.result);
8871 }
8872
8873 struct rpccli_spoolss_ReplyOpenPrinter_state {
8874         struct spoolss_ReplyOpenPrinter orig;
8875         struct spoolss_ReplyOpenPrinter tmp;
8876         TALLOC_CTX *out_mem_ctx;
8877         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8878 };
8879
8880 static void rpccli_spoolss_ReplyOpenPrinter_done(struct tevent_req *subreq);
8881
8882 struct tevent_req *rpccli_spoolss_ReplyOpenPrinter_send(TALLOC_CTX *mem_ctx,
8883                                                         struct tevent_context *ev,
8884                                                         struct rpc_pipe_client *cli,
8885                                                         const char *_server_name /* [in] [charset(UTF16)] */,
8886                                                         uint32_t _printer_local /* [in]  */,
8887                                                         enum winreg_Type _type /* [in]  */,
8888                                                         uint32_t _bufsize /* [in] [range(0,512)] */,
8889                                                         uint8_t *_buffer /* [in] [unique,size_is(bufsize)] */,
8890                                                         struct policy_handle *_handle /* [out] [ref] */)
8891 {
8892         struct tevent_req *req;
8893         struct rpccli_spoolss_ReplyOpenPrinter_state *state;
8894         struct tevent_req *subreq;
8895
8896         req = tevent_req_create(mem_ctx, &state,
8897                                 struct rpccli_spoolss_ReplyOpenPrinter_state);
8898         if (req == NULL) {
8899                 return NULL;
8900         }
8901         state->out_mem_ctx = NULL;
8902         state->dispatch_recv = cli->dispatch_recv;
8903
8904         /* In parameters */
8905         state->orig.in.server_name = _server_name;
8906         state->orig.in.printer_local = _printer_local;
8907         state->orig.in.type = _type;
8908         state->orig.in.bufsize = _bufsize;
8909         state->orig.in.buffer = _buffer;
8910
8911         /* Out parameters */
8912         state->orig.out.handle = _handle;
8913
8914         /* Result */
8915         ZERO_STRUCT(state->orig.out.result);
8916
8917         state->out_mem_ctx = talloc_named_const(state, 0,
8918                              "rpccli_spoolss_ReplyOpenPrinter_out_memory");
8919         if (tevent_req_nomem(state->out_mem_ctx, req)) {
8920                 return tevent_req_post(req, ev);
8921         }
8922
8923         /* make a temporary copy, that we pass to the dispatch function */
8924         state->tmp = state->orig;
8925
8926         subreq = cli->dispatch_send(state, ev, cli,
8927                                     &ndr_table_spoolss,
8928                                     NDR_SPOOLSS_REPLYOPENPRINTER,
8929                                     &state->tmp);
8930         if (tevent_req_nomem(subreq, req)) {
8931                 return tevent_req_post(req, ev);
8932         }
8933         tevent_req_set_callback(subreq, rpccli_spoolss_ReplyOpenPrinter_done, req);
8934         return req;
8935 }
8936
8937 static void rpccli_spoolss_ReplyOpenPrinter_done(struct tevent_req *subreq)
8938 {
8939         struct tevent_req *req = tevent_req_callback_data(
8940                 subreq, struct tevent_req);
8941         struct rpccli_spoolss_ReplyOpenPrinter_state *state = tevent_req_data(
8942                 req, struct rpccli_spoolss_ReplyOpenPrinter_state);
8943         NTSTATUS status;
8944         TALLOC_CTX *mem_ctx;
8945
8946         if (state->out_mem_ctx) {
8947                 mem_ctx = state->out_mem_ctx;
8948         } else {
8949                 mem_ctx = state;
8950         }
8951
8952         status = state->dispatch_recv(subreq, mem_ctx);
8953         TALLOC_FREE(subreq);
8954         if (!NT_STATUS_IS_OK(status)) {
8955                 tevent_req_nterror(req, status);
8956                 return;
8957         }
8958
8959         /* Copy out parameters */
8960         *state->orig.out.handle = *state->tmp.out.handle;
8961
8962         /* Copy result */
8963         state->orig.out.result = state->tmp.out.result;
8964
8965         /* Reset temporary structure */
8966         ZERO_STRUCT(state->tmp);
8967
8968         tevent_req_done(req);
8969 }
8970
8971 NTSTATUS rpccli_spoolss_ReplyOpenPrinter_recv(struct tevent_req *req,
8972                                               TALLOC_CTX *mem_ctx,
8973                                               WERROR *result)
8974 {
8975         struct rpccli_spoolss_ReplyOpenPrinter_state *state = tevent_req_data(
8976                 req, struct rpccli_spoolss_ReplyOpenPrinter_state);
8977         NTSTATUS status;
8978
8979         if (tevent_req_is_nterror(req, &status)) {
8980                 tevent_req_received(req);
8981                 return status;
8982         }
8983
8984         /* Steal possbile out parameters to the callers context */
8985         talloc_steal(mem_ctx, state->out_mem_ctx);
8986
8987         /* Return result */
8988         *result = state->orig.out.result;
8989
8990         tevent_req_received(req);
8991         return NT_STATUS_OK;
8992 }
8993
8994 NTSTATUS rpccli_spoolss_ReplyOpenPrinter(struct rpc_pipe_client *cli,
8995                                          TALLOC_CTX *mem_ctx,
8996                                          const char *server_name /* [in] [charset(UTF16)] */,
8997                                          uint32_t printer_local /* [in]  */,
8998                                          enum winreg_Type type /* [in]  */,
8999                                          uint32_t bufsize /* [in] [range(0,512)] */,
9000                                          uint8_t *buffer /* [in] [unique,size_is(bufsize)] */,
9001                                          struct policy_handle *handle /* [out] [ref] */,
9002                                          WERROR *werror)
9003 {
9004         struct spoolss_ReplyOpenPrinter r;
9005         NTSTATUS status;
9006
9007         /* In parameters */
9008         r.in.server_name = server_name;
9009         r.in.printer_local = printer_local;
9010         r.in.type = type;
9011         r.in.bufsize = bufsize;
9012         r.in.buffer = buffer;
9013
9014         status = cli->dispatch(cli,
9015                                 mem_ctx,
9016                                 &ndr_table_spoolss,
9017                                 NDR_SPOOLSS_REPLYOPENPRINTER,
9018                                 &r);
9019
9020         if (!NT_STATUS_IS_OK(status)) {
9021                 return status;
9022         }
9023
9024         if (NT_STATUS_IS_ERR(status)) {
9025                 return status;
9026         }
9027
9028         /* Return variables */
9029         *handle = *r.out.handle;
9030
9031         /* Return result */
9032         if (werror) {
9033                 *werror = r.out.result;
9034         }
9035
9036         return werror_to_ntstatus(r.out.result);
9037 }
9038
9039 struct rpccli_spoolss_RouterReplyPrinter_state {
9040         struct spoolss_RouterReplyPrinter orig;
9041         struct spoolss_RouterReplyPrinter tmp;
9042         TALLOC_CTX *out_mem_ctx;
9043         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9044 };
9045
9046 static void rpccli_spoolss_RouterReplyPrinter_done(struct tevent_req *subreq);
9047
9048 struct tevent_req *rpccli_spoolss_RouterReplyPrinter_send(TALLOC_CTX *mem_ctx,
9049                                                           struct tevent_context *ev,
9050                                                           struct rpc_pipe_client *cli,
9051                                                           struct policy_handle *_handle /* [in] [ref] */,
9052                                                           uint32_t _flags /* [in]  */,
9053                                                           uint32_t _bufsize /* [in] [range(0,512)] */,
9054                                                           uint8_t *_buffer /* [in] [unique,size_is(bufsize)] */)
9055 {
9056         struct tevent_req *req;
9057         struct rpccli_spoolss_RouterReplyPrinter_state *state;
9058         struct tevent_req *subreq;
9059
9060         req = tevent_req_create(mem_ctx, &state,
9061                                 struct rpccli_spoolss_RouterReplyPrinter_state);
9062         if (req == NULL) {
9063                 return NULL;
9064         }
9065         state->out_mem_ctx = NULL;
9066         state->dispatch_recv = cli->dispatch_recv;
9067
9068         /* In parameters */
9069         state->orig.in.handle = _handle;
9070         state->orig.in.flags = _flags;
9071         state->orig.in.bufsize = _bufsize;
9072         state->orig.in.buffer = _buffer;
9073
9074         /* Out parameters */
9075
9076         /* Result */
9077         ZERO_STRUCT(state->orig.out.result);
9078
9079         /* make a temporary copy, that we pass to the dispatch function */
9080         state->tmp = state->orig;
9081
9082         subreq = cli->dispatch_send(state, ev, cli,
9083                                     &ndr_table_spoolss,
9084                                     NDR_SPOOLSS_ROUTERREPLYPRINTER,
9085                                     &state->tmp);
9086         if (tevent_req_nomem(subreq, req)) {
9087                 return tevent_req_post(req, ev);
9088         }
9089         tevent_req_set_callback(subreq, rpccli_spoolss_RouterReplyPrinter_done, req);
9090         return req;
9091 }
9092
9093 static void rpccli_spoolss_RouterReplyPrinter_done(struct tevent_req *subreq)
9094 {
9095         struct tevent_req *req = tevent_req_callback_data(
9096                 subreq, struct tevent_req);
9097         struct rpccli_spoolss_RouterReplyPrinter_state *state = tevent_req_data(
9098                 req, struct rpccli_spoolss_RouterReplyPrinter_state);
9099         NTSTATUS status;
9100         TALLOC_CTX *mem_ctx;
9101
9102         if (state->out_mem_ctx) {
9103                 mem_ctx = state->out_mem_ctx;
9104         } else {
9105                 mem_ctx = state;
9106         }
9107
9108         status = state->dispatch_recv(subreq, mem_ctx);
9109         TALLOC_FREE(subreq);
9110         if (!NT_STATUS_IS_OK(status)) {
9111                 tevent_req_nterror(req, status);
9112                 return;
9113         }
9114
9115         /* Copy out parameters */
9116
9117         /* Copy result */
9118         state->orig.out.result = state->tmp.out.result;
9119
9120         /* Reset temporary structure */
9121         ZERO_STRUCT(state->tmp);
9122
9123         tevent_req_done(req);
9124 }
9125
9126 NTSTATUS rpccli_spoolss_RouterReplyPrinter_recv(struct tevent_req *req,
9127                                                 TALLOC_CTX *mem_ctx,
9128                                                 WERROR *result)
9129 {
9130         struct rpccli_spoolss_RouterReplyPrinter_state *state = tevent_req_data(
9131                 req, struct rpccli_spoolss_RouterReplyPrinter_state);
9132         NTSTATUS status;
9133
9134         if (tevent_req_is_nterror(req, &status)) {
9135                 tevent_req_received(req);
9136                 return status;
9137         }
9138
9139         /* Steal possbile out parameters to the callers context */
9140         talloc_steal(mem_ctx, state->out_mem_ctx);
9141
9142         /* Return result */
9143         *result = state->orig.out.result;
9144
9145         tevent_req_received(req);
9146         return NT_STATUS_OK;
9147 }
9148
9149 NTSTATUS rpccli_spoolss_RouterReplyPrinter(struct rpc_pipe_client *cli,
9150                                            TALLOC_CTX *mem_ctx,
9151                                            struct policy_handle *handle /* [in] [ref] */,
9152                                            uint32_t flags /* [in]  */,
9153                                            uint32_t bufsize /* [in] [range(0,512)] */,
9154                                            uint8_t *buffer /* [in] [unique,size_is(bufsize)] */,
9155                                            WERROR *werror)
9156 {
9157         struct spoolss_RouterReplyPrinter r;
9158         NTSTATUS status;
9159
9160         /* In parameters */
9161         r.in.handle = handle;
9162         r.in.flags = flags;
9163         r.in.bufsize = bufsize;
9164         r.in.buffer = buffer;
9165
9166         status = cli->dispatch(cli,
9167                                 mem_ctx,
9168                                 &ndr_table_spoolss,
9169                                 NDR_SPOOLSS_ROUTERREPLYPRINTER,
9170                                 &r);
9171
9172         if (!NT_STATUS_IS_OK(status)) {
9173                 return status;
9174         }
9175
9176         if (NT_STATUS_IS_ERR(status)) {
9177                 return status;
9178         }
9179
9180         /* Return variables */
9181
9182         /* Return result */
9183         if (werror) {
9184                 *werror = r.out.result;
9185         }
9186
9187         return werror_to_ntstatus(r.out.result);
9188 }
9189
9190 struct rpccli_spoolss_ReplyClosePrinter_state {
9191         struct spoolss_ReplyClosePrinter orig;
9192         struct spoolss_ReplyClosePrinter tmp;
9193         TALLOC_CTX *out_mem_ctx;
9194         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9195 };
9196
9197 static void rpccli_spoolss_ReplyClosePrinter_done(struct tevent_req *subreq);
9198
9199 struct tevent_req *rpccli_spoolss_ReplyClosePrinter_send(TALLOC_CTX *mem_ctx,
9200                                                          struct tevent_context *ev,
9201                                                          struct rpc_pipe_client *cli,
9202                                                          struct policy_handle *_handle /* [in,out] [ref] */)
9203 {
9204         struct tevent_req *req;
9205         struct rpccli_spoolss_ReplyClosePrinter_state *state;
9206         struct tevent_req *subreq;
9207
9208         req = tevent_req_create(mem_ctx, &state,
9209                                 struct rpccli_spoolss_ReplyClosePrinter_state);
9210         if (req == NULL) {
9211                 return NULL;
9212         }
9213         state->out_mem_ctx = NULL;
9214         state->dispatch_recv = cli->dispatch_recv;
9215
9216         /* In parameters */
9217         state->orig.in.handle = _handle;
9218
9219         /* Out parameters */
9220         state->orig.out.handle = _handle;
9221
9222         /* Result */
9223         ZERO_STRUCT(state->orig.out.result);
9224
9225         state->out_mem_ctx = talloc_named_const(state, 0,
9226                              "rpccli_spoolss_ReplyClosePrinter_out_memory");
9227         if (tevent_req_nomem(state->out_mem_ctx, req)) {
9228                 return tevent_req_post(req, ev);
9229         }
9230
9231         /* make a temporary copy, that we pass to the dispatch function */
9232         state->tmp = state->orig;
9233
9234         subreq = cli->dispatch_send(state, ev, cli,
9235                                     &ndr_table_spoolss,
9236                                     NDR_SPOOLSS_REPLYCLOSEPRINTER,
9237                                     &state->tmp);
9238         if (tevent_req_nomem(subreq, req)) {
9239                 return tevent_req_post(req, ev);
9240         }
9241         tevent_req_set_callback(subreq, rpccli_spoolss_ReplyClosePrinter_done, req);
9242         return req;
9243 }
9244
9245 static void rpccli_spoolss_ReplyClosePrinter_done(struct tevent_req *subreq)
9246 {
9247         struct tevent_req *req = tevent_req_callback_data(
9248                 subreq, struct tevent_req);
9249         struct rpccli_spoolss_ReplyClosePrinter_state *state = tevent_req_data(
9250                 req, struct rpccli_spoolss_ReplyClosePrinter_state);
9251         NTSTATUS status;
9252         TALLOC_CTX *mem_ctx;
9253
9254         if (state->out_mem_ctx) {
9255                 mem_ctx = state->out_mem_ctx;
9256         } else {
9257                 mem_ctx = state;
9258         }
9259
9260         status = state->dispatch_recv(subreq, mem_ctx);
9261         TALLOC_FREE(subreq);
9262         if (!NT_STATUS_IS_OK(status)) {
9263                 tevent_req_nterror(req, status);
9264                 return;
9265         }
9266
9267         /* Copy out parameters */
9268         *state->orig.out.handle = *state->tmp.out.handle;
9269
9270         /* Copy result */
9271         state->orig.out.result = state->tmp.out.result;
9272
9273         /* Reset temporary structure */
9274         ZERO_STRUCT(state->tmp);
9275
9276         tevent_req_done(req);
9277 }
9278
9279 NTSTATUS rpccli_spoolss_ReplyClosePrinter_recv(struct tevent_req *req,
9280                                                TALLOC_CTX *mem_ctx,
9281                                                WERROR *result)
9282 {
9283         struct rpccli_spoolss_ReplyClosePrinter_state *state = tevent_req_data(
9284                 req, struct rpccli_spoolss_ReplyClosePrinter_state);
9285         NTSTATUS status;
9286
9287         if (tevent_req_is_nterror(req, &status)) {
9288                 tevent_req_received(req);
9289                 return status;
9290         }
9291
9292         /* Steal possbile out parameters to the callers context */
9293         talloc_steal(mem_ctx, state->out_mem_ctx);
9294
9295         /* Return result */
9296         *result = state->orig.out.result;
9297
9298         tevent_req_received(req);
9299         return NT_STATUS_OK;
9300 }
9301
9302 NTSTATUS rpccli_spoolss_ReplyClosePrinter(struct rpc_pipe_client *cli,
9303                                           TALLOC_CTX *mem_ctx,
9304                                           struct policy_handle *handle /* [in,out] [ref] */,
9305                                           WERROR *werror)
9306 {
9307         struct spoolss_ReplyClosePrinter r;
9308         NTSTATUS status;
9309
9310         /* In parameters */
9311         r.in.handle = handle;
9312
9313         status = cli->dispatch(cli,
9314                                 mem_ctx,
9315                                 &ndr_table_spoolss,
9316                                 NDR_SPOOLSS_REPLYCLOSEPRINTER,
9317                                 &r);
9318
9319         if (!NT_STATUS_IS_OK(status)) {
9320                 return status;
9321         }
9322
9323         if (NT_STATUS_IS_ERR(status)) {
9324                 return status;
9325         }
9326
9327         /* Return variables */
9328         *handle = *r.out.handle;
9329
9330         /* Return result */
9331         if (werror) {
9332                 *werror = r.out.result;
9333         }
9334
9335         return werror_to_ntstatus(r.out.result);
9336 }
9337
9338 struct rpccli_spoolss_AddPortEx_state {
9339         struct spoolss_AddPortEx orig;
9340         struct spoolss_AddPortEx tmp;
9341         TALLOC_CTX *out_mem_ctx;
9342         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9343 };
9344
9345 static void rpccli_spoolss_AddPortEx_done(struct tevent_req *subreq);
9346
9347 struct tevent_req *rpccli_spoolss_AddPortEx_send(TALLOC_CTX *mem_ctx,
9348                                                  struct tevent_context *ev,
9349                                                  struct rpc_pipe_client *cli)
9350 {
9351         struct tevent_req *req;
9352         struct rpccli_spoolss_AddPortEx_state *state;
9353         struct tevent_req *subreq;
9354
9355         req = tevent_req_create(mem_ctx, &state,
9356                                 struct rpccli_spoolss_AddPortEx_state);
9357         if (req == NULL) {
9358                 return NULL;
9359         }
9360         state->out_mem_ctx = NULL;
9361         state->dispatch_recv = cli->dispatch_recv;
9362
9363         /* In parameters */
9364
9365         /* Out parameters */
9366
9367         /* Result */
9368         ZERO_STRUCT(state->orig.out.result);
9369
9370         /* make a temporary copy, that we pass to the dispatch function */
9371         state->tmp = state->orig;
9372
9373         subreq = cli->dispatch_send(state, ev, cli,
9374                                     &ndr_table_spoolss,
9375                                     NDR_SPOOLSS_ADDPORTEX,
9376                                     &state->tmp);
9377         if (tevent_req_nomem(subreq, req)) {
9378                 return tevent_req_post(req, ev);
9379         }
9380         tevent_req_set_callback(subreq, rpccli_spoolss_AddPortEx_done, req);
9381         return req;
9382 }
9383
9384 static void rpccli_spoolss_AddPortEx_done(struct tevent_req *subreq)
9385 {
9386         struct tevent_req *req = tevent_req_callback_data(
9387                 subreq, struct tevent_req);
9388         struct rpccli_spoolss_AddPortEx_state *state = tevent_req_data(
9389                 req, struct rpccli_spoolss_AddPortEx_state);
9390         NTSTATUS status;
9391         TALLOC_CTX *mem_ctx;
9392
9393         if (state->out_mem_ctx) {
9394                 mem_ctx = state->out_mem_ctx;
9395         } else {
9396                 mem_ctx = state;
9397         }
9398
9399         status = state->dispatch_recv(subreq, mem_ctx);
9400         TALLOC_FREE(subreq);
9401         if (!NT_STATUS_IS_OK(status)) {
9402                 tevent_req_nterror(req, status);
9403                 return;
9404         }
9405
9406         /* Copy out parameters */
9407
9408         /* Copy result */
9409         state->orig.out.result = state->tmp.out.result;
9410
9411         /* Reset temporary structure */
9412         ZERO_STRUCT(state->tmp);
9413
9414         tevent_req_done(req);
9415 }
9416
9417 NTSTATUS rpccli_spoolss_AddPortEx_recv(struct tevent_req *req,
9418                                        TALLOC_CTX *mem_ctx,
9419                                        WERROR *result)
9420 {
9421         struct rpccli_spoolss_AddPortEx_state *state = tevent_req_data(
9422                 req, struct rpccli_spoolss_AddPortEx_state);
9423         NTSTATUS status;
9424
9425         if (tevent_req_is_nterror(req, &status)) {
9426                 tevent_req_received(req);
9427                 return status;
9428         }
9429
9430         /* Steal possbile out parameters to the callers context */
9431         talloc_steal(mem_ctx, state->out_mem_ctx);
9432
9433         /* Return result */
9434         *result = state->orig.out.result;
9435
9436         tevent_req_received(req);
9437         return NT_STATUS_OK;
9438 }
9439
9440 NTSTATUS rpccli_spoolss_AddPortEx(struct rpc_pipe_client *cli,
9441                                   TALLOC_CTX *mem_ctx,
9442                                   WERROR *werror)
9443 {
9444         struct spoolss_AddPortEx r;
9445         NTSTATUS status;
9446
9447         /* In parameters */
9448
9449         status = cli->dispatch(cli,
9450                                 mem_ctx,
9451                                 &ndr_table_spoolss,
9452                                 NDR_SPOOLSS_ADDPORTEX,
9453                                 &r);
9454
9455         if (!NT_STATUS_IS_OK(status)) {
9456                 return status;
9457         }
9458
9459         if (NT_STATUS_IS_ERR(status)) {
9460                 return status;
9461         }
9462
9463         /* Return variables */
9464
9465         /* Return result */
9466         if (werror) {
9467                 *werror = r.out.result;
9468         }
9469
9470         return werror_to_ntstatus(r.out.result);
9471 }
9472
9473 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state {
9474         struct spoolss_RouterFindFirstPrinterChangeNotification orig;
9475         struct spoolss_RouterFindFirstPrinterChangeNotification tmp;
9476         TALLOC_CTX *out_mem_ctx;
9477         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9478 };
9479
9480 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotification_done(struct tevent_req *subreq);
9481
9482 struct tevent_req *rpccli_spoolss_RouterFindFirstPrinterChangeNotification_send(TALLOC_CTX *mem_ctx,
9483                                                                                 struct tevent_context *ev,
9484                                                                                 struct rpc_pipe_client *cli)
9485 {
9486         struct tevent_req *req;
9487         struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state *state;
9488         struct tevent_req *subreq;
9489
9490         req = tevent_req_create(mem_ctx, &state,
9491                                 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state);
9492         if (req == NULL) {
9493                 return NULL;
9494         }
9495         state->out_mem_ctx = NULL;
9496         state->dispatch_recv = cli->dispatch_recv;
9497
9498         /* In parameters */
9499
9500         /* Out parameters */
9501
9502         /* Result */
9503         ZERO_STRUCT(state->orig.out.result);
9504
9505         /* make a temporary copy, that we pass to the dispatch function */
9506         state->tmp = state->orig;
9507
9508         subreq = cli->dispatch_send(state, ev, cli,
9509                                     &ndr_table_spoolss,
9510                                     NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION,
9511                                     &state->tmp);
9512         if (tevent_req_nomem(subreq, req)) {
9513                 return tevent_req_post(req, ev);
9514         }
9515         tevent_req_set_callback(subreq, rpccli_spoolss_RouterFindFirstPrinterChangeNotification_done, req);
9516         return req;
9517 }
9518
9519 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotification_done(struct tevent_req *subreq)
9520 {
9521         struct tevent_req *req = tevent_req_callback_data(
9522                 subreq, struct tevent_req);
9523         struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state *state = tevent_req_data(
9524                 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state);
9525         NTSTATUS status;
9526         TALLOC_CTX *mem_ctx;
9527
9528         if (state->out_mem_ctx) {
9529                 mem_ctx = state->out_mem_ctx;
9530         } else {
9531                 mem_ctx = state;
9532         }
9533
9534         status = state->dispatch_recv(subreq, mem_ctx);
9535         TALLOC_FREE(subreq);
9536         if (!NT_STATUS_IS_OK(status)) {
9537                 tevent_req_nterror(req, status);
9538                 return;
9539         }
9540
9541         /* Copy out parameters */
9542
9543         /* Copy result */
9544         state->orig.out.result = state->tmp.out.result;
9545
9546         /* Reset temporary structure */
9547         ZERO_STRUCT(state->tmp);
9548
9549         tevent_req_done(req);
9550 }
9551
9552 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotification_recv(struct tevent_req *req,
9553                                                                       TALLOC_CTX *mem_ctx,
9554                                                                       WERROR *result)
9555 {
9556         struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state *state = tevent_req_data(
9557                 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state);
9558         NTSTATUS status;
9559
9560         if (tevent_req_is_nterror(req, &status)) {
9561                 tevent_req_received(req);
9562                 return status;
9563         }
9564
9565         /* Steal possbile out parameters to the callers context */
9566         talloc_steal(mem_ctx, state->out_mem_ctx);
9567
9568         /* Return result */
9569         *result = state->orig.out.result;
9570
9571         tevent_req_received(req);
9572         return NT_STATUS_OK;
9573 }
9574
9575 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotification(struct rpc_pipe_client *cli,
9576                                                                  TALLOC_CTX *mem_ctx,
9577                                                                  WERROR *werror)
9578 {
9579         struct spoolss_RouterFindFirstPrinterChangeNotification r;
9580         NTSTATUS status;
9581
9582         /* In parameters */
9583
9584         status = cli->dispatch(cli,
9585                                 mem_ctx,
9586                                 &ndr_table_spoolss,
9587                                 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION,
9588                                 &r);
9589
9590         if (!NT_STATUS_IS_OK(status)) {
9591                 return status;
9592         }
9593
9594         if (NT_STATUS_IS_ERR(status)) {
9595                 return status;
9596         }
9597
9598         /* Return variables */
9599
9600         /* Return result */
9601         if (werror) {
9602                 *werror = r.out.result;
9603         }
9604
9605         return werror_to_ntstatus(r.out.result);
9606 }
9607
9608 struct rpccli_spoolss_SpoolerInit_state {
9609         struct spoolss_SpoolerInit orig;
9610         struct spoolss_SpoolerInit tmp;
9611         TALLOC_CTX *out_mem_ctx;
9612         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9613 };
9614
9615 static void rpccli_spoolss_SpoolerInit_done(struct tevent_req *subreq);
9616
9617 struct tevent_req *rpccli_spoolss_SpoolerInit_send(TALLOC_CTX *mem_ctx,
9618                                                    struct tevent_context *ev,
9619                                                    struct rpc_pipe_client *cli)
9620 {
9621         struct tevent_req *req;
9622         struct rpccli_spoolss_SpoolerInit_state *state;
9623         struct tevent_req *subreq;
9624
9625         req = tevent_req_create(mem_ctx, &state,
9626                                 struct rpccli_spoolss_SpoolerInit_state);
9627         if (req == NULL) {
9628                 return NULL;
9629         }
9630         state->out_mem_ctx = NULL;
9631         state->dispatch_recv = cli->dispatch_recv;
9632
9633         /* In parameters */
9634
9635         /* Out parameters */
9636
9637         /* Result */
9638         ZERO_STRUCT(state->orig.out.result);
9639
9640         /* make a temporary copy, that we pass to the dispatch function */
9641         state->tmp = state->orig;
9642
9643         subreq = cli->dispatch_send(state, ev, cli,
9644                                     &ndr_table_spoolss,
9645                                     NDR_SPOOLSS_SPOOLERINIT,
9646                                     &state->tmp);
9647         if (tevent_req_nomem(subreq, req)) {
9648                 return tevent_req_post(req, ev);
9649         }
9650         tevent_req_set_callback(subreq, rpccli_spoolss_SpoolerInit_done, req);
9651         return req;
9652 }
9653
9654 static void rpccli_spoolss_SpoolerInit_done(struct tevent_req *subreq)
9655 {
9656         struct tevent_req *req = tevent_req_callback_data(
9657                 subreq, struct tevent_req);
9658         struct rpccli_spoolss_SpoolerInit_state *state = tevent_req_data(
9659                 req, struct rpccli_spoolss_SpoolerInit_state);
9660         NTSTATUS status;
9661         TALLOC_CTX *mem_ctx;
9662
9663         if (state->out_mem_ctx) {
9664                 mem_ctx = state->out_mem_ctx;
9665         } else {
9666                 mem_ctx = state;
9667         }
9668
9669         status = state->dispatch_recv(subreq, mem_ctx);
9670         TALLOC_FREE(subreq);
9671         if (!NT_STATUS_IS_OK(status)) {
9672                 tevent_req_nterror(req, status);
9673                 return;
9674         }
9675
9676         /* Copy out parameters */
9677
9678         /* Copy result */
9679         state->orig.out.result = state->tmp.out.result;
9680
9681         /* Reset temporary structure */
9682         ZERO_STRUCT(state->tmp);
9683
9684         tevent_req_done(req);
9685 }
9686
9687 NTSTATUS rpccli_spoolss_SpoolerInit_recv(struct tevent_req *req,
9688                                          TALLOC_CTX *mem_ctx,
9689                                          WERROR *result)
9690 {
9691         struct rpccli_spoolss_SpoolerInit_state *state = tevent_req_data(
9692                 req, struct rpccli_spoolss_SpoolerInit_state);
9693         NTSTATUS status;
9694
9695         if (tevent_req_is_nterror(req, &status)) {
9696                 tevent_req_received(req);
9697                 return status;
9698         }
9699
9700         /* Steal possbile out parameters to the callers context */
9701         talloc_steal(mem_ctx, state->out_mem_ctx);
9702
9703         /* Return result */
9704         *result = state->orig.out.result;
9705
9706         tevent_req_received(req);
9707         return NT_STATUS_OK;
9708 }
9709
9710 NTSTATUS rpccli_spoolss_SpoolerInit(struct rpc_pipe_client *cli,
9711                                     TALLOC_CTX *mem_ctx,
9712                                     WERROR *werror)
9713 {
9714         struct spoolss_SpoolerInit r;
9715         NTSTATUS status;
9716
9717         /* In parameters */
9718
9719         status = cli->dispatch(cli,
9720                                 mem_ctx,
9721                                 &ndr_table_spoolss,
9722                                 NDR_SPOOLSS_SPOOLERINIT,
9723                                 &r);
9724
9725         if (!NT_STATUS_IS_OK(status)) {
9726                 return status;
9727         }
9728
9729         if (NT_STATUS_IS_ERR(status)) {
9730                 return status;
9731         }
9732
9733         /* Return variables */
9734
9735         /* Return result */
9736         if (werror) {
9737                 *werror = r.out.result;
9738         }
9739
9740         return werror_to_ntstatus(r.out.result);
9741 }
9742
9743 struct rpccli_spoolss_ResetPrinterEx_state {
9744         struct spoolss_ResetPrinterEx orig;
9745         struct spoolss_ResetPrinterEx tmp;
9746         TALLOC_CTX *out_mem_ctx;
9747         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9748 };
9749
9750 static void rpccli_spoolss_ResetPrinterEx_done(struct tevent_req *subreq);
9751
9752 struct tevent_req *rpccli_spoolss_ResetPrinterEx_send(TALLOC_CTX *mem_ctx,
9753                                                       struct tevent_context *ev,
9754                                                       struct rpc_pipe_client *cli)
9755 {
9756         struct tevent_req *req;
9757         struct rpccli_spoolss_ResetPrinterEx_state *state;
9758         struct tevent_req *subreq;
9759
9760         req = tevent_req_create(mem_ctx, &state,
9761                                 struct rpccli_spoolss_ResetPrinterEx_state);
9762         if (req == NULL) {
9763                 return NULL;
9764         }
9765         state->out_mem_ctx = NULL;
9766         state->dispatch_recv = cli->dispatch_recv;
9767
9768         /* In parameters */
9769
9770         /* Out parameters */
9771
9772         /* Result */
9773         ZERO_STRUCT(state->orig.out.result);
9774
9775         /* make a temporary copy, that we pass to the dispatch function */
9776         state->tmp = state->orig;
9777
9778         subreq = cli->dispatch_send(state, ev, cli,
9779                                     &ndr_table_spoolss,
9780                                     NDR_SPOOLSS_RESETPRINTEREX,
9781                                     &state->tmp);
9782         if (tevent_req_nomem(subreq, req)) {
9783                 return tevent_req_post(req, ev);
9784         }
9785         tevent_req_set_callback(subreq, rpccli_spoolss_ResetPrinterEx_done, req);
9786         return req;
9787 }
9788
9789 static void rpccli_spoolss_ResetPrinterEx_done(struct tevent_req *subreq)
9790 {
9791         struct tevent_req *req = tevent_req_callback_data(
9792                 subreq, struct tevent_req);
9793         struct rpccli_spoolss_ResetPrinterEx_state *state = tevent_req_data(
9794                 req, struct rpccli_spoolss_ResetPrinterEx_state);
9795         NTSTATUS status;
9796         TALLOC_CTX *mem_ctx;
9797
9798         if (state->out_mem_ctx) {
9799                 mem_ctx = state->out_mem_ctx;
9800         } else {
9801                 mem_ctx = state;
9802         }
9803
9804         status = state->dispatch_recv(subreq, mem_ctx);
9805         TALLOC_FREE(subreq);
9806         if (!NT_STATUS_IS_OK(status)) {
9807                 tevent_req_nterror(req, status);
9808                 return;
9809         }
9810
9811         /* Copy out parameters */
9812
9813         /* Copy result */
9814         state->orig.out.result = state->tmp.out.result;
9815
9816         /* Reset temporary structure */
9817         ZERO_STRUCT(state->tmp);
9818
9819         tevent_req_done(req);
9820 }
9821
9822 NTSTATUS rpccli_spoolss_ResetPrinterEx_recv(struct tevent_req *req,
9823                                             TALLOC_CTX *mem_ctx,
9824                                             WERROR *result)
9825 {
9826         struct rpccli_spoolss_ResetPrinterEx_state *state = tevent_req_data(
9827                 req, struct rpccli_spoolss_ResetPrinterEx_state);
9828         NTSTATUS status;
9829
9830         if (tevent_req_is_nterror(req, &status)) {
9831                 tevent_req_received(req);
9832                 return status;
9833         }
9834
9835         /* Steal possbile out parameters to the callers context */
9836         talloc_steal(mem_ctx, state->out_mem_ctx);
9837
9838         /* Return result */
9839         *result = state->orig.out.result;
9840
9841         tevent_req_received(req);
9842         return NT_STATUS_OK;
9843 }
9844
9845 NTSTATUS rpccli_spoolss_ResetPrinterEx(struct rpc_pipe_client *cli,
9846                                        TALLOC_CTX *mem_ctx,
9847                                        WERROR *werror)
9848 {
9849         struct spoolss_ResetPrinterEx r;
9850         NTSTATUS status;
9851
9852         /* In parameters */
9853
9854         status = cli->dispatch(cli,
9855                                 mem_ctx,
9856                                 &ndr_table_spoolss,
9857                                 NDR_SPOOLSS_RESETPRINTEREX,
9858                                 &r);
9859
9860         if (!NT_STATUS_IS_OK(status)) {
9861                 return status;
9862         }
9863
9864         if (NT_STATUS_IS_ERR(status)) {
9865                 return status;
9866         }
9867
9868         /* Return variables */
9869
9870         /* Return result */
9871         if (werror) {
9872                 *werror = r.out.result;
9873         }
9874
9875         return werror_to_ntstatus(r.out.result);
9876 }
9877
9878 struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state {
9879         struct spoolss_RemoteFindFirstPrinterChangeNotifyEx orig;
9880         struct spoolss_RemoteFindFirstPrinterChangeNotifyEx tmp;
9881         TALLOC_CTX *out_mem_ctx;
9882         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9883 };
9884
9885 static void rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_done(struct tevent_req *subreq);
9886
9887 struct tevent_req *rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_send(TALLOC_CTX *mem_ctx,
9888                                                                             struct tevent_context *ev,
9889                                                                             struct rpc_pipe_client *cli,
9890                                                                             struct policy_handle *_handle /* [in] [ref] */,
9891                                                                             uint32_t _flags /* [in]  */,
9892                                                                             uint32_t _options /* [in]  */,
9893                                                                             const char *_local_machine /* [in] [unique,charset(UTF16)] */,
9894                                                                             uint32_t _printer_local /* [in]  */,
9895                                                                             struct spoolss_NotifyOption *_notify_options /* [in] [unique] */)
9896 {
9897         struct tevent_req *req;
9898         struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state *state;
9899         struct tevent_req *subreq;
9900
9901         req = tevent_req_create(mem_ctx, &state,
9902                                 struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state);
9903         if (req == NULL) {
9904                 return NULL;
9905         }
9906         state->out_mem_ctx = NULL;
9907         state->dispatch_recv = cli->dispatch_recv;
9908
9909         /* In parameters */
9910         state->orig.in.handle = _handle;
9911         state->orig.in.flags = _flags;
9912         state->orig.in.options = _options;
9913         state->orig.in.local_machine = _local_machine;
9914         state->orig.in.printer_local = _printer_local;
9915         state->orig.in.notify_options = _notify_options;
9916
9917         /* Out parameters */
9918
9919         /* Result */
9920         ZERO_STRUCT(state->orig.out.result);
9921
9922         /* make a temporary copy, that we pass to the dispatch function */
9923         state->tmp = state->orig;
9924
9925         subreq = cli->dispatch_send(state, ev, cli,
9926                                     &ndr_table_spoolss,
9927                                     NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX,
9928                                     &state->tmp);
9929         if (tevent_req_nomem(subreq, req)) {
9930                 return tevent_req_post(req, ev);
9931         }
9932         tevent_req_set_callback(subreq, rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_done, req);
9933         return req;
9934 }
9935
9936 static void rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_done(struct tevent_req *subreq)
9937 {
9938         struct tevent_req *req = tevent_req_callback_data(
9939                 subreq, struct tevent_req);
9940         struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state *state = tevent_req_data(
9941                 req, struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state);
9942         NTSTATUS status;
9943         TALLOC_CTX *mem_ctx;
9944
9945         if (state->out_mem_ctx) {
9946                 mem_ctx = state->out_mem_ctx;
9947         } else {
9948                 mem_ctx = state;
9949         }
9950
9951         status = state->dispatch_recv(subreq, mem_ctx);
9952         TALLOC_FREE(subreq);
9953         if (!NT_STATUS_IS_OK(status)) {
9954                 tevent_req_nterror(req, status);
9955                 return;
9956         }
9957
9958         /* Copy out parameters */
9959
9960         /* Copy result */
9961         state->orig.out.result = state->tmp.out.result;
9962
9963         /* Reset temporary structure */
9964         ZERO_STRUCT(state->tmp);
9965
9966         tevent_req_done(req);
9967 }
9968
9969 NTSTATUS rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_recv(struct tevent_req *req,
9970                                                                   TALLOC_CTX *mem_ctx,
9971                                                                   WERROR *result)
9972 {
9973         struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state *state = tevent_req_data(
9974                 req, struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state);
9975         NTSTATUS status;
9976
9977         if (tevent_req_is_nterror(req, &status)) {
9978                 tevent_req_received(req);
9979                 return status;
9980         }
9981
9982         /* Steal possbile out parameters to the callers context */
9983         talloc_steal(mem_ctx, state->out_mem_ctx);
9984
9985         /* Return result */
9986         *result = state->orig.out.result;
9987
9988         tevent_req_received(req);
9989         return NT_STATUS_OK;
9990 }
9991
9992 NTSTATUS rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct rpc_pipe_client *cli,
9993                                                              TALLOC_CTX *mem_ctx,
9994                                                              struct policy_handle *handle /* [in] [ref] */,
9995                                                              uint32_t flags /* [in]  */,
9996                                                              uint32_t options /* [in]  */,
9997                                                              const char *local_machine /* [in] [unique,charset(UTF16)] */,
9998                                                              uint32_t printer_local /* [in]  */,
9999                                                              struct spoolss_NotifyOption *notify_options /* [in] [unique] */,
10000                                                              WERROR *werror)
10001 {
10002         struct spoolss_RemoteFindFirstPrinterChangeNotifyEx r;
10003         NTSTATUS status;
10004
10005         /* In parameters */
10006         r.in.handle = handle;
10007         r.in.flags = flags;
10008         r.in.options = options;
10009         r.in.local_machine = local_machine;
10010         r.in.printer_local = printer_local;
10011         r.in.notify_options = notify_options;
10012
10013         status = cli->dispatch(cli,
10014                                 mem_ctx,
10015                                 &ndr_table_spoolss,
10016                                 NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX,
10017                                 &r);
10018
10019         if (!NT_STATUS_IS_OK(status)) {
10020                 return status;
10021         }
10022
10023         if (NT_STATUS_IS_ERR(status)) {
10024                 return status;
10025         }
10026
10027         /* Return variables */
10028
10029         /* Return result */
10030         if (werror) {
10031                 *werror = r.out.result;
10032         }
10033
10034         return werror_to_ntstatus(r.out.result);
10035 }
10036
10037 struct rpccli_spoolss_RouterReplyPrinterEx_state {
10038         struct spoolss_RouterReplyPrinterEx orig;
10039         struct spoolss_RouterReplyPrinterEx tmp;
10040         TALLOC_CTX *out_mem_ctx;
10041         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10042 };
10043
10044 static void rpccli_spoolss_RouterReplyPrinterEx_done(struct tevent_req *subreq);
10045
10046 struct tevent_req *rpccli_spoolss_RouterReplyPrinterEx_send(TALLOC_CTX *mem_ctx,
10047                                                             struct tevent_context *ev,
10048                                                             struct rpc_pipe_client *cli,
10049                                                             struct policy_handle *_handle /* [in] [ref] */,
10050                                                             uint32_t _color /* [in]  */,
10051                                                             uint32_t _flags /* [in]  */,
10052                                                             uint32_t *_reply_result /* [out] [ref] */,
10053                                                             uint32_t _reply_type /* [in]  */,
10054                                                             union spoolss_ReplyPrinterInfo _info /* [in] [switch_is(reply_type)] */)
10055 {
10056         struct tevent_req *req;
10057         struct rpccli_spoolss_RouterReplyPrinterEx_state *state;
10058         struct tevent_req *subreq;
10059
10060         req = tevent_req_create(mem_ctx, &state,
10061                                 struct rpccli_spoolss_RouterReplyPrinterEx_state);
10062         if (req == NULL) {
10063                 return NULL;
10064         }
10065         state->out_mem_ctx = NULL;
10066         state->dispatch_recv = cli->dispatch_recv;
10067
10068         /* In parameters */
10069         state->orig.in.handle = _handle;
10070         state->orig.in.color = _color;
10071         state->orig.in.flags = _flags;
10072         state->orig.in.reply_type = _reply_type;
10073         state->orig.in.info = _info;
10074
10075         /* Out parameters */
10076         state->orig.out.reply_result = _reply_result;
10077
10078         /* Result */
10079         ZERO_STRUCT(state->orig.out.result);
10080
10081         state->out_mem_ctx = talloc_named_const(state, 0,
10082                              "rpccli_spoolss_RouterReplyPrinterEx_out_memory");
10083         if (tevent_req_nomem(state->out_mem_ctx, req)) {
10084                 return tevent_req_post(req, ev);
10085         }
10086
10087         /* make a temporary copy, that we pass to the dispatch function */
10088         state->tmp = state->orig;
10089
10090         subreq = cli->dispatch_send(state, ev, cli,
10091                                     &ndr_table_spoolss,
10092                                     NDR_SPOOLSS_ROUTERREPLYPRINTEREX,
10093                                     &state->tmp);
10094         if (tevent_req_nomem(subreq, req)) {
10095                 return tevent_req_post(req, ev);
10096         }
10097         tevent_req_set_callback(subreq, rpccli_spoolss_RouterReplyPrinterEx_done, req);
10098         return req;
10099 }
10100
10101 static void rpccli_spoolss_RouterReplyPrinterEx_done(struct tevent_req *subreq)
10102 {
10103         struct tevent_req *req = tevent_req_callback_data(
10104                 subreq, struct tevent_req);
10105         struct rpccli_spoolss_RouterReplyPrinterEx_state *state = tevent_req_data(
10106                 req, struct rpccli_spoolss_RouterReplyPrinterEx_state);
10107         NTSTATUS status;
10108         TALLOC_CTX *mem_ctx;
10109
10110         if (state->out_mem_ctx) {
10111                 mem_ctx = state->out_mem_ctx;
10112         } else {
10113                 mem_ctx = state;
10114         }
10115
10116         status = state->dispatch_recv(subreq, mem_ctx);
10117         TALLOC_FREE(subreq);
10118         if (!NT_STATUS_IS_OK(status)) {
10119                 tevent_req_nterror(req, status);
10120                 return;
10121         }
10122
10123         /* Copy out parameters */
10124         *state->orig.out.reply_result = *state->tmp.out.reply_result;
10125
10126         /* Copy result */
10127         state->orig.out.result = state->tmp.out.result;
10128
10129         /* Reset temporary structure */
10130         ZERO_STRUCT(state->tmp);
10131
10132         tevent_req_done(req);
10133 }
10134
10135 NTSTATUS rpccli_spoolss_RouterReplyPrinterEx_recv(struct tevent_req *req,
10136                                                   TALLOC_CTX *mem_ctx,
10137                                                   WERROR *result)
10138 {
10139         struct rpccli_spoolss_RouterReplyPrinterEx_state *state = tevent_req_data(
10140                 req, struct rpccli_spoolss_RouterReplyPrinterEx_state);
10141         NTSTATUS status;
10142
10143         if (tevent_req_is_nterror(req, &status)) {
10144                 tevent_req_received(req);
10145                 return status;
10146         }
10147
10148         /* Steal possbile out parameters to the callers context */
10149         talloc_steal(mem_ctx, state->out_mem_ctx);
10150
10151         /* Return result */
10152         *result = state->orig.out.result;
10153
10154         tevent_req_received(req);
10155         return NT_STATUS_OK;
10156 }
10157
10158 NTSTATUS rpccli_spoolss_RouterReplyPrinterEx(struct rpc_pipe_client *cli,
10159                                              TALLOC_CTX *mem_ctx,
10160                                              struct policy_handle *handle /* [in] [ref] */,
10161                                              uint32_t color /* [in]  */,
10162                                              uint32_t flags /* [in]  */,
10163                                              uint32_t *reply_result /* [out] [ref] */,
10164                                              uint32_t reply_type /* [in]  */,
10165                                              union spoolss_ReplyPrinterInfo info /* [in] [switch_is(reply_type)] */,
10166                                              WERROR *werror)
10167 {
10168         struct spoolss_RouterReplyPrinterEx r;
10169         NTSTATUS status;
10170
10171         /* In parameters */
10172         r.in.handle = handle;
10173         r.in.color = color;
10174         r.in.flags = flags;
10175         r.in.reply_type = reply_type;
10176         r.in.info = info;
10177
10178         status = cli->dispatch(cli,
10179                                 mem_ctx,
10180                                 &ndr_table_spoolss,
10181                                 NDR_SPOOLSS_ROUTERREPLYPRINTEREX,
10182                                 &r);
10183
10184         if (!NT_STATUS_IS_OK(status)) {
10185                 return status;
10186         }
10187
10188         if (NT_STATUS_IS_ERR(status)) {
10189                 return status;
10190         }
10191
10192         /* Return variables */
10193         *reply_result = *r.out.reply_result;
10194
10195         /* Return result */
10196         if (werror) {
10197                 *werror = r.out.result;
10198         }
10199
10200         return werror_to_ntstatus(r.out.result);
10201 }
10202
10203 struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state {
10204         struct spoolss_RouterRefreshPrinterChangeNotify orig;
10205         struct spoolss_RouterRefreshPrinterChangeNotify tmp;
10206         TALLOC_CTX *out_mem_ctx;
10207         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10208 };
10209
10210 static void rpccli_spoolss_RouterRefreshPrinterChangeNotify_done(struct tevent_req *subreq);
10211
10212 struct tevent_req *rpccli_spoolss_RouterRefreshPrinterChangeNotify_send(TALLOC_CTX *mem_ctx,
10213                                                                         struct tevent_context *ev,
10214                                                                         struct rpc_pipe_client *cli,
10215                                                                         struct policy_handle *_handle /* [in] [ref] */,
10216                                                                         uint32_t _change_low /* [in]  */,
10217                                                                         struct spoolss_NotifyOption *_options /* [in] [unique] */,
10218                                                                         struct spoolss_NotifyInfo **_info /* [out] [ref] */)
10219 {
10220         struct tevent_req *req;
10221         struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state *state;
10222         struct tevent_req *subreq;
10223
10224         req = tevent_req_create(mem_ctx, &state,
10225                                 struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state);
10226         if (req == NULL) {
10227                 return NULL;
10228         }
10229         state->out_mem_ctx = NULL;
10230         state->dispatch_recv = cli->dispatch_recv;
10231
10232         /* In parameters */
10233         state->orig.in.handle = _handle;
10234         state->orig.in.change_low = _change_low;
10235         state->orig.in.options = _options;
10236
10237         /* Out parameters */
10238         state->orig.out.info = _info;
10239
10240         /* Result */
10241         ZERO_STRUCT(state->orig.out.result);
10242
10243         state->out_mem_ctx = talloc_named_const(state, 0,
10244                              "rpccli_spoolss_RouterRefreshPrinterChangeNotify_out_memory");
10245         if (tevent_req_nomem(state->out_mem_ctx, req)) {
10246                 return tevent_req_post(req, ev);
10247         }
10248
10249         /* make a temporary copy, that we pass to the dispatch function */
10250         state->tmp = state->orig;
10251
10252         subreq = cli->dispatch_send(state, ev, cli,
10253                                     &ndr_table_spoolss,
10254                                     NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY,
10255                                     &state->tmp);
10256         if (tevent_req_nomem(subreq, req)) {
10257                 return tevent_req_post(req, ev);
10258         }
10259         tevent_req_set_callback(subreq, rpccli_spoolss_RouterRefreshPrinterChangeNotify_done, req);
10260         return req;
10261 }
10262
10263 static void rpccli_spoolss_RouterRefreshPrinterChangeNotify_done(struct tevent_req *subreq)
10264 {
10265         struct tevent_req *req = tevent_req_callback_data(
10266                 subreq, struct tevent_req);
10267         struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state *state = tevent_req_data(
10268                 req, struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state);
10269         NTSTATUS status;
10270         TALLOC_CTX *mem_ctx;
10271
10272         if (state->out_mem_ctx) {
10273                 mem_ctx = state->out_mem_ctx;
10274         } else {
10275                 mem_ctx = state;
10276         }
10277
10278         status = state->dispatch_recv(subreq, mem_ctx);
10279         TALLOC_FREE(subreq);
10280         if (!NT_STATUS_IS_OK(status)) {
10281                 tevent_req_nterror(req, status);
10282                 return;
10283         }
10284
10285         /* Copy out parameters */
10286         *state->orig.out.info = *state->tmp.out.info;
10287
10288         /* Copy result */
10289         state->orig.out.result = state->tmp.out.result;
10290
10291         /* Reset temporary structure */
10292         ZERO_STRUCT(state->tmp);
10293
10294         tevent_req_done(req);
10295 }
10296
10297 NTSTATUS rpccli_spoolss_RouterRefreshPrinterChangeNotify_recv(struct tevent_req *req,
10298                                                               TALLOC_CTX *mem_ctx,
10299                                                               WERROR *result)
10300 {
10301         struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state *state = tevent_req_data(
10302                 req, struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state);
10303         NTSTATUS status;
10304
10305         if (tevent_req_is_nterror(req, &status)) {
10306                 tevent_req_received(req);
10307                 return status;
10308         }
10309
10310         /* Steal possbile out parameters to the callers context */
10311         talloc_steal(mem_ctx, state->out_mem_ctx);
10312
10313         /* Return result */
10314         *result = state->orig.out.result;
10315
10316         tevent_req_received(req);
10317         return NT_STATUS_OK;
10318 }
10319
10320 NTSTATUS rpccli_spoolss_RouterRefreshPrinterChangeNotify(struct rpc_pipe_client *cli,
10321                                                          TALLOC_CTX *mem_ctx,
10322                                                          struct policy_handle *handle /* [in] [ref] */,
10323                                                          uint32_t change_low /* [in]  */,
10324                                                          struct spoolss_NotifyOption *options /* [in] [unique] */,
10325                                                          struct spoolss_NotifyInfo **info /* [out] [ref] */,
10326                                                          WERROR *werror)
10327 {
10328         struct spoolss_RouterRefreshPrinterChangeNotify r;
10329         NTSTATUS status;
10330
10331         /* In parameters */
10332         r.in.handle = handle;
10333         r.in.change_low = change_low;
10334         r.in.options = options;
10335
10336         status = cli->dispatch(cli,
10337                                 mem_ctx,
10338                                 &ndr_table_spoolss,
10339                                 NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY,
10340                                 &r);
10341
10342         if (!NT_STATUS_IS_OK(status)) {
10343                 return status;
10344         }
10345
10346         if (NT_STATUS_IS_ERR(status)) {
10347                 return status;
10348         }
10349
10350         /* Return variables */
10351         *info = *r.out.info;
10352
10353         /* Return result */
10354         if (werror) {
10355                 *werror = r.out.result;
10356         }
10357
10358         return werror_to_ntstatus(r.out.result);
10359 }
10360
10361 struct rpccli_spoolss_44_state {
10362         struct spoolss_44 orig;
10363         struct spoolss_44 tmp;
10364         TALLOC_CTX *out_mem_ctx;
10365         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10366 };
10367
10368 static void rpccli_spoolss_44_done(struct tevent_req *subreq);
10369
10370 struct tevent_req *rpccli_spoolss_44_send(TALLOC_CTX *mem_ctx,
10371                                           struct tevent_context *ev,
10372                                           struct rpc_pipe_client *cli)
10373 {
10374         struct tevent_req *req;
10375         struct rpccli_spoolss_44_state *state;
10376         struct tevent_req *subreq;
10377
10378         req = tevent_req_create(mem_ctx, &state,
10379                                 struct rpccli_spoolss_44_state);
10380         if (req == NULL) {
10381                 return NULL;
10382         }
10383         state->out_mem_ctx = NULL;
10384         state->dispatch_recv = cli->dispatch_recv;
10385
10386         /* In parameters */
10387
10388         /* Out parameters */
10389
10390         /* Result */
10391         ZERO_STRUCT(state->orig.out.result);
10392
10393         /* make a temporary copy, that we pass to the dispatch function */
10394         state->tmp = state->orig;
10395
10396         subreq = cli->dispatch_send(state, ev, cli,
10397                                     &ndr_table_spoolss,
10398                                     NDR_SPOOLSS_44,
10399                                     &state->tmp);
10400         if (tevent_req_nomem(subreq, req)) {
10401                 return tevent_req_post(req, ev);
10402         }
10403         tevent_req_set_callback(subreq, rpccli_spoolss_44_done, req);
10404         return req;
10405 }
10406
10407 static void rpccli_spoolss_44_done(struct tevent_req *subreq)
10408 {
10409         struct tevent_req *req = tevent_req_callback_data(
10410                 subreq, struct tevent_req);
10411         struct rpccli_spoolss_44_state *state = tevent_req_data(
10412                 req, struct rpccli_spoolss_44_state);
10413         NTSTATUS status;
10414         TALLOC_CTX *mem_ctx;
10415
10416         if (state->out_mem_ctx) {
10417                 mem_ctx = state->out_mem_ctx;
10418         } else {
10419                 mem_ctx = state;
10420         }
10421
10422         status = state->dispatch_recv(subreq, mem_ctx);
10423         TALLOC_FREE(subreq);
10424         if (!NT_STATUS_IS_OK(status)) {
10425                 tevent_req_nterror(req, status);
10426                 return;
10427         }
10428
10429         /* Copy out parameters */
10430
10431         /* Copy result */
10432         state->orig.out.result = state->tmp.out.result;
10433
10434         /* Reset temporary structure */
10435         ZERO_STRUCT(state->tmp);
10436
10437         tevent_req_done(req);
10438 }
10439
10440 NTSTATUS rpccli_spoolss_44_recv(struct tevent_req *req,
10441                                 TALLOC_CTX *mem_ctx,
10442                                 WERROR *result)
10443 {
10444         struct rpccli_spoolss_44_state *state = tevent_req_data(
10445                 req, struct rpccli_spoolss_44_state);
10446         NTSTATUS status;
10447
10448         if (tevent_req_is_nterror(req, &status)) {
10449                 tevent_req_received(req);
10450                 return status;
10451         }
10452
10453         /* Steal possbile out parameters to the callers context */
10454         talloc_steal(mem_ctx, state->out_mem_ctx);
10455
10456         /* Return result */
10457         *result = state->orig.out.result;
10458
10459         tevent_req_received(req);
10460         return NT_STATUS_OK;
10461 }
10462
10463 NTSTATUS rpccli_spoolss_44(struct rpc_pipe_client *cli,
10464                            TALLOC_CTX *mem_ctx,
10465                            WERROR *werror)
10466 {
10467         struct spoolss_44 r;
10468         NTSTATUS status;
10469
10470         /* In parameters */
10471
10472         status = cli->dispatch(cli,
10473                                 mem_ctx,
10474                                 &ndr_table_spoolss,
10475                                 NDR_SPOOLSS_44,
10476                                 &r);
10477
10478         if (!NT_STATUS_IS_OK(status)) {
10479                 return status;
10480         }
10481
10482         if (NT_STATUS_IS_ERR(status)) {
10483                 return status;
10484         }
10485
10486         /* Return variables */
10487
10488         /* Return result */
10489         if (werror) {
10490                 *werror = r.out.result;
10491         }
10492
10493         return werror_to_ntstatus(r.out.result);
10494 }
10495
10496 struct rpccli_spoolss_OpenPrinterEx_state {
10497         struct spoolss_OpenPrinterEx orig;
10498         struct spoolss_OpenPrinterEx tmp;
10499         TALLOC_CTX *out_mem_ctx;
10500         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10501 };
10502
10503 static void rpccli_spoolss_OpenPrinterEx_done(struct tevent_req *subreq);
10504
10505 struct tevent_req *rpccli_spoolss_OpenPrinterEx_send(TALLOC_CTX *mem_ctx,
10506                                                      struct tevent_context *ev,
10507                                                      struct rpc_pipe_client *cli,
10508                                                      const char *_printername /* [in] [unique,charset(UTF16)] */,
10509                                                      const char *_datatype /* [in] [unique,charset(UTF16)] */,
10510                                                      struct spoolss_DevmodeContainer _devmode_ctr /* [in]  */,
10511                                                      uint32_t _access_mask /* [in]  */,
10512                                                      uint32_t _level /* [in]  */,
10513                                                      union spoolss_UserLevel _userlevel /* [in] [switch_is(level)] */,
10514                                                      struct policy_handle *_handle /* [out] [ref] */)
10515 {
10516         struct tevent_req *req;
10517         struct rpccli_spoolss_OpenPrinterEx_state *state;
10518         struct tevent_req *subreq;
10519
10520         req = tevent_req_create(mem_ctx, &state,
10521                                 struct rpccli_spoolss_OpenPrinterEx_state);
10522         if (req == NULL) {
10523                 return NULL;
10524         }
10525         state->out_mem_ctx = NULL;
10526         state->dispatch_recv = cli->dispatch_recv;
10527
10528         /* In parameters */
10529         state->orig.in.printername = _printername;
10530         state->orig.in.datatype = _datatype;
10531         state->orig.in.devmode_ctr = _devmode_ctr;
10532         state->orig.in.access_mask = _access_mask;
10533         state->orig.in.level = _level;
10534         state->orig.in.userlevel = _userlevel;
10535
10536         /* Out parameters */
10537         state->orig.out.handle = _handle;
10538
10539         /* Result */
10540         ZERO_STRUCT(state->orig.out.result);
10541
10542         state->out_mem_ctx = talloc_named_const(state, 0,
10543                              "rpccli_spoolss_OpenPrinterEx_out_memory");
10544         if (tevent_req_nomem(state->out_mem_ctx, req)) {
10545                 return tevent_req_post(req, ev);
10546         }
10547
10548         /* make a temporary copy, that we pass to the dispatch function */
10549         state->tmp = state->orig;
10550
10551         subreq = cli->dispatch_send(state, ev, cli,
10552                                     &ndr_table_spoolss,
10553                                     NDR_SPOOLSS_OPENPRINTEREX,
10554                                     &state->tmp);
10555         if (tevent_req_nomem(subreq, req)) {
10556                 return tevent_req_post(req, ev);
10557         }
10558         tevent_req_set_callback(subreq, rpccli_spoolss_OpenPrinterEx_done, req);
10559         return req;
10560 }
10561
10562 static void rpccli_spoolss_OpenPrinterEx_done(struct tevent_req *subreq)
10563 {
10564         struct tevent_req *req = tevent_req_callback_data(
10565                 subreq, struct tevent_req);
10566         struct rpccli_spoolss_OpenPrinterEx_state *state = tevent_req_data(
10567                 req, struct rpccli_spoolss_OpenPrinterEx_state);
10568         NTSTATUS status;
10569         TALLOC_CTX *mem_ctx;
10570
10571         if (state->out_mem_ctx) {
10572                 mem_ctx = state->out_mem_ctx;
10573         } else {
10574                 mem_ctx = state;
10575         }
10576
10577         status = state->dispatch_recv(subreq, mem_ctx);
10578         TALLOC_FREE(subreq);
10579         if (!NT_STATUS_IS_OK(status)) {
10580                 tevent_req_nterror(req, status);
10581                 return;
10582         }
10583
10584         /* Copy out parameters */
10585         *state->orig.out.handle = *state->tmp.out.handle;
10586
10587         /* Copy result */
10588         state->orig.out.result = state->tmp.out.result;
10589
10590         /* Reset temporary structure */
10591         ZERO_STRUCT(state->tmp);
10592
10593         tevent_req_done(req);
10594 }
10595
10596 NTSTATUS rpccli_spoolss_OpenPrinterEx_recv(struct tevent_req *req,
10597                                            TALLOC_CTX *mem_ctx,
10598                                            WERROR *result)
10599 {
10600         struct rpccli_spoolss_OpenPrinterEx_state *state = tevent_req_data(
10601                 req, struct rpccli_spoolss_OpenPrinterEx_state);
10602         NTSTATUS status;
10603
10604         if (tevent_req_is_nterror(req, &status)) {
10605                 tevent_req_received(req);
10606                 return status;
10607         }
10608
10609         /* Steal possbile out parameters to the callers context */
10610         talloc_steal(mem_ctx, state->out_mem_ctx);
10611
10612         /* Return result */
10613         *result = state->orig.out.result;
10614
10615         tevent_req_received(req);
10616         return NT_STATUS_OK;
10617 }
10618
10619 NTSTATUS rpccli_spoolss_OpenPrinterEx(struct rpc_pipe_client *cli,
10620                                       TALLOC_CTX *mem_ctx,
10621                                       const char *printername /* [in] [unique,charset(UTF16)] */,
10622                                       const char *datatype /* [in] [unique,charset(UTF16)] */,
10623                                       struct spoolss_DevmodeContainer devmode_ctr /* [in]  */,
10624                                       uint32_t access_mask /* [in]  */,
10625                                       uint32_t level /* [in]  */,
10626                                       union spoolss_UserLevel userlevel /* [in] [switch_is(level)] */,
10627                                       struct policy_handle *handle /* [out] [ref] */,
10628                                       WERROR *werror)
10629 {
10630         struct spoolss_OpenPrinterEx r;
10631         NTSTATUS status;
10632
10633         /* In parameters */
10634         r.in.printername = printername;
10635         r.in.datatype = datatype;
10636         r.in.devmode_ctr = devmode_ctr;
10637         r.in.access_mask = access_mask;
10638         r.in.level = level;
10639         r.in.userlevel = userlevel;
10640
10641         status = cli->dispatch(cli,
10642                                 mem_ctx,
10643                                 &ndr_table_spoolss,
10644                                 NDR_SPOOLSS_OPENPRINTEREX,
10645                                 &r);
10646
10647         if (!NT_STATUS_IS_OK(status)) {
10648                 return status;
10649         }
10650
10651         if (NT_STATUS_IS_ERR(status)) {
10652                 return status;
10653         }
10654
10655         /* Return variables */
10656         *handle = *r.out.handle;
10657
10658         /* Return result */
10659         if (werror) {
10660                 *werror = r.out.result;
10661         }
10662
10663         return werror_to_ntstatus(r.out.result);
10664 }
10665
10666 struct rpccli_spoolss_AddPrinterEx_state {
10667         struct spoolss_AddPrinterEx orig;
10668         struct spoolss_AddPrinterEx tmp;
10669         TALLOC_CTX *out_mem_ctx;
10670         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10671 };
10672
10673 static void rpccli_spoolss_AddPrinterEx_done(struct tevent_req *subreq);
10674
10675 struct tevent_req *rpccli_spoolss_AddPrinterEx_send(TALLOC_CTX *mem_ctx,
10676                                                     struct tevent_context *ev,
10677                                                     struct rpc_pipe_client *cli,
10678                                                     const char *_server /* [in] [unique,charset(UTF16)] */,
10679                                                     struct spoolss_SetPrinterInfoCtr *_info_ctr /* [in] [ref] */,
10680                                                     struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */,
10681                                                     struct sec_desc_buf *_secdesc_ctr /* [in] [ref] */,
10682                                                     struct spoolss_UserLevelCtr *_userlevel_ctr /* [in] [ref] */,
10683                                                     struct policy_handle *_handle /* [out] [ref] */)
10684 {
10685         struct tevent_req *req;
10686         struct rpccli_spoolss_AddPrinterEx_state *state;
10687         struct tevent_req *subreq;
10688
10689         req = tevent_req_create(mem_ctx, &state,
10690                                 struct rpccli_spoolss_AddPrinterEx_state);
10691         if (req == NULL) {
10692                 return NULL;
10693         }
10694         state->out_mem_ctx = NULL;
10695         state->dispatch_recv = cli->dispatch_recv;
10696
10697         /* In parameters */
10698         state->orig.in.server = _server;
10699         state->orig.in.info_ctr = _info_ctr;
10700         state->orig.in.devmode_ctr = _devmode_ctr;
10701         state->orig.in.secdesc_ctr = _secdesc_ctr;
10702         state->orig.in.userlevel_ctr = _userlevel_ctr;
10703
10704         /* Out parameters */
10705         state->orig.out.handle = _handle;
10706
10707         /* Result */
10708         ZERO_STRUCT(state->orig.out.result);
10709
10710         state->out_mem_ctx = talloc_named_const(state, 0,
10711                              "rpccli_spoolss_AddPrinterEx_out_memory");
10712         if (tevent_req_nomem(state->out_mem_ctx, req)) {
10713                 return tevent_req_post(req, ev);
10714         }
10715
10716         /* make a temporary copy, that we pass to the dispatch function */
10717         state->tmp = state->orig;
10718
10719         subreq = cli->dispatch_send(state, ev, cli,
10720                                     &ndr_table_spoolss,
10721                                     NDR_SPOOLSS_ADDPRINTEREX,
10722                                     &state->tmp);
10723         if (tevent_req_nomem(subreq, req)) {
10724                 return tevent_req_post(req, ev);
10725         }
10726         tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterEx_done, req);
10727         return req;
10728 }
10729
10730 static void rpccli_spoolss_AddPrinterEx_done(struct tevent_req *subreq)
10731 {
10732         struct tevent_req *req = tevent_req_callback_data(
10733                 subreq, struct tevent_req);
10734         struct rpccli_spoolss_AddPrinterEx_state *state = tevent_req_data(
10735                 req, struct rpccli_spoolss_AddPrinterEx_state);
10736         NTSTATUS status;
10737         TALLOC_CTX *mem_ctx;
10738
10739         if (state->out_mem_ctx) {
10740                 mem_ctx = state->out_mem_ctx;
10741         } else {
10742                 mem_ctx = state;
10743         }
10744
10745         status = state->dispatch_recv(subreq, mem_ctx);
10746         TALLOC_FREE(subreq);
10747         if (!NT_STATUS_IS_OK(status)) {
10748                 tevent_req_nterror(req, status);
10749                 return;
10750         }
10751
10752         /* Copy out parameters */
10753         *state->orig.out.handle = *state->tmp.out.handle;
10754
10755         /* Copy result */
10756         state->orig.out.result = state->tmp.out.result;
10757
10758         /* Reset temporary structure */
10759         ZERO_STRUCT(state->tmp);
10760
10761         tevent_req_done(req);
10762 }
10763
10764 NTSTATUS rpccli_spoolss_AddPrinterEx_recv(struct tevent_req *req,
10765                                           TALLOC_CTX *mem_ctx,
10766                                           WERROR *result)
10767 {
10768         struct rpccli_spoolss_AddPrinterEx_state *state = tevent_req_data(
10769                 req, struct rpccli_spoolss_AddPrinterEx_state);
10770         NTSTATUS status;
10771
10772         if (tevent_req_is_nterror(req, &status)) {
10773                 tevent_req_received(req);
10774                 return status;
10775         }
10776
10777         /* Steal possbile out parameters to the callers context */
10778         talloc_steal(mem_ctx, state->out_mem_ctx);
10779
10780         /* Return result */
10781         *result = state->orig.out.result;
10782
10783         tevent_req_received(req);
10784         return NT_STATUS_OK;
10785 }
10786
10787 NTSTATUS rpccli_spoolss_AddPrinterEx(struct rpc_pipe_client *cli,
10788                                      TALLOC_CTX *mem_ctx,
10789                                      const char *server /* [in] [unique,charset(UTF16)] */,
10790                                      struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */,
10791                                      struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
10792                                      struct sec_desc_buf *secdesc_ctr /* [in] [ref] */,
10793                                      struct spoolss_UserLevelCtr *userlevel_ctr /* [in] [ref] */,
10794                                      struct policy_handle *handle /* [out] [ref] */,
10795                                      WERROR *werror)
10796 {
10797         struct spoolss_AddPrinterEx r;
10798         NTSTATUS status;
10799
10800         /* In parameters */
10801         r.in.server = server;
10802         r.in.info_ctr = info_ctr;
10803         r.in.devmode_ctr = devmode_ctr;
10804         r.in.secdesc_ctr = secdesc_ctr;
10805         r.in.userlevel_ctr = userlevel_ctr;
10806
10807         status = cli->dispatch(cli,
10808                                 mem_ctx,
10809                                 &ndr_table_spoolss,
10810                                 NDR_SPOOLSS_ADDPRINTEREX,
10811                                 &r);
10812
10813         if (!NT_STATUS_IS_OK(status)) {
10814                 return status;
10815         }
10816
10817         if (NT_STATUS_IS_ERR(status)) {
10818                 return status;
10819         }
10820
10821         /* Return variables */
10822         *handle = *r.out.handle;
10823
10824         /* Return result */
10825         if (werror) {
10826                 *werror = r.out.result;
10827         }
10828
10829         return werror_to_ntstatus(r.out.result);
10830 }
10831
10832 struct rpccli_spoolss_47_state {
10833         struct spoolss_47 orig;
10834         struct spoolss_47 tmp;
10835         TALLOC_CTX *out_mem_ctx;
10836         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10837 };
10838
10839 static void rpccli_spoolss_47_done(struct tevent_req *subreq);
10840
10841 struct tevent_req *rpccli_spoolss_47_send(TALLOC_CTX *mem_ctx,
10842                                           struct tevent_context *ev,
10843                                           struct rpc_pipe_client *cli)
10844 {
10845         struct tevent_req *req;
10846         struct rpccli_spoolss_47_state *state;
10847         struct tevent_req *subreq;
10848
10849         req = tevent_req_create(mem_ctx, &state,
10850                                 struct rpccli_spoolss_47_state);
10851         if (req == NULL) {
10852                 return NULL;
10853         }
10854         state->out_mem_ctx = NULL;
10855         state->dispatch_recv = cli->dispatch_recv;
10856
10857         /* In parameters */
10858
10859         /* Out parameters */
10860
10861         /* Result */
10862         ZERO_STRUCT(state->orig.out.result);
10863
10864         /* make a temporary copy, that we pass to the dispatch function */
10865         state->tmp = state->orig;
10866
10867         subreq = cli->dispatch_send(state, ev, cli,
10868                                     &ndr_table_spoolss,
10869                                     NDR_SPOOLSS_47,
10870                                     &state->tmp);
10871         if (tevent_req_nomem(subreq, req)) {
10872                 return tevent_req_post(req, ev);
10873         }
10874         tevent_req_set_callback(subreq, rpccli_spoolss_47_done, req);
10875         return req;
10876 }
10877
10878 static void rpccli_spoolss_47_done(struct tevent_req *subreq)
10879 {
10880         struct tevent_req *req = tevent_req_callback_data(
10881                 subreq, struct tevent_req);
10882         struct rpccli_spoolss_47_state *state = tevent_req_data(
10883                 req, struct rpccli_spoolss_47_state);
10884         NTSTATUS status;
10885         TALLOC_CTX *mem_ctx;
10886
10887         if (state->out_mem_ctx) {
10888                 mem_ctx = state->out_mem_ctx;
10889         } else {
10890                 mem_ctx = state;
10891         }
10892
10893         status = state->dispatch_recv(subreq, mem_ctx);
10894         TALLOC_FREE(subreq);
10895         if (!NT_STATUS_IS_OK(status)) {
10896                 tevent_req_nterror(req, status);
10897                 return;
10898         }
10899
10900         /* Copy out parameters */
10901
10902         /* Copy result */
10903         state->orig.out.result = state->tmp.out.result;
10904
10905         /* Reset temporary structure */
10906         ZERO_STRUCT(state->tmp);
10907
10908         tevent_req_done(req);
10909 }
10910
10911 NTSTATUS rpccli_spoolss_47_recv(struct tevent_req *req,
10912                                 TALLOC_CTX *mem_ctx,
10913                                 WERROR *result)
10914 {
10915         struct rpccli_spoolss_47_state *state = tevent_req_data(
10916                 req, struct rpccli_spoolss_47_state);
10917         NTSTATUS status;
10918
10919         if (tevent_req_is_nterror(req, &status)) {
10920                 tevent_req_received(req);
10921                 return status;
10922         }
10923
10924         /* Steal possbile out parameters to the callers context */
10925         talloc_steal(mem_ctx, state->out_mem_ctx);
10926
10927         /* Return result */
10928         *result = state->orig.out.result;
10929
10930         tevent_req_received(req);
10931         return NT_STATUS_OK;
10932 }
10933
10934 NTSTATUS rpccli_spoolss_47(struct rpc_pipe_client *cli,
10935                            TALLOC_CTX *mem_ctx,
10936                            WERROR *werror)
10937 {
10938         struct spoolss_47 r;
10939         NTSTATUS status;
10940
10941         /* In parameters */
10942
10943         status = cli->dispatch(cli,
10944                                 mem_ctx,
10945                                 &ndr_table_spoolss,
10946                                 NDR_SPOOLSS_47,
10947                                 &r);
10948
10949         if (!NT_STATUS_IS_OK(status)) {
10950                 return status;
10951         }
10952
10953         if (NT_STATUS_IS_ERR(status)) {
10954                 return status;
10955         }
10956
10957         /* Return variables */
10958
10959         /* Return result */
10960         if (werror) {
10961                 *werror = r.out.result;
10962         }
10963
10964         return werror_to_ntstatus(r.out.result);
10965 }
10966
10967 struct rpccli_spoolss_EnumPrinterData_state {
10968         struct spoolss_EnumPrinterData orig;
10969         struct spoolss_EnumPrinterData tmp;
10970         TALLOC_CTX *out_mem_ctx;
10971         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10972 };
10973
10974 static void rpccli_spoolss_EnumPrinterData_done(struct tevent_req *subreq);
10975
10976 struct tevent_req *rpccli_spoolss_EnumPrinterData_send(TALLOC_CTX *mem_ctx,
10977                                                        struct tevent_context *ev,
10978                                                        struct rpc_pipe_client *cli,
10979                                                        struct policy_handle *_handle /* [in] [ref] */,
10980                                                        uint32_t _enum_index /* [in]  */,
10981                                                        const char *_value_name /* [out] [charset(UTF16),size_is(value_offered/2)] */,
10982                                                        uint32_t _value_offered /* [in]  */,
10983                                                        uint32_t *_value_needed /* [out] [ref] */,
10984                                                        enum winreg_Type *_type /* [out] [ref] */,
10985                                                        uint8_t *_data /* [out] [ref,flag(LIBNDR_PRINT_ARRAY_HEX),size_is(data_offered)] */,
10986                                                        uint32_t _data_offered /* [in]  */,
10987                                                        uint32_t *_data_needed /* [out] [ref] */)
10988 {
10989         struct tevent_req *req;
10990         struct rpccli_spoolss_EnumPrinterData_state *state;
10991         struct tevent_req *subreq;
10992
10993         req = tevent_req_create(mem_ctx, &state,
10994                                 struct rpccli_spoolss_EnumPrinterData_state);
10995         if (req == NULL) {
10996                 return NULL;
10997         }
10998         state->out_mem_ctx = NULL;
10999         state->dispatch_recv = cli->dispatch_recv;
11000
11001         /* In parameters */
11002         state->orig.in.handle = _handle;
11003         state->orig.in.enum_index = _enum_index;
11004         state->orig.in.value_offered = _value_offered;
11005         state->orig.in.data_offered = _data_offered;
11006
11007         /* Out parameters */
11008         state->orig.out.value_name = _value_name;
11009         state->orig.out.value_needed = _value_needed;
11010         state->orig.out.type = _type;
11011         state->orig.out.data = _data;
11012         state->orig.out.data_needed = _data_needed;
11013
11014         /* Result */
11015         ZERO_STRUCT(state->orig.out.result);
11016
11017         state->out_mem_ctx = talloc_named_const(state, 0,
11018                              "rpccli_spoolss_EnumPrinterData_out_memory");
11019         if (tevent_req_nomem(state->out_mem_ctx, req)) {
11020                 return tevent_req_post(req, ev);
11021         }
11022
11023         /* make a temporary copy, that we pass to the dispatch function */
11024         state->tmp = state->orig;
11025
11026         subreq = cli->dispatch_send(state, ev, cli,
11027                                     &ndr_table_spoolss,
11028                                     NDR_SPOOLSS_ENUMPRINTERDATA,
11029                                     &state->tmp);
11030         if (tevent_req_nomem(subreq, req)) {
11031                 return tevent_req_post(req, ev);
11032         }
11033         tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinterData_done, req);
11034         return req;
11035 }
11036
11037 static void rpccli_spoolss_EnumPrinterData_done(struct tevent_req *subreq)
11038 {
11039         struct tevent_req *req = tevent_req_callback_data(
11040                 subreq, struct tevent_req);
11041         struct rpccli_spoolss_EnumPrinterData_state *state = tevent_req_data(
11042                 req, struct rpccli_spoolss_EnumPrinterData_state);
11043         NTSTATUS status;
11044         TALLOC_CTX *mem_ctx;
11045
11046         if (state->out_mem_ctx) {
11047                 mem_ctx = state->out_mem_ctx;
11048         } else {
11049                 mem_ctx = state;
11050         }
11051
11052         status = state->dispatch_recv(subreq, mem_ctx);
11053         TALLOC_FREE(subreq);
11054         if (!NT_STATUS_IS_OK(status)) {
11055                 tevent_req_nterror(req, status);
11056                 return;
11057         }
11058
11059         /* Copy out parameters */
11060         memcpy(discard_const_p(uint8_t *, state->orig.out.value_name), state->tmp.out.value_name, (state->tmp.in.value_offered / 2) * sizeof(*state->orig.out.value_name));
11061         *state->orig.out.value_needed = *state->tmp.out.value_needed;
11062         *state->orig.out.type = *state->tmp.out.type;
11063         memcpy(state->orig.out.data, state->tmp.out.data, (state->tmp.in.data_offered) * sizeof(*state->orig.out.data));
11064         *state->orig.out.data_needed = *state->tmp.out.data_needed;
11065
11066         /* Copy result */
11067         state->orig.out.result = state->tmp.out.result;
11068
11069         /* Reset temporary structure */
11070         ZERO_STRUCT(state->tmp);
11071
11072         tevent_req_done(req);
11073 }
11074
11075 NTSTATUS rpccli_spoolss_EnumPrinterData_recv(struct tevent_req *req,
11076                                              TALLOC_CTX *mem_ctx,
11077                                              WERROR *result)
11078 {
11079         struct rpccli_spoolss_EnumPrinterData_state *state = tevent_req_data(
11080                 req, struct rpccli_spoolss_EnumPrinterData_state);
11081         NTSTATUS status;
11082
11083         if (tevent_req_is_nterror(req, &status)) {
11084                 tevent_req_received(req);
11085                 return status;
11086         }
11087
11088         /* Steal possbile out parameters to the callers context */
11089         talloc_steal(mem_ctx, state->out_mem_ctx);
11090
11091         /* Return result */
11092         *result = state->orig.out.result;
11093
11094         tevent_req_received(req);
11095         return NT_STATUS_OK;
11096 }
11097
11098 NTSTATUS rpccli_spoolss_EnumPrinterData(struct rpc_pipe_client *cli,
11099                                         TALLOC_CTX *mem_ctx,
11100                                         struct policy_handle *handle /* [in] [ref] */,
11101                                         uint32_t enum_index /* [in]  */,
11102                                         const char *value_name /* [out] [charset(UTF16),size_is(value_offered/2)] */,
11103                                         uint32_t value_offered /* [in]  */,
11104                                         uint32_t *value_needed /* [out] [ref] */,
11105                                         enum winreg_Type *type /* [out] [ref] */,
11106                                         uint8_t *data /* [out] [ref,flag(LIBNDR_PRINT_ARRAY_HEX),size_is(data_offered)] */,
11107                                         uint32_t data_offered /* [in]  */,
11108                                         uint32_t *data_needed /* [out] [ref] */,
11109                                         WERROR *werror)
11110 {
11111         struct spoolss_EnumPrinterData r;
11112         NTSTATUS status;
11113
11114         /* In parameters */
11115         r.in.handle = handle;
11116         r.in.enum_index = enum_index;
11117         r.in.value_offered = value_offered;
11118         r.in.data_offered = data_offered;
11119
11120         status = cli->dispatch(cli,
11121                                 mem_ctx,
11122                                 &ndr_table_spoolss,
11123                                 NDR_SPOOLSS_ENUMPRINTERDATA,
11124                                 &r);
11125
11126         if (!NT_STATUS_IS_OK(status)) {
11127                 return status;
11128         }
11129
11130         if (NT_STATUS_IS_ERR(status)) {
11131                 return status;
11132         }
11133
11134         /* Return variables */
11135         memcpy(discard_const_p(uint8_t *, value_name), r.out.value_name, (r.in.value_offered / 2) * sizeof(*value_name));
11136         *value_needed = *r.out.value_needed;
11137         *type = *r.out.type;
11138         memcpy(data, r.out.data, (r.in.data_offered) * sizeof(*data));
11139         *data_needed = *r.out.data_needed;
11140
11141         /* Return result */
11142         if (werror) {
11143                 *werror = r.out.result;
11144         }
11145
11146         return werror_to_ntstatus(r.out.result);
11147 }
11148
11149 struct rpccli_spoolss_DeletePrinterData_state {
11150         struct spoolss_DeletePrinterData orig;
11151         struct spoolss_DeletePrinterData tmp;
11152         TALLOC_CTX *out_mem_ctx;
11153         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11154 };
11155
11156 static void rpccli_spoolss_DeletePrinterData_done(struct tevent_req *subreq);
11157
11158 struct tevent_req *rpccli_spoolss_DeletePrinterData_send(TALLOC_CTX *mem_ctx,
11159                                                          struct tevent_context *ev,
11160                                                          struct rpc_pipe_client *cli,
11161                                                          struct policy_handle *_handle /* [in] [ref] */,
11162                                                          const char *_value_name /* [in] [charset(UTF16)] */)
11163 {
11164         struct tevent_req *req;
11165         struct rpccli_spoolss_DeletePrinterData_state *state;
11166         struct tevent_req *subreq;
11167
11168         req = tevent_req_create(mem_ctx, &state,
11169                                 struct rpccli_spoolss_DeletePrinterData_state);
11170         if (req == NULL) {
11171                 return NULL;
11172         }
11173         state->out_mem_ctx = NULL;
11174         state->dispatch_recv = cli->dispatch_recv;
11175
11176         /* In parameters */
11177         state->orig.in.handle = _handle;
11178         state->orig.in.value_name = _value_name;
11179
11180         /* Out parameters */
11181
11182         /* Result */
11183         ZERO_STRUCT(state->orig.out.result);
11184
11185         /* make a temporary copy, that we pass to the dispatch function */
11186         state->tmp = state->orig;
11187
11188         subreq = cli->dispatch_send(state, ev, cli,
11189                                     &ndr_table_spoolss,
11190                                     NDR_SPOOLSS_DELETEPRINTERDATA,
11191                                     &state->tmp);
11192         if (tevent_req_nomem(subreq, req)) {
11193                 return tevent_req_post(req, ev);
11194         }
11195         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterData_done, req);
11196         return req;
11197 }
11198
11199 static void rpccli_spoolss_DeletePrinterData_done(struct tevent_req *subreq)
11200 {
11201         struct tevent_req *req = tevent_req_callback_data(
11202                 subreq, struct tevent_req);
11203         struct rpccli_spoolss_DeletePrinterData_state *state = tevent_req_data(
11204                 req, struct rpccli_spoolss_DeletePrinterData_state);
11205         NTSTATUS status;
11206         TALLOC_CTX *mem_ctx;
11207
11208         if (state->out_mem_ctx) {
11209                 mem_ctx = state->out_mem_ctx;
11210         } else {
11211                 mem_ctx = state;
11212         }
11213
11214         status = state->dispatch_recv(subreq, mem_ctx);
11215         TALLOC_FREE(subreq);
11216         if (!NT_STATUS_IS_OK(status)) {
11217                 tevent_req_nterror(req, status);
11218                 return;
11219         }
11220
11221         /* Copy out parameters */
11222
11223         /* Copy result */
11224         state->orig.out.result = state->tmp.out.result;
11225
11226         /* Reset temporary structure */
11227         ZERO_STRUCT(state->tmp);
11228
11229         tevent_req_done(req);
11230 }
11231
11232 NTSTATUS rpccli_spoolss_DeletePrinterData_recv(struct tevent_req *req,
11233                                                TALLOC_CTX *mem_ctx,
11234                                                WERROR *result)
11235 {
11236         struct rpccli_spoolss_DeletePrinterData_state *state = tevent_req_data(
11237                 req, struct rpccli_spoolss_DeletePrinterData_state);
11238         NTSTATUS status;
11239
11240         if (tevent_req_is_nterror(req, &status)) {
11241                 tevent_req_received(req);
11242                 return status;
11243         }
11244
11245         /* Steal possbile out parameters to the callers context */
11246         talloc_steal(mem_ctx, state->out_mem_ctx);
11247
11248         /* Return result */
11249         *result = state->orig.out.result;
11250
11251         tevent_req_received(req);
11252         return NT_STATUS_OK;
11253 }
11254
11255 NTSTATUS rpccli_spoolss_DeletePrinterData(struct rpc_pipe_client *cli,
11256                                           TALLOC_CTX *mem_ctx,
11257                                           struct policy_handle *handle /* [in] [ref] */,
11258                                           const char *value_name /* [in] [charset(UTF16)] */,
11259                                           WERROR *werror)
11260 {
11261         struct spoolss_DeletePrinterData r;
11262         NTSTATUS status;
11263
11264         /* In parameters */
11265         r.in.handle = handle;
11266         r.in.value_name = value_name;
11267
11268         status = cli->dispatch(cli,
11269                                 mem_ctx,
11270                                 &ndr_table_spoolss,
11271                                 NDR_SPOOLSS_DELETEPRINTERDATA,
11272                                 &r);
11273
11274         if (!NT_STATUS_IS_OK(status)) {
11275                 return status;
11276         }
11277
11278         if (NT_STATUS_IS_ERR(status)) {
11279                 return status;
11280         }
11281
11282         /* Return variables */
11283
11284         /* Return result */
11285         if (werror) {
11286                 *werror = r.out.result;
11287         }
11288
11289         return werror_to_ntstatus(r.out.result);
11290 }
11291
11292 struct rpccli_spoolss_4a_state {
11293         struct spoolss_4a orig;
11294         struct spoolss_4a tmp;
11295         TALLOC_CTX *out_mem_ctx;
11296         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11297 };
11298
11299 static void rpccli_spoolss_4a_done(struct tevent_req *subreq);
11300
11301 struct tevent_req *rpccli_spoolss_4a_send(TALLOC_CTX *mem_ctx,
11302                                           struct tevent_context *ev,
11303                                           struct rpc_pipe_client *cli)
11304 {
11305         struct tevent_req *req;
11306         struct rpccli_spoolss_4a_state *state;
11307         struct tevent_req *subreq;
11308
11309         req = tevent_req_create(mem_ctx, &state,
11310                                 struct rpccli_spoolss_4a_state);
11311         if (req == NULL) {
11312                 return NULL;
11313         }
11314         state->out_mem_ctx = NULL;
11315         state->dispatch_recv = cli->dispatch_recv;
11316
11317         /* In parameters */
11318
11319         /* Out parameters */
11320
11321         /* Result */
11322         ZERO_STRUCT(state->orig.out.result);
11323
11324         /* make a temporary copy, that we pass to the dispatch function */
11325         state->tmp = state->orig;
11326
11327         subreq = cli->dispatch_send(state, ev, cli,
11328                                     &ndr_table_spoolss,
11329                                     NDR_SPOOLSS_4A,
11330                                     &state->tmp);
11331         if (tevent_req_nomem(subreq, req)) {
11332                 return tevent_req_post(req, ev);
11333         }
11334         tevent_req_set_callback(subreq, rpccli_spoolss_4a_done, req);
11335         return req;
11336 }
11337
11338 static void rpccli_spoolss_4a_done(struct tevent_req *subreq)
11339 {
11340         struct tevent_req *req = tevent_req_callback_data(
11341                 subreq, struct tevent_req);
11342         struct rpccli_spoolss_4a_state *state = tevent_req_data(
11343                 req, struct rpccli_spoolss_4a_state);
11344         NTSTATUS status;
11345         TALLOC_CTX *mem_ctx;
11346
11347         if (state->out_mem_ctx) {
11348                 mem_ctx = state->out_mem_ctx;
11349         } else {
11350                 mem_ctx = state;
11351         }
11352
11353         status = state->dispatch_recv(subreq, mem_ctx);
11354         TALLOC_FREE(subreq);
11355         if (!NT_STATUS_IS_OK(status)) {
11356                 tevent_req_nterror(req, status);
11357                 return;
11358         }
11359
11360         /* Copy out parameters */
11361
11362         /* Copy result */
11363         state->orig.out.result = state->tmp.out.result;
11364
11365         /* Reset temporary structure */
11366         ZERO_STRUCT(state->tmp);
11367
11368         tevent_req_done(req);
11369 }
11370
11371 NTSTATUS rpccli_spoolss_4a_recv(struct tevent_req *req,
11372                                 TALLOC_CTX *mem_ctx,
11373                                 WERROR *result)
11374 {
11375         struct rpccli_spoolss_4a_state *state = tevent_req_data(
11376                 req, struct rpccli_spoolss_4a_state);
11377         NTSTATUS status;
11378
11379         if (tevent_req_is_nterror(req, &status)) {
11380                 tevent_req_received(req);
11381                 return status;
11382         }
11383
11384         /* Steal possbile out parameters to the callers context */
11385         talloc_steal(mem_ctx, state->out_mem_ctx);
11386
11387         /* Return result */
11388         *result = state->orig.out.result;
11389
11390         tevent_req_received(req);
11391         return NT_STATUS_OK;
11392 }
11393
11394 NTSTATUS rpccli_spoolss_4a(struct rpc_pipe_client *cli,
11395                            TALLOC_CTX *mem_ctx,
11396                            WERROR *werror)
11397 {
11398         struct spoolss_4a r;
11399         NTSTATUS status;
11400
11401         /* In parameters */
11402
11403         status = cli->dispatch(cli,
11404                                 mem_ctx,
11405                                 &ndr_table_spoolss,
11406                                 NDR_SPOOLSS_4A,
11407                                 &r);
11408
11409         if (!NT_STATUS_IS_OK(status)) {
11410                 return status;
11411         }
11412
11413         if (NT_STATUS_IS_ERR(status)) {
11414                 return status;
11415         }
11416
11417         /* Return variables */
11418
11419         /* Return result */
11420         if (werror) {
11421                 *werror = r.out.result;
11422         }
11423
11424         return werror_to_ntstatus(r.out.result);
11425 }
11426
11427 struct rpccli_spoolss_4b_state {
11428         struct spoolss_4b orig;
11429         struct spoolss_4b tmp;
11430         TALLOC_CTX *out_mem_ctx;
11431         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11432 };
11433
11434 static void rpccli_spoolss_4b_done(struct tevent_req *subreq);
11435
11436 struct tevent_req *rpccli_spoolss_4b_send(TALLOC_CTX *mem_ctx,
11437                                           struct tevent_context *ev,
11438                                           struct rpc_pipe_client *cli)
11439 {
11440         struct tevent_req *req;
11441         struct rpccli_spoolss_4b_state *state;
11442         struct tevent_req *subreq;
11443
11444         req = tevent_req_create(mem_ctx, &state,
11445                                 struct rpccli_spoolss_4b_state);
11446         if (req == NULL) {
11447                 return NULL;
11448         }
11449         state->out_mem_ctx = NULL;
11450         state->dispatch_recv = cli->dispatch_recv;
11451
11452         /* In parameters */
11453
11454         /* Out parameters */
11455
11456         /* Result */
11457         ZERO_STRUCT(state->orig.out.result);
11458
11459         /* make a temporary copy, that we pass to the dispatch function */
11460         state->tmp = state->orig;
11461
11462         subreq = cli->dispatch_send(state, ev, cli,
11463                                     &ndr_table_spoolss,
11464                                     NDR_SPOOLSS_4B,
11465                                     &state->tmp);
11466         if (tevent_req_nomem(subreq, req)) {
11467                 return tevent_req_post(req, ev);
11468         }
11469         tevent_req_set_callback(subreq, rpccli_spoolss_4b_done, req);
11470         return req;
11471 }
11472
11473 static void rpccli_spoolss_4b_done(struct tevent_req *subreq)
11474 {
11475         struct tevent_req *req = tevent_req_callback_data(
11476                 subreq, struct tevent_req);
11477         struct rpccli_spoolss_4b_state *state = tevent_req_data(
11478                 req, struct rpccli_spoolss_4b_state);
11479         NTSTATUS status;
11480         TALLOC_CTX *mem_ctx;
11481
11482         if (state->out_mem_ctx) {
11483                 mem_ctx = state->out_mem_ctx;
11484         } else {
11485                 mem_ctx = state;
11486         }
11487
11488         status = state->dispatch_recv(subreq, mem_ctx);
11489         TALLOC_FREE(subreq);
11490         if (!NT_STATUS_IS_OK(status)) {
11491                 tevent_req_nterror(req, status);
11492                 return;
11493         }
11494
11495         /* Copy out parameters */
11496
11497         /* Copy result */
11498         state->orig.out.result = state->tmp.out.result;
11499
11500         /* Reset temporary structure */
11501         ZERO_STRUCT(state->tmp);
11502
11503         tevent_req_done(req);
11504 }
11505
11506 NTSTATUS rpccli_spoolss_4b_recv(struct tevent_req *req,
11507                                 TALLOC_CTX *mem_ctx,
11508                                 WERROR *result)
11509 {
11510         struct rpccli_spoolss_4b_state *state = tevent_req_data(
11511                 req, struct rpccli_spoolss_4b_state);
11512         NTSTATUS status;
11513
11514         if (tevent_req_is_nterror(req, &status)) {
11515                 tevent_req_received(req);
11516                 return status;
11517         }
11518
11519         /* Steal possbile out parameters to the callers context */
11520         talloc_steal(mem_ctx, state->out_mem_ctx);
11521
11522         /* Return result */
11523         *result = state->orig.out.result;
11524
11525         tevent_req_received(req);
11526         return NT_STATUS_OK;
11527 }
11528
11529 NTSTATUS rpccli_spoolss_4b(struct rpc_pipe_client *cli,
11530                            TALLOC_CTX *mem_ctx,
11531                            WERROR *werror)
11532 {
11533         struct spoolss_4b r;
11534         NTSTATUS status;
11535
11536         /* In parameters */
11537
11538         status = cli->dispatch(cli,
11539                                 mem_ctx,
11540                                 &ndr_table_spoolss,
11541                                 NDR_SPOOLSS_4B,
11542                                 &r);
11543
11544         if (!NT_STATUS_IS_OK(status)) {
11545                 return status;
11546         }
11547
11548         if (NT_STATUS_IS_ERR(status)) {
11549                 return status;
11550         }
11551
11552         /* Return variables */
11553
11554         /* Return result */
11555         if (werror) {
11556                 *werror = r.out.result;
11557         }
11558
11559         return werror_to_ntstatus(r.out.result);
11560 }
11561
11562 struct rpccli_spoolss_4c_state {
11563         struct spoolss_4c orig;
11564         struct spoolss_4c tmp;
11565         TALLOC_CTX *out_mem_ctx;
11566         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11567 };
11568
11569 static void rpccli_spoolss_4c_done(struct tevent_req *subreq);
11570
11571 struct tevent_req *rpccli_spoolss_4c_send(TALLOC_CTX *mem_ctx,
11572                                           struct tevent_context *ev,
11573                                           struct rpc_pipe_client *cli)
11574 {
11575         struct tevent_req *req;
11576         struct rpccli_spoolss_4c_state *state;
11577         struct tevent_req *subreq;
11578
11579         req = tevent_req_create(mem_ctx, &state,
11580                                 struct rpccli_spoolss_4c_state);
11581         if (req == NULL) {
11582                 return NULL;
11583         }
11584         state->out_mem_ctx = NULL;
11585         state->dispatch_recv = cli->dispatch_recv;
11586
11587         /* In parameters */
11588
11589         /* Out parameters */
11590
11591         /* Result */
11592         ZERO_STRUCT(state->orig.out.result);
11593
11594         /* make a temporary copy, that we pass to the dispatch function */
11595         state->tmp = state->orig;
11596
11597         subreq = cli->dispatch_send(state, ev, cli,
11598                                     &ndr_table_spoolss,
11599                                     NDR_SPOOLSS_4C,
11600                                     &state->tmp);
11601         if (tevent_req_nomem(subreq, req)) {
11602                 return tevent_req_post(req, ev);
11603         }
11604         tevent_req_set_callback(subreq, rpccli_spoolss_4c_done, req);
11605         return req;
11606 }
11607
11608 static void rpccli_spoolss_4c_done(struct tevent_req *subreq)
11609 {
11610         struct tevent_req *req = tevent_req_callback_data(
11611                 subreq, struct tevent_req);
11612         struct rpccli_spoolss_4c_state *state = tevent_req_data(
11613                 req, struct rpccli_spoolss_4c_state);
11614         NTSTATUS status;
11615         TALLOC_CTX *mem_ctx;
11616
11617         if (state->out_mem_ctx) {
11618                 mem_ctx = state->out_mem_ctx;
11619         } else {
11620                 mem_ctx = state;
11621         }
11622
11623         status = state->dispatch_recv(subreq, mem_ctx);
11624         TALLOC_FREE(subreq);
11625         if (!NT_STATUS_IS_OK(status)) {
11626                 tevent_req_nterror(req, status);
11627                 return;
11628         }
11629
11630         /* Copy out parameters */
11631
11632         /* Copy result */
11633         state->orig.out.result = state->tmp.out.result;
11634
11635         /* Reset temporary structure */
11636         ZERO_STRUCT(state->tmp);
11637
11638         tevent_req_done(req);
11639 }
11640
11641 NTSTATUS rpccli_spoolss_4c_recv(struct tevent_req *req,
11642                                 TALLOC_CTX *mem_ctx,
11643                                 WERROR *result)
11644 {
11645         struct rpccli_spoolss_4c_state *state = tevent_req_data(
11646                 req, struct rpccli_spoolss_4c_state);
11647         NTSTATUS status;
11648
11649         if (tevent_req_is_nterror(req, &status)) {
11650                 tevent_req_received(req);
11651                 return status;
11652         }
11653
11654         /* Steal possbile out parameters to the callers context */
11655         talloc_steal(mem_ctx, state->out_mem_ctx);
11656
11657         /* Return result */
11658         *result = state->orig.out.result;
11659
11660         tevent_req_received(req);
11661         return NT_STATUS_OK;
11662 }
11663
11664 NTSTATUS rpccli_spoolss_4c(struct rpc_pipe_client *cli,
11665                            TALLOC_CTX *mem_ctx,
11666                            WERROR *werror)
11667 {
11668         struct spoolss_4c r;
11669         NTSTATUS status;
11670
11671         /* In parameters */
11672
11673         status = cli->dispatch(cli,
11674                                 mem_ctx,
11675                                 &ndr_table_spoolss,
11676                                 NDR_SPOOLSS_4C,
11677                                 &r);
11678
11679         if (!NT_STATUS_IS_OK(status)) {
11680                 return status;
11681         }
11682
11683         if (NT_STATUS_IS_ERR(status)) {
11684                 return status;
11685         }
11686
11687         /* Return variables */
11688
11689         /* Return result */
11690         if (werror) {
11691                 *werror = r.out.result;
11692         }
11693
11694         return werror_to_ntstatus(r.out.result);
11695 }
11696
11697 struct rpccli_spoolss_SetPrinterDataEx_state {
11698         struct spoolss_SetPrinterDataEx orig;
11699         struct spoolss_SetPrinterDataEx tmp;
11700         TALLOC_CTX *out_mem_ctx;
11701         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11702 };
11703
11704 static void rpccli_spoolss_SetPrinterDataEx_done(struct tevent_req *subreq);
11705
11706 struct tevent_req *rpccli_spoolss_SetPrinterDataEx_send(TALLOC_CTX *mem_ctx,
11707                                                         struct tevent_context *ev,
11708                                                         struct rpc_pipe_client *cli,
11709                                                         struct policy_handle *_handle /* [in] [ref] */,
11710                                                         const char *_key_name /* [in] [charset(UTF16)] */,
11711                                                         const char *_value_name /* [in] [charset(UTF16)] */,
11712                                                         enum winreg_Type _type /* [in]  */,
11713                                                         uint8_t *_data /* [in] [ref,size_is(offered)] */,
11714                                                         uint32_t _offered /* [in]  */)
11715 {
11716         struct tevent_req *req;
11717         struct rpccli_spoolss_SetPrinterDataEx_state *state;
11718         struct tevent_req *subreq;
11719
11720         req = tevent_req_create(mem_ctx, &state,
11721                                 struct rpccli_spoolss_SetPrinterDataEx_state);
11722         if (req == NULL) {
11723                 return NULL;
11724         }
11725         state->out_mem_ctx = NULL;
11726         state->dispatch_recv = cli->dispatch_recv;
11727
11728         /* In parameters */
11729         state->orig.in.handle = _handle;
11730         state->orig.in.key_name = _key_name;
11731         state->orig.in.value_name = _value_name;
11732         state->orig.in.type = _type;
11733         state->orig.in.data = _data;
11734         state->orig.in.offered = _offered;
11735
11736         /* Out parameters */
11737
11738         /* Result */
11739         ZERO_STRUCT(state->orig.out.result);
11740
11741         /* make a temporary copy, that we pass to the dispatch function */
11742         state->tmp = state->orig;
11743
11744         subreq = cli->dispatch_send(state, ev, cli,
11745                                     &ndr_table_spoolss,
11746                                     NDR_SPOOLSS_SETPRINTERDATAEX,
11747                                     &state->tmp);
11748         if (tevent_req_nomem(subreq, req)) {
11749                 return tevent_req_post(req, ev);
11750         }
11751         tevent_req_set_callback(subreq, rpccli_spoolss_SetPrinterDataEx_done, req);
11752         return req;
11753 }
11754
11755 static void rpccli_spoolss_SetPrinterDataEx_done(struct tevent_req *subreq)
11756 {
11757         struct tevent_req *req = tevent_req_callback_data(
11758                 subreq, struct tevent_req);
11759         struct rpccli_spoolss_SetPrinterDataEx_state *state = tevent_req_data(
11760                 req, struct rpccli_spoolss_SetPrinterDataEx_state);
11761         NTSTATUS status;
11762         TALLOC_CTX *mem_ctx;
11763
11764         if (state->out_mem_ctx) {
11765                 mem_ctx = state->out_mem_ctx;
11766         } else {
11767                 mem_ctx = state;
11768         }
11769
11770         status = state->dispatch_recv(subreq, mem_ctx);
11771         TALLOC_FREE(subreq);
11772         if (!NT_STATUS_IS_OK(status)) {
11773                 tevent_req_nterror(req, status);
11774                 return;
11775         }
11776
11777         /* Copy out parameters */
11778
11779         /* Copy result */
11780         state->orig.out.result = state->tmp.out.result;
11781
11782         /* Reset temporary structure */
11783         ZERO_STRUCT(state->tmp);
11784
11785         tevent_req_done(req);
11786 }
11787
11788 NTSTATUS rpccli_spoolss_SetPrinterDataEx_recv(struct tevent_req *req,
11789                                               TALLOC_CTX *mem_ctx,
11790                                               WERROR *result)
11791 {
11792         struct rpccli_spoolss_SetPrinterDataEx_state *state = tevent_req_data(
11793                 req, struct rpccli_spoolss_SetPrinterDataEx_state);
11794         NTSTATUS status;
11795
11796         if (tevent_req_is_nterror(req, &status)) {
11797                 tevent_req_received(req);
11798                 return status;
11799         }
11800
11801         /* Steal possbile out parameters to the callers context */
11802         talloc_steal(mem_ctx, state->out_mem_ctx);
11803
11804         /* Return result */
11805         *result = state->orig.out.result;
11806
11807         tevent_req_received(req);
11808         return NT_STATUS_OK;
11809 }
11810
11811 NTSTATUS rpccli_spoolss_SetPrinterDataEx(struct rpc_pipe_client *cli,
11812                                          TALLOC_CTX *mem_ctx,
11813                                          struct policy_handle *handle /* [in] [ref] */,
11814                                          const char *key_name /* [in] [charset(UTF16)] */,
11815                                          const char *value_name /* [in] [charset(UTF16)] */,
11816                                          enum winreg_Type type /* [in]  */,
11817                                          uint8_t *data /* [in] [ref,size_is(offered)] */,
11818                                          uint32_t offered /* [in]  */,
11819                                          WERROR *werror)
11820 {
11821         struct spoolss_SetPrinterDataEx r;
11822         NTSTATUS status;
11823
11824         /* In parameters */
11825         r.in.handle = handle;
11826         r.in.key_name = key_name;
11827         r.in.value_name = value_name;
11828         r.in.type = type;
11829         r.in.data = data;
11830         r.in.offered = offered;
11831
11832         status = cli->dispatch(cli,
11833                                 mem_ctx,
11834                                 &ndr_table_spoolss,
11835                                 NDR_SPOOLSS_SETPRINTERDATAEX,
11836                                 &r);
11837
11838         if (!NT_STATUS_IS_OK(status)) {
11839                 return status;
11840         }
11841
11842         if (NT_STATUS_IS_ERR(status)) {
11843                 return status;
11844         }
11845
11846         /* Return variables */
11847
11848         /* Return result */
11849         if (werror) {
11850                 *werror = r.out.result;
11851         }
11852
11853         return werror_to_ntstatus(r.out.result);
11854 }
11855
11856 struct rpccli_spoolss_GetPrinterDataEx_state {
11857         struct spoolss_GetPrinterDataEx orig;
11858         struct spoolss_GetPrinterDataEx tmp;
11859         TALLOC_CTX *out_mem_ctx;
11860         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11861 };
11862
11863 static void rpccli_spoolss_GetPrinterDataEx_done(struct tevent_req *subreq);
11864
11865 struct tevent_req *rpccli_spoolss_GetPrinterDataEx_send(TALLOC_CTX *mem_ctx,
11866                                                         struct tevent_context *ev,
11867                                                         struct rpc_pipe_client *cli,
11868                                                         struct policy_handle *_handle /* [in] [ref] */,
11869                                                         const char *_key_name /* [in] [charset(UTF16)] */,
11870                                                         const char *_value_name /* [in] [charset(UTF16)] */,
11871                                                         enum winreg_Type *_type /* [out] [ref] */,
11872                                                         uint8_t *_data /* [out] [ref,size_is(offered)] */,
11873                                                         uint32_t _offered /* [in]  */,
11874                                                         uint32_t *_needed /* [out] [ref] */)
11875 {
11876         struct tevent_req *req;
11877         struct rpccli_spoolss_GetPrinterDataEx_state *state;
11878         struct tevent_req *subreq;
11879
11880         req = tevent_req_create(mem_ctx, &state,
11881                                 struct rpccli_spoolss_GetPrinterDataEx_state);
11882         if (req == NULL) {
11883                 return NULL;
11884         }
11885         state->out_mem_ctx = NULL;
11886         state->dispatch_recv = cli->dispatch_recv;
11887
11888         /* In parameters */
11889         state->orig.in.handle = _handle;
11890         state->orig.in.key_name = _key_name;
11891         state->orig.in.value_name = _value_name;
11892         state->orig.in.offered = _offered;
11893
11894         /* Out parameters */
11895         state->orig.out.type = _type;
11896         state->orig.out.data = _data;
11897         state->orig.out.needed = _needed;
11898
11899         /* Result */
11900         ZERO_STRUCT(state->orig.out.result);
11901
11902         state->out_mem_ctx = talloc_named_const(state, 0,
11903                              "rpccli_spoolss_GetPrinterDataEx_out_memory");
11904         if (tevent_req_nomem(state->out_mem_ctx, req)) {
11905                 return tevent_req_post(req, ev);
11906         }
11907
11908         /* make a temporary copy, that we pass to the dispatch function */
11909         state->tmp = state->orig;
11910
11911         subreq = cli->dispatch_send(state, ev, cli,
11912                                     &ndr_table_spoolss,
11913                                     NDR_SPOOLSS_GETPRINTERDATAEX,
11914                                     &state->tmp);
11915         if (tevent_req_nomem(subreq, req)) {
11916                 return tevent_req_post(req, ev);
11917         }
11918         tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDataEx_done, req);
11919         return req;
11920 }
11921
11922 static void rpccli_spoolss_GetPrinterDataEx_done(struct tevent_req *subreq)
11923 {
11924         struct tevent_req *req = tevent_req_callback_data(
11925                 subreq, struct tevent_req);
11926         struct rpccli_spoolss_GetPrinterDataEx_state *state = tevent_req_data(
11927                 req, struct rpccli_spoolss_GetPrinterDataEx_state);
11928         NTSTATUS status;
11929         TALLOC_CTX *mem_ctx;
11930
11931         if (state->out_mem_ctx) {
11932                 mem_ctx = state->out_mem_ctx;
11933         } else {
11934                 mem_ctx = state;
11935         }
11936
11937         status = state->dispatch_recv(subreq, mem_ctx);
11938         TALLOC_FREE(subreq);
11939         if (!NT_STATUS_IS_OK(status)) {
11940                 tevent_req_nterror(req, status);
11941                 return;
11942         }
11943
11944         /* Copy out parameters */
11945         *state->orig.out.type = *state->tmp.out.type;
11946         memcpy(state->orig.out.data, state->tmp.out.data, (state->tmp.in.offered) * sizeof(*state->orig.out.data));
11947         *state->orig.out.needed = *state->tmp.out.needed;
11948
11949         /* Copy result */
11950         state->orig.out.result = state->tmp.out.result;
11951
11952         /* Reset temporary structure */
11953         ZERO_STRUCT(state->tmp);
11954
11955         tevent_req_done(req);
11956 }
11957
11958 NTSTATUS rpccli_spoolss_GetPrinterDataEx_recv(struct tevent_req *req,
11959                                               TALLOC_CTX *mem_ctx,
11960                                               WERROR *result)
11961 {
11962         struct rpccli_spoolss_GetPrinterDataEx_state *state = tevent_req_data(
11963                 req, struct rpccli_spoolss_GetPrinterDataEx_state);
11964         NTSTATUS status;
11965
11966         if (tevent_req_is_nterror(req, &status)) {
11967                 tevent_req_received(req);
11968                 return status;
11969         }
11970
11971         /* Steal possbile out parameters to the callers context */
11972         talloc_steal(mem_ctx, state->out_mem_ctx);
11973
11974         /* Return result */
11975         *result = state->orig.out.result;
11976
11977         tevent_req_received(req);
11978         return NT_STATUS_OK;
11979 }
11980
11981 NTSTATUS rpccli_spoolss_GetPrinterDataEx(struct rpc_pipe_client *cli,
11982                                          TALLOC_CTX *mem_ctx,
11983                                          struct policy_handle *handle /* [in] [ref] */,
11984                                          const char *key_name /* [in] [charset(UTF16)] */,
11985                                          const char *value_name /* [in] [charset(UTF16)] */,
11986                                          enum winreg_Type *type /* [out] [ref] */,
11987                                          uint8_t *data /* [out] [ref,size_is(offered)] */,
11988                                          uint32_t offered /* [in]  */,
11989                                          uint32_t *needed /* [out] [ref] */,
11990                                          WERROR *werror)
11991 {
11992         struct spoolss_GetPrinterDataEx r;
11993         NTSTATUS status;
11994
11995         /* In parameters */
11996         r.in.handle = handle;
11997         r.in.key_name = key_name;
11998         r.in.value_name = value_name;
11999         r.in.offered = offered;
12000
12001         status = cli->dispatch(cli,
12002                                 mem_ctx,
12003                                 &ndr_table_spoolss,
12004                                 NDR_SPOOLSS_GETPRINTERDATAEX,
12005                                 &r);
12006
12007         if (!NT_STATUS_IS_OK(status)) {
12008                 return status;
12009         }
12010
12011         if (NT_STATUS_IS_ERR(status)) {
12012                 return status;
12013         }
12014
12015         /* Return variables */
12016         *type = *r.out.type;
12017         memcpy(data, r.out.data, (r.in.offered) * sizeof(*data));
12018         *needed = *r.out.needed;
12019
12020         /* Return result */
12021         if (werror) {
12022                 *werror = r.out.result;
12023         }
12024
12025         return werror_to_ntstatus(r.out.result);
12026 }
12027
12028 struct rpccli_spoolss_EnumPrinterDataEx_state {
12029         struct spoolss_EnumPrinterDataEx orig;
12030         struct spoolss_EnumPrinterDataEx tmp;
12031         TALLOC_CTX *out_mem_ctx;
12032         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12033 };
12034
12035 static void rpccli_spoolss_EnumPrinterDataEx_done(struct tevent_req *subreq);
12036
12037 struct tevent_req *rpccli_spoolss_EnumPrinterDataEx_send(TALLOC_CTX *mem_ctx,
12038                                                          struct tevent_context *ev,
12039                                                          struct rpc_pipe_client *cli,
12040                                                          struct policy_handle *_handle /* [in] [ref] */,
12041                                                          const char *_key_name /* [in] [charset(UTF16)] */,
12042                                                          uint32_t _offered /* [in]  */,
12043                                                          uint32_t *_count /* [out] [ref] */,
12044                                                          struct spoolss_PrinterEnumValues **_info /* [out] [ref,size_is(,*count)] */,
12045                                                          uint32_t *_needed /* [out] [ref] */)
12046 {
12047         struct tevent_req *req;
12048         struct rpccli_spoolss_EnumPrinterDataEx_state *state;
12049         struct tevent_req *subreq;
12050
12051         req = tevent_req_create(mem_ctx, &state,
12052                                 struct rpccli_spoolss_EnumPrinterDataEx_state);
12053         if (req == NULL) {
12054                 return NULL;
12055         }
12056         state->out_mem_ctx = NULL;
12057         state->dispatch_recv = cli->dispatch_recv;
12058
12059         /* In parameters */
12060         state->orig.in.handle = _handle;
12061         state->orig.in.key_name = _key_name;
12062         state->orig.in.offered = _offered;
12063
12064         /* Out parameters */
12065         state->orig.out.count = _count;
12066         state->orig.out.info = _info;
12067         state->orig.out.needed = _needed;
12068
12069         /* Result */
12070         ZERO_STRUCT(state->orig.out.result);
12071
12072         state->out_mem_ctx = talloc_named_const(state, 0,
12073                              "rpccli_spoolss_EnumPrinterDataEx_out_memory");
12074         if (tevent_req_nomem(state->out_mem_ctx, req)) {
12075                 return tevent_req_post(req, ev);
12076         }
12077
12078         /* make a temporary copy, that we pass to the dispatch function */
12079         state->tmp = state->orig;
12080
12081         subreq = cli->dispatch_send(state, ev, cli,
12082                                     &ndr_table_spoolss,
12083                                     NDR_SPOOLSS_ENUMPRINTERDATAEX,
12084                                     &state->tmp);
12085         if (tevent_req_nomem(subreq, req)) {
12086                 return tevent_req_post(req, ev);
12087         }
12088         tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinterDataEx_done, req);
12089         return req;
12090 }
12091
12092 static void rpccli_spoolss_EnumPrinterDataEx_done(struct tevent_req *subreq)
12093 {
12094         struct tevent_req *req = tevent_req_callback_data(
12095                 subreq, struct tevent_req);
12096         struct rpccli_spoolss_EnumPrinterDataEx_state *state = tevent_req_data(
12097                 req, struct rpccli_spoolss_EnumPrinterDataEx_state);
12098         NTSTATUS status;
12099         TALLOC_CTX *mem_ctx;
12100
12101         if (state->out_mem_ctx) {
12102                 mem_ctx = state->out_mem_ctx;
12103         } else {
12104                 mem_ctx = state;
12105         }
12106
12107         status = state->dispatch_recv(subreq, mem_ctx);
12108         TALLOC_FREE(subreq);
12109         if (!NT_STATUS_IS_OK(status)) {
12110                 tevent_req_nterror(req, status);
12111                 return;
12112         }
12113
12114         /* Copy out parameters */
12115         *state->orig.out.count = *state->tmp.out.count;
12116         *state->orig.out.info = *state->tmp.out.info;
12117         *state->orig.out.needed = *state->tmp.out.needed;
12118
12119         /* Copy result */
12120         state->orig.out.result = state->tmp.out.result;
12121
12122         /* Reset temporary structure */
12123         ZERO_STRUCT(state->tmp);
12124
12125         tevent_req_done(req);
12126 }
12127
12128 NTSTATUS rpccli_spoolss_EnumPrinterDataEx_recv(struct tevent_req *req,
12129                                                TALLOC_CTX *mem_ctx,
12130                                                WERROR *result)
12131 {
12132         struct rpccli_spoolss_EnumPrinterDataEx_state *state = tevent_req_data(
12133                 req, struct rpccli_spoolss_EnumPrinterDataEx_state);
12134         NTSTATUS status;
12135
12136         if (tevent_req_is_nterror(req, &status)) {
12137                 tevent_req_received(req);
12138                 return status;
12139         }
12140
12141         /* Steal possbile out parameters to the callers context */
12142         talloc_steal(mem_ctx, state->out_mem_ctx);
12143
12144         /* Return result */
12145         *result = state->orig.out.result;
12146
12147         tevent_req_received(req);
12148         return NT_STATUS_OK;
12149 }
12150
12151 NTSTATUS rpccli_spoolss_EnumPrinterDataEx(struct rpc_pipe_client *cli,
12152                                           TALLOC_CTX *mem_ctx,
12153                                           struct policy_handle *handle /* [in] [ref] */,
12154                                           const char *key_name /* [in] [charset(UTF16)] */,
12155                                           uint32_t offered /* [in]  */,
12156                                           uint32_t *count /* [out] [ref] */,
12157                                           struct spoolss_PrinterEnumValues **info /* [out] [ref,size_is(,*count)] */,
12158                                           uint32_t *needed /* [out] [ref] */,
12159                                           WERROR *werror)
12160 {
12161         struct spoolss_EnumPrinterDataEx r;
12162         NTSTATUS status;
12163
12164         /* In parameters */
12165         r.in.handle = handle;
12166         r.in.key_name = key_name;
12167         r.in.offered = offered;
12168
12169         status = cli->dispatch(cli,
12170                                 mem_ctx,
12171                                 &ndr_table_spoolss,
12172                                 NDR_SPOOLSS_ENUMPRINTERDATAEX,
12173                                 &r);
12174
12175         if (!NT_STATUS_IS_OK(status)) {
12176                 return status;
12177         }
12178
12179         if (NT_STATUS_IS_ERR(status)) {
12180                 return status;
12181         }
12182
12183         /* Return variables */
12184         *count = *r.out.count;
12185         *info = *r.out.info;
12186         *needed = *r.out.needed;
12187
12188         /* Return result */
12189         if (werror) {
12190                 *werror = r.out.result;
12191         }
12192
12193         return werror_to_ntstatus(r.out.result);
12194 }
12195
12196 struct rpccli_spoolss_EnumPrinterKey_state {
12197         struct spoolss_EnumPrinterKey orig;
12198         struct spoolss_EnumPrinterKey tmp;
12199         TALLOC_CTX *out_mem_ctx;
12200         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12201 };
12202
12203 static void rpccli_spoolss_EnumPrinterKey_done(struct tevent_req *subreq);
12204
12205 struct tevent_req *rpccli_spoolss_EnumPrinterKey_send(TALLOC_CTX *mem_ctx,
12206                                                       struct tevent_context *ev,
12207                                                       struct rpc_pipe_client *cli,
12208                                                       struct policy_handle *_handle /* [in] [ref] */,
12209                                                       const char *_key_name /* [in] [charset(UTF16)] */,
12210                                                       uint32_t *__ndr_size /* [out] [ref] */,
12211                                                       union spoolss_KeyNames *_key_buffer /* [out] [subcontext_size(*_ndr_size*2),ref,subcontext(0),switch_is(*_ndr_size)] */,
12212                                                       uint32_t _offered /* [in]  */,
12213                                                       uint32_t *_needed /* [out] [ref] */)
12214 {
12215         struct tevent_req *req;
12216         struct rpccli_spoolss_EnumPrinterKey_state *state;
12217         struct tevent_req *subreq;
12218
12219         req = tevent_req_create(mem_ctx, &state,
12220                                 struct rpccli_spoolss_EnumPrinterKey_state);
12221         if (req == NULL) {
12222                 return NULL;
12223         }
12224         state->out_mem_ctx = NULL;
12225         state->dispatch_recv = cli->dispatch_recv;
12226
12227         /* In parameters */
12228         state->orig.in.handle = _handle;
12229         state->orig.in.key_name = _key_name;
12230         state->orig.in.offered = _offered;
12231
12232         /* Out parameters */
12233         state->orig.out._ndr_size = __ndr_size;
12234         state->orig.out.key_buffer = _key_buffer;
12235         state->orig.out.needed = _needed;
12236
12237         /* Result */
12238         ZERO_STRUCT(state->orig.out.result);
12239
12240         state->out_mem_ctx = talloc_named_const(state, 0,
12241                              "rpccli_spoolss_EnumPrinterKey_out_memory");
12242         if (tevent_req_nomem(state->out_mem_ctx, req)) {
12243                 return tevent_req_post(req, ev);
12244         }
12245
12246         /* make a temporary copy, that we pass to the dispatch function */
12247         state->tmp = state->orig;
12248
12249         subreq = cli->dispatch_send(state, ev, cli,
12250                                     &ndr_table_spoolss,
12251                                     NDR_SPOOLSS_ENUMPRINTERKEY,
12252                                     &state->tmp);
12253         if (tevent_req_nomem(subreq, req)) {
12254                 return tevent_req_post(req, ev);
12255         }
12256         tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinterKey_done, req);
12257         return req;
12258 }
12259
12260 static void rpccli_spoolss_EnumPrinterKey_done(struct tevent_req *subreq)
12261 {
12262         struct tevent_req *req = tevent_req_callback_data(
12263                 subreq, struct tevent_req);
12264         struct rpccli_spoolss_EnumPrinterKey_state *state = tevent_req_data(
12265                 req, struct rpccli_spoolss_EnumPrinterKey_state);
12266         NTSTATUS status;
12267         TALLOC_CTX *mem_ctx;
12268
12269         if (state->out_mem_ctx) {
12270                 mem_ctx = state->out_mem_ctx;
12271         } else {
12272                 mem_ctx = state;
12273         }
12274
12275         status = state->dispatch_recv(subreq, mem_ctx);
12276         TALLOC_FREE(subreq);
12277         if (!NT_STATUS_IS_OK(status)) {
12278                 tevent_req_nterror(req, status);
12279                 return;
12280         }
12281
12282         /* Copy out parameters */
12283         *state->orig.out._ndr_size = *state->tmp.out._ndr_size;
12284         *state->orig.out.key_buffer = *state->tmp.out.key_buffer;
12285         *state->orig.out.needed = *state->tmp.out.needed;
12286
12287         /* Copy result */
12288         state->orig.out.result = state->tmp.out.result;
12289
12290         /* Reset temporary structure */
12291         ZERO_STRUCT(state->tmp);
12292
12293         tevent_req_done(req);
12294 }
12295
12296 NTSTATUS rpccli_spoolss_EnumPrinterKey_recv(struct tevent_req *req,
12297                                             TALLOC_CTX *mem_ctx,
12298                                             WERROR *result)
12299 {
12300         struct rpccli_spoolss_EnumPrinterKey_state *state = tevent_req_data(
12301                 req, struct rpccli_spoolss_EnumPrinterKey_state);
12302         NTSTATUS status;
12303
12304         if (tevent_req_is_nterror(req, &status)) {
12305                 tevent_req_received(req);
12306                 return status;
12307         }
12308
12309         /* Steal possbile out parameters to the callers context */
12310         talloc_steal(mem_ctx, state->out_mem_ctx);
12311
12312         /* Return result */
12313         *result = state->orig.out.result;
12314
12315         tevent_req_received(req);
12316         return NT_STATUS_OK;
12317 }
12318
12319 NTSTATUS rpccli_spoolss_EnumPrinterKey(struct rpc_pipe_client *cli,
12320                                        TALLOC_CTX *mem_ctx,
12321                                        struct policy_handle *handle /* [in] [ref] */,
12322                                        const char *key_name /* [in] [charset(UTF16)] */,
12323                                        uint32_t *_ndr_size /* [out] [ref] */,
12324                                        union spoolss_KeyNames *key_buffer /* [out] [subcontext_size(*_ndr_size*2),ref,subcontext(0),switch_is(*_ndr_size)] */,
12325                                        uint32_t offered /* [in]  */,
12326                                        uint32_t *needed /* [out] [ref] */,
12327                                        WERROR *werror)
12328 {
12329         struct spoolss_EnumPrinterKey r;
12330         NTSTATUS status;
12331
12332         /* In parameters */
12333         r.in.handle = handle;
12334         r.in.key_name = key_name;
12335         r.in.offered = offered;
12336
12337         status = cli->dispatch(cli,
12338                                 mem_ctx,
12339                                 &ndr_table_spoolss,
12340                                 NDR_SPOOLSS_ENUMPRINTERKEY,
12341                                 &r);
12342
12343         if (!NT_STATUS_IS_OK(status)) {
12344                 return status;
12345         }
12346
12347         if (NT_STATUS_IS_ERR(status)) {
12348                 return status;
12349         }
12350
12351         /* Return variables */
12352         *_ndr_size = *r.out._ndr_size;
12353         *key_buffer = *r.out.key_buffer;
12354         *needed = *r.out.needed;
12355
12356         /* Return result */
12357         if (werror) {
12358                 *werror = r.out.result;
12359         }
12360
12361         return werror_to_ntstatus(r.out.result);
12362 }
12363
12364 struct rpccli_spoolss_DeletePrinterDataEx_state {
12365         struct spoolss_DeletePrinterDataEx orig;
12366         struct spoolss_DeletePrinterDataEx tmp;
12367         TALLOC_CTX *out_mem_ctx;
12368         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12369 };
12370
12371 static void rpccli_spoolss_DeletePrinterDataEx_done(struct tevent_req *subreq);
12372
12373 struct tevent_req *rpccli_spoolss_DeletePrinterDataEx_send(TALLOC_CTX *mem_ctx,
12374                                                            struct tevent_context *ev,
12375                                                            struct rpc_pipe_client *cli,
12376                                                            struct policy_handle *_handle /* [in] [ref] */,
12377                                                            const char *_key_name /* [in] [charset(UTF16)] */,
12378                                                            const char *_value_name /* [in] [charset(UTF16)] */)
12379 {
12380         struct tevent_req *req;
12381         struct rpccli_spoolss_DeletePrinterDataEx_state *state;
12382         struct tevent_req *subreq;
12383
12384         req = tevent_req_create(mem_ctx, &state,
12385                                 struct rpccli_spoolss_DeletePrinterDataEx_state);
12386         if (req == NULL) {
12387                 return NULL;
12388         }
12389         state->out_mem_ctx = NULL;
12390         state->dispatch_recv = cli->dispatch_recv;
12391
12392         /* In parameters */
12393         state->orig.in.handle = _handle;
12394         state->orig.in.key_name = _key_name;
12395         state->orig.in.value_name = _value_name;
12396
12397         /* Out parameters */
12398
12399         /* Result */
12400         ZERO_STRUCT(state->orig.out.result);
12401
12402         /* make a temporary copy, that we pass to the dispatch function */
12403         state->tmp = state->orig;
12404
12405         subreq = cli->dispatch_send(state, ev, cli,
12406                                     &ndr_table_spoolss,
12407                                     NDR_SPOOLSS_DELETEPRINTERDATAEX,
12408                                     &state->tmp);
12409         if (tevent_req_nomem(subreq, req)) {
12410                 return tevent_req_post(req, ev);
12411         }
12412         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterDataEx_done, req);
12413         return req;
12414 }
12415
12416 static void rpccli_spoolss_DeletePrinterDataEx_done(struct tevent_req *subreq)
12417 {
12418         struct tevent_req *req = tevent_req_callback_data(
12419                 subreq, struct tevent_req);
12420         struct rpccli_spoolss_DeletePrinterDataEx_state *state = tevent_req_data(
12421                 req, struct rpccli_spoolss_DeletePrinterDataEx_state);
12422         NTSTATUS status;
12423         TALLOC_CTX *mem_ctx;
12424
12425         if (state->out_mem_ctx) {
12426                 mem_ctx = state->out_mem_ctx;
12427         } else {
12428                 mem_ctx = state;
12429         }
12430
12431         status = state->dispatch_recv(subreq, mem_ctx);
12432         TALLOC_FREE(subreq);
12433         if (!NT_STATUS_IS_OK(status)) {
12434                 tevent_req_nterror(req, status);
12435                 return;
12436         }
12437
12438         /* Copy out parameters */
12439
12440         /* Copy result */
12441         state->orig.out.result = state->tmp.out.result;
12442
12443         /* Reset temporary structure */
12444         ZERO_STRUCT(state->tmp);
12445
12446         tevent_req_done(req);
12447 }
12448
12449 NTSTATUS rpccli_spoolss_DeletePrinterDataEx_recv(struct tevent_req *req,
12450                                                  TALLOC_CTX *mem_ctx,
12451                                                  WERROR *result)
12452 {
12453         struct rpccli_spoolss_DeletePrinterDataEx_state *state = tevent_req_data(
12454                 req, struct rpccli_spoolss_DeletePrinterDataEx_state);
12455         NTSTATUS status;
12456
12457         if (tevent_req_is_nterror(req, &status)) {
12458                 tevent_req_received(req);
12459                 return status;
12460         }
12461
12462         /* Steal possbile out parameters to the callers context */
12463         talloc_steal(mem_ctx, state->out_mem_ctx);
12464
12465         /* Return result */
12466         *result = state->orig.out.result;
12467
12468         tevent_req_received(req);
12469         return NT_STATUS_OK;
12470 }
12471
12472 NTSTATUS rpccli_spoolss_DeletePrinterDataEx(struct rpc_pipe_client *cli,
12473                                             TALLOC_CTX *mem_ctx,
12474                                             struct policy_handle *handle /* [in] [ref] */,
12475                                             const char *key_name /* [in] [charset(UTF16)] */,
12476                                             const char *value_name /* [in] [charset(UTF16)] */,
12477                                             WERROR *werror)
12478 {
12479         struct spoolss_DeletePrinterDataEx r;
12480         NTSTATUS status;
12481
12482         /* In parameters */
12483         r.in.handle = handle;
12484         r.in.key_name = key_name;
12485         r.in.value_name = value_name;
12486
12487         status = cli->dispatch(cli,
12488                                 mem_ctx,
12489                                 &ndr_table_spoolss,
12490                                 NDR_SPOOLSS_DELETEPRINTERDATAEX,
12491                                 &r);
12492
12493         if (!NT_STATUS_IS_OK(status)) {
12494                 return status;
12495         }
12496
12497         if (NT_STATUS_IS_ERR(status)) {
12498                 return status;
12499         }
12500
12501         /* Return variables */
12502
12503         /* Return result */
12504         if (werror) {
12505                 *werror = r.out.result;
12506         }
12507
12508         return werror_to_ntstatus(r.out.result);
12509 }
12510
12511 struct rpccli_spoolss_DeletePrinterKey_state {
12512         struct spoolss_DeletePrinterKey orig;
12513         struct spoolss_DeletePrinterKey tmp;
12514         TALLOC_CTX *out_mem_ctx;
12515         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12516 };
12517
12518 static void rpccli_spoolss_DeletePrinterKey_done(struct tevent_req *subreq);
12519
12520 struct tevent_req *rpccli_spoolss_DeletePrinterKey_send(TALLOC_CTX *mem_ctx,
12521                                                         struct tevent_context *ev,
12522                                                         struct rpc_pipe_client *cli,
12523                                                         struct policy_handle *_handle /* [in] [ref] */,
12524                                                         const char *_key_name /* [in] [charset(UTF16)] */)
12525 {
12526         struct tevent_req *req;
12527         struct rpccli_spoolss_DeletePrinterKey_state *state;
12528         struct tevent_req *subreq;
12529
12530         req = tevent_req_create(mem_ctx, &state,
12531                                 struct rpccli_spoolss_DeletePrinterKey_state);
12532         if (req == NULL) {
12533                 return NULL;
12534         }
12535         state->out_mem_ctx = NULL;
12536         state->dispatch_recv = cli->dispatch_recv;
12537
12538         /* In parameters */
12539         state->orig.in.handle = _handle;
12540         state->orig.in.key_name = _key_name;
12541
12542         /* Out parameters */
12543
12544         /* Result */
12545         ZERO_STRUCT(state->orig.out.result);
12546
12547         /* make a temporary copy, that we pass to the dispatch function */
12548         state->tmp = state->orig;
12549
12550         subreq = cli->dispatch_send(state, ev, cli,
12551                                     &ndr_table_spoolss,
12552                                     NDR_SPOOLSS_DELETEPRINTERKEY,
12553                                     &state->tmp);
12554         if (tevent_req_nomem(subreq, req)) {
12555                 return tevent_req_post(req, ev);
12556         }
12557         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterKey_done, req);
12558         return req;
12559 }
12560
12561 static void rpccli_spoolss_DeletePrinterKey_done(struct tevent_req *subreq)
12562 {
12563         struct tevent_req *req = tevent_req_callback_data(
12564                 subreq, struct tevent_req);
12565         struct rpccli_spoolss_DeletePrinterKey_state *state = tevent_req_data(
12566                 req, struct rpccli_spoolss_DeletePrinterKey_state);
12567         NTSTATUS status;
12568         TALLOC_CTX *mem_ctx;
12569
12570         if (state->out_mem_ctx) {
12571                 mem_ctx = state->out_mem_ctx;
12572         } else {
12573                 mem_ctx = state;
12574         }
12575
12576         status = state->dispatch_recv(subreq, mem_ctx);
12577         TALLOC_FREE(subreq);
12578         if (!NT_STATUS_IS_OK(status)) {
12579                 tevent_req_nterror(req, status);
12580                 return;
12581         }
12582
12583         /* Copy out parameters */
12584
12585         /* Copy result */
12586         state->orig.out.result = state->tmp.out.result;
12587
12588         /* Reset temporary structure */
12589         ZERO_STRUCT(state->tmp);
12590
12591         tevent_req_done(req);
12592 }
12593
12594 NTSTATUS rpccli_spoolss_DeletePrinterKey_recv(struct tevent_req *req,
12595                                               TALLOC_CTX *mem_ctx,
12596                                               WERROR *result)
12597 {
12598         struct rpccli_spoolss_DeletePrinterKey_state *state = tevent_req_data(
12599                 req, struct rpccli_spoolss_DeletePrinterKey_state);
12600         NTSTATUS status;
12601
12602         if (tevent_req_is_nterror(req, &status)) {
12603                 tevent_req_received(req);
12604                 return status;
12605         }
12606
12607         /* Steal possbile out parameters to the callers context */
12608         talloc_steal(mem_ctx, state->out_mem_ctx);
12609
12610         /* Return result */
12611         *result = state->orig.out.result;
12612
12613         tevent_req_received(req);
12614         return NT_STATUS_OK;
12615 }
12616
12617 NTSTATUS rpccli_spoolss_DeletePrinterKey(struct rpc_pipe_client *cli,
12618                                          TALLOC_CTX *mem_ctx,
12619                                          struct policy_handle *handle /* [in] [ref] */,
12620                                          const char *key_name /* [in] [charset(UTF16)] */,
12621                                          WERROR *werror)
12622 {
12623         struct spoolss_DeletePrinterKey r;
12624         NTSTATUS status;
12625
12626         /* In parameters */
12627         r.in.handle = handle;
12628         r.in.key_name = key_name;
12629
12630         status = cli->dispatch(cli,
12631                                 mem_ctx,
12632                                 &ndr_table_spoolss,
12633                                 NDR_SPOOLSS_DELETEPRINTERKEY,
12634                                 &r);
12635
12636         if (!NT_STATUS_IS_OK(status)) {
12637                 return status;
12638         }
12639
12640         if (NT_STATUS_IS_ERR(status)) {
12641                 return status;
12642         }
12643
12644         /* Return variables */
12645
12646         /* Return result */
12647         if (werror) {
12648                 *werror = r.out.result;
12649         }
12650
12651         return werror_to_ntstatus(r.out.result);
12652 }
12653
12654 struct rpccli_spoolss_53_state {
12655         struct spoolss_53 orig;
12656         struct spoolss_53 tmp;
12657         TALLOC_CTX *out_mem_ctx;
12658         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12659 };
12660
12661 static void rpccli_spoolss_53_done(struct tevent_req *subreq);
12662
12663 struct tevent_req *rpccli_spoolss_53_send(TALLOC_CTX *mem_ctx,
12664                                           struct tevent_context *ev,
12665                                           struct rpc_pipe_client *cli)
12666 {
12667         struct tevent_req *req;
12668         struct rpccli_spoolss_53_state *state;
12669         struct tevent_req *subreq;
12670
12671         req = tevent_req_create(mem_ctx, &state,
12672                                 struct rpccli_spoolss_53_state);
12673         if (req == NULL) {
12674                 return NULL;
12675         }
12676         state->out_mem_ctx = NULL;
12677         state->dispatch_recv = cli->dispatch_recv;
12678
12679         /* In parameters */
12680
12681         /* Out parameters */
12682
12683         /* Result */
12684         ZERO_STRUCT(state->orig.out.result);
12685
12686         /* make a temporary copy, that we pass to the dispatch function */
12687         state->tmp = state->orig;
12688
12689         subreq = cli->dispatch_send(state, ev, cli,
12690                                     &ndr_table_spoolss,
12691                                     NDR_SPOOLSS_53,
12692                                     &state->tmp);
12693         if (tevent_req_nomem(subreq, req)) {
12694                 return tevent_req_post(req, ev);
12695         }
12696         tevent_req_set_callback(subreq, rpccli_spoolss_53_done, req);
12697         return req;
12698 }
12699
12700 static void rpccli_spoolss_53_done(struct tevent_req *subreq)
12701 {
12702         struct tevent_req *req = tevent_req_callback_data(
12703                 subreq, struct tevent_req);
12704         struct rpccli_spoolss_53_state *state = tevent_req_data(
12705                 req, struct rpccli_spoolss_53_state);
12706         NTSTATUS status;
12707         TALLOC_CTX *mem_ctx;
12708
12709         if (state->out_mem_ctx) {
12710                 mem_ctx = state->out_mem_ctx;
12711         } else {
12712                 mem_ctx = state;
12713         }
12714
12715         status = state->dispatch_recv(subreq, mem_ctx);
12716         TALLOC_FREE(subreq);
12717         if (!NT_STATUS_IS_OK(status)) {
12718                 tevent_req_nterror(req, status);
12719                 return;
12720         }
12721
12722         /* Copy out parameters */
12723
12724         /* Copy result */
12725         state->orig.out.result = state->tmp.out.result;
12726
12727         /* Reset temporary structure */
12728         ZERO_STRUCT(state->tmp);
12729
12730         tevent_req_done(req);
12731 }
12732
12733 NTSTATUS rpccli_spoolss_53_recv(struct tevent_req *req,
12734                                 TALLOC_CTX *mem_ctx,
12735                                 WERROR *result)
12736 {
12737         struct rpccli_spoolss_53_state *state = tevent_req_data(
12738                 req, struct rpccli_spoolss_53_state);
12739         NTSTATUS status;
12740
12741         if (tevent_req_is_nterror(req, &status)) {
12742                 tevent_req_received(req);
12743                 return status;
12744         }
12745
12746         /* Steal possbile out parameters to the callers context */
12747         talloc_steal(mem_ctx, state->out_mem_ctx);
12748
12749         /* Return result */
12750         *result = state->orig.out.result;
12751
12752         tevent_req_received(req);
12753         return NT_STATUS_OK;
12754 }
12755
12756 NTSTATUS rpccli_spoolss_53(struct rpc_pipe_client *cli,
12757                            TALLOC_CTX *mem_ctx,
12758                            WERROR *werror)
12759 {
12760         struct spoolss_53 r;
12761         NTSTATUS status;
12762
12763         /* In parameters */
12764
12765         status = cli->dispatch(cli,
12766                                 mem_ctx,
12767                                 &ndr_table_spoolss,
12768                                 NDR_SPOOLSS_53,
12769                                 &r);
12770
12771         if (!NT_STATUS_IS_OK(status)) {
12772                 return status;
12773         }
12774
12775         if (NT_STATUS_IS_ERR(status)) {
12776                 return status;
12777         }
12778
12779         /* Return variables */
12780
12781         /* Return result */
12782         if (werror) {
12783                 *werror = r.out.result;
12784         }
12785
12786         return werror_to_ntstatus(r.out.result);
12787 }
12788
12789 struct rpccli_spoolss_DeletePrinterDriverEx_state {
12790         struct spoolss_DeletePrinterDriverEx orig;
12791         struct spoolss_DeletePrinterDriverEx tmp;
12792         TALLOC_CTX *out_mem_ctx;
12793         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12794 };
12795
12796 static void rpccli_spoolss_DeletePrinterDriverEx_done(struct tevent_req *subreq);
12797
12798 struct tevent_req *rpccli_spoolss_DeletePrinterDriverEx_send(TALLOC_CTX *mem_ctx,
12799                                                              struct tevent_context *ev,
12800                                                              struct rpc_pipe_client *cli,
12801                                                              const char *_server /* [in] [unique,charset(UTF16)] */,
12802                                                              const char *_architecture /* [in] [charset(UTF16)] */,
12803                                                              const char *_driver /* [in] [charset(UTF16)] */,
12804                                                              uint32_t _delete_flags /* [in]  */,
12805                                                              uint32_t _version /* [in]  */)
12806 {
12807         struct tevent_req *req;
12808         struct rpccli_spoolss_DeletePrinterDriverEx_state *state;
12809         struct tevent_req *subreq;
12810
12811         req = tevent_req_create(mem_ctx, &state,
12812                                 struct rpccli_spoolss_DeletePrinterDriverEx_state);
12813         if (req == NULL) {
12814                 return NULL;
12815         }
12816         state->out_mem_ctx = NULL;
12817         state->dispatch_recv = cli->dispatch_recv;
12818
12819         /* In parameters */
12820         state->orig.in.server = _server;
12821         state->orig.in.architecture = _architecture;
12822         state->orig.in.driver = _driver;
12823         state->orig.in.delete_flags = _delete_flags;
12824         state->orig.in.version = _version;
12825
12826         /* Out parameters */
12827
12828         /* Result */
12829         ZERO_STRUCT(state->orig.out.result);
12830
12831         /* make a temporary copy, that we pass to the dispatch function */
12832         state->tmp = state->orig;
12833
12834         subreq = cli->dispatch_send(state, ev, cli,
12835                                     &ndr_table_spoolss,
12836                                     NDR_SPOOLSS_DELETEPRINTERDRIVEREX,
12837                                     &state->tmp);
12838         if (tevent_req_nomem(subreq, req)) {
12839                 return tevent_req_post(req, ev);
12840         }
12841         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterDriverEx_done, req);
12842         return req;
12843 }
12844
12845 static void rpccli_spoolss_DeletePrinterDriverEx_done(struct tevent_req *subreq)
12846 {
12847         struct tevent_req *req = tevent_req_callback_data(
12848                 subreq, struct tevent_req);
12849         struct rpccli_spoolss_DeletePrinterDriverEx_state *state = tevent_req_data(
12850                 req, struct rpccli_spoolss_DeletePrinterDriverEx_state);
12851         NTSTATUS status;
12852         TALLOC_CTX *mem_ctx;
12853
12854         if (state->out_mem_ctx) {
12855                 mem_ctx = state->out_mem_ctx;
12856         } else {
12857                 mem_ctx = state;
12858         }
12859
12860         status = state->dispatch_recv(subreq, mem_ctx);
12861         TALLOC_FREE(subreq);
12862         if (!NT_STATUS_IS_OK(status)) {
12863                 tevent_req_nterror(req, status);
12864                 return;
12865         }
12866
12867         /* Copy out parameters */
12868
12869         /* Copy result */
12870         state->orig.out.result = state->tmp.out.result;
12871
12872         /* Reset temporary structure */
12873         ZERO_STRUCT(state->tmp);
12874
12875         tevent_req_done(req);
12876 }
12877
12878 NTSTATUS rpccli_spoolss_DeletePrinterDriverEx_recv(struct tevent_req *req,
12879                                                    TALLOC_CTX *mem_ctx,
12880                                                    WERROR *result)
12881 {
12882         struct rpccli_spoolss_DeletePrinterDriverEx_state *state = tevent_req_data(
12883                 req, struct rpccli_spoolss_DeletePrinterDriverEx_state);
12884         NTSTATUS status;
12885
12886         if (tevent_req_is_nterror(req, &status)) {
12887                 tevent_req_received(req);
12888                 return status;
12889         }
12890
12891         /* Steal possbile out parameters to the callers context */
12892         talloc_steal(mem_ctx, state->out_mem_ctx);
12893
12894         /* Return result */
12895         *result = state->orig.out.result;
12896
12897         tevent_req_received(req);
12898         return NT_STATUS_OK;
12899 }
12900
12901 NTSTATUS rpccli_spoolss_DeletePrinterDriverEx(struct rpc_pipe_client *cli,
12902                                               TALLOC_CTX *mem_ctx,
12903                                               const char *server /* [in] [unique,charset(UTF16)] */,
12904                                               const char *architecture /* [in] [charset(UTF16)] */,
12905                                               const char *driver /* [in] [charset(UTF16)] */,
12906                                               uint32_t delete_flags /* [in]  */,
12907                                               uint32_t version /* [in]  */,
12908                                               WERROR *werror)
12909 {
12910         struct spoolss_DeletePrinterDriverEx r;
12911         NTSTATUS status;
12912
12913         /* In parameters */
12914         r.in.server = server;
12915         r.in.architecture = architecture;
12916         r.in.driver = driver;
12917         r.in.delete_flags = delete_flags;
12918         r.in.version = version;
12919
12920         status = cli->dispatch(cli,
12921                                 mem_ctx,
12922                                 &ndr_table_spoolss,
12923                                 NDR_SPOOLSS_DELETEPRINTERDRIVEREX,
12924                                 &r);
12925
12926         if (!NT_STATUS_IS_OK(status)) {
12927                 return status;
12928         }
12929
12930         if (NT_STATUS_IS_ERR(status)) {
12931                 return status;
12932         }
12933
12934         /* Return variables */
12935
12936         /* Return result */
12937         if (werror) {
12938                 *werror = r.out.result;
12939         }
12940
12941         return werror_to_ntstatus(r.out.result);
12942 }
12943
12944 struct rpccli_spoolss_55_state {
12945         struct spoolss_55 orig;
12946         struct spoolss_55 tmp;
12947         TALLOC_CTX *out_mem_ctx;
12948         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12949 };
12950
12951 static void rpccli_spoolss_55_done(struct tevent_req *subreq);
12952
12953 struct tevent_req *rpccli_spoolss_55_send(TALLOC_CTX *mem_ctx,
12954                                           struct tevent_context *ev,
12955                                           struct rpc_pipe_client *cli)
12956 {
12957         struct tevent_req *req;
12958         struct rpccli_spoolss_55_state *state;
12959         struct tevent_req *subreq;
12960
12961         req = tevent_req_create(mem_ctx, &state,
12962                                 struct rpccli_spoolss_55_state);
12963         if (req == NULL) {
12964                 return NULL;
12965         }
12966         state->out_mem_ctx = NULL;
12967         state->dispatch_recv = cli->dispatch_recv;
12968
12969         /* In parameters */
12970
12971         /* Out parameters */
12972
12973         /* Result */
12974         ZERO_STRUCT(state->orig.out.result);
12975
12976         /* make a temporary copy, that we pass to the dispatch function */
12977         state->tmp = state->orig;
12978
12979         subreq = cli->dispatch_send(state, ev, cli,
12980                                     &ndr_table_spoolss,
12981                                     NDR_SPOOLSS_55,
12982                                     &state->tmp);
12983         if (tevent_req_nomem(subreq, req)) {
12984                 return tevent_req_post(req, ev);
12985         }
12986         tevent_req_set_callback(subreq, rpccli_spoolss_55_done, req);
12987         return req;
12988 }
12989
12990 static void rpccli_spoolss_55_done(struct tevent_req *subreq)
12991 {
12992         struct tevent_req *req = tevent_req_callback_data(
12993                 subreq, struct tevent_req);
12994         struct rpccli_spoolss_55_state *state = tevent_req_data(
12995                 req, struct rpccli_spoolss_55_state);
12996         NTSTATUS status;
12997         TALLOC_CTX *mem_ctx;
12998
12999         if (state->out_mem_ctx) {
13000                 mem_ctx = state->out_mem_ctx;
13001         } else {
13002                 mem_ctx = state;
13003         }
13004
13005         status = state->dispatch_recv(subreq, mem_ctx);
13006         TALLOC_FREE(subreq);
13007         if (!NT_STATUS_IS_OK(status)) {
13008                 tevent_req_nterror(req, status);
13009                 return;
13010         }
13011
13012         /* Copy out parameters */
13013
13014         /* Copy result */
13015         state->orig.out.result = state->tmp.out.result;
13016
13017         /* Reset temporary structure */
13018         ZERO_STRUCT(state->tmp);
13019
13020         tevent_req_done(req);
13021 }
13022
13023 NTSTATUS rpccli_spoolss_55_recv(struct tevent_req *req,
13024                                 TALLOC_CTX *mem_ctx,
13025                                 WERROR *result)
13026 {
13027         struct rpccli_spoolss_55_state *state = tevent_req_data(
13028                 req, struct rpccli_spoolss_55_state);
13029         NTSTATUS status;
13030
13031         if (tevent_req_is_nterror(req, &status)) {
13032                 tevent_req_received(req);
13033                 return status;
13034         }
13035
13036         /* Steal possbile out parameters to the callers context */
13037         talloc_steal(mem_ctx, state->out_mem_ctx);
13038
13039         /* Return result */
13040         *result = state->orig.out.result;
13041
13042         tevent_req_received(req);
13043         return NT_STATUS_OK;
13044 }
13045
13046 NTSTATUS rpccli_spoolss_55(struct rpc_pipe_client *cli,
13047                            TALLOC_CTX *mem_ctx,
13048                            WERROR *werror)
13049 {
13050         struct spoolss_55 r;
13051         NTSTATUS status;
13052
13053         /* In parameters */
13054
13055         status = cli->dispatch(cli,
13056                                 mem_ctx,
13057                                 &ndr_table_spoolss,
13058                                 NDR_SPOOLSS_55,
13059                                 &r);
13060
13061         if (!NT_STATUS_IS_OK(status)) {
13062                 return status;
13063         }
13064
13065         if (NT_STATUS_IS_ERR(status)) {
13066                 return status;
13067         }
13068
13069         /* Return variables */
13070
13071         /* Return result */
13072         if (werror) {
13073                 *werror = r.out.result;
13074         }
13075
13076         return werror_to_ntstatus(r.out.result);
13077 }
13078
13079 struct rpccli_spoolss_56_state {
13080         struct spoolss_56 orig;
13081         struct spoolss_56 tmp;
13082         TALLOC_CTX *out_mem_ctx;
13083         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13084 };
13085
13086 static void rpccli_spoolss_56_done(struct tevent_req *subreq);
13087
13088 struct tevent_req *rpccli_spoolss_56_send(TALLOC_CTX *mem_ctx,
13089                                           struct tevent_context *ev,
13090                                           struct rpc_pipe_client *cli)
13091 {
13092         struct tevent_req *req;
13093         struct rpccli_spoolss_56_state *state;
13094         struct tevent_req *subreq;
13095
13096         req = tevent_req_create(mem_ctx, &state,
13097                                 struct rpccli_spoolss_56_state);
13098         if (req == NULL) {
13099                 return NULL;
13100         }
13101         state->out_mem_ctx = NULL;
13102         state->dispatch_recv = cli->dispatch_recv;
13103
13104         /* In parameters */
13105
13106         /* Out parameters */
13107
13108         /* Result */
13109         ZERO_STRUCT(state->orig.out.result);
13110
13111         /* make a temporary copy, that we pass to the dispatch function */
13112         state->tmp = state->orig;
13113
13114         subreq = cli->dispatch_send(state, ev, cli,
13115                                     &ndr_table_spoolss,
13116                                     NDR_SPOOLSS_56,
13117                                     &state->tmp);
13118         if (tevent_req_nomem(subreq, req)) {
13119                 return tevent_req_post(req, ev);
13120         }
13121         tevent_req_set_callback(subreq, rpccli_spoolss_56_done, req);
13122         return req;
13123 }
13124
13125 static void rpccli_spoolss_56_done(struct tevent_req *subreq)
13126 {
13127         struct tevent_req *req = tevent_req_callback_data(
13128                 subreq, struct tevent_req);
13129         struct rpccli_spoolss_56_state *state = tevent_req_data(
13130                 req, struct rpccli_spoolss_56_state);
13131         NTSTATUS status;
13132         TALLOC_CTX *mem_ctx;
13133
13134         if (state->out_mem_ctx) {
13135                 mem_ctx = state->out_mem_ctx;
13136         } else {
13137                 mem_ctx = state;
13138         }
13139
13140         status = state->dispatch_recv(subreq, mem_ctx);
13141         TALLOC_FREE(subreq);
13142         if (!NT_STATUS_IS_OK(status)) {
13143                 tevent_req_nterror(req, status);
13144                 return;
13145         }
13146
13147         /* Copy out parameters */
13148
13149         /* Copy result */
13150         state->orig.out.result = state->tmp.out.result;
13151
13152         /* Reset temporary structure */
13153         ZERO_STRUCT(state->tmp);
13154
13155         tevent_req_done(req);
13156 }
13157
13158 NTSTATUS rpccli_spoolss_56_recv(struct tevent_req *req,
13159                                 TALLOC_CTX *mem_ctx,
13160                                 WERROR *result)
13161 {
13162         struct rpccli_spoolss_56_state *state = tevent_req_data(
13163                 req, struct rpccli_spoolss_56_state);
13164         NTSTATUS status;
13165
13166         if (tevent_req_is_nterror(req, &status)) {
13167                 tevent_req_received(req);
13168                 return status;
13169         }
13170
13171         /* Steal possbile out parameters to the callers context */
13172         talloc_steal(mem_ctx, state->out_mem_ctx);
13173
13174         /* Return result */
13175         *result = state->orig.out.result;
13176
13177         tevent_req_received(req);
13178         return NT_STATUS_OK;
13179 }
13180
13181 NTSTATUS rpccli_spoolss_56(struct rpc_pipe_client *cli,
13182                            TALLOC_CTX *mem_ctx,
13183                            WERROR *werror)
13184 {
13185         struct spoolss_56 r;
13186         NTSTATUS status;
13187
13188         /* In parameters */
13189
13190         status = cli->dispatch(cli,
13191                                 mem_ctx,
13192                                 &ndr_table_spoolss,
13193                                 NDR_SPOOLSS_56,
13194                                 &r);
13195
13196         if (!NT_STATUS_IS_OK(status)) {
13197                 return status;
13198         }
13199
13200         if (NT_STATUS_IS_ERR(status)) {
13201                 return status;
13202         }
13203
13204         /* Return variables */
13205
13206         /* Return result */
13207         if (werror) {
13208                 *werror = r.out.result;
13209         }
13210
13211         return werror_to_ntstatus(r.out.result);
13212 }
13213
13214 struct rpccli_spoolss_57_state {
13215         struct spoolss_57 orig;
13216         struct spoolss_57 tmp;
13217         TALLOC_CTX *out_mem_ctx;
13218         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13219 };
13220
13221 static void rpccli_spoolss_57_done(struct tevent_req *subreq);
13222
13223 struct tevent_req *rpccli_spoolss_57_send(TALLOC_CTX *mem_ctx,
13224                                           struct tevent_context *ev,
13225                                           struct rpc_pipe_client *cli)
13226 {
13227         struct tevent_req *req;
13228         struct rpccli_spoolss_57_state *state;
13229         struct tevent_req *subreq;
13230
13231         req = tevent_req_create(mem_ctx, &state,
13232                                 struct rpccli_spoolss_57_state);
13233         if (req == NULL) {
13234                 return NULL;
13235         }
13236         state->out_mem_ctx = NULL;
13237         state->dispatch_recv = cli->dispatch_recv;
13238
13239         /* In parameters */
13240
13241         /* Out parameters */
13242
13243         /* Result */
13244         ZERO_STRUCT(state->orig.out.result);
13245
13246         /* make a temporary copy, that we pass to the dispatch function */
13247         state->tmp = state->orig;
13248
13249         subreq = cli->dispatch_send(state, ev, cli,
13250                                     &ndr_table_spoolss,
13251                                     NDR_SPOOLSS_57,
13252                                     &state->tmp);
13253         if (tevent_req_nomem(subreq, req)) {
13254                 return tevent_req_post(req, ev);
13255         }
13256         tevent_req_set_callback(subreq, rpccli_spoolss_57_done, req);
13257         return req;
13258 }
13259
13260 static void rpccli_spoolss_57_done(struct tevent_req *subreq)
13261 {
13262         struct tevent_req *req = tevent_req_callback_data(
13263                 subreq, struct tevent_req);
13264         struct rpccli_spoolss_57_state *state = tevent_req_data(
13265                 req, struct rpccli_spoolss_57_state);
13266         NTSTATUS status;
13267         TALLOC_CTX *mem_ctx;
13268
13269         if (state->out_mem_ctx) {
13270                 mem_ctx = state->out_mem_ctx;
13271         } else {
13272                 mem_ctx = state;
13273         }
13274
13275         status = state->dispatch_recv(subreq, mem_ctx);
13276         TALLOC_FREE(subreq);
13277         if (!NT_STATUS_IS_OK(status)) {
13278                 tevent_req_nterror(req, status);
13279                 return;
13280         }
13281
13282         /* Copy out parameters */
13283
13284         /* Copy result */
13285         state->orig.out.result = state->tmp.out.result;
13286
13287         /* Reset temporary structure */
13288         ZERO_STRUCT(state->tmp);
13289
13290         tevent_req_done(req);
13291 }
13292
13293 NTSTATUS rpccli_spoolss_57_recv(struct tevent_req *req,
13294                                 TALLOC_CTX *mem_ctx,
13295                                 WERROR *result)
13296 {
13297         struct rpccli_spoolss_57_state *state = tevent_req_data(
13298                 req, struct rpccli_spoolss_57_state);
13299         NTSTATUS status;
13300
13301         if (tevent_req_is_nterror(req, &status)) {
13302                 tevent_req_received(req);
13303                 return status;
13304         }
13305
13306         /* Steal possbile out parameters to the callers context */
13307         talloc_steal(mem_ctx, state->out_mem_ctx);
13308
13309         /* Return result */
13310         *result = state->orig.out.result;
13311
13312         tevent_req_received(req);
13313         return NT_STATUS_OK;
13314 }
13315
13316 NTSTATUS rpccli_spoolss_57(struct rpc_pipe_client *cli,
13317                            TALLOC_CTX *mem_ctx,
13318                            WERROR *werror)
13319 {
13320         struct spoolss_57 r;
13321         NTSTATUS status;
13322
13323         /* In parameters */
13324
13325         status = cli->dispatch(cli,
13326                                 mem_ctx,
13327                                 &ndr_table_spoolss,
13328                                 NDR_SPOOLSS_57,
13329                                 &r);
13330
13331         if (!NT_STATUS_IS_OK(status)) {
13332                 return status;
13333         }
13334
13335         if (NT_STATUS_IS_ERR(status)) {
13336                 return status;
13337         }
13338
13339         /* Return variables */
13340
13341         /* Return result */
13342         if (werror) {
13343                 *werror = r.out.result;
13344         }
13345
13346         return werror_to_ntstatus(r.out.result);
13347 }
13348
13349 struct rpccli_spoolss_XcvData_state {
13350         struct spoolss_XcvData orig;
13351         struct spoolss_XcvData tmp;
13352         TALLOC_CTX *out_mem_ctx;
13353         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13354 };
13355
13356 static void rpccli_spoolss_XcvData_done(struct tevent_req *subreq);
13357
13358 struct tevent_req *rpccli_spoolss_XcvData_send(TALLOC_CTX *mem_ctx,
13359                                                struct tevent_context *ev,
13360                                                struct rpc_pipe_client *cli,
13361                                                struct policy_handle *_handle /* [in] [ref] */,
13362                                                const char *_function_name /* [in] [charset(UTF16)] */,
13363                                                DATA_BLOB _in_data /* [in]  */,
13364                                                uint32_t __in_data_length /* [in] [value(r->in.in_data.length)] */,
13365                                                uint8_t *_out_data /* [out] [ref,size_is(out_data_size)] */,
13366                                                uint32_t _out_data_size /* [in]  */,
13367                                                uint32_t *_needed /* [out] [ref] */,
13368                                                uint32_t *_status_code /* [in,out] [ref] */)
13369 {
13370         struct tevent_req *req;
13371         struct rpccli_spoolss_XcvData_state *state;
13372         struct tevent_req *subreq;
13373
13374         req = tevent_req_create(mem_ctx, &state,
13375                                 struct rpccli_spoolss_XcvData_state);
13376         if (req == NULL) {
13377                 return NULL;
13378         }
13379         state->out_mem_ctx = NULL;
13380         state->dispatch_recv = cli->dispatch_recv;
13381
13382         /* In parameters */
13383         state->orig.in.handle = _handle;
13384         state->orig.in.function_name = _function_name;
13385         state->orig.in.in_data = _in_data;
13386         state->orig.in._in_data_length = __in_data_length;
13387         state->orig.in.out_data_size = _out_data_size;
13388         state->orig.in.status_code = _status_code;
13389
13390         /* Out parameters */
13391         state->orig.out.out_data = _out_data;
13392         state->orig.out.needed = _needed;
13393         state->orig.out.status_code = _status_code;
13394
13395         /* Result */
13396         ZERO_STRUCT(state->orig.out.result);
13397
13398         state->out_mem_ctx = talloc_named_const(state, 0,
13399                              "rpccli_spoolss_XcvData_out_memory");
13400         if (tevent_req_nomem(state->out_mem_ctx, req)) {
13401                 return tevent_req_post(req, ev);
13402         }
13403
13404         /* make a temporary copy, that we pass to the dispatch function */
13405         state->tmp = state->orig;
13406
13407         subreq = cli->dispatch_send(state, ev, cli,
13408                                     &ndr_table_spoolss,
13409                                     NDR_SPOOLSS_XCVDATA,
13410                                     &state->tmp);
13411         if (tevent_req_nomem(subreq, req)) {
13412                 return tevent_req_post(req, ev);
13413         }
13414         tevent_req_set_callback(subreq, rpccli_spoolss_XcvData_done, req);
13415         return req;
13416 }
13417
13418 static void rpccli_spoolss_XcvData_done(struct tevent_req *subreq)
13419 {
13420         struct tevent_req *req = tevent_req_callback_data(
13421                 subreq, struct tevent_req);
13422         struct rpccli_spoolss_XcvData_state *state = tevent_req_data(
13423                 req, struct rpccli_spoolss_XcvData_state);
13424         NTSTATUS status;
13425         TALLOC_CTX *mem_ctx;
13426
13427         if (state->out_mem_ctx) {
13428                 mem_ctx = state->out_mem_ctx;
13429         } else {
13430                 mem_ctx = state;
13431         }
13432
13433         status = state->dispatch_recv(subreq, mem_ctx);
13434         TALLOC_FREE(subreq);
13435         if (!NT_STATUS_IS_OK(status)) {
13436                 tevent_req_nterror(req, status);
13437                 return;
13438         }
13439
13440         /* Copy out parameters */
13441         memcpy(state->orig.out.out_data, state->tmp.out.out_data, (state->tmp.in.out_data_size) * sizeof(*state->orig.out.out_data));
13442         *state->orig.out.needed = *state->tmp.out.needed;
13443         *state->orig.out.status_code = *state->tmp.out.status_code;
13444
13445         /* Copy result */
13446         state->orig.out.result = state->tmp.out.result;
13447
13448         /* Reset temporary structure */
13449         ZERO_STRUCT(state->tmp);
13450
13451         tevent_req_done(req);
13452 }
13453
13454 NTSTATUS rpccli_spoolss_XcvData_recv(struct tevent_req *req,
13455                                      TALLOC_CTX *mem_ctx,
13456                                      WERROR *result)
13457 {
13458         struct rpccli_spoolss_XcvData_state *state = tevent_req_data(
13459                 req, struct rpccli_spoolss_XcvData_state);
13460         NTSTATUS status;
13461
13462         if (tevent_req_is_nterror(req, &status)) {
13463                 tevent_req_received(req);
13464                 return status;
13465         }
13466
13467         /* Steal possbile out parameters to the callers context */
13468         talloc_steal(mem_ctx, state->out_mem_ctx);
13469
13470         /* Return result */
13471         *result = state->orig.out.result;
13472
13473         tevent_req_received(req);
13474         return NT_STATUS_OK;
13475 }
13476
13477 NTSTATUS rpccli_spoolss_XcvData(struct rpc_pipe_client *cli,
13478                                 TALLOC_CTX *mem_ctx,
13479                                 struct policy_handle *handle /* [in] [ref] */,
13480                                 const char *function_name /* [in] [charset(UTF16)] */,
13481                                 DATA_BLOB in_data /* [in]  */,
13482                                 uint32_t _in_data_length /* [in] [value(r->in.in_data.length)] */,
13483                                 uint8_t *out_data /* [out] [ref,size_is(out_data_size)] */,
13484                                 uint32_t out_data_size /* [in]  */,
13485                                 uint32_t *needed /* [out] [ref] */,
13486                                 uint32_t *status_code /* [in,out] [ref] */,
13487                                 WERROR *werror)
13488 {
13489         struct spoolss_XcvData r;
13490         NTSTATUS status;
13491
13492         /* In parameters */
13493         r.in.handle = handle;
13494         r.in.function_name = function_name;
13495         r.in.in_data = in_data;
13496         r.in._in_data_length = _in_data_length;
13497         r.in.out_data_size = out_data_size;
13498         r.in.status_code = status_code;
13499
13500         status = cli->dispatch(cli,
13501                                 mem_ctx,
13502                                 &ndr_table_spoolss,
13503                                 NDR_SPOOLSS_XCVDATA,
13504                                 &r);
13505
13506         if (!NT_STATUS_IS_OK(status)) {
13507                 return status;
13508         }
13509
13510         if (NT_STATUS_IS_ERR(status)) {
13511                 return status;
13512         }
13513
13514         /* Return variables */
13515         memcpy(out_data, r.out.out_data, (r.in.out_data_size) * sizeof(*out_data));
13516         *needed = *r.out.needed;
13517         *status_code = *r.out.status_code;
13518
13519         /* Return result */
13520         if (werror) {
13521                 *werror = r.out.result;
13522         }
13523
13524         return werror_to_ntstatus(r.out.result);
13525 }
13526
13527 struct rpccli_spoolss_AddPrinterDriverEx_state {
13528         struct spoolss_AddPrinterDriverEx orig;
13529         struct spoolss_AddPrinterDriverEx tmp;
13530         TALLOC_CTX *out_mem_ctx;
13531         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13532 };
13533
13534 static void rpccli_spoolss_AddPrinterDriverEx_done(struct tevent_req *subreq);
13535
13536 struct tevent_req *rpccli_spoolss_AddPrinterDriverEx_send(TALLOC_CTX *mem_ctx,
13537                                                           struct tevent_context *ev,
13538                                                           struct rpc_pipe_client *cli,
13539                                                           const char *_servername /* [in] [unique,charset(UTF16)] */,
13540                                                           struct spoolss_AddDriverInfoCtr *_info_ctr /* [in] [ref] */,
13541                                                           uint32_t _flags /* [in]  */)
13542 {
13543         struct tevent_req *req;
13544         struct rpccli_spoolss_AddPrinterDriverEx_state *state;
13545         struct tevent_req *subreq;
13546
13547         req = tevent_req_create(mem_ctx, &state,
13548                                 struct rpccli_spoolss_AddPrinterDriverEx_state);
13549         if (req == NULL) {
13550                 return NULL;
13551         }
13552         state->out_mem_ctx = NULL;
13553         state->dispatch_recv = cli->dispatch_recv;
13554
13555         /* In parameters */
13556         state->orig.in.servername = _servername;
13557         state->orig.in.info_ctr = _info_ctr;
13558         state->orig.in.flags = _flags;
13559
13560         /* Out parameters */
13561
13562         /* Result */
13563         ZERO_STRUCT(state->orig.out.result);
13564
13565         /* make a temporary copy, that we pass to the dispatch function */
13566         state->tmp = state->orig;
13567
13568         subreq = cli->dispatch_send(state, ev, cli,
13569                                     &ndr_table_spoolss,
13570                                     NDR_SPOOLSS_ADDPRINTERDRIVEREX,
13571                                     &state->tmp);
13572         if (tevent_req_nomem(subreq, req)) {
13573                 return tevent_req_post(req, ev);
13574         }
13575         tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterDriverEx_done, req);
13576         return req;
13577 }
13578
13579 static void rpccli_spoolss_AddPrinterDriverEx_done(struct tevent_req *subreq)
13580 {
13581         struct tevent_req *req = tevent_req_callback_data(
13582                 subreq, struct tevent_req);
13583         struct rpccli_spoolss_AddPrinterDriverEx_state *state = tevent_req_data(
13584                 req, struct rpccli_spoolss_AddPrinterDriverEx_state);
13585         NTSTATUS status;
13586         TALLOC_CTX *mem_ctx;
13587
13588         if (state->out_mem_ctx) {
13589                 mem_ctx = state->out_mem_ctx;
13590         } else {
13591                 mem_ctx = state;
13592         }
13593
13594         status = state->dispatch_recv(subreq, mem_ctx);
13595         TALLOC_FREE(subreq);
13596         if (!NT_STATUS_IS_OK(status)) {
13597                 tevent_req_nterror(req, status);
13598                 return;
13599         }
13600
13601         /* Copy out parameters */
13602
13603         /* Copy result */
13604         state->orig.out.result = state->tmp.out.result;
13605
13606         /* Reset temporary structure */
13607         ZERO_STRUCT(state->tmp);
13608
13609         tevent_req_done(req);
13610 }
13611
13612 NTSTATUS rpccli_spoolss_AddPrinterDriverEx_recv(struct tevent_req *req,
13613                                                 TALLOC_CTX *mem_ctx,
13614                                                 WERROR *result)
13615 {
13616         struct rpccli_spoolss_AddPrinterDriverEx_state *state = tevent_req_data(
13617                 req, struct rpccli_spoolss_AddPrinterDriverEx_state);
13618         NTSTATUS status;
13619
13620         if (tevent_req_is_nterror(req, &status)) {
13621                 tevent_req_received(req);
13622                 return status;
13623         }
13624
13625         /* Steal possbile out parameters to the callers context */
13626         talloc_steal(mem_ctx, state->out_mem_ctx);
13627
13628         /* Return result */
13629         *result = state->orig.out.result;
13630
13631         tevent_req_received(req);
13632         return NT_STATUS_OK;
13633 }
13634
13635 NTSTATUS rpccli_spoolss_AddPrinterDriverEx(struct rpc_pipe_client *cli,
13636                                            TALLOC_CTX *mem_ctx,
13637                                            const char *servername /* [in] [unique,charset(UTF16)] */,
13638                                            struct spoolss_AddDriverInfoCtr *info_ctr /* [in] [ref] */,
13639                                            uint32_t flags /* [in]  */,
13640                                            WERROR *werror)
13641 {
13642         struct spoolss_AddPrinterDriverEx r;
13643         NTSTATUS status;
13644
13645         /* In parameters */
13646         r.in.servername = servername;
13647         r.in.info_ctr = info_ctr;
13648         r.in.flags = flags;
13649
13650         status = cli->dispatch(cli,
13651                                 mem_ctx,
13652                                 &ndr_table_spoolss,
13653                                 NDR_SPOOLSS_ADDPRINTERDRIVEREX,
13654                                 &r);
13655
13656         if (!NT_STATUS_IS_OK(status)) {
13657                 return status;
13658         }
13659
13660         if (NT_STATUS_IS_ERR(status)) {
13661                 return status;
13662         }
13663
13664         /* Return variables */
13665
13666         /* Return result */
13667         if (werror) {
13668                 *werror = r.out.result;
13669         }
13670
13671         return werror_to_ntstatus(r.out.result);
13672 }
13673
13674 struct rpccli_spoolss_5a_state {
13675         struct spoolss_5a orig;
13676         struct spoolss_5a tmp;
13677         TALLOC_CTX *out_mem_ctx;
13678         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13679 };
13680
13681 static void rpccli_spoolss_5a_done(struct tevent_req *subreq);
13682
13683 struct tevent_req *rpccli_spoolss_5a_send(TALLOC_CTX *mem_ctx,
13684                                           struct tevent_context *ev,
13685                                           struct rpc_pipe_client *cli)
13686 {
13687         struct tevent_req *req;
13688         struct rpccli_spoolss_5a_state *state;
13689         struct tevent_req *subreq;
13690
13691         req = tevent_req_create(mem_ctx, &state,
13692                                 struct rpccli_spoolss_5a_state);
13693         if (req == NULL) {
13694                 return NULL;
13695         }
13696         state->out_mem_ctx = NULL;
13697         state->dispatch_recv = cli->dispatch_recv;
13698
13699         /* In parameters */
13700
13701         /* Out parameters */
13702
13703         /* Result */
13704         ZERO_STRUCT(state->orig.out.result);
13705
13706         /* make a temporary copy, that we pass to the dispatch function */
13707         state->tmp = state->orig;
13708
13709         subreq = cli->dispatch_send(state, ev, cli,
13710                                     &ndr_table_spoolss,
13711                                     NDR_SPOOLSS_5A,
13712                                     &state->tmp);
13713         if (tevent_req_nomem(subreq, req)) {
13714                 return tevent_req_post(req, ev);
13715         }
13716         tevent_req_set_callback(subreq, rpccli_spoolss_5a_done, req);
13717         return req;
13718 }
13719
13720 static void rpccli_spoolss_5a_done(struct tevent_req *subreq)
13721 {
13722         struct tevent_req *req = tevent_req_callback_data(
13723                 subreq, struct tevent_req);
13724         struct rpccli_spoolss_5a_state *state = tevent_req_data(
13725                 req, struct rpccli_spoolss_5a_state);
13726         NTSTATUS status;
13727         TALLOC_CTX *mem_ctx;
13728
13729         if (state->out_mem_ctx) {
13730                 mem_ctx = state->out_mem_ctx;
13731         } else {
13732                 mem_ctx = state;
13733         }
13734
13735         status = state->dispatch_recv(subreq, mem_ctx);
13736         TALLOC_FREE(subreq);
13737         if (!NT_STATUS_IS_OK(status)) {
13738                 tevent_req_nterror(req, status);
13739                 return;
13740         }
13741
13742         /* Copy out parameters */
13743
13744         /* Copy result */
13745         state->orig.out.result = state->tmp.out.result;
13746
13747         /* Reset temporary structure */
13748         ZERO_STRUCT(state->tmp);
13749
13750         tevent_req_done(req);
13751 }
13752
13753 NTSTATUS rpccli_spoolss_5a_recv(struct tevent_req *req,
13754                                 TALLOC_CTX *mem_ctx,
13755                                 WERROR *result)
13756 {
13757         struct rpccli_spoolss_5a_state *state = tevent_req_data(
13758                 req, struct rpccli_spoolss_5a_state);
13759         NTSTATUS status;
13760
13761         if (tevent_req_is_nterror(req, &status)) {
13762                 tevent_req_received(req);
13763                 return status;
13764         }
13765
13766         /* Steal possbile out parameters to the callers context */
13767         talloc_steal(mem_ctx, state->out_mem_ctx);
13768
13769         /* Return result */
13770         *result = state->orig.out.result;
13771
13772         tevent_req_received(req);
13773         return NT_STATUS_OK;
13774 }
13775
13776 NTSTATUS rpccli_spoolss_5a(struct rpc_pipe_client *cli,
13777                            TALLOC_CTX *mem_ctx,
13778                            WERROR *werror)
13779 {
13780         struct spoolss_5a r;
13781         NTSTATUS status;
13782
13783         /* In parameters */
13784
13785         status = cli->dispatch(cli,
13786                                 mem_ctx,
13787                                 &ndr_table_spoolss,
13788                                 NDR_SPOOLSS_5A,
13789                                 &r);
13790
13791         if (!NT_STATUS_IS_OK(status)) {
13792                 return status;
13793         }
13794
13795         if (NT_STATUS_IS_ERR(status)) {
13796                 return status;
13797         }
13798
13799         /* Return variables */
13800
13801         /* Return result */
13802         if (werror) {
13803                 *werror = r.out.result;
13804         }
13805
13806         return werror_to_ntstatus(r.out.result);
13807 }
13808
13809 struct rpccli_spoolss_5b_state {
13810         struct spoolss_5b orig;
13811         struct spoolss_5b tmp;
13812         TALLOC_CTX *out_mem_ctx;
13813         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13814 };
13815
13816 static void rpccli_spoolss_5b_done(struct tevent_req *subreq);
13817
13818 struct tevent_req *rpccli_spoolss_5b_send(TALLOC_CTX *mem_ctx,
13819                                           struct tevent_context *ev,
13820                                           struct rpc_pipe_client *cli)
13821 {
13822         struct tevent_req *req;
13823         struct rpccli_spoolss_5b_state *state;
13824         struct tevent_req *subreq;
13825
13826         req = tevent_req_create(mem_ctx, &state,
13827                                 struct rpccli_spoolss_5b_state);
13828         if (req == NULL) {
13829                 return NULL;
13830         }
13831         state->out_mem_ctx = NULL;
13832         state->dispatch_recv = cli->dispatch_recv;
13833
13834         /* In parameters */
13835
13836         /* Out parameters */
13837
13838         /* Result */
13839         ZERO_STRUCT(state->orig.out.result);
13840
13841         /* make a temporary copy, that we pass to the dispatch function */
13842         state->tmp = state->orig;
13843
13844         subreq = cli->dispatch_send(state, ev, cli,
13845                                     &ndr_table_spoolss,
13846                                     NDR_SPOOLSS_5B,
13847                                     &state->tmp);
13848         if (tevent_req_nomem(subreq, req)) {
13849                 return tevent_req_post(req, ev);
13850         }
13851         tevent_req_set_callback(subreq, rpccli_spoolss_5b_done, req);
13852         return req;
13853 }
13854
13855 static void rpccli_spoolss_5b_done(struct tevent_req *subreq)
13856 {
13857         struct tevent_req *req = tevent_req_callback_data(
13858                 subreq, struct tevent_req);
13859         struct rpccli_spoolss_5b_state *state = tevent_req_data(
13860                 req, struct rpccli_spoolss_5b_state);
13861         NTSTATUS status;
13862         TALLOC_CTX *mem_ctx;
13863
13864         if (state->out_mem_ctx) {
13865                 mem_ctx = state->out_mem_ctx;
13866         } else {
13867                 mem_ctx = state;
13868         }
13869
13870         status = state->dispatch_recv(subreq, mem_ctx);
13871         TALLOC_FREE(subreq);
13872         if (!NT_STATUS_IS_OK(status)) {
13873                 tevent_req_nterror(req, status);
13874                 return;
13875         }
13876
13877         /* Copy out parameters */
13878
13879         /* Copy result */
13880         state->orig.out.result = state->tmp.out.result;
13881
13882         /* Reset temporary structure */
13883         ZERO_STRUCT(state->tmp);
13884
13885         tevent_req_done(req);
13886 }
13887
13888 NTSTATUS rpccli_spoolss_5b_recv(struct tevent_req *req,
13889                                 TALLOC_CTX *mem_ctx,
13890                                 WERROR *result)
13891 {
13892         struct rpccli_spoolss_5b_state *state = tevent_req_data(
13893                 req, struct rpccli_spoolss_5b_state);
13894         NTSTATUS status;
13895
13896         if (tevent_req_is_nterror(req, &status)) {
13897                 tevent_req_received(req);
13898                 return status;
13899         }
13900
13901         /* Steal possbile out parameters to the callers context */
13902         talloc_steal(mem_ctx, state->out_mem_ctx);
13903
13904         /* Return result */
13905         *result = state->orig.out.result;
13906
13907         tevent_req_received(req);
13908         return NT_STATUS_OK;
13909 }
13910
13911 NTSTATUS rpccli_spoolss_5b(struct rpc_pipe_client *cli,
13912                            TALLOC_CTX *mem_ctx,
13913                            WERROR *werror)
13914 {
13915         struct spoolss_5b r;
13916         NTSTATUS status;
13917
13918         /* In parameters */
13919
13920         status = cli->dispatch(cli,
13921                                 mem_ctx,
13922                                 &ndr_table_spoolss,
13923                                 NDR_SPOOLSS_5B,
13924                                 &r);
13925
13926         if (!NT_STATUS_IS_OK(status)) {
13927                 return status;
13928         }
13929
13930         if (NT_STATUS_IS_ERR(status)) {
13931                 return status;
13932         }
13933
13934         /* Return variables */
13935
13936         /* Return result */
13937         if (werror) {
13938                 *werror = r.out.result;
13939         }
13940
13941         return werror_to_ntstatus(r.out.result);
13942 }
13943
13944 struct rpccli_spoolss_5c_state {
13945         struct spoolss_5c orig;
13946         struct spoolss_5c tmp;
13947         TALLOC_CTX *out_mem_ctx;
13948         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13949 };
13950
13951 static void rpccli_spoolss_5c_done(struct tevent_req *subreq);
13952
13953 struct tevent_req *rpccli_spoolss_5c_send(TALLOC_CTX *mem_ctx,
13954                                           struct tevent_context *ev,
13955                                           struct rpc_pipe_client *cli)
13956 {
13957         struct tevent_req *req;
13958         struct rpccli_spoolss_5c_state *state;
13959         struct tevent_req *subreq;
13960
13961         req = tevent_req_create(mem_ctx, &state,
13962                                 struct rpccli_spoolss_5c_state);
13963         if (req == NULL) {
13964                 return NULL;
13965         }
13966         state->out_mem_ctx = NULL;
13967         state->dispatch_recv = cli->dispatch_recv;
13968
13969         /* In parameters */
13970
13971         /* Out parameters */
13972
13973         /* Result */
13974         ZERO_STRUCT(state->orig.out.result);
13975
13976         /* make a temporary copy, that we pass to the dispatch function */
13977         state->tmp = state->orig;
13978
13979         subreq = cli->dispatch_send(state, ev, cli,
13980                                     &ndr_table_spoolss,
13981                                     NDR_SPOOLSS_5C,
13982                                     &state->tmp);
13983         if (tevent_req_nomem(subreq, req)) {
13984                 return tevent_req_post(req, ev);
13985         }
13986         tevent_req_set_callback(subreq, rpccli_spoolss_5c_done, req);
13987         return req;
13988 }
13989
13990 static void rpccli_spoolss_5c_done(struct tevent_req *subreq)
13991 {
13992         struct tevent_req *req = tevent_req_callback_data(
13993                 subreq, struct tevent_req);
13994         struct rpccli_spoolss_5c_state *state = tevent_req_data(
13995                 req, struct rpccli_spoolss_5c_state);
13996         NTSTATUS status;
13997         TALLOC_CTX *mem_ctx;
13998
13999         if (state->out_mem_ctx) {
14000                 mem_ctx = state->out_mem_ctx;
14001         } else {
14002                 mem_ctx = state;
14003         }
14004
14005         status = state->dispatch_recv(subreq, mem_ctx);
14006         TALLOC_FREE(subreq);
14007         if (!NT_STATUS_IS_OK(status)) {
14008                 tevent_req_nterror(req, status);
14009                 return;
14010         }
14011
14012         /* Copy out parameters */
14013
14014         /* Copy result */
14015         state->orig.out.result = state->tmp.out.result;
14016
14017         /* Reset temporary structure */
14018         ZERO_STRUCT(state->tmp);
14019
14020         tevent_req_done(req);
14021 }
14022
14023 NTSTATUS rpccli_spoolss_5c_recv(struct tevent_req *req,
14024                                 TALLOC_CTX *mem_ctx,
14025                                 WERROR *result)
14026 {
14027         struct rpccli_spoolss_5c_state *state = tevent_req_data(
14028                 req, struct rpccli_spoolss_5c_state);
14029         NTSTATUS status;
14030
14031         if (tevent_req_is_nterror(req, &status)) {
14032                 tevent_req_received(req);
14033                 return status;
14034         }
14035
14036         /* Steal possbile out parameters to the callers context */
14037         talloc_steal(mem_ctx, state->out_mem_ctx);
14038
14039         /* Return result */
14040         *result = state->orig.out.result;
14041
14042         tevent_req_received(req);
14043         return NT_STATUS_OK;
14044 }
14045
14046 NTSTATUS rpccli_spoolss_5c(struct rpc_pipe_client *cli,
14047                            TALLOC_CTX *mem_ctx,
14048                            WERROR *werror)
14049 {
14050         struct spoolss_5c r;
14051         NTSTATUS status;
14052
14053         /* In parameters */
14054
14055         status = cli->dispatch(cli,
14056                                 mem_ctx,
14057                                 &ndr_table_spoolss,
14058                                 NDR_SPOOLSS_5C,
14059                                 &r);
14060
14061         if (!NT_STATUS_IS_OK(status)) {
14062                 return status;
14063         }
14064
14065         if (NT_STATUS_IS_ERR(status)) {
14066                 return status;
14067         }
14068
14069         /* Return variables */
14070
14071         /* Return result */
14072         if (werror) {
14073                 *werror = r.out.result;
14074         }
14075
14076         return werror_to_ntstatus(r.out.result);
14077 }
14078
14079 struct rpccli_spoolss_5d_state {
14080         struct spoolss_5d orig;
14081         struct spoolss_5d tmp;
14082         TALLOC_CTX *out_mem_ctx;
14083         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14084 };
14085
14086 static void rpccli_spoolss_5d_done(struct tevent_req *subreq);
14087
14088 struct tevent_req *rpccli_spoolss_5d_send(TALLOC_CTX *mem_ctx,
14089                                           struct tevent_context *ev,
14090                                           struct rpc_pipe_client *cli)
14091 {
14092         struct tevent_req *req;
14093         struct rpccli_spoolss_5d_state *state;
14094         struct tevent_req *subreq;
14095
14096         req = tevent_req_create(mem_ctx, &state,
14097                                 struct rpccli_spoolss_5d_state);
14098         if (req == NULL) {
14099                 return NULL;
14100         }
14101         state->out_mem_ctx = NULL;
14102         state->dispatch_recv = cli->dispatch_recv;
14103
14104         /* In parameters */
14105
14106         /* Out parameters */
14107
14108         /* Result */
14109         ZERO_STRUCT(state->orig.out.result);
14110
14111         /* make a temporary copy, that we pass to the dispatch function */
14112         state->tmp = state->orig;
14113
14114         subreq = cli->dispatch_send(state, ev, cli,
14115                                     &ndr_table_spoolss,
14116                                     NDR_SPOOLSS_5D,
14117                                     &state->tmp);
14118         if (tevent_req_nomem(subreq, req)) {
14119                 return tevent_req_post(req, ev);
14120         }
14121         tevent_req_set_callback(subreq, rpccli_spoolss_5d_done, req);
14122         return req;
14123 }
14124
14125 static void rpccli_spoolss_5d_done(struct tevent_req *subreq)
14126 {
14127         struct tevent_req *req = tevent_req_callback_data(
14128                 subreq, struct tevent_req);
14129         struct rpccli_spoolss_5d_state *state = tevent_req_data(
14130                 req, struct rpccli_spoolss_5d_state);
14131         NTSTATUS status;
14132         TALLOC_CTX *mem_ctx;
14133
14134         if (state->out_mem_ctx) {
14135                 mem_ctx = state->out_mem_ctx;
14136         } else {
14137                 mem_ctx = state;
14138         }
14139
14140         status = state->dispatch_recv(subreq, mem_ctx);
14141         TALLOC_FREE(subreq);
14142         if (!NT_STATUS_IS_OK(status)) {
14143                 tevent_req_nterror(req, status);
14144                 return;
14145         }
14146
14147         /* Copy out parameters */
14148
14149         /* Copy result */
14150         state->orig.out.result = state->tmp.out.result;
14151
14152         /* Reset temporary structure */
14153         ZERO_STRUCT(state->tmp);
14154
14155         tevent_req_done(req);
14156 }
14157
14158 NTSTATUS rpccli_spoolss_5d_recv(struct tevent_req *req,
14159                                 TALLOC_CTX *mem_ctx,
14160                                 WERROR *result)
14161 {
14162         struct rpccli_spoolss_5d_state *state = tevent_req_data(
14163                 req, struct rpccli_spoolss_5d_state);
14164         NTSTATUS status;
14165
14166         if (tevent_req_is_nterror(req, &status)) {
14167                 tevent_req_received(req);
14168                 return status;
14169         }
14170
14171         /* Steal possbile out parameters to the callers context */
14172         talloc_steal(mem_ctx, state->out_mem_ctx);
14173
14174         /* Return result */
14175         *result = state->orig.out.result;
14176
14177         tevent_req_received(req);
14178         return NT_STATUS_OK;
14179 }
14180
14181 NTSTATUS rpccli_spoolss_5d(struct rpc_pipe_client *cli,
14182                            TALLOC_CTX *mem_ctx,
14183                            WERROR *werror)
14184 {
14185         struct spoolss_5d r;
14186         NTSTATUS status;
14187
14188         /* In parameters */
14189
14190         status = cli->dispatch(cli,
14191                                 mem_ctx,
14192                                 &ndr_table_spoolss,
14193                                 NDR_SPOOLSS_5D,
14194                                 &r);
14195
14196         if (!NT_STATUS_IS_OK(status)) {
14197                 return status;
14198         }
14199
14200         if (NT_STATUS_IS_ERR(status)) {
14201                 return status;
14202         }
14203
14204         /* Return variables */
14205
14206         /* Return result */
14207         if (werror) {
14208                 *werror = r.out.result;
14209         }
14210
14211         return werror_to_ntstatus(r.out.result);
14212 }
14213
14214 struct rpccli_spoolss_5e_state {
14215         struct spoolss_5e orig;
14216         struct spoolss_5e tmp;
14217         TALLOC_CTX *out_mem_ctx;
14218         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14219 };
14220
14221 static void rpccli_spoolss_5e_done(struct tevent_req *subreq);
14222
14223 struct tevent_req *rpccli_spoolss_5e_send(TALLOC_CTX *mem_ctx,
14224                                           struct tevent_context *ev,
14225                                           struct rpc_pipe_client *cli)
14226 {
14227         struct tevent_req *req;
14228         struct rpccli_spoolss_5e_state *state;
14229         struct tevent_req *subreq;
14230
14231         req = tevent_req_create(mem_ctx, &state,
14232                                 struct rpccli_spoolss_5e_state);
14233         if (req == NULL) {
14234                 return NULL;
14235         }
14236         state->out_mem_ctx = NULL;
14237         state->dispatch_recv = cli->dispatch_recv;
14238
14239         /* In parameters */
14240
14241         /* Out parameters */
14242
14243         /* Result */
14244         ZERO_STRUCT(state->orig.out.result);
14245
14246         /* make a temporary copy, that we pass to the dispatch function */
14247         state->tmp = state->orig;
14248
14249         subreq = cli->dispatch_send(state, ev, cli,
14250                                     &ndr_table_spoolss,
14251                                     NDR_SPOOLSS_5E,
14252                                     &state->tmp);
14253         if (tevent_req_nomem(subreq, req)) {
14254                 return tevent_req_post(req, ev);
14255         }
14256         tevent_req_set_callback(subreq, rpccli_spoolss_5e_done, req);
14257         return req;
14258 }
14259
14260 static void rpccli_spoolss_5e_done(struct tevent_req *subreq)
14261 {
14262         struct tevent_req *req = tevent_req_callback_data(
14263                 subreq, struct tevent_req);
14264         struct rpccli_spoolss_5e_state *state = tevent_req_data(
14265                 req, struct rpccli_spoolss_5e_state);
14266         NTSTATUS status;
14267         TALLOC_CTX *mem_ctx;
14268
14269         if (state->out_mem_ctx) {
14270                 mem_ctx = state->out_mem_ctx;
14271         } else {
14272                 mem_ctx = state;
14273         }
14274
14275         status = state->dispatch_recv(subreq, mem_ctx);
14276         TALLOC_FREE(subreq);
14277         if (!NT_STATUS_IS_OK(status)) {
14278                 tevent_req_nterror(req, status);
14279                 return;
14280         }
14281
14282         /* Copy out parameters */
14283
14284         /* Copy result */
14285         state->orig.out.result = state->tmp.out.result;
14286
14287         /* Reset temporary structure */
14288         ZERO_STRUCT(state->tmp);
14289
14290         tevent_req_done(req);
14291 }
14292
14293 NTSTATUS rpccli_spoolss_5e_recv(struct tevent_req *req,
14294                                 TALLOC_CTX *mem_ctx,
14295                                 WERROR *result)
14296 {
14297         struct rpccli_spoolss_5e_state *state = tevent_req_data(
14298                 req, struct rpccli_spoolss_5e_state);
14299         NTSTATUS status;
14300
14301         if (tevent_req_is_nterror(req, &status)) {
14302                 tevent_req_received(req);
14303                 return status;
14304         }
14305
14306         /* Steal possbile out parameters to the callers context */
14307         talloc_steal(mem_ctx, state->out_mem_ctx);
14308
14309         /* Return result */
14310         *result = state->orig.out.result;
14311
14312         tevent_req_received(req);
14313         return NT_STATUS_OK;
14314 }
14315
14316 NTSTATUS rpccli_spoolss_5e(struct rpc_pipe_client *cli,
14317                            TALLOC_CTX *mem_ctx,
14318                            WERROR *werror)
14319 {
14320         struct spoolss_5e r;
14321         NTSTATUS status;
14322
14323         /* In parameters */
14324
14325         status = cli->dispatch(cli,
14326                                 mem_ctx,
14327                                 &ndr_table_spoolss,
14328                                 NDR_SPOOLSS_5E,
14329                                 &r);
14330
14331         if (!NT_STATUS_IS_OK(status)) {
14332                 return status;
14333         }
14334
14335         if (NT_STATUS_IS_ERR(status)) {
14336                 return status;
14337         }
14338
14339         /* Return variables */
14340
14341         /* Return result */
14342         if (werror) {
14343                 *werror = r.out.result;
14344         }
14345
14346         return werror_to_ntstatus(r.out.result);
14347 }
14348
14349 struct rpccli_spoolss_5f_state {
14350         struct spoolss_5f orig;
14351         struct spoolss_5f tmp;
14352         TALLOC_CTX *out_mem_ctx;
14353         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14354 };
14355
14356 static void rpccli_spoolss_5f_done(struct tevent_req *subreq);
14357
14358 struct tevent_req *rpccli_spoolss_5f_send(TALLOC_CTX *mem_ctx,
14359                                           struct tevent_context *ev,
14360                                           struct rpc_pipe_client *cli)
14361 {
14362         struct tevent_req *req;
14363         struct rpccli_spoolss_5f_state *state;
14364         struct tevent_req *subreq;
14365
14366         req = tevent_req_create(mem_ctx, &state,
14367                                 struct rpccli_spoolss_5f_state);
14368         if (req == NULL) {
14369                 return NULL;
14370         }
14371         state->out_mem_ctx = NULL;
14372         state->dispatch_recv = cli->dispatch_recv;
14373
14374         /* In parameters */
14375
14376         /* Out parameters */
14377
14378         /* Result */
14379         ZERO_STRUCT(state->orig.out.result);
14380
14381         /* make a temporary copy, that we pass to the dispatch function */
14382         state->tmp = state->orig;
14383
14384         subreq = cli->dispatch_send(state, ev, cli,
14385                                     &ndr_table_spoolss,
14386                                     NDR_SPOOLSS_5F,
14387                                     &state->tmp);
14388         if (tevent_req_nomem(subreq, req)) {
14389                 return tevent_req_post(req, ev);
14390         }
14391         tevent_req_set_callback(subreq, rpccli_spoolss_5f_done, req);
14392         return req;
14393 }
14394
14395 static void rpccli_spoolss_5f_done(struct tevent_req *subreq)
14396 {
14397         struct tevent_req *req = tevent_req_callback_data(
14398                 subreq, struct tevent_req);
14399         struct rpccli_spoolss_5f_state *state = tevent_req_data(
14400                 req, struct rpccli_spoolss_5f_state);
14401         NTSTATUS status;
14402         TALLOC_CTX *mem_ctx;
14403
14404         if (state->out_mem_ctx) {
14405                 mem_ctx = state->out_mem_ctx;
14406         } else {
14407                 mem_ctx = state;
14408         }
14409
14410         status = state->dispatch_recv(subreq, mem_ctx);
14411         TALLOC_FREE(subreq);
14412         if (!NT_STATUS_IS_OK(status)) {
14413                 tevent_req_nterror(req, status);
14414                 return;
14415         }
14416
14417         /* Copy out parameters */
14418
14419         /* Copy result */
14420         state->orig.out.result = state->tmp.out.result;
14421
14422         /* Reset temporary structure */
14423         ZERO_STRUCT(state->tmp);
14424
14425         tevent_req_done(req);
14426 }
14427
14428 NTSTATUS rpccli_spoolss_5f_recv(struct tevent_req *req,
14429                                 TALLOC_CTX *mem_ctx,
14430                                 WERROR *result)
14431 {
14432         struct rpccli_spoolss_5f_state *state = tevent_req_data(
14433                 req, struct rpccli_spoolss_5f_state);
14434         NTSTATUS status;
14435
14436         if (tevent_req_is_nterror(req, &status)) {
14437                 tevent_req_received(req);
14438                 return status;
14439         }
14440
14441         /* Steal possbile out parameters to the callers context */
14442         talloc_steal(mem_ctx, state->out_mem_ctx);
14443
14444         /* Return result */
14445         *result = state->orig.out.result;
14446
14447         tevent_req_received(req);
14448         return NT_STATUS_OK;
14449 }
14450
14451 NTSTATUS rpccli_spoolss_5f(struct rpc_pipe_client *cli,
14452                            TALLOC_CTX *mem_ctx,
14453                            WERROR *werror)
14454 {
14455         struct spoolss_5f r;
14456         NTSTATUS status;
14457
14458         /* In parameters */
14459
14460         status = cli->dispatch(cli,
14461                                 mem_ctx,
14462                                 &ndr_table_spoolss,
14463                                 NDR_SPOOLSS_5F,
14464                                 &r);
14465
14466         if (!NT_STATUS_IS_OK(status)) {
14467                 return status;
14468         }
14469
14470         if (NT_STATUS_IS_ERR(status)) {
14471                 return status;
14472         }
14473
14474         /* Return variables */
14475
14476         /* Return result */
14477         if (werror) {
14478                 *werror = r.out.result;
14479         }
14480
14481         return werror_to_ntstatus(r.out.result);
14482 }
14483
14484 struct rpccli_spoolss_60_state {
14485         struct spoolss_60 orig;
14486         struct spoolss_60 tmp;
14487         TALLOC_CTX *out_mem_ctx;
14488         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14489 };
14490
14491 static void rpccli_spoolss_60_done(struct tevent_req *subreq);
14492
14493 struct tevent_req *rpccli_spoolss_60_send(TALLOC_CTX *mem_ctx,
14494                                           struct tevent_context *ev,
14495                                           struct rpc_pipe_client *cli)
14496 {
14497         struct tevent_req *req;
14498         struct rpccli_spoolss_60_state *state;
14499         struct tevent_req *subreq;
14500
14501         req = tevent_req_create(mem_ctx, &state,
14502                                 struct rpccli_spoolss_60_state);
14503         if (req == NULL) {
14504                 return NULL;
14505         }
14506         state->out_mem_ctx = NULL;
14507         state->dispatch_recv = cli->dispatch_recv;
14508
14509         /* In parameters */
14510
14511         /* Out parameters */
14512
14513         /* Result */
14514         ZERO_STRUCT(state->orig.out.result);
14515
14516         /* make a temporary copy, that we pass to the dispatch function */
14517         state->tmp = state->orig;
14518
14519         subreq = cli->dispatch_send(state, ev, cli,
14520                                     &ndr_table_spoolss,
14521                                     NDR_SPOOLSS_60,
14522                                     &state->tmp);
14523         if (tevent_req_nomem(subreq, req)) {
14524                 return tevent_req_post(req, ev);
14525         }
14526         tevent_req_set_callback(subreq, rpccli_spoolss_60_done, req);
14527         return req;
14528 }
14529
14530 static void rpccli_spoolss_60_done(struct tevent_req *subreq)
14531 {
14532         struct tevent_req *req = tevent_req_callback_data(
14533                 subreq, struct tevent_req);
14534         struct rpccli_spoolss_60_state *state = tevent_req_data(
14535                 req, struct rpccli_spoolss_60_state);
14536         NTSTATUS status;
14537         TALLOC_CTX *mem_ctx;
14538
14539         if (state->out_mem_ctx) {
14540                 mem_ctx = state->out_mem_ctx;
14541         } else {
14542                 mem_ctx = state;
14543         }
14544
14545         status = state->dispatch_recv(subreq, mem_ctx);
14546         TALLOC_FREE(subreq);
14547         if (!NT_STATUS_IS_OK(status)) {
14548                 tevent_req_nterror(req, status);
14549                 return;
14550         }
14551
14552         /* Copy out parameters */
14553
14554         /* Copy result */
14555         state->orig.out.result = state->tmp.out.result;
14556
14557         /* Reset temporary structure */
14558         ZERO_STRUCT(state->tmp);
14559
14560         tevent_req_done(req);
14561 }
14562
14563 NTSTATUS rpccli_spoolss_60_recv(struct tevent_req *req,
14564                                 TALLOC_CTX *mem_ctx,
14565                                 WERROR *result)
14566 {
14567         struct rpccli_spoolss_60_state *state = tevent_req_data(
14568                 req, struct rpccli_spoolss_60_state);
14569         NTSTATUS status;
14570
14571         if (tevent_req_is_nterror(req, &status)) {
14572                 tevent_req_received(req);
14573                 return status;
14574         }
14575
14576         /* Steal possbile out parameters to the callers context */
14577         talloc_steal(mem_ctx, state->out_mem_ctx);
14578
14579         /* Return result */
14580         *result = state->orig.out.result;
14581
14582         tevent_req_received(req);
14583         return NT_STATUS_OK;
14584 }
14585
14586 NTSTATUS rpccli_spoolss_60(struct rpc_pipe_client *cli,
14587                            TALLOC_CTX *mem_ctx,
14588                            WERROR *werror)
14589 {
14590         struct spoolss_60 r;
14591         NTSTATUS status;
14592
14593         /* In parameters */
14594
14595         status = cli->dispatch(cli,
14596                                 mem_ctx,
14597                                 &ndr_table_spoolss,
14598                                 NDR_SPOOLSS_60,
14599                                 &r);
14600
14601         if (!NT_STATUS_IS_OK(status)) {
14602                 return status;
14603         }
14604
14605         if (NT_STATUS_IS_ERR(status)) {
14606                 return status;
14607         }
14608
14609         /* Return variables */
14610
14611         /* Return result */
14612         if (werror) {
14613                 *werror = r.out.result;
14614         }
14615
14616         return werror_to_ntstatus(r.out.result);
14617 }
14618
14619 struct rpccli_spoolss_61_state {
14620         struct spoolss_61 orig;
14621         struct spoolss_61 tmp;
14622         TALLOC_CTX *out_mem_ctx;
14623         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14624 };
14625
14626 static void rpccli_spoolss_61_done(struct tevent_req *subreq);
14627
14628 struct tevent_req *rpccli_spoolss_61_send(TALLOC_CTX *mem_ctx,
14629                                           struct tevent_context *ev,
14630                                           struct rpc_pipe_client *cli)
14631 {
14632         struct tevent_req *req;
14633         struct rpccli_spoolss_61_state *state;
14634         struct tevent_req *subreq;
14635
14636         req = tevent_req_create(mem_ctx, &state,
14637                                 struct rpccli_spoolss_61_state);
14638         if (req == NULL) {
14639                 return NULL;
14640         }
14641         state->out_mem_ctx = NULL;
14642         state->dispatch_recv = cli->dispatch_recv;
14643
14644         /* In parameters */
14645
14646         /* Out parameters */
14647
14648         /* Result */
14649         ZERO_STRUCT(state->orig.out.result);
14650
14651         /* make a temporary copy, that we pass to the dispatch function */
14652         state->tmp = state->orig;
14653
14654         subreq = cli->dispatch_send(state, ev, cli,
14655                                     &ndr_table_spoolss,
14656                                     NDR_SPOOLSS_61,
14657                                     &state->tmp);
14658         if (tevent_req_nomem(subreq, req)) {
14659                 return tevent_req_post(req, ev);
14660         }
14661         tevent_req_set_callback(subreq, rpccli_spoolss_61_done, req);
14662         return req;
14663 }
14664
14665 static void rpccli_spoolss_61_done(struct tevent_req *subreq)
14666 {
14667         struct tevent_req *req = tevent_req_callback_data(
14668                 subreq, struct tevent_req);
14669         struct rpccli_spoolss_61_state *state = tevent_req_data(
14670                 req, struct rpccli_spoolss_61_state);
14671         NTSTATUS status;
14672         TALLOC_CTX *mem_ctx;
14673
14674         if (state->out_mem_ctx) {
14675                 mem_ctx = state->out_mem_ctx;
14676         } else {
14677                 mem_ctx = state;
14678         }
14679
14680         status = state->dispatch_recv(subreq, mem_ctx);
14681         TALLOC_FREE(subreq);
14682         if (!NT_STATUS_IS_OK(status)) {
14683                 tevent_req_nterror(req, status);
14684                 return;
14685         }
14686
14687         /* Copy out parameters */
14688
14689         /* Copy result */
14690         state->orig.out.result = state->tmp.out.result;
14691
14692         /* Reset temporary structure */
14693         ZERO_STRUCT(state->tmp);
14694
14695         tevent_req_done(req);
14696 }
14697
14698 NTSTATUS rpccli_spoolss_61_recv(struct tevent_req *req,
14699                                 TALLOC_CTX *mem_ctx,
14700                                 WERROR *result)
14701 {
14702         struct rpccli_spoolss_61_state *state = tevent_req_data(
14703                 req, struct rpccli_spoolss_61_state);
14704         NTSTATUS status;
14705
14706         if (tevent_req_is_nterror(req, &status)) {
14707                 tevent_req_received(req);
14708                 return status;
14709         }
14710
14711         /* Steal possbile out parameters to the callers context */
14712         talloc_steal(mem_ctx, state->out_mem_ctx);
14713
14714         /* Return result */
14715         *result = state->orig.out.result;
14716
14717         tevent_req_received(req);
14718         return NT_STATUS_OK;
14719 }
14720
14721 NTSTATUS rpccli_spoolss_61(struct rpc_pipe_client *cli,
14722                            TALLOC_CTX *mem_ctx,
14723                            WERROR *werror)
14724 {
14725         struct spoolss_61 r;
14726         NTSTATUS status;
14727
14728         /* In parameters */
14729
14730         status = cli->dispatch(cli,
14731                                 mem_ctx,
14732                                 &ndr_table_spoolss,
14733                                 NDR_SPOOLSS_61,
14734                                 &r);
14735
14736         if (!NT_STATUS_IS_OK(status)) {
14737                 return status;
14738         }
14739
14740         if (NT_STATUS_IS_ERR(status)) {
14741                 return status;
14742         }
14743
14744         /* Return variables */
14745
14746         /* Return result */
14747         if (werror) {
14748                 *werror = r.out.result;
14749         }
14750
14751         return werror_to_ntstatus(r.out.result);
14752 }
14753
14754 struct rpccli_spoolss_62_state {
14755         struct spoolss_62 orig;
14756         struct spoolss_62 tmp;
14757         TALLOC_CTX *out_mem_ctx;
14758         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14759 };
14760
14761 static void rpccli_spoolss_62_done(struct tevent_req *subreq);
14762
14763 struct tevent_req *rpccli_spoolss_62_send(TALLOC_CTX *mem_ctx,
14764                                           struct tevent_context *ev,
14765                                           struct rpc_pipe_client *cli)
14766 {
14767         struct tevent_req *req;
14768         struct rpccli_spoolss_62_state *state;
14769         struct tevent_req *subreq;
14770
14771         req = tevent_req_create(mem_ctx, &state,
14772                                 struct rpccli_spoolss_62_state);
14773         if (req == NULL) {
14774                 return NULL;
14775         }
14776         state->out_mem_ctx = NULL;
14777         state->dispatch_recv = cli->dispatch_recv;
14778
14779         /* In parameters */
14780
14781         /* Out parameters */
14782
14783         /* Result */
14784         ZERO_STRUCT(state->orig.out.result);
14785
14786         /* make a temporary copy, that we pass to the dispatch function */
14787         state->tmp = state->orig;
14788
14789         subreq = cli->dispatch_send(state, ev, cli,
14790                                     &ndr_table_spoolss,
14791                                     NDR_SPOOLSS_62,
14792                                     &state->tmp);
14793         if (tevent_req_nomem(subreq, req)) {
14794                 return tevent_req_post(req, ev);
14795         }
14796         tevent_req_set_callback(subreq, rpccli_spoolss_62_done, req);
14797         return req;
14798 }
14799
14800 static void rpccli_spoolss_62_done(struct tevent_req *subreq)
14801 {
14802         struct tevent_req *req = tevent_req_callback_data(
14803                 subreq, struct tevent_req);
14804         struct rpccli_spoolss_62_state *state = tevent_req_data(
14805                 req, struct rpccli_spoolss_62_state);
14806         NTSTATUS status;
14807         TALLOC_CTX *mem_ctx;
14808
14809         if (state->out_mem_ctx) {
14810                 mem_ctx = state->out_mem_ctx;
14811         } else {
14812                 mem_ctx = state;
14813         }
14814
14815         status = state->dispatch_recv(subreq, mem_ctx);
14816         TALLOC_FREE(subreq);
14817         if (!NT_STATUS_IS_OK(status)) {
14818                 tevent_req_nterror(req, status);
14819                 return;
14820         }
14821
14822         /* Copy out parameters */
14823
14824         /* Copy result */
14825         state->orig.out.result = state->tmp.out.result;
14826
14827         /* Reset temporary structure */
14828         ZERO_STRUCT(state->tmp);
14829
14830         tevent_req_done(req);
14831 }
14832
14833 NTSTATUS rpccli_spoolss_62_recv(struct tevent_req *req,
14834                                 TALLOC_CTX *mem_ctx,
14835                                 WERROR *result)
14836 {
14837         struct rpccli_spoolss_62_state *state = tevent_req_data(
14838                 req, struct rpccli_spoolss_62_state);
14839         NTSTATUS status;
14840
14841         if (tevent_req_is_nterror(req, &status)) {
14842                 tevent_req_received(req);
14843                 return status;
14844         }
14845
14846         /* Steal possbile out parameters to the callers context */
14847         talloc_steal(mem_ctx, state->out_mem_ctx);
14848
14849         /* Return result */
14850         *result = state->orig.out.result;
14851
14852         tevent_req_received(req);
14853         return NT_STATUS_OK;
14854 }
14855
14856 NTSTATUS rpccli_spoolss_62(struct rpc_pipe_client *cli,
14857                            TALLOC_CTX *mem_ctx,
14858                            WERROR *werror)
14859 {
14860         struct spoolss_62 r;
14861         NTSTATUS status;
14862
14863         /* In parameters */
14864
14865         status = cli->dispatch(cli,
14866                                 mem_ctx,
14867                                 &ndr_table_spoolss,
14868                                 NDR_SPOOLSS_62,
14869                                 &r);
14870
14871         if (!NT_STATUS_IS_OK(status)) {
14872                 return status;
14873         }
14874
14875         if (NT_STATUS_IS_ERR(status)) {
14876                 return status;
14877         }
14878
14879         /* Return variables */
14880
14881         /* Return result */
14882         if (werror) {
14883                 *werror = r.out.result;
14884         }
14885
14886         return werror_to_ntstatus(r.out.result);
14887 }
14888
14889 struct rpccli_spoolss_63_state {
14890         struct spoolss_63 orig;
14891         struct spoolss_63 tmp;
14892         TALLOC_CTX *out_mem_ctx;
14893         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14894 };
14895
14896 static void rpccli_spoolss_63_done(struct tevent_req *subreq);
14897
14898 struct tevent_req *rpccli_spoolss_63_send(TALLOC_CTX *mem_ctx,
14899                                           struct tevent_context *ev,
14900                                           struct rpc_pipe_client *cli)
14901 {
14902         struct tevent_req *req;
14903         struct rpccli_spoolss_63_state *state;
14904         struct tevent_req *subreq;
14905
14906         req = tevent_req_create(mem_ctx, &state,
14907                                 struct rpccli_spoolss_63_state);
14908         if (req == NULL) {
14909                 return NULL;
14910         }
14911         state->out_mem_ctx = NULL;
14912         state->dispatch_recv = cli->dispatch_recv;
14913
14914         /* In parameters */
14915
14916         /* Out parameters */
14917
14918         /* Result */
14919         ZERO_STRUCT(state->orig.out.result);
14920
14921         /* make a temporary copy, that we pass to the dispatch function */
14922         state->tmp = state->orig;
14923
14924         subreq = cli->dispatch_send(state, ev, cli,
14925                                     &ndr_table_spoolss,
14926                                     NDR_SPOOLSS_63,
14927                                     &state->tmp);
14928         if (tevent_req_nomem(subreq, req)) {
14929                 return tevent_req_post(req, ev);
14930         }
14931         tevent_req_set_callback(subreq, rpccli_spoolss_63_done, req);
14932         return req;
14933 }
14934
14935 static void rpccli_spoolss_63_done(struct tevent_req *subreq)
14936 {
14937         struct tevent_req *req = tevent_req_callback_data(
14938                 subreq, struct tevent_req);
14939         struct rpccli_spoolss_63_state *state = tevent_req_data(
14940                 req, struct rpccli_spoolss_63_state);
14941         NTSTATUS status;
14942         TALLOC_CTX *mem_ctx;
14943
14944         if (state->out_mem_ctx) {
14945                 mem_ctx = state->out_mem_ctx;
14946         } else {
14947                 mem_ctx = state;
14948         }
14949
14950         status = state->dispatch_recv(subreq, mem_ctx);
14951         TALLOC_FREE(subreq);
14952         if (!NT_STATUS_IS_OK(status)) {
14953                 tevent_req_nterror(req, status);
14954                 return;
14955         }
14956
14957         /* Copy out parameters */
14958
14959         /* Copy result */
14960         state->orig.out.result = state->tmp.out.result;
14961
14962         /* Reset temporary structure */
14963         ZERO_STRUCT(state->tmp);
14964
14965         tevent_req_done(req);
14966 }
14967
14968 NTSTATUS rpccli_spoolss_63_recv(struct tevent_req *req,
14969                                 TALLOC_CTX *mem_ctx,
14970                                 WERROR *result)
14971 {
14972         struct rpccli_spoolss_63_state *state = tevent_req_data(
14973                 req, struct rpccli_spoolss_63_state);
14974         NTSTATUS status;
14975
14976         if (tevent_req_is_nterror(req, &status)) {
14977                 tevent_req_received(req);
14978                 return status;
14979         }
14980
14981         /* Steal possbile out parameters to the callers context */
14982         talloc_steal(mem_ctx, state->out_mem_ctx);
14983
14984         /* Return result */
14985         *result = state->orig.out.result;
14986
14987         tevent_req_received(req);
14988         return NT_STATUS_OK;
14989 }
14990
14991 NTSTATUS rpccli_spoolss_63(struct rpc_pipe_client *cli,
14992                            TALLOC_CTX *mem_ctx,
14993                            WERROR *werror)
14994 {
14995         struct spoolss_63 r;
14996         NTSTATUS status;
14997
14998         /* In parameters */
14999
15000         status = cli->dispatch(cli,
15001                                 mem_ctx,
15002                                 &ndr_table_spoolss,
15003                                 NDR_SPOOLSS_63,
15004                                 &r);
15005
15006         if (!NT_STATUS_IS_OK(status)) {
15007                 return status;
15008         }
15009
15010         if (NT_STATUS_IS_ERR(status)) {
15011                 return status;
15012         }
15013
15014         /* Return variables */
15015
15016         /* Return result */
15017         if (werror) {
15018                 *werror = r.out.result;
15019         }
15020
15021         return werror_to_ntstatus(r.out.result);
15022 }
15023
15024 struct rpccli_spoolss_64_state {
15025         struct spoolss_64 orig;
15026         struct spoolss_64 tmp;
15027         TALLOC_CTX *out_mem_ctx;
15028         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15029 };
15030
15031 static void rpccli_spoolss_64_done(struct tevent_req *subreq);
15032
15033 struct tevent_req *rpccli_spoolss_64_send(TALLOC_CTX *mem_ctx,
15034                                           struct tevent_context *ev,
15035                                           struct rpc_pipe_client *cli)
15036 {
15037         struct tevent_req *req;
15038         struct rpccli_spoolss_64_state *state;
15039         struct tevent_req *subreq;
15040
15041         req = tevent_req_create(mem_ctx, &state,
15042                                 struct rpccli_spoolss_64_state);
15043         if (req == NULL) {
15044                 return NULL;
15045         }
15046         state->out_mem_ctx = NULL;
15047         state->dispatch_recv = cli->dispatch_recv;
15048
15049         /* In parameters */
15050
15051         /* Out parameters */
15052
15053         /* Result */
15054         ZERO_STRUCT(state->orig.out.result);
15055
15056         /* make a temporary copy, that we pass to the dispatch function */
15057         state->tmp = state->orig;
15058
15059         subreq = cli->dispatch_send(state, ev, cli,
15060                                     &ndr_table_spoolss,
15061                                     NDR_SPOOLSS_64,
15062                                     &state->tmp);
15063         if (tevent_req_nomem(subreq, req)) {
15064                 return tevent_req_post(req, ev);
15065         }
15066         tevent_req_set_callback(subreq, rpccli_spoolss_64_done, req);
15067         return req;
15068 }
15069
15070 static void rpccli_spoolss_64_done(struct tevent_req *subreq)
15071 {
15072         struct tevent_req *req = tevent_req_callback_data(
15073                 subreq, struct tevent_req);
15074         struct rpccli_spoolss_64_state *state = tevent_req_data(
15075                 req, struct rpccli_spoolss_64_state);
15076         NTSTATUS status;
15077         TALLOC_CTX *mem_ctx;
15078
15079         if (state->out_mem_ctx) {
15080                 mem_ctx = state->out_mem_ctx;
15081         } else {
15082                 mem_ctx = state;
15083         }
15084
15085         status = state->dispatch_recv(subreq, mem_ctx);
15086         TALLOC_FREE(subreq);
15087         if (!NT_STATUS_IS_OK(status)) {
15088                 tevent_req_nterror(req, status);
15089                 return;
15090         }
15091
15092         /* Copy out parameters */
15093
15094         /* Copy result */
15095         state->orig.out.result = state->tmp.out.result;
15096
15097         /* Reset temporary structure */
15098         ZERO_STRUCT(state->tmp);
15099
15100         tevent_req_done(req);
15101 }
15102
15103 NTSTATUS rpccli_spoolss_64_recv(struct tevent_req *req,
15104                                 TALLOC_CTX *mem_ctx,
15105                                 WERROR *result)
15106 {
15107         struct rpccli_spoolss_64_state *state = tevent_req_data(
15108                 req, struct rpccli_spoolss_64_state);
15109         NTSTATUS status;
15110
15111         if (tevent_req_is_nterror(req, &status)) {
15112                 tevent_req_received(req);
15113                 return status;
15114         }
15115
15116         /* Steal possbile out parameters to the callers context */
15117         talloc_steal(mem_ctx, state->out_mem_ctx);
15118
15119         /* Return result */
15120         *result = state->orig.out.result;
15121
15122         tevent_req_received(req);
15123         return NT_STATUS_OK;
15124 }
15125
15126 NTSTATUS rpccli_spoolss_64(struct rpc_pipe_client *cli,
15127                            TALLOC_CTX *mem_ctx,
15128                            WERROR *werror)
15129 {
15130         struct spoolss_64 r;
15131         NTSTATUS status;
15132
15133         /* In parameters */
15134
15135         status = cli->dispatch(cli,
15136                                 mem_ctx,
15137                                 &ndr_table_spoolss,
15138                                 NDR_SPOOLSS_64,
15139                                 &r);
15140
15141         if (!NT_STATUS_IS_OK(status)) {
15142                 return status;
15143         }
15144
15145         if (NT_STATUS_IS_ERR(status)) {
15146                 return status;
15147         }
15148
15149         /* Return variables */
15150
15151         /* Return result */
15152         if (werror) {
15153                 *werror = r.out.result;
15154         }
15155
15156         return werror_to_ntstatus(r.out.result);
15157 }
15158
15159 struct rpccli_spoolss_65_state {
15160         struct spoolss_65 orig;
15161         struct spoolss_65 tmp;
15162         TALLOC_CTX *out_mem_ctx;
15163         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15164 };
15165
15166 static void rpccli_spoolss_65_done(struct tevent_req *subreq);
15167
15168 struct tevent_req *rpccli_spoolss_65_send(TALLOC_CTX *mem_ctx,
15169                                           struct tevent_context *ev,
15170                                           struct rpc_pipe_client *cli)
15171 {
15172         struct tevent_req *req;
15173         struct rpccli_spoolss_65_state *state;
15174         struct tevent_req *subreq;
15175
15176         req = tevent_req_create(mem_ctx, &state,
15177                                 struct rpccli_spoolss_65_state);
15178         if (req == NULL) {
15179                 return NULL;
15180         }
15181         state->out_mem_ctx = NULL;
15182         state->dispatch_recv = cli->dispatch_recv;
15183
15184         /* In parameters */
15185
15186         /* Out parameters */
15187
15188         /* Result */
15189         ZERO_STRUCT(state->orig.out.result);
15190
15191         /* make a temporary copy, that we pass to the dispatch function */
15192         state->tmp = state->orig;
15193
15194         subreq = cli->dispatch_send(state, ev, cli,
15195                                     &ndr_table_spoolss,
15196                                     NDR_SPOOLSS_65,
15197                                     &state->tmp);
15198         if (tevent_req_nomem(subreq, req)) {
15199                 return tevent_req_post(req, ev);
15200         }
15201         tevent_req_set_callback(subreq, rpccli_spoolss_65_done, req);
15202         return req;
15203 }
15204
15205 static void rpccli_spoolss_65_done(struct tevent_req *subreq)
15206 {
15207         struct tevent_req *req = tevent_req_callback_data(
15208                 subreq, struct tevent_req);
15209         struct rpccli_spoolss_65_state *state = tevent_req_data(
15210                 req, struct rpccli_spoolss_65_state);
15211         NTSTATUS status;
15212         TALLOC_CTX *mem_ctx;
15213
15214         if (state->out_mem_ctx) {
15215                 mem_ctx = state->out_mem_ctx;
15216         } else {
15217                 mem_ctx = state;
15218         }
15219
15220         status = state->dispatch_recv(subreq, mem_ctx);
15221         TALLOC_FREE(subreq);
15222         if (!NT_STATUS_IS_OK(status)) {
15223                 tevent_req_nterror(req, status);
15224                 return;
15225         }
15226
15227         /* Copy out parameters */
15228
15229         /* Copy result */
15230         state->orig.out.result = state->tmp.out.result;
15231
15232         /* Reset temporary structure */
15233         ZERO_STRUCT(state->tmp);
15234
15235         tevent_req_done(req);
15236 }
15237
15238 NTSTATUS rpccli_spoolss_65_recv(struct tevent_req *req,
15239                                 TALLOC_CTX *mem_ctx,
15240                                 WERROR *result)
15241 {
15242         struct rpccli_spoolss_65_state *state = tevent_req_data(
15243                 req, struct rpccli_spoolss_65_state);
15244         NTSTATUS status;
15245
15246         if (tevent_req_is_nterror(req, &status)) {
15247                 tevent_req_received(req);
15248                 return status;
15249         }
15250
15251         /* Steal possbile out parameters to the callers context */
15252         talloc_steal(mem_ctx, state->out_mem_ctx);
15253
15254         /* Return result */
15255         *result = state->orig.out.result;
15256
15257         tevent_req_received(req);
15258         return NT_STATUS_OK;
15259 }
15260
15261 NTSTATUS rpccli_spoolss_65(struct rpc_pipe_client *cli,
15262                            TALLOC_CTX *mem_ctx,
15263                            WERROR *werror)
15264 {
15265         struct spoolss_65 r;
15266         NTSTATUS status;
15267
15268         /* In parameters */
15269
15270         status = cli->dispatch(cli,
15271                                 mem_ctx,
15272                                 &ndr_table_spoolss,
15273                                 NDR_SPOOLSS_65,
15274                                 &r);
15275
15276         if (!NT_STATUS_IS_OK(status)) {
15277                 return status;
15278         }
15279
15280         if (NT_STATUS_IS_ERR(status)) {
15281                 return status;
15282         }
15283
15284         /* Return variables */
15285
15286         /* Return result */
15287         if (werror) {
15288                 *werror = r.out.result;
15289         }
15290
15291         return werror_to_ntstatus(r.out.result);
15292 }
15293
15294 struct rpccli_spoolss_GetCorePrinterDrivers_state {
15295         struct spoolss_GetCorePrinterDrivers orig;
15296         struct spoolss_GetCorePrinterDrivers tmp;
15297         TALLOC_CTX *out_mem_ctx;
15298         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15299 };
15300
15301 static void rpccli_spoolss_GetCorePrinterDrivers_done(struct tevent_req *subreq);
15302
15303 struct tevent_req *rpccli_spoolss_GetCorePrinterDrivers_send(TALLOC_CTX *mem_ctx,
15304                                                              struct tevent_context *ev,
15305                                                              struct rpc_pipe_client *cli,
15306                                                              const char *_servername /* [in] [unique,charset(UTF16)] */,
15307                                                              const char *_architecture /* [in] [ref,charset(UTF16)] */,
15308                                                              uint32_t _core_driver_size /* [in]  */,
15309                                                              const char *_core_driver_dependencies /* [in] [ref,charset(UTF16),size_is(core_driver_size)] */,
15310                                                              uint32_t _core_printer_driver_count /* [in]  */,
15311                                                              struct spoolss_CorePrinterDriver *_core_printer_drivers /* [out] [ref,size_is(core_printer_driver_count)] */)
15312 {
15313         struct tevent_req *req;
15314         struct rpccli_spoolss_GetCorePrinterDrivers_state *state;
15315         struct tevent_req *subreq;
15316
15317         req = tevent_req_create(mem_ctx, &state,
15318                                 struct rpccli_spoolss_GetCorePrinterDrivers_state);
15319         if (req == NULL) {
15320                 return NULL;
15321         }
15322         state->out_mem_ctx = NULL;
15323         state->dispatch_recv = cli->dispatch_recv;
15324
15325         /* In parameters */
15326         state->orig.in.servername = _servername;
15327         state->orig.in.architecture = _architecture;
15328         state->orig.in.core_driver_size = _core_driver_size;
15329         state->orig.in.core_driver_dependencies = _core_driver_dependencies;
15330         state->orig.in.core_printer_driver_count = _core_printer_driver_count;
15331
15332         /* Out parameters */
15333         state->orig.out.core_printer_drivers = _core_printer_drivers;
15334
15335         /* Result */
15336         ZERO_STRUCT(state->orig.out.result);
15337
15338         state->out_mem_ctx = talloc_named_const(state, 0,
15339                              "rpccli_spoolss_GetCorePrinterDrivers_out_memory");
15340         if (tevent_req_nomem(state->out_mem_ctx, req)) {
15341                 return tevent_req_post(req, ev);
15342         }
15343
15344         /* make a temporary copy, that we pass to the dispatch function */
15345         state->tmp = state->orig;
15346
15347         subreq = cli->dispatch_send(state, ev, cli,
15348                                     &ndr_table_spoolss,
15349                                     NDR_SPOOLSS_GETCOREPRINTERDRIVERS,
15350                                     &state->tmp);
15351         if (tevent_req_nomem(subreq, req)) {
15352                 return tevent_req_post(req, ev);
15353         }
15354         tevent_req_set_callback(subreq, rpccli_spoolss_GetCorePrinterDrivers_done, req);
15355         return req;
15356 }
15357
15358 static void rpccli_spoolss_GetCorePrinterDrivers_done(struct tevent_req *subreq)
15359 {
15360         struct tevent_req *req = tevent_req_callback_data(
15361                 subreq, struct tevent_req);
15362         struct rpccli_spoolss_GetCorePrinterDrivers_state *state = tevent_req_data(
15363                 req, struct rpccli_spoolss_GetCorePrinterDrivers_state);
15364         NTSTATUS status;
15365         TALLOC_CTX *mem_ctx;
15366
15367         if (state->out_mem_ctx) {
15368                 mem_ctx = state->out_mem_ctx;
15369         } else {
15370                 mem_ctx = state;
15371         }
15372
15373         status = state->dispatch_recv(subreq, mem_ctx);
15374         TALLOC_FREE(subreq);
15375         if (!NT_STATUS_IS_OK(status)) {
15376                 tevent_req_nterror(req, status);
15377                 return;
15378         }
15379
15380         /* Copy out parameters */
15381         memcpy(state->orig.out.core_printer_drivers, state->tmp.out.core_printer_drivers, (state->tmp.in.core_printer_driver_count) * sizeof(*state->orig.out.core_printer_drivers));
15382
15383         /* Copy result */
15384         state->orig.out.result = state->tmp.out.result;
15385
15386         /* Reset temporary structure */
15387         ZERO_STRUCT(state->tmp);
15388
15389         tevent_req_done(req);
15390 }
15391
15392 NTSTATUS rpccli_spoolss_GetCorePrinterDrivers_recv(struct tevent_req *req,
15393                                                    TALLOC_CTX *mem_ctx,
15394                                                    WERROR *result)
15395 {
15396         struct rpccli_spoolss_GetCorePrinterDrivers_state *state = tevent_req_data(
15397                 req, struct rpccli_spoolss_GetCorePrinterDrivers_state);
15398         NTSTATUS status;
15399
15400         if (tevent_req_is_nterror(req, &status)) {
15401                 tevent_req_received(req);
15402                 return status;
15403         }
15404
15405         /* Steal possbile out parameters to the callers context */
15406         talloc_steal(mem_ctx, state->out_mem_ctx);
15407
15408         /* Return result */
15409         *result = state->orig.out.result;
15410
15411         tevent_req_received(req);
15412         return NT_STATUS_OK;
15413 }
15414
15415 NTSTATUS rpccli_spoolss_GetCorePrinterDrivers(struct rpc_pipe_client *cli,
15416                                               TALLOC_CTX *mem_ctx,
15417                                               const char *servername /* [in] [unique,charset(UTF16)] */,
15418                                               const char *architecture /* [in] [ref,charset(UTF16)] */,
15419                                               uint32_t core_driver_size /* [in]  */,
15420                                               const char *core_driver_dependencies /* [in] [ref,charset(UTF16),size_is(core_driver_size)] */,
15421                                               uint32_t core_printer_driver_count /* [in]  */,
15422                                               struct spoolss_CorePrinterDriver *core_printer_drivers /* [out] [ref,size_is(core_printer_driver_count)] */,
15423                                               WERROR *werror)
15424 {
15425         struct spoolss_GetCorePrinterDrivers r;
15426         NTSTATUS status;
15427
15428         /* In parameters */
15429         r.in.servername = servername;
15430         r.in.architecture = architecture;
15431         r.in.core_driver_size = core_driver_size;
15432         r.in.core_driver_dependencies = core_driver_dependencies;
15433         r.in.core_printer_driver_count = core_printer_driver_count;
15434
15435         status = cli->dispatch(cli,
15436                                 mem_ctx,
15437                                 &ndr_table_spoolss,
15438                                 NDR_SPOOLSS_GETCOREPRINTERDRIVERS,
15439                                 &r);
15440
15441         if (!NT_STATUS_IS_OK(status)) {
15442                 return status;
15443         }
15444
15445         if (NT_STATUS_IS_ERR(status)) {
15446                 return status;
15447         }
15448
15449         /* Return variables */
15450         memcpy(core_printer_drivers, r.out.core_printer_drivers, (r.in.core_printer_driver_count) * sizeof(*core_printer_drivers));
15451
15452         /* Return result */
15453         if (werror) {
15454                 *werror = r.out.result;
15455         }
15456
15457         return werror_to_ntstatus(r.out.result);
15458 }
15459
15460 struct rpccli_spoolss_67_state {
15461         struct spoolss_67 orig;
15462         struct spoolss_67 tmp;
15463         TALLOC_CTX *out_mem_ctx;
15464         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15465 };
15466
15467 static void rpccli_spoolss_67_done(struct tevent_req *subreq);
15468
15469 struct tevent_req *rpccli_spoolss_67_send(TALLOC_CTX *mem_ctx,
15470                                           struct tevent_context *ev,
15471                                           struct rpc_pipe_client *cli)
15472 {
15473         struct tevent_req *req;
15474         struct rpccli_spoolss_67_state *state;
15475         struct tevent_req *subreq;
15476
15477         req = tevent_req_create(mem_ctx, &state,
15478                                 struct rpccli_spoolss_67_state);
15479         if (req == NULL) {
15480                 return NULL;
15481         }
15482         state->out_mem_ctx = NULL;
15483         state->dispatch_recv = cli->dispatch_recv;
15484
15485         /* In parameters */
15486
15487         /* Out parameters */
15488
15489         /* Result */
15490         ZERO_STRUCT(state->orig.out.result);
15491
15492         /* make a temporary copy, that we pass to the dispatch function */
15493         state->tmp = state->orig;
15494
15495         subreq = cli->dispatch_send(state, ev, cli,
15496                                     &ndr_table_spoolss,
15497                                     NDR_SPOOLSS_67,
15498                                     &state->tmp);
15499         if (tevent_req_nomem(subreq, req)) {
15500                 return tevent_req_post(req, ev);
15501         }
15502         tevent_req_set_callback(subreq, rpccli_spoolss_67_done, req);
15503         return req;
15504 }
15505
15506 static void rpccli_spoolss_67_done(struct tevent_req *subreq)
15507 {
15508         struct tevent_req *req = tevent_req_callback_data(
15509                 subreq, struct tevent_req);
15510         struct rpccli_spoolss_67_state *state = tevent_req_data(
15511                 req, struct rpccli_spoolss_67_state);
15512         NTSTATUS status;
15513         TALLOC_CTX *mem_ctx;
15514
15515         if (state->out_mem_ctx) {
15516                 mem_ctx = state->out_mem_ctx;
15517         } else {
15518                 mem_ctx = state;
15519         }
15520
15521         status = state->dispatch_recv(subreq, mem_ctx);
15522         TALLOC_FREE(subreq);
15523         if (!NT_STATUS_IS_OK(status)) {
15524                 tevent_req_nterror(req, status);
15525                 return;
15526         }
15527
15528         /* Copy out parameters */
15529
15530         /* Copy result */
15531         state->orig.out.result = state->tmp.out.result;
15532
15533         /* Reset temporary structure */
15534         ZERO_STRUCT(state->tmp);
15535
15536         tevent_req_done(req);
15537 }
15538
15539 NTSTATUS rpccli_spoolss_67_recv(struct tevent_req *req,
15540                                 TALLOC_CTX *mem_ctx,
15541                                 WERROR *result)
15542 {
15543         struct rpccli_spoolss_67_state *state = tevent_req_data(
15544                 req, struct rpccli_spoolss_67_state);
15545         NTSTATUS status;
15546
15547         if (tevent_req_is_nterror(req, &status)) {
15548                 tevent_req_received(req);
15549                 return status;
15550         }
15551
15552         /* Steal possbile out parameters to the callers context */
15553         talloc_steal(mem_ctx, state->out_mem_ctx);
15554
15555         /* Return result */
15556         *result = state->orig.out.result;
15557
15558         tevent_req_received(req);
15559         return NT_STATUS_OK;
15560 }
15561
15562 NTSTATUS rpccli_spoolss_67(struct rpc_pipe_client *cli,
15563                            TALLOC_CTX *mem_ctx,
15564                            WERROR *werror)
15565 {
15566         struct spoolss_67 r;
15567         NTSTATUS status;
15568
15569         /* In parameters */
15570
15571         status = cli->dispatch(cli,
15572                                 mem_ctx,
15573                                 &ndr_table_spoolss,
15574                                 NDR_SPOOLSS_67,
15575                                 &r);
15576
15577         if (!NT_STATUS_IS_OK(status)) {
15578                 return status;
15579         }
15580
15581         if (NT_STATUS_IS_ERR(status)) {
15582                 return status;
15583         }
15584
15585         /* Return variables */
15586
15587         /* Return result */
15588         if (werror) {
15589                 *werror = r.out.result;
15590         }
15591
15592         return werror_to_ntstatus(r.out.result);
15593 }
15594
15595 struct rpccli_spoolss_GetPrinterDriverPackagePath_state {
15596         struct spoolss_GetPrinterDriverPackagePath orig;
15597         struct spoolss_GetPrinterDriverPackagePath tmp;
15598         TALLOC_CTX *out_mem_ctx;
15599         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15600 };
15601
15602 static void rpccli_spoolss_GetPrinterDriverPackagePath_done(struct tevent_req *subreq);
15603
15604 struct tevent_req *rpccli_spoolss_GetPrinterDriverPackagePath_send(TALLOC_CTX *mem_ctx,
15605                                                                    struct tevent_context *ev,
15606                                                                    struct rpc_pipe_client *cli,
15607                                                                    const char *_servername /* [in] [unique,charset(UTF16)] */,
15608                                                                    const char *_architecture /* [in] [ref,charset(UTF16)] */,
15609                                                                    const char *_language /* [in] [unique,charset(UTF16)] */,
15610                                                                    const char *_package_id /* [in] [ref,charset(UTF16)] */,
15611                                                                    const char *_driver_package_cab /* [in,out] [unique,charset(UTF16),size_is(driver_package_cab_size)] */,
15612                                                                    uint32_t _driver_package_cab_size /* [in]  */,
15613                                                                    uint32_t *_required /* [out] [ref] */)
15614 {
15615         struct tevent_req *req;
15616         struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state;
15617         struct tevent_req *subreq;
15618
15619         req = tevent_req_create(mem_ctx, &state,
15620                                 struct rpccli_spoolss_GetPrinterDriverPackagePath_state);
15621         if (req == NULL) {
15622                 return NULL;
15623         }
15624         state->out_mem_ctx = NULL;
15625         state->dispatch_recv = cli->dispatch_recv;
15626
15627         /* In parameters */
15628         state->orig.in.servername = _servername;
15629         state->orig.in.architecture = _architecture;
15630         state->orig.in.language = _language;
15631         state->orig.in.package_id = _package_id;
15632         state->orig.in.driver_package_cab = _driver_package_cab;
15633         state->orig.in.driver_package_cab_size = _driver_package_cab_size;
15634
15635         /* Out parameters */
15636         state->orig.out.driver_package_cab = _driver_package_cab;
15637         state->orig.out.required = _required;
15638
15639         /* Result */
15640         ZERO_STRUCT(state->orig.out.result);
15641
15642         state->out_mem_ctx = talloc_named_const(state, 0,
15643                              "rpccli_spoolss_GetPrinterDriverPackagePath_out_memory");
15644         if (tevent_req_nomem(state->out_mem_ctx, req)) {
15645                 return tevent_req_post(req, ev);
15646         }
15647
15648         /* make a temporary copy, that we pass to the dispatch function */
15649         state->tmp = state->orig;
15650
15651         subreq = cli->dispatch_send(state, ev, cli,
15652                                     &ndr_table_spoolss,
15653                                     NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH,
15654                                     &state->tmp);
15655         if (tevent_req_nomem(subreq, req)) {
15656                 return tevent_req_post(req, ev);
15657         }
15658         tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriverPackagePath_done, req);
15659         return req;
15660 }
15661
15662 static void rpccli_spoolss_GetPrinterDriverPackagePath_done(struct tevent_req *subreq)
15663 {
15664         struct tevent_req *req = tevent_req_callback_data(
15665                 subreq, struct tevent_req);
15666         struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state = tevent_req_data(
15667                 req, struct rpccli_spoolss_GetPrinterDriverPackagePath_state);
15668         NTSTATUS status;
15669         TALLOC_CTX *mem_ctx;
15670
15671         if (state->out_mem_ctx) {
15672                 mem_ctx = state->out_mem_ctx;
15673         } else {
15674                 mem_ctx = state;
15675         }
15676
15677         status = state->dispatch_recv(subreq, mem_ctx);
15678         TALLOC_FREE(subreq);
15679         if (!NT_STATUS_IS_OK(status)) {
15680                 tevent_req_nterror(req, status);
15681                 return;
15682         }
15683
15684         /* Copy out parameters */
15685         if (state->orig.out.driver_package_cab && state->tmp.out.driver_package_cab) {
15686                 memcpy(discard_const_p(uint8_t *, state->orig.out.driver_package_cab), state->tmp.out.driver_package_cab, (state->tmp.in.driver_package_cab_size) * sizeof(*state->orig.out.driver_package_cab));
15687         }
15688         *state->orig.out.required = *state->tmp.out.required;
15689
15690         /* Copy result */
15691         state->orig.out.result = state->tmp.out.result;
15692
15693         /* Reset temporary structure */
15694         ZERO_STRUCT(state->tmp);
15695
15696         tevent_req_done(req);
15697 }
15698
15699 NTSTATUS rpccli_spoolss_GetPrinterDriverPackagePath_recv(struct tevent_req *req,
15700                                                          TALLOC_CTX *mem_ctx,
15701                                                          WERROR *result)
15702 {
15703         struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state = tevent_req_data(
15704                 req, struct rpccli_spoolss_GetPrinterDriverPackagePath_state);
15705         NTSTATUS status;
15706
15707         if (tevent_req_is_nterror(req, &status)) {
15708                 tevent_req_received(req);
15709                 return status;
15710         }
15711
15712         /* Steal possbile out parameters to the callers context */
15713         talloc_steal(mem_ctx, state->out_mem_ctx);
15714
15715         /* Return result */
15716         *result = state->orig.out.result;
15717
15718         tevent_req_received(req);
15719         return NT_STATUS_OK;
15720 }
15721
15722 NTSTATUS rpccli_spoolss_GetPrinterDriverPackagePath(struct rpc_pipe_client *cli,
15723                                                     TALLOC_CTX *mem_ctx,
15724                                                     const char *servername /* [in] [unique,charset(UTF16)] */,
15725                                                     const char *architecture /* [in] [ref,charset(UTF16)] */,
15726                                                     const char *language /* [in] [unique,charset(UTF16)] */,
15727                                                     const char *package_id /* [in] [ref,charset(UTF16)] */,
15728                                                     const char *driver_package_cab /* [in,out] [unique,charset(UTF16),size_is(driver_package_cab_size)] */,
15729                                                     uint32_t driver_package_cab_size /* [in]  */,
15730                                                     uint32_t *required /* [out] [ref] */,
15731                                                     WERROR *werror)
15732 {
15733         struct spoolss_GetPrinterDriverPackagePath r;
15734         NTSTATUS status;
15735
15736         /* In parameters */
15737         r.in.servername = servername;
15738         r.in.architecture = architecture;
15739         r.in.language = language;
15740         r.in.package_id = package_id;
15741         r.in.driver_package_cab = driver_package_cab;
15742         r.in.driver_package_cab_size = driver_package_cab_size;
15743
15744         status = cli->dispatch(cli,
15745                                 mem_ctx,
15746                                 &ndr_table_spoolss,
15747                                 NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH,
15748                                 &r);
15749
15750         if (!NT_STATUS_IS_OK(status)) {
15751                 return status;
15752         }
15753
15754         if (NT_STATUS_IS_ERR(status)) {
15755                 return status;
15756         }
15757
15758         /* Return variables */
15759         if (driver_package_cab && r.out.driver_package_cab) {
15760                 memcpy(discard_const_p(uint8_t *, driver_package_cab), r.out.driver_package_cab, (r.in.driver_package_cab_size) * sizeof(*driver_package_cab));
15761         }
15762         *required = *r.out.required;
15763
15764         /* Return result */
15765         if (werror) {
15766                 *werror = r.out.result;
15767         }
15768
15769         return werror_to_ntstatus(r.out.result);
15770 }
15771
15772 struct rpccli_spoolss_69_state {
15773         struct spoolss_69 orig;
15774         struct spoolss_69 tmp;
15775         TALLOC_CTX *out_mem_ctx;
15776         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15777 };
15778
15779 static void rpccli_spoolss_69_done(struct tevent_req *subreq);
15780
15781 struct tevent_req *rpccli_spoolss_69_send(TALLOC_CTX *mem_ctx,
15782                                           struct tevent_context *ev,
15783                                           struct rpc_pipe_client *cli)
15784 {
15785         struct tevent_req *req;
15786         struct rpccli_spoolss_69_state *state;
15787         struct tevent_req *subreq;
15788
15789         req = tevent_req_create(mem_ctx, &state,
15790                                 struct rpccli_spoolss_69_state);
15791         if (req == NULL) {
15792                 return NULL;
15793         }
15794         state->out_mem_ctx = NULL;
15795         state->dispatch_recv = cli->dispatch_recv;
15796
15797         /* In parameters */
15798
15799         /* Out parameters */
15800
15801         /* Result */
15802         ZERO_STRUCT(state->orig.out.result);
15803
15804         /* make a temporary copy, that we pass to the dispatch function */
15805         state->tmp = state->orig;
15806
15807         subreq = cli->dispatch_send(state, ev, cli,
15808                                     &ndr_table_spoolss,
15809                                     NDR_SPOOLSS_69,
15810                                     &state->tmp);
15811         if (tevent_req_nomem(subreq, req)) {
15812                 return tevent_req_post(req, ev);
15813         }
15814         tevent_req_set_callback(subreq, rpccli_spoolss_69_done, req);
15815         return req;
15816 }
15817
15818 static void rpccli_spoolss_69_done(struct tevent_req *subreq)
15819 {
15820         struct tevent_req *req = tevent_req_callback_data(
15821                 subreq, struct tevent_req);
15822         struct rpccli_spoolss_69_state *state = tevent_req_data(
15823                 req, struct rpccli_spoolss_69_state);
15824         NTSTATUS status;
15825         TALLOC_CTX *mem_ctx;
15826
15827         if (state->out_mem_ctx) {
15828                 mem_ctx = state->out_mem_ctx;
15829         } else {
15830                 mem_ctx = state;
15831         }
15832
15833         status = state->dispatch_recv(subreq, mem_ctx);
15834         TALLOC_FREE(subreq);
15835         if (!NT_STATUS_IS_OK(status)) {
15836                 tevent_req_nterror(req, status);
15837                 return;
15838         }
15839
15840         /* Copy out parameters */
15841
15842         /* Copy result */
15843         state->orig.out.result = state->tmp.out.result;
15844
15845         /* Reset temporary structure */
15846         ZERO_STRUCT(state->tmp);
15847
15848         tevent_req_done(req);
15849 }
15850
15851 NTSTATUS rpccli_spoolss_69_recv(struct tevent_req *req,
15852                                 TALLOC_CTX *mem_ctx,
15853                                 WERROR *result)
15854 {
15855         struct rpccli_spoolss_69_state *state = tevent_req_data(
15856                 req, struct rpccli_spoolss_69_state);
15857         NTSTATUS status;
15858
15859         if (tevent_req_is_nterror(req, &status)) {
15860                 tevent_req_received(req);
15861                 return status;
15862         }
15863
15864         /* Steal possbile out parameters to the callers context */
15865         talloc_steal(mem_ctx, state->out_mem_ctx);
15866
15867         /* Return result */
15868         *result = state->orig.out.result;
15869
15870         tevent_req_received(req);
15871         return NT_STATUS_OK;
15872 }
15873
15874 NTSTATUS rpccli_spoolss_69(struct rpc_pipe_client *cli,
15875                            TALLOC_CTX *mem_ctx,
15876                            WERROR *werror)
15877 {
15878         struct spoolss_69 r;
15879         NTSTATUS status;
15880
15881         /* In parameters */
15882
15883         status = cli->dispatch(cli,
15884                                 mem_ctx,
15885                                 &ndr_table_spoolss,
15886                                 NDR_SPOOLSS_69,
15887                                 &r);
15888
15889         if (!NT_STATUS_IS_OK(status)) {
15890                 return status;
15891         }
15892
15893         if (NT_STATUS_IS_ERR(status)) {
15894                 return status;
15895         }
15896
15897         /* Return variables */
15898
15899         /* Return result */
15900         if (werror) {
15901                 *werror = r.out.result;
15902         }
15903
15904         return werror_to_ntstatus(r.out.result);
15905 }
15906
15907 struct rpccli_spoolss_6a_state {
15908         struct spoolss_6a orig;
15909         struct spoolss_6a tmp;
15910         TALLOC_CTX *out_mem_ctx;
15911         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15912 };
15913
15914 static void rpccli_spoolss_6a_done(struct tevent_req *subreq);
15915
15916 struct tevent_req *rpccli_spoolss_6a_send(TALLOC_CTX *mem_ctx,
15917                                           struct tevent_context *ev,
15918                                           struct rpc_pipe_client *cli)
15919 {
15920         struct tevent_req *req;
15921         struct rpccli_spoolss_6a_state *state;
15922         struct tevent_req *subreq;
15923
15924         req = tevent_req_create(mem_ctx, &state,
15925                                 struct rpccli_spoolss_6a_state);
15926         if (req == NULL) {
15927                 return NULL;
15928         }
15929         state->out_mem_ctx = NULL;
15930         state->dispatch_recv = cli->dispatch_recv;
15931
15932         /* In parameters */
15933
15934         /* Out parameters */
15935
15936         /* Result */
15937         ZERO_STRUCT(state->orig.out.result);
15938
15939         /* make a temporary copy, that we pass to the dispatch function */
15940         state->tmp = state->orig;
15941
15942         subreq = cli->dispatch_send(state, ev, cli,
15943                                     &ndr_table_spoolss,
15944                                     NDR_SPOOLSS_6A,
15945                                     &state->tmp);
15946         if (tevent_req_nomem(subreq, req)) {
15947                 return tevent_req_post(req, ev);
15948         }
15949         tevent_req_set_callback(subreq, rpccli_spoolss_6a_done, req);
15950         return req;
15951 }
15952
15953 static void rpccli_spoolss_6a_done(struct tevent_req *subreq)
15954 {
15955         struct tevent_req *req = tevent_req_callback_data(
15956                 subreq, struct tevent_req);
15957         struct rpccli_spoolss_6a_state *state = tevent_req_data(
15958                 req, struct rpccli_spoolss_6a_state);
15959         NTSTATUS status;
15960         TALLOC_CTX *mem_ctx;
15961
15962         if (state->out_mem_ctx) {
15963                 mem_ctx = state->out_mem_ctx;
15964         } else {
15965                 mem_ctx = state;
15966         }
15967
15968         status = state->dispatch_recv(subreq, mem_ctx);
15969         TALLOC_FREE(subreq);
15970         if (!NT_STATUS_IS_OK(status)) {
15971                 tevent_req_nterror(req, status);
15972                 return;
15973         }
15974
15975         /* Copy out parameters */
15976
15977         /* Copy result */
15978         state->orig.out.result = state->tmp.out.result;
15979
15980         /* Reset temporary structure */
15981         ZERO_STRUCT(state->tmp);
15982
15983         tevent_req_done(req);
15984 }
15985
15986 NTSTATUS rpccli_spoolss_6a_recv(struct tevent_req *req,
15987                                 TALLOC_CTX *mem_ctx,
15988                                 WERROR *result)
15989 {
15990         struct rpccli_spoolss_6a_state *state = tevent_req_data(
15991                 req, struct rpccli_spoolss_6a_state);
15992         NTSTATUS status;
15993
15994         if (tevent_req_is_nterror(req, &status)) {
15995                 tevent_req_received(req);
15996                 return status;
15997         }
15998
15999         /* Steal possbile out parameters to the callers context */
16000         talloc_steal(mem_ctx, state->out_mem_ctx);
16001
16002         /* Return result */
16003         *result = state->orig.out.result;
16004
16005         tevent_req_received(req);
16006         return NT_STATUS_OK;
16007 }
16008
16009 NTSTATUS rpccli_spoolss_6a(struct rpc_pipe_client *cli,
16010                            TALLOC_CTX *mem_ctx,
16011                            WERROR *werror)
16012 {
16013         struct spoolss_6a r;
16014         NTSTATUS status;
16015
16016         /* In parameters */
16017
16018         status = cli->dispatch(cli,
16019                                 mem_ctx,
16020                                 &ndr_table_spoolss,
16021                                 NDR_SPOOLSS_6A,
16022                                 &r);
16023
16024         if (!NT_STATUS_IS_OK(status)) {
16025                 return status;
16026         }
16027
16028         if (NT_STATUS_IS_ERR(status)) {
16029                 return status;
16030         }
16031
16032         /* Return variables */
16033
16034         /* Return result */
16035         if (werror) {
16036                 *werror = r.out.result;
16037         }
16038
16039         return werror_to_ntstatus(r.out.result);
16040 }
16041
16042 struct rpccli_spoolss_6b_state {
16043         struct spoolss_6b orig;
16044         struct spoolss_6b tmp;
16045         TALLOC_CTX *out_mem_ctx;
16046         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16047 };
16048
16049 static void rpccli_spoolss_6b_done(struct tevent_req *subreq);
16050
16051 struct tevent_req *rpccli_spoolss_6b_send(TALLOC_CTX *mem_ctx,
16052                                           struct tevent_context *ev,
16053                                           struct rpc_pipe_client *cli)
16054 {
16055         struct tevent_req *req;
16056         struct rpccli_spoolss_6b_state *state;
16057         struct tevent_req *subreq;
16058
16059         req = tevent_req_create(mem_ctx, &state,
16060                                 struct rpccli_spoolss_6b_state);
16061         if (req == NULL) {
16062                 return NULL;
16063         }
16064         state->out_mem_ctx = NULL;
16065         state->dispatch_recv = cli->dispatch_recv;
16066
16067         /* In parameters */
16068
16069         /* Out parameters */
16070
16071         /* Result */
16072         ZERO_STRUCT(state->orig.out.result);
16073
16074         /* make a temporary copy, that we pass to the dispatch function */
16075         state->tmp = state->orig;
16076
16077         subreq = cli->dispatch_send(state, ev, cli,
16078                                     &ndr_table_spoolss,
16079                                     NDR_SPOOLSS_6B,
16080                                     &state->tmp);
16081         if (tevent_req_nomem(subreq, req)) {
16082                 return tevent_req_post(req, ev);
16083         }
16084         tevent_req_set_callback(subreq, rpccli_spoolss_6b_done, req);
16085         return req;
16086 }
16087
16088 static void rpccli_spoolss_6b_done(struct tevent_req *subreq)
16089 {
16090         struct tevent_req *req = tevent_req_callback_data(
16091                 subreq, struct tevent_req);
16092         struct rpccli_spoolss_6b_state *state = tevent_req_data(
16093                 req, struct rpccli_spoolss_6b_state);
16094         NTSTATUS status;
16095         TALLOC_CTX *mem_ctx;
16096
16097         if (state->out_mem_ctx) {
16098                 mem_ctx = state->out_mem_ctx;
16099         } else {
16100                 mem_ctx = state;
16101         }
16102
16103         status = state->dispatch_recv(subreq, mem_ctx);
16104         TALLOC_FREE(subreq);
16105         if (!NT_STATUS_IS_OK(status)) {
16106                 tevent_req_nterror(req, status);
16107                 return;
16108         }
16109
16110         /* Copy out parameters */
16111
16112         /* Copy result */
16113         state->orig.out.result = state->tmp.out.result;
16114
16115         /* Reset temporary structure */
16116         ZERO_STRUCT(state->tmp);
16117
16118         tevent_req_done(req);
16119 }
16120
16121 NTSTATUS rpccli_spoolss_6b_recv(struct tevent_req *req,
16122                                 TALLOC_CTX *mem_ctx,
16123                                 WERROR *result)
16124 {
16125         struct rpccli_spoolss_6b_state *state = tevent_req_data(
16126                 req, struct rpccli_spoolss_6b_state);
16127         NTSTATUS status;
16128
16129         if (tevent_req_is_nterror(req, &status)) {
16130                 tevent_req_received(req);
16131                 return status;
16132         }
16133
16134         /* Steal possbile out parameters to the callers context */
16135         talloc_steal(mem_ctx, state->out_mem_ctx);
16136
16137         /* Return result */
16138         *result = state->orig.out.result;
16139
16140         tevent_req_received(req);
16141         return NT_STATUS_OK;
16142 }
16143
16144 NTSTATUS rpccli_spoolss_6b(struct rpc_pipe_client *cli,
16145                            TALLOC_CTX *mem_ctx,
16146                            WERROR *werror)
16147 {
16148         struct spoolss_6b r;
16149         NTSTATUS status;
16150
16151         /* In parameters */
16152
16153         status = cli->dispatch(cli,
16154                                 mem_ctx,
16155                                 &ndr_table_spoolss,
16156                                 NDR_SPOOLSS_6B,
16157                                 &r);
16158
16159         if (!NT_STATUS_IS_OK(status)) {
16160                 return status;
16161         }
16162
16163         if (NT_STATUS_IS_ERR(status)) {
16164                 return status;
16165         }
16166
16167         /* Return variables */
16168
16169         /* Return result */
16170         if (werror) {
16171                 *werror = r.out.result;
16172         }
16173
16174         return werror_to_ntstatus(r.out.result);
16175 }
16176
16177 struct rpccli_spoolss_6c_state {
16178         struct spoolss_6c orig;
16179         struct spoolss_6c tmp;
16180         TALLOC_CTX *out_mem_ctx;
16181         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16182 };
16183
16184 static void rpccli_spoolss_6c_done(struct tevent_req *subreq);
16185
16186 struct tevent_req *rpccli_spoolss_6c_send(TALLOC_CTX *mem_ctx,
16187                                           struct tevent_context *ev,
16188                                           struct rpc_pipe_client *cli)
16189 {
16190         struct tevent_req *req;
16191         struct rpccli_spoolss_6c_state *state;
16192         struct tevent_req *subreq;
16193
16194         req = tevent_req_create(mem_ctx, &state,
16195                                 struct rpccli_spoolss_6c_state);
16196         if (req == NULL) {
16197                 return NULL;
16198         }
16199         state->out_mem_ctx = NULL;
16200         state->dispatch_recv = cli->dispatch_recv;
16201
16202         /* In parameters */
16203
16204         /* Out parameters */
16205
16206         /* Result */
16207         ZERO_STRUCT(state->orig.out.result);
16208
16209         /* make a temporary copy, that we pass to the dispatch function */
16210         state->tmp = state->orig;
16211
16212         subreq = cli->dispatch_send(state, ev, cli,
16213                                     &ndr_table_spoolss,
16214                                     NDR_SPOOLSS_6C,
16215                                     &state->tmp);
16216         if (tevent_req_nomem(subreq, req)) {
16217                 return tevent_req_post(req, ev);
16218         }
16219         tevent_req_set_callback(subreq, rpccli_spoolss_6c_done, req);
16220         return req;
16221 }
16222
16223 static void rpccli_spoolss_6c_done(struct tevent_req *subreq)
16224 {
16225         struct tevent_req *req = tevent_req_callback_data(
16226                 subreq, struct tevent_req);
16227         struct rpccli_spoolss_6c_state *state = tevent_req_data(
16228                 req, struct rpccli_spoolss_6c_state);
16229         NTSTATUS status;
16230         TALLOC_CTX *mem_ctx;
16231
16232         if (state->out_mem_ctx) {
16233                 mem_ctx = state->out_mem_ctx;
16234         } else {
16235                 mem_ctx = state;
16236         }
16237
16238         status = state->dispatch_recv(subreq, mem_ctx);
16239         TALLOC_FREE(subreq);
16240         if (!NT_STATUS_IS_OK(status)) {
16241                 tevent_req_nterror(req, status);
16242                 return;
16243         }
16244
16245         /* Copy out parameters */
16246
16247         /* Copy result */
16248         state->orig.out.result = state->tmp.out.result;
16249
16250         /* Reset temporary structure */
16251         ZERO_STRUCT(state->tmp);
16252
16253         tevent_req_done(req);
16254 }
16255
16256 NTSTATUS rpccli_spoolss_6c_recv(struct tevent_req *req,
16257                                 TALLOC_CTX *mem_ctx,
16258                                 WERROR *result)
16259 {
16260         struct rpccli_spoolss_6c_state *state = tevent_req_data(
16261                 req, struct rpccli_spoolss_6c_state);
16262         NTSTATUS status;
16263
16264         if (tevent_req_is_nterror(req, &status)) {
16265                 tevent_req_received(req);
16266                 return status;
16267         }
16268
16269         /* Steal possbile out parameters to the callers context */
16270         talloc_steal(mem_ctx, state->out_mem_ctx);
16271
16272         /* Return result */
16273         *result = state->orig.out.result;
16274
16275         tevent_req_received(req);
16276         return NT_STATUS_OK;
16277 }
16278
16279 NTSTATUS rpccli_spoolss_6c(struct rpc_pipe_client *cli,
16280                            TALLOC_CTX *mem_ctx,
16281                            WERROR *werror)
16282 {
16283         struct spoolss_6c r;
16284         NTSTATUS status;
16285
16286         /* In parameters */
16287
16288         status = cli->dispatch(cli,
16289                                 mem_ctx,
16290                                 &ndr_table_spoolss,
16291                                 NDR_SPOOLSS_6C,
16292                                 &r);
16293
16294         if (!NT_STATUS_IS_OK(status)) {
16295                 return status;
16296         }
16297
16298         if (NT_STATUS_IS_ERR(status)) {
16299                 return status;
16300         }
16301
16302         /* Return variables */
16303
16304         /* Return result */
16305         if (werror) {
16306                 *werror = r.out.result;
16307         }
16308
16309         return werror_to_ntstatus(r.out.result);
16310 }
16311
16312 struct rpccli_spoolss_6d_state {
16313         struct spoolss_6d orig;
16314         struct spoolss_6d tmp;
16315         TALLOC_CTX *out_mem_ctx;
16316         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16317 };
16318
16319 static void rpccli_spoolss_6d_done(struct tevent_req *subreq);
16320
16321 struct tevent_req *rpccli_spoolss_6d_send(TALLOC_CTX *mem_ctx,
16322                                           struct tevent_context *ev,
16323                                           struct rpc_pipe_client *cli)
16324 {
16325         struct tevent_req *req;
16326         struct rpccli_spoolss_6d_state *state;
16327         struct tevent_req *subreq;
16328
16329         req = tevent_req_create(mem_ctx, &state,
16330                                 struct rpccli_spoolss_6d_state);
16331         if (req == NULL) {
16332                 return NULL;
16333         }
16334         state->out_mem_ctx = NULL;
16335         state->dispatch_recv = cli->dispatch_recv;
16336
16337         /* In parameters */
16338
16339         /* Out parameters */
16340
16341         /* Result */
16342         ZERO_STRUCT(state->orig.out.result);
16343
16344         /* make a temporary copy, that we pass to the dispatch function */
16345         state->tmp = state->orig;
16346
16347         subreq = cli->dispatch_send(state, ev, cli,
16348                                     &ndr_table_spoolss,
16349                                     NDR_SPOOLSS_6D,
16350                                     &state->tmp);
16351         if (tevent_req_nomem(subreq, req)) {
16352                 return tevent_req_post(req, ev);
16353         }
16354         tevent_req_set_callback(subreq, rpccli_spoolss_6d_done, req);
16355         return req;
16356 }
16357
16358 static void rpccli_spoolss_6d_done(struct tevent_req *subreq)
16359 {
16360         struct tevent_req *req = tevent_req_callback_data(
16361                 subreq, struct tevent_req);
16362         struct rpccli_spoolss_6d_state *state = tevent_req_data(
16363                 req, struct rpccli_spoolss_6d_state);
16364         NTSTATUS status;
16365         TALLOC_CTX *mem_ctx;
16366
16367         if (state->out_mem_ctx) {
16368                 mem_ctx = state->out_mem_ctx;
16369         } else {
16370                 mem_ctx = state;
16371         }
16372
16373         status = state->dispatch_recv(subreq, mem_ctx);
16374         TALLOC_FREE(subreq);
16375         if (!NT_STATUS_IS_OK(status)) {
16376                 tevent_req_nterror(req, status);
16377                 return;
16378         }
16379
16380         /* Copy out parameters */
16381
16382         /* Copy result */
16383         state->orig.out.result = state->tmp.out.result;
16384
16385         /* Reset temporary structure */
16386         ZERO_STRUCT(state->tmp);
16387
16388         tevent_req_done(req);
16389 }
16390
16391 NTSTATUS rpccli_spoolss_6d_recv(struct tevent_req *req,
16392                                 TALLOC_CTX *mem_ctx,
16393                                 WERROR *result)
16394 {
16395         struct rpccli_spoolss_6d_state *state = tevent_req_data(
16396                 req, struct rpccli_spoolss_6d_state);
16397         NTSTATUS status;
16398
16399         if (tevent_req_is_nterror(req, &status)) {
16400                 tevent_req_received(req);
16401                 return status;
16402         }
16403
16404         /* Steal possbile out parameters to the callers context */
16405         talloc_steal(mem_ctx, state->out_mem_ctx);
16406
16407         /* Return result */
16408         *result = state->orig.out.result;
16409
16410         tevent_req_received(req);
16411         return NT_STATUS_OK;
16412 }
16413
16414 NTSTATUS rpccli_spoolss_6d(struct rpc_pipe_client *cli,
16415                            TALLOC_CTX *mem_ctx,
16416                            WERROR *werror)
16417 {
16418         struct spoolss_6d r;
16419         NTSTATUS status;
16420
16421         /* In parameters */
16422
16423         status = cli->dispatch(cli,
16424                                 mem_ctx,
16425                                 &ndr_table_spoolss,
16426                                 NDR_SPOOLSS_6D,
16427                                 &r);
16428
16429         if (!NT_STATUS_IS_OK(status)) {
16430                 return status;
16431         }
16432
16433         if (NT_STATUS_IS_ERR(status)) {
16434                 return status;
16435         }
16436
16437         /* Return variables */
16438
16439         /* Return result */
16440         if (werror) {
16441                 *werror = r.out.result;
16442         }
16443
16444         return werror_to_ntstatus(r.out.result);
16445 }
16446