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                                                       uint32_t _offered /* [in]  */,
4156                                                       enum winreg_Type *_type /* [out] [ref] */,
4157                                                       union spoolss_PrinterData *_data /* [out] [subcontext_size(offered),ref,subcontext(4),switch_is(*type)] */,
4158                                                       uint32_t *_needed /* [out] [ref] */)
4159 {
4160         struct tevent_req *req;
4161         struct rpccli_spoolss_GetPrinterData_state *state;
4162         struct tevent_req *subreq;
4163
4164         req = tevent_req_create(mem_ctx, &state,
4165                                 struct rpccli_spoolss_GetPrinterData_state);
4166         if (req == NULL) {
4167                 return NULL;
4168         }
4169         state->out_mem_ctx = NULL;
4170         state->dispatch_recv = cli->dispatch_recv;
4171
4172         /* In parameters */
4173         state->orig.in.handle = _handle;
4174         state->orig.in.value_name = _value_name;
4175         state->orig.in.offered = _offered;
4176
4177         /* Out parameters */
4178         state->orig.out.type = _type;
4179         state->orig.out.data = _data;
4180         state->orig.out.needed = _needed;
4181
4182         /* Result */
4183         ZERO_STRUCT(state->orig.out.result);
4184
4185         state->out_mem_ctx = talloc_named_const(state, 0,
4186                              "rpccli_spoolss_GetPrinterData_out_memory");
4187         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4188                 return tevent_req_post(req, ev);
4189         }
4190
4191         /* make a temporary copy, that we pass to the dispatch function */
4192         state->tmp = state->orig;
4193
4194         subreq = cli->dispatch_send(state, ev, cli,
4195                                     &ndr_table_spoolss,
4196                                     NDR_SPOOLSS_GETPRINTERDATA,
4197                                     &state->tmp);
4198         if (tevent_req_nomem(subreq, req)) {
4199                 return tevent_req_post(req, ev);
4200         }
4201         tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterData_done, req);
4202         return req;
4203 }
4204
4205 static void rpccli_spoolss_GetPrinterData_done(struct tevent_req *subreq)
4206 {
4207         struct tevent_req *req = tevent_req_callback_data(
4208                 subreq, struct tevent_req);
4209         struct rpccli_spoolss_GetPrinterData_state *state = tevent_req_data(
4210                 req, struct rpccli_spoolss_GetPrinterData_state);
4211         NTSTATUS status;
4212         TALLOC_CTX *mem_ctx;
4213
4214         if (state->out_mem_ctx) {
4215                 mem_ctx = state->out_mem_ctx;
4216         } else {
4217                 mem_ctx = state;
4218         }
4219
4220         status = state->dispatch_recv(subreq, mem_ctx);
4221         TALLOC_FREE(subreq);
4222         if (!NT_STATUS_IS_OK(status)) {
4223                 tevent_req_nterror(req, status);
4224                 return;
4225         }
4226
4227         /* Copy out parameters */
4228         *state->orig.out.type = *state->tmp.out.type;
4229         *state->orig.out.data = *state->tmp.out.data;
4230         *state->orig.out.needed = *state->tmp.out.needed;
4231
4232         /* Copy result */
4233         state->orig.out.result = state->tmp.out.result;
4234
4235         /* Reset temporary structure */
4236         ZERO_STRUCT(state->tmp);
4237
4238         tevent_req_done(req);
4239 }
4240
4241 NTSTATUS rpccli_spoolss_GetPrinterData_recv(struct tevent_req *req,
4242                                             TALLOC_CTX *mem_ctx,
4243                                             WERROR *result)
4244 {
4245         struct rpccli_spoolss_GetPrinterData_state *state = tevent_req_data(
4246                 req, struct rpccli_spoolss_GetPrinterData_state);
4247         NTSTATUS status;
4248
4249         if (tevent_req_is_nterror(req, &status)) {
4250                 tevent_req_received(req);
4251                 return status;
4252         }
4253
4254         /* Steal possbile out parameters to the callers context */
4255         talloc_steal(mem_ctx, state->out_mem_ctx);
4256
4257         /* Return result */
4258         *result = state->orig.out.result;
4259
4260         tevent_req_received(req);
4261         return NT_STATUS_OK;
4262 }
4263
4264 NTSTATUS rpccli_spoolss_GetPrinterData(struct rpc_pipe_client *cli,
4265                                        TALLOC_CTX *mem_ctx,
4266                                        struct policy_handle *handle /* [in] [ref] */,
4267                                        const char *value_name /* [in] [charset(UTF16)] */,
4268                                        uint32_t offered /* [in]  */,
4269                                        enum winreg_Type *type /* [out] [ref] */,
4270                                        union spoolss_PrinterData *data /* [out] [subcontext_size(offered),ref,subcontext(4),switch_is(*type)] */,
4271                                        uint32_t *needed /* [out] [ref] */,
4272                                        WERROR *werror)
4273 {
4274         struct spoolss_GetPrinterData r;
4275         NTSTATUS status;
4276
4277         /* In parameters */
4278         r.in.handle = handle;
4279         r.in.value_name = value_name;
4280         r.in.offered = offered;
4281
4282         status = cli->dispatch(cli,
4283                                 mem_ctx,
4284                                 &ndr_table_spoolss,
4285                                 NDR_SPOOLSS_GETPRINTERDATA,
4286                                 &r);
4287
4288         if (!NT_STATUS_IS_OK(status)) {
4289                 return status;
4290         }
4291
4292         if (NT_STATUS_IS_ERR(status)) {
4293                 return status;
4294         }
4295
4296         /* Return variables */
4297         *type = *r.out.type;
4298         *data = *r.out.data;
4299         *needed = *r.out.needed;
4300
4301         /* Return result */
4302         if (werror) {
4303                 *werror = r.out.result;
4304         }
4305
4306         return werror_to_ntstatus(r.out.result);
4307 }
4308
4309 struct rpccli_spoolss_SetPrinterData_state {
4310         struct spoolss_SetPrinterData orig;
4311         struct spoolss_SetPrinterData tmp;
4312         TALLOC_CTX *out_mem_ctx;
4313         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4314 };
4315
4316 static void rpccli_spoolss_SetPrinterData_done(struct tevent_req *subreq);
4317
4318 struct tevent_req *rpccli_spoolss_SetPrinterData_send(TALLOC_CTX *mem_ctx,
4319                                                       struct tevent_context *ev,
4320                                                       struct rpc_pipe_client *cli,
4321                                                       struct policy_handle *_handle /* [in] [ref] */,
4322                                                       const char *_value_name /* [in] [charset(UTF16)] */,
4323                                                       enum winreg_Type _type /* [in]  */,
4324                                                       union spoolss_PrinterData _data /* [in] [subcontext(4),switch_is(type)] */,
4325                                                       uint32_t __offered /* [in] [value(ndr_size_spoolss_PrinterData(&data,type,ndr->iconv_convenience,flags))] */)
4326 {
4327         struct tevent_req *req;
4328         struct rpccli_spoolss_SetPrinterData_state *state;
4329         struct tevent_req *subreq;
4330
4331         req = tevent_req_create(mem_ctx, &state,
4332                                 struct rpccli_spoolss_SetPrinterData_state);
4333         if (req == NULL) {
4334                 return NULL;
4335         }
4336         state->out_mem_ctx = NULL;
4337         state->dispatch_recv = cli->dispatch_recv;
4338
4339         /* In parameters */
4340         state->orig.in.handle = _handle;
4341         state->orig.in.value_name = _value_name;
4342         state->orig.in.type = _type;
4343         state->orig.in.data = _data;
4344         state->orig.in._offered = __offered;
4345
4346         /* Out parameters */
4347
4348         /* Result */
4349         ZERO_STRUCT(state->orig.out.result);
4350
4351         /* make a temporary copy, that we pass to the dispatch function */
4352         state->tmp = state->orig;
4353
4354         subreq = cli->dispatch_send(state, ev, cli,
4355                                     &ndr_table_spoolss,
4356                                     NDR_SPOOLSS_SETPRINTERDATA,
4357                                     &state->tmp);
4358         if (tevent_req_nomem(subreq, req)) {
4359                 return tevent_req_post(req, ev);
4360         }
4361         tevent_req_set_callback(subreq, rpccli_spoolss_SetPrinterData_done, req);
4362         return req;
4363 }
4364
4365 static void rpccli_spoolss_SetPrinterData_done(struct tevent_req *subreq)
4366 {
4367         struct tevent_req *req = tevent_req_callback_data(
4368                 subreq, struct tevent_req);
4369         struct rpccli_spoolss_SetPrinterData_state *state = tevent_req_data(
4370                 req, struct rpccli_spoolss_SetPrinterData_state);
4371         NTSTATUS status;
4372         TALLOC_CTX *mem_ctx;
4373
4374         if (state->out_mem_ctx) {
4375                 mem_ctx = state->out_mem_ctx;
4376         } else {
4377                 mem_ctx = state;
4378         }
4379
4380         status = state->dispatch_recv(subreq, mem_ctx);
4381         TALLOC_FREE(subreq);
4382         if (!NT_STATUS_IS_OK(status)) {
4383                 tevent_req_nterror(req, status);
4384                 return;
4385         }
4386
4387         /* Copy out parameters */
4388
4389         /* Copy result */
4390         state->orig.out.result = state->tmp.out.result;
4391
4392         /* Reset temporary structure */
4393         ZERO_STRUCT(state->tmp);
4394
4395         tevent_req_done(req);
4396 }
4397
4398 NTSTATUS rpccli_spoolss_SetPrinterData_recv(struct tevent_req *req,
4399                                             TALLOC_CTX *mem_ctx,
4400                                             WERROR *result)
4401 {
4402         struct rpccli_spoolss_SetPrinterData_state *state = tevent_req_data(
4403                 req, struct rpccli_spoolss_SetPrinterData_state);
4404         NTSTATUS status;
4405
4406         if (tevent_req_is_nterror(req, &status)) {
4407                 tevent_req_received(req);
4408                 return status;
4409         }
4410
4411         /* Steal possbile out parameters to the callers context */
4412         talloc_steal(mem_ctx, state->out_mem_ctx);
4413
4414         /* Return result */
4415         *result = state->orig.out.result;
4416
4417         tevent_req_received(req);
4418         return NT_STATUS_OK;
4419 }
4420
4421 NTSTATUS rpccli_spoolss_SetPrinterData(struct rpc_pipe_client *cli,
4422                                        TALLOC_CTX *mem_ctx,
4423                                        struct policy_handle *handle /* [in] [ref] */,
4424                                        const char *value_name /* [in] [charset(UTF16)] */,
4425                                        enum winreg_Type type /* [in]  */,
4426                                        union spoolss_PrinterData data /* [in] [subcontext(4),switch_is(type)] */,
4427                                        uint32_t _offered /* [in] [value(ndr_size_spoolss_PrinterData(&data,type,ndr->iconv_convenience,flags))] */,
4428                                        WERROR *werror)
4429 {
4430         struct spoolss_SetPrinterData r;
4431         NTSTATUS status;
4432
4433         /* In parameters */
4434         r.in.handle = handle;
4435         r.in.value_name = value_name;
4436         r.in.type = type;
4437         r.in.data = data;
4438         r.in._offered = _offered;
4439
4440         status = cli->dispatch(cli,
4441                                 mem_ctx,
4442                                 &ndr_table_spoolss,
4443                                 NDR_SPOOLSS_SETPRINTERDATA,
4444                                 &r);
4445
4446         if (!NT_STATUS_IS_OK(status)) {
4447                 return status;
4448         }
4449
4450         if (NT_STATUS_IS_ERR(status)) {
4451                 return status;
4452         }
4453
4454         /* Return variables */
4455
4456         /* Return result */
4457         if (werror) {
4458                 *werror = r.out.result;
4459         }
4460
4461         return werror_to_ntstatus(r.out.result);
4462 }
4463
4464 struct rpccli_spoolss_WaitForPrinterChange_state {
4465         struct spoolss_WaitForPrinterChange orig;
4466         struct spoolss_WaitForPrinterChange tmp;
4467         TALLOC_CTX *out_mem_ctx;
4468         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4469 };
4470
4471 static void rpccli_spoolss_WaitForPrinterChange_done(struct tevent_req *subreq);
4472
4473 struct tevent_req *rpccli_spoolss_WaitForPrinterChange_send(TALLOC_CTX *mem_ctx,
4474                                                             struct tevent_context *ev,
4475                                                             struct rpc_pipe_client *cli)
4476 {
4477         struct tevent_req *req;
4478         struct rpccli_spoolss_WaitForPrinterChange_state *state;
4479         struct tevent_req *subreq;
4480
4481         req = tevent_req_create(mem_ctx, &state,
4482                                 struct rpccli_spoolss_WaitForPrinterChange_state);
4483         if (req == NULL) {
4484                 return NULL;
4485         }
4486         state->out_mem_ctx = NULL;
4487         state->dispatch_recv = cli->dispatch_recv;
4488
4489         /* In parameters */
4490
4491         /* Out parameters */
4492
4493         /* Result */
4494         ZERO_STRUCT(state->orig.out.result);
4495
4496         /* make a temporary copy, that we pass to the dispatch function */
4497         state->tmp = state->orig;
4498
4499         subreq = cli->dispatch_send(state, ev, cli,
4500                                     &ndr_table_spoolss,
4501                                     NDR_SPOOLSS_WAITFORPRINTERCHANGE,
4502                                     &state->tmp);
4503         if (tevent_req_nomem(subreq, req)) {
4504                 return tevent_req_post(req, ev);
4505         }
4506         tevent_req_set_callback(subreq, rpccli_spoolss_WaitForPrinterChange_done, req);
4507         return req;
4508 }
4509
4510 static void rpccli_spoolss_WaitForPrinterChange_done(struct tevent_req *subreq)
4511 {
4512         struct tevent_req *req = tevent_req_callback_data(
4513                 subreq, struct tevent_req);
4514         struct rpccli_spoolss_WaitForPrinterChange_state *state = tevent_req_data(
4515                 req, struct rpccli_spoolss_WaitForPrinterChange_state);
4516         NTSTATUS status;
4517         TALLOC_CTX *mem_ctx;
4518
4519         if (state->out_mem_ctx) {
4520                 mem_ctx = state->out_mem_ctx;
4521         } else {
4522                 mem_ctx = state;
4523         }
4524
4525         status = state->dispatch_recv(subreq, mem_ctx);
4526         TALLOC_FREE(subreq);
4527         if (!NT_STATUS_IS_OK(status)) {
4528                 tevent_req_nterror(req, status);
4529                 return;
4530         }
4531
4532         /* Copy out parameters */
4533
4534         /* Copy result */
4535         state->orig.out.result = state->tmp.out.result;
4536
4537         /* Reset temporary structure */
4538         ZERO_STRUCT(state->tmp);
4539
4540         tevent_req_done(req);
4541 }
4542
4543 NTSTATUS rpccli_spoolss_WaitForPrinterChange_recv(struct tevent_req *req,
4544                                                   TALLOC_CTX *mem_ctx,
4545                                                   WERROR *result)
4546 {
4547         struct rpccli_spoolss_WaitForPrinterChange_state *state = tevent_req_data(
4548                 req, struct rpccli_spoolss_WaitForPrinterChange_state);
4549         NTSTATUS status;
4550
4551         if (tevent_req_is_nterror(req, &status)) {
4552                 tevent_req_received(req);
4553                 return status;
4554         }
4555
4556         /* Steal possbile out parameters to the callers context */
4557         talloc_steal(mem_ctx, state->out_mem_ctx);
4558
4559         /* Return result */
4560         *result = state->orig.out.result;
4561
4562         tevent_req_received(req);
4563         return NT_STATUS_OK;
4564 }
4565
4566 NTSTATUS rpccli_spoolss_WaitForPrinterChange(struct rpc_pipe_client *cli,
4567                                              TALLOC_CTX *mem_ctx,
4568                                              WERROR *werror)
4569 {
4570         struct spoolss_WaitForPrinterChange r;
4571         NTSTATUS status;
4572
4573         /* In parameters */
4574
4575         status = cli->dispatch(cli,
4576                                 mem_ctx,
4577                                 &ndr_table_spoolss,
4578                                 NDR_SPOOLSS_WAITFORPRINTERCHANGE,
4579                                 &r);
4580
4581         if (!NT_STATUS_IS_OK(status)) {
4582                 return status;
4583         }
4584
4585         if (NT_STATUS_IS_ERR(status)) {
4586                 return status;
4587         }
4588
4589         /* Return variables */
4590
4591         /* Return result */
4592         if (werror) {
4593                 *werror = r.out.result;
4594         }
4595
4596         return werror_to_ntstatus(r.out.result);
4597 }
4598
4599 struct rpccli_spoolss_ClosePrinter_state {
4600         struct spoolss_ClosePrinter orig;
4601         struct spoolss_ClosePrinter tmp;
4602         TALLOC_CTX *out_mem_ctx;
4603         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4604 };
4605
4606 static void rpccli_spoolss_ClosePrinter_done(struct tevent_req *subreq);
4607
4608 struct tevent_req *rpccli_spoolss_ClosePrinter_send(TALLOC_CTX *mem_ctx,
4609                                                     struct tevent_context *ev,
4610                                                     struct rpc_pipe_client *cli,
4611                                                     struct policy_handle *_handle /* [in,out] [ref] */)
4612 {
4613         struct tevent_req *req;
4614         struct rpccli_spoolss_ClosePrinter_state *state;
4615         struct tevent_req *subreq;
4616
4617         req = tevent_req_create(mem_ctx, &state,
4618                                 struct rpccli_spoolss_ClosePrinter_state);
4619         if (req == NULL) {
4620                 return NULL;
4621         }
4622         state->out_mem_ctx = NULL;
4623         state->dispatch_recv = cli->dispatch_recv;
4624
4625         /* In parameters */
4626         state->orig.in.handle = _handle;
4627
4628         /* Out parameters */
4629         state->orig.out.handle = _handle;
4630
4631         /* Result */
4632         ZERO_STRUCT(state->orig.out.result);
4633
4634         state->out_mem_ctx = talloc_named_const(state, 0,
4635                              "rpccli_spoolss_ClosePrinter_out_memory");
4636         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4637                 return tevent_req_post(req, ev);
4638         }
4639
4640         /* make a temporary copy, that we pass to the dispatch function */
4641         state->tmp = state->orig;
4642
4643         subreq = cli->dispatch_send(state, ev, cli,
4644                                     &ndr_table_spoolss,
4645                                     NDR_SPOOLSS_CLOSEPRINTER,
4646                                     &state->tmp);
4647         if (tevent_req_nomem(subreq, req)) {
4648                 return tevent_req_post(req, ev);
4649         }
4650         tevent_req_set_callback(subreq, rpccli_spoolss_ClosePrinter_done, req);
4651         return req;
4652 }
4653
4654 static void rpccli_spoolss_ClosePrinter_done(struct tevent_req *subreq)
4655 {
4656         struct tevent_req *req = tevent_req_callback_data(
4657                 subreq, struct tevent_req);
4658         struct rpccli_spoolss_ClosePrinter_state *state = tevent_req_data(
4659                 req, struct rpccli_spoolss_ClosePrinter_state);
4660         NTSTATUS status;
4661         TALLOC_CTX *mem_ctx;
4662
4663         if (state->out_mem_ctx) {
4664                 mem_ctx = state->out_mem_ctx;
4665         } else {
4666                 mem_ctx = state;
4667         }
4668
4669         status = state->dispatch_recv(subreq, mem_ctx);
4670         TALLOC_FREE(subreq);
4671         if (!NT_STATUS_IS_OK(status)) {
4672                 tevent_req_nterror(req, status);
4673                 return;
4674         }
4675
4676         /* Copy out parameters */
4677         *state->orig.out.handle = *state->tmp.out.handle;
4678
4679         /* Copy result */
4680         state->orig.out.result = state->tmp.out.result;
4681
4682         /* Reset temporary structure */
4683         ZERO_STRUCT(state->tmp);
4684
4685         tevent_req_done(req);
4686 }
4687
4688 NTSTATUS rpccli_spoolss_ClosePrinter_recv(struct tevent_req *req,
4689                                           TALLOC_CTX *mem_ctx,
4690                                           WERROR *result)
4691 {
4692         struct rpccli_spoolss_ClosePrinter_state *state = tevent_req_data(
4693                 req, struct rpccli_spoolss_ClosePrinter_state);
4694         NTSTATUS status;
4695
4696         if (tevent_req_is_nterror(req, &status)) {
4697                 tevent_req_received(req);
4698                 return status;
4699         }
4700
4701         /* Steal possbile out parameters to the callers context */
4702         talloc_steal(mem_ctx, state->out_mem_ctx);
4703
4704         /* Return result */
4705         *result = state->orig.out.result;
4706
4707         tevent_req_received(req);
4708         return NT_STATUS_OK;
4709 }
4710
4711 NTSTATUS rpccli_spoolss_ClosePrinter(struct rpc_pipe_client *cli,
4712                                      TALLOC_CTX *mem_ctx,
4713                                      struct policy_handle *handle /* [in,out] [ref] */,
4714                                      WERROR *werror)
4715 {
4716         struct spoolss_ClosePrinter r;
4717         NTSTATUS status;
4718
4719         /* In parameters */
4720         r.in.handle = handle;
4721
4722         status = cli->dispatch(cli,
4723                                 mem_ctx,
4724                                 &ndr_table_spoolss,
4725                                 NDR_SPOOLSS_CLOSEPRINTER,
4726                                 &r);
4727
4728         if (!NT_STATUS_IS_OK(status)) {
4729                 return status;
4730         }
4731
4732         if (NT_STATUS_IS_ERR(status)) {
4733                 return status;
4734         }
4735
4736         /* Return variables */
4737         *handle = *r.out.handle;
4738
4739         /* Return result */
4740         if (werror) {
4741                 *werror = r.out.result;
4742         }
4743
4744         return werror_to_ntstatus(r.out.result);
4745 }
4746
4747 struct rpccli_spoolss_AddForm_state {
4748         struct spoolss_AddForm orig;
4749         struct spoolss_AddForm tmp;
4750         TALLOC_CTX *out_mem_ctx;
4751         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4752 };
4753
4754 static void rpccli_spoolss_AddForm_done(struct tevent_req *subreq);
4755
4756 struct tevent_req *rpccli_spoolss_AddForm_send(TALLOC_CTX *mem_ctx,
4757                                                struct tevent_context *ev,
4758                                                struct rpc_pipe_client *cli,
4759                                                struct policy_handle *_handle /* [in] [ref] */,
4760                                                uint32_t _level /* [in]  */,
4761                                                union spoolss_AddFormInfo _info /* [in] [switch_is(level)] */)
4762 {
4763         struct tevent_req *req;
4764         struct rpccli_spoolss_AddForm_state *state;
4765         struct tevent_req *subreq;
4766
4767         req = tevent_req_create(mem_ctx, &state,
4768                                 struct rpccli_spoolss_AddForm_state);
4769         if (req == NULL) {
4770                 return NULL;
4771         }
4772         state->out_mem_ctx = NULL;
4773         state->dispatch_recv = cli->dispatch_recv;
4774
4775         /* In parameters */
4776         state->orig.in.handle = _handle;
4777         state->orig.in.level = _level;
4778         state->orig.in.info = _info;
4779
4780         /* Out parameters */
4781
4782         /* Result */
4783         ZERO_STRUCT(state->orig.out.result);
4784
4785         /* make a temporary copy, that we pass to the dispatch function */
4786         state->tmp = state->orig;
4787
4788         subreq = cli->dispatch_send(state, ev, cli,
4789                                     &ndr_table_spoolss,
4790                                     NDR_SPOOLSS_ADDFORM,
4791                                     &state->tmp);
4792         if (tevent_req_nomem(subreq, req)) {
4793                 return tevent_req_post(req, ev);
4794         }
4795         tevent_req_set_callback(subreq, rpccli_spoolss_AddForm_done, req);
4796         return req;
4797 }
4798
4799 static void rpccli_spoolss_AddForm_done(struct tevent_req *subreq)
4800 {
4801         struct tevent_req *req = tevent_req_callback_data(
4802                 subreq, struct tevent_req);
4803         struct rpccli_spoolss_AddForm_state *state = tevent_req_data(
4804                 req, struct rpccli_spoolss_AddForm_state);
4805         NTSTATUS status;
4806         TALLOC_CTX *mem_ctx;
4807
4808         if (state->out_mem_ctx) {
4809                 mem_ctx = state->out_mem_ctx;
4810         } else {
4811                 mem_ctx = state;
4812         }
4813
4814         status = state->dispatch_recv(subreq, mem_ctx);
4815         TALLOC_FREE(subreq);
4816         if (!NT_STATUS_IS_OK(status)) {
4817                 tevent_req_nterror(req, status);
4818                 return;
4819         }
4820
4821         /* Copy out parameters */
4822
4823         /* Copy result */
4824         state->orig.out.result = state->tmp.out.result;
4825
4826         /* Reset temporary structure */
4827         ZERO_STRUCT(state->tmp);
4828
4829         tevent_req_done(req);
4830 }
4831
4832 NTSTATUS rpccli_spoolss_AddForm_recv(struct tevent_req *req,
4833                                      TALLOC_CTX *mem_ctx,
4834                                      WERROR *result)
4835 {
4836         struct rpccli_spoolss_AddForm_state *state = tevent_req_data(
4837                 req, struct rpccli_spoolss_AddForm_state);
4838         NTSTATUS status;
4839
4840         if (tevent_req_is_nterror(req, &status)) {
4841                 tevent_req_received(req);
4842                 return status;
4843         }
4844
4845         /* Steal possbile out parameters to the callers context */
4846         talloc_steal(mem_ctx, state->out_mem_ctx);
4847
4848         /* Return result */
4849         *result = state->orig.out.result;
4850
4851         tevent_req_received(req);
4852         return NT_STATUS_OK;
4853 }
4854
4855 NTSTATUS rpccli_spoolss_AddForm(struct rpc_pipe_client *cli,
4856                                 TALLOC_CTX *mem_ctx,
4857                                 struct policy_handle *handle /* [in] [ref] */,
4858                                 uint32_t level /* [in]  */,
4859                                 union spoolss_AddFormInfo info /* [in] [switch_is(level)] */,
4860                                 WERROR *werror)
4861 {
4862         struct spoolss_AddForm r;
4863         NTSTATUS status;
4864
4865         /* In parameters */
4866         r.in.handle = handle;
4867         r.in.level = level;
4868         r.in.info = info;
4869
4870         status = cli->dispatch(cli,
4871                                 mem_ctx,
4872                                 &ndr_table_spoolss,
4873                                 NDR_SPOOLSS_ADDFORM,
4874                                 &r);
4875
4876         if (!NT_STATUS_IS_OK(status)) {
4877                 return status;
4878         }
4879
4880         if (NT_STATUS_IS_ERR(status)) {
4881                 return status;
4882         }
4883
4884         /* Return variables */
4885
4886         /* Return result */
4887         if (werror) {
4888                 *werror = r.out.result;
4889         }
4890
4891         return werror_to_ntstatus(r.out.result);
4892 }
4893
4894 struct rpccli_spoolss_DeleteForm_state {
4895         struct spoolss_DeleteForm orig;
4896         struct spoolss_DeleteForm tmp;
4897         TALLOC_CTX *out_mem_ctx;
4898         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4899 };
4900
4901 static void rpccli_spoolss_DeleteForm_done(struct tevent_req *subreq);
4902
4903 struct tevent_req *rpccli_spoolss_DeleteForm_send(TALLOC_CTX *mem_ctx,
4904                                                   struct tevent_context *ev,
4905                                                   struct rpc_pipe_client *cli,
4906                                                   struct policy_handle *_handle /* [in] [ref] */,
4907                                                   const char *_form_name /* [in] [charset(UTF16)] */)
4908 {
4909         struct tevent_req *req;
4910         struct rpccli_spoolss_DeleteForm_state *state;
4911         struct tevent_req *subreq;
4912
4913         req = tevent_req_create(mem_ctx, &state,
4914                                 struct rpccli_spoolss_DeleteForm_state);
4915         if (req == NULL) {
4916                 return NULL;
4917         }
4918         state->out_mem_ctx = NULL;
4919         state->dispatch_recv = cli->dispatch_recv;
4920
4921         /* In parameters */
4922         state->orig.in.handle = _handle;
4923         state->orig.in.form_name = _form_name;
4924
4925         /* Out parameters */
4926
4927         /* Result */
4928         ZERO_STRUCT(state->orig.out.result);
4929
4930         /* make a temporary copy, that we pass to the dispatch function */
4931         state->tmp = state->orig;
4932
4933         subreq = cli->dispatch_send(state, ev, cli,
4934                                     &ndr_table_spoolss,
4935                                     NDR_SPOOLSS_DELETEFORM,
4936                                     &state->tmp);
4937         if (tevent_req_nomem(subreq, req)) {
4938                 return tevent_req_post(req, ev);
4939         }
4940         tevent_req_set_callback(subreq, rpccli_spoolss_DeleteForm_done, req);
4941         return req;
4942 }
4943
4944 static void rpccli_spoolss_DeleteForm_done(struct tevent_req *subreq)
4945 {
4946         struct tevent_req *req = tevent_req_callback_data(
4947                 subreq, struct tevent_req);
4948         struct rpccli_spoolss_DeleteForm_state *state = tevent_req_data(
4949                 req, struct rpccli_spoolss_DeleteForm_state);
4950         NTSTATUS status;
4951         TALLOC_CTX *mem_ctx;
4952
4953         if (state->out_mem_ctx) {
4954                 mem_ctx = state->out_mem_ctx;
4955         } else {
4956                 mem_ctx = state;
4957         }
4958
4959         status = state->dispatch_recv(subreq, mem_ctx);
4960         TALLOC_FREE(subreq);
4961         if (!NT_STATUS_IS_OK(status)) {
4962                 tevent_req_nterror(req, status);
4963                 return;
4964         }
4965
4966         /* Copy out parameters */
4967
4968         /* Copy result */
4969         state->orig.out.result = state->tmp.out.result;
4970
4971         /* Reset temporary structure */
4972         ZERO_STRUCT(state->tmp);
4973
4974         tevent_req_done(req);
4975 }
4976
4977 NTSTATUS rpccli_spoolss_DeleteForm_recv(struct tevent_req *req,
4978                                         TALLOC_CTX *mem_ctx,
4979                                         WERROR *result)
4980 {
4981         struct rpccli_spoolss_DeleteForm_state *state = tevent_req_data(
4982                 req, struct rpccli_spoolss_DeleteForm_state);
4983         NTSTATUS status;
4984
4985         if (tevent_req_is_nterror(req, &status)) {
4986                 tevent_req_received(req);
4987                 return status;
4988         }
4989
4990         /* Steal possbile out parameters to the callers context */
4991         talloc_steal(mem_ctx, state->out_mem_ctx);
4992
4993         /* Return result */
4994         *result = state->orig.out.result;
4995
4996         tevent_req_received(req);
4997         return NT_STATUS_OK;
4998 }
4999
5000 NTSTATUS rpccli_spoolss_DeleteForm(struct rpc_pipe_client *cli,
5001                                    TALLOC_CTX *mem_ctx,
5002                                    struct policy_handle *handle /* [in] [ref] */,
5003                                    const char *form_name /* [in] [charset(UTF16)] */,
5004                                    WERROR *werror)
5005 {
5006         struct spoolss_DeleteForm r;
5007         NTSTATUS status;
5008
5009         /* In parameters */
5010         r.in.handle = handle;
5011         r.in.form_name = form_name;
5012
5013         status = cli->dispatch(cli,
5014                                 mem_ctx,
5015                                 &ndr_table_spoolss,
5016                                 NDR_SPOOLSS_DELETEFORM,
5017                                 &r);
5018
5019         if (!NT_STATUS_IS_OK(status)) {
5020                 return status;
5021         }
5022
5023         if (NT_STATUS_IS_ERR(status)) {
5024                 return status;
5025         }
5026
5027         /* Return variables */
5028
5029         /* Return result */
5030         if (werror) {
5031                 *werror = r.out.result;
5032         }
5033
5034         return werror_to_ntstatus(r.out.result);
5035 }
5036
5037 struct rpccli_spoolss_GetForm_state {
5038         struct spoolss_GetForm orig;
5039         struct spoolss_GetForm tmp;
5040         TALLOC_CTX *out_mem_ctx;
5041         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5042 };
5043
5044 static void rpccli_spoolss_GetForm_done(struct tevent_req *subreq);
5045
5046 struct tevent_req *rpccli_spoolss_GetForm_send(TALLOC_CTX *mem_ctx,
5047                                                struct tevent_context *ev,
5048                                                struct rpc_pipe_client *cli,
5049                                                struct policy_handle *_handle /* [in] [ref] */,
5050                                                const char *_form_name /* [in] [charset(UTF16)] */,
5051                                                uint32_t _level /* [in]  */,
5052                                                DATA_BLOB *_buffer /* [in] [unique] */,
5053                                                uint32_t _offered /* [in]  */,
5054                                                union spoolss_FormInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
5055                                                uint32_t *_needed /* [out] [ref] */)
5056 {
5057         struct tevent_req *req;
5058         struct rpccli_spoolss_GetForm_state *state;
5059         struct tevent_req *subreq;
5060
5061         req = tevent_req_create(mem_ctx, &state,
5062                                 struct rpccli_spoolss_GetForm_state);
5063         if (req == NULL) {
5064                 return NULL;
5065         }
5066         state->out_mem_ctx = NULL;
5067         state->dispatch_recv = cli->dispatch_recv;
5068
5069         /* In parameters */
5070         state->orig.in.handle = _handle;
5071         state->orig.in.form_name = _form_name;
5072         state->orig.in.level = _level;
5073         state->orig.in.buffer = _buffer;
5074         state->orig.in.offered = _offered;
5075
5076         /* Out parameters */
5077         state->orig.out.info = _info;
5078         state->orig.out.needed = _needed;
5079
5080         /* Result */
5081         ZERO_STRUCT(state->orig.out.result);
5082
5083         state->out_mem_ctx = talloc_named_const(state, 0,
5084                              "rpccli_spoolss_GetForm_out_memory");
5085         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5086                 return tevent_req_post(req, ev);
5087         }
5088
5089         /* make a temporary copy, that we pass to the dispatch function */
5090         state->tmp = state->orig;
5091
5092         subreq = cli->dispatch_send(state, ev, cli,
5093                                     &ndr_table_spoolss,
5094                                     NDR_SPOOLSS_GETFORM,
5095                                     &state->tmp);
5096         if (tevent_req_nomem(subreq, req)) {
5097                 return tevent_req_post(req, ev);
5098         }
5099         tevent_req_set_callback(subreq, rpccli_spoolss_GetForm_done, req);
5100         return req;
5101 }
5102
5103 static void rpccli_spoolss_GetForm_done(struct tevent_req *subreq)
5104 {
5105         struct tevent_req *req = tevent_req_callback_data(
5106                 subreq, struct tevent_req);
5107         struct rpccli_spoolss_GetForm_state *state = tevent_req_data(
5108                 req, struct rpccli_spoolss_GetForm_state);
5109         NTSTATUS status;
5110         TALLOC_CTX *mem_ctx;
5111
5112         if (state->out_mem_ctx) {
5113                 mem_ctx = state->out_mem_ctx;
5114         } else {
5115                 mem_ctx = state;
5116         }
5117
5118         status = state->dispatch_recv(subreq, mem_ctx);
5119         TALLOC_FREE(subreq);
5120         if (!NT_STATUS_IS_OK(status)) {
5121                 tevent_req_nterror(req, status);
5122                 return;
5123         }
5124
5125         /* Copy out parameters */
5126         if (state->orig.out.info && state->tmp.out.info) {
5127                 *state->orig.out.info = *state->tmp.out.info;
5128         }
5129         *state->orig.out.needed = *state->tmp.out.needed;
5130
5131         /* Copy result */
5132         state->orig.out.result = state->tmp.out.result;
5133
5134         /* Reset temporary structure */
5135         ZERO_STRUCT(state->tmp);
5136
5137         tevent_req_done(req);
5138 }
5139
5140 NTSTATUS rpccli_spoolss_GetForm_recv(struct tevent_req *req,
5141                                      TALLOC_CTX *mem_ctx,
5142                                      WERROR *result)
5143 {
5144         struct rpccli_spoolss_GetForm_state *state = tevent_req_data(
5145                 req, struct rpccli_spoolss_GetForm_state);
5146         NTSTATUS status;
5147
5148         if (tevent_req_is_nterror(req, &status)) {
5149                 tevent_req_received(req);
5150                 return status;
5151         }
5152
5153         /* Steal possbile out parameters to the callers context */
5154         talloc_steal(mem_ctx, state->out_mem_ctx);
5155
5156         /* Return result */
5157         *result = state->orig.out.result;
5158
5159         tevent_req_received(req);
5160         return NT_STATUS_OK;
5161 }
5162
5163 NTSTATUS rpccli_spoolss_GetForm(struct rpc_pipe_client *cli,
5164                                 TALLOC_CTX *mem_ctx,
5165                                 struct policy_handle *handle /* [in] [ref] */,
5166                                 const char *form_name /* [in] [charset(UTF16)] */,
5167                                 uint32_t level /* [in]  */,
5168                                 DATA_BLOB *buffer /* [in] [unique] */,
5169                                 uint32_t offered /* [in]  */,
5170                                 union spoolss_FormInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
5171                                 uint32_t *needed /* [out] [ref] */,
5172                                 WERROR *werror)
5173 {
5174         struct spoolss_GetForm r;
5175         NTSTATUS status;
5176
5177         /* In parameters */
5178         r.in.handle = handle;
5179         r.in.form_name = form_name;
5180         r.in.level = level;
5181         r.in.buffer = buffer;
5182         r.in.offered = offered;
5183
5184         status = cli->dispatch(cli,
5185                                 mem_ctx,
5186                                 &ndr_table_spoolss,
5187                                 NDR_SPOOLSS_GETFORM,
5188                                 &r);
5189
5190         if (!NT_STATUS_IS_OK(status)) {
5191                 return status;
5192         }
5193
5194         if (NT_STATUS_IS_ERR(status)) {
5195                 return status;
5196         }
5197
5198         /* Return variables */
5199         if (info && r.out.info) {
5200                 *info = *r.out.info;
5201         }
5202         *needed = *r.out.needed;
5203
5204         /* Return result */
5205         if (werror) {
5206                 *werror = r.out.result;
5207         }
5208
5209         return werror_to_ntstatus(r.out.result);
5210 }
5211
5212 struct rpccli_spoolss_SetForm_state {
5213         struct spoolss_SetForm orig;
5214         struct spoolss_SetForm tmp;
5215         TALLOC_CTX *out_mem_ctx;
5216         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5217 };
5218
5219 static void rpccli_spoolss_SetForm_done(struct tevent_req *subreq);
5220
5221 struct tevent_req *rpccli_spoolss_SetForm_send(TALLOC_CTX *mem_ctx,
5222                                                struct tevent_context *ev,
5223                                                struct rpc_pipe_client *cli,
5224                                                struct policy_handle *_handle /* [in] [ref] */,
5225                                                const char *_form_name /* [in] [charset(UTF16)] */,
5226                                                uint32_t _level /* [in]  */,
5227                                                union spoolss_AddFormInfo _info /* [in] [switch_is(level)] */)
5228 {
5229         struct tevent_req *req;
5230         struct rpccli_spoolss_SetForm_state *state;
5231         struct tevent_req *subreq;
5232
5233         req = tevent_req_create(mem_ctx, &state,
5234                                 struct rpccli_spoolss_SetForm_state);
5235         if (req == NULL) {
5236                 return NULL;
5237         }
5238         state->out_mem_ctx = NULL;
5239         state->dispatch_recv = cli->dispatch_recv;
5240
5241         /* In parameters */
5242         state->orig.in.handle = _handle;
5243         state->orig.in.form_name = _form_name;
5244         state->orig.in.level = _level;
5245         state->orig.in.info = _info;
5246
5247         /* Out parameters */
5248
5249         /* Result */
5250         ZERO_STRUCT(state->orig.out.result);
5251
5252         /* make a temporary copy, that we pass to the dispatch function */
5253         state->tmp = state->orig;
5254
5255         subreq = cli->dispatch_send(state, ev, cli,
5256                                     &ndr_table_spoolss,
5257                                     NDR_SPOOLSS_SETFORM,
5258                                     &state->tmp);
5259         if (tevent_req_nomem(subreq, req)) {
5260                 return tevent_req_post(req, ev);
5261         }
5262         tevent_req_set_callback(subreq, rpccli_spoolss_SetForm_done, req);
5263         return req;
5264 }
5265
5266 static void rpccli_spoolss_SetForm_done(struct tevent_req *subreq)
5267 {
5268         struct tevent_req *req = tevent_req_callback_data(
5269                 subreq, struct tevent_req);
5270         struct rpccli_spoolss_SetForm_state *state = tevent_req_data(
5271                 req, struct rpccli_spoolss_SetForm_state);
5272         NTSTATUS status;
5273         TALLOC_CTX *mem_ctx;
5274
5275         if (state->out_mem_ctx) {
5276                 mem_ctx = state->out_mem_ctx;
5277         } else {
5278                 mem_ctx = state;
5279         }
5280
5281         status = state->dispatch_recv(subreq, mem_ctx);
5282         TALLOC_FREE(subreq);
5283         if (!NT_STATUS_IS_OK(status)) {
5284                 tevent_req_nterror(req, status);
5285                 return;
5286         }
5287
5288         /* Copy out parameters */
5289
5290         /* Copy result */
5291         state->orig.out.result = state->tmp.out.result;
5292
5293         /* Reset temporary structure */
5294         ZERO_STRUCT(state->tmp);
5295
5296         tevent_req_done(req);
5297 }
5298
5299 NTSTATUS rpccli_spoolss_SetForm_recv(struct tevent_req *req,
5300                                      TALLOC_CTX *mem_ctx,
5301                                      WERROR *result)
5302 {
5303         struct rpccli_spoolss_SetForm_state *state = tevent_req_data(
5304                 req, struct rpccli_spoolss_SetForm_state);
5305         NTSTATUS status;
5306
5307         if (tevent_req_is_nterror(req, &status)) {
5308                 tevent_req_received(req);
5309                 return status;
5310         }
5311
5312         /* Steal possbile out parameters to the callers context */
5313         talloc_steal(mem_ctx, state->out_mem_ctx);
5314
5315         /* Return result */
5316         *result = state->orig.out.result;
5317
5318         tevent_req_received(req);
5319         return NT_STATUS_OK;
5320 }
5321
5322 NTSTATUS rpccli_spoolss_SetForm(struct rpc_pipe_client *cli,
5323                                 TALLOC_CTX *mem_ctx,
5324                                 struct policy_handle *handle /* [in] [ref] */,
5325                                 const char *form_name /* [in] [charset(UTF16)] */,
5326                                 uint32_t level /* [in]  */,
5327                                 union spoolss_AddFormInfo info /* [in] [switch_is(level)] */,
5328                                 WERROR *werror)
5329 {
5330         struct spoolss_SetForm r;
5331         NTSTATUS status;
5332
5333         /* In parameters */
5334         r.in.handle = handle;
5335         r.in.form_name = form_name;
5336         r.in.level = level;
5337         r.in.info = info;
5338
5339         status = cli->dispatch(cli,
5340                                 mem_ctx,
5341                                 &ndr_table_spoolss,
5342                                 NDR_SPOOLSS_SETFORM,
5343                                 &r);
5344
5345         if (!NT_STATUS_IS_OK(status)) {
5346                 return status;
5347         }
5348
5349         if (NT_STATUS_IS_ERR(status)) {
5350                 return status;
5351         }
5352
5353         /* Return variables */
5354
5355         /* Return result */
5356         if (werror) {
5357                 *werror = r.out.result;
5358         }
5359
5360         return werror_to_ntstatus(r.out.result);
5361 }
5362
5363 struct rpccli_spoolss_EnumForms_state {
5364         struct spoolss_EnumForms orig;
5365         struct spoolss_EnumForms tmp;
5366         TALLOC_CTX *out_mem_ctx;
5367         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5368 };
5369
5370 static void rpccli_spoolss_EnumForms_done(struct tevent_req *subreq);
5371
5372 struct tevent_req *rpccli_spoolss_EnumForms_send(TALLOC_CTX *mem_ctx,
5373                                                  struct tevent_context *ev,
5374                                                  struct rpc_pipe_client *cli,
5375                                                  struct policy_handle *_handle /* [in] [ref] */,
5376                                                  uint32_t _level /* [in]  */,
5377                                                  DATA_BLOB *_buffer /* [in] [unique] */,
5378                                                  uint32_t _offered /* [in]  */,
5379                                                  uint32_t *_count /* [out] [ref] */,
5380                                                  union spoolss_FormInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5381                                                  uint32_t *_needed /* [out] [ref] */)
5382 {
5383         struct tevent_req *req;
5384         struct rpccli_spoolss_EnumForms_state *state;
5385         struct tevent_req *subreq;
5386
5387         req = tevent_req_create(mem_ctx, &state,
5388                                 struct rpccli_spoolss_EnumForms_state);
5389         if (req == NULL) {
5390                 return NULL;
5391         }
5392         state->out_mem_ctx = NULL;
5393         state->dispatch_recv = cli->dispatch_recv;
5394
5395         /* In parameters */
5396         state->orig.in.handle = _handle;
5397         state->orig.in.level = _level;
5398         state->orig.in.buffer = _buffer;
5399         state->orig.in.offered = _offered;
5400
5401         /* Out parameters */
5402         state->orig.out.count = _count;
5403         state->orig.out.info = _info;
5404         state->orig.out.needed = _needed;
5405
5406         /* Result */
5407         ZERO_STRUCT(state->orig.out.result);
5408
5409         state->out_mem_ctx = talloc_named_const(state, 0,
5410                              "rpccli_spoolss_EnumForms_out_memory");
5411         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5412                 return tevent_req_post(req, ev);
5413         }
5414
5415         /* make a temporary copy, that we pass to the dispatch function */
5416         state->tmp = state->orig;
5417
5418         subreq = cli->dispatch_send(state, ev, cli,
5419                                     &ndr_table_spoolss,
5420                                     NDR_SPOOLSS_ENUMFORMS,
5421                                     &state->tmp);
5422         if (tevent_req_nomem(subreq, req)) {
5423                 return tevent_req_post(req, ev);
5424         }
5425         tevent_req_set_callback(subreq, rpccli_spoolss_EnumForms_done, req);
5426         return req;
5427 }
5428
5429 static void rpccli_spoolss_EnumForms_done(struct tevent_req *subreq)
5430 {
5431         struct tevent_req *req = tevent_req_callback_data(
5432                 subreq, struct tevent_req);
5433         struct rpccli_spoolss_EnumForms_state *state = tevent_req_data(
5434                 req, struct rpccli_spoolss_EnumForms_state);
5435         NTSTATUS status;
5436         TALLOC_CTX *mem_ctx;
5437
5438         if (state->out_mem_ctx) {
5439                 mem_ctx = state->out_mem_ctx;
5440         } else {
5441                 mem_ctx = state;
5442         }
5443
5444         status = state->dispatch_recv(subreq, mem_ctx);
5445         TALLOC_FREE(subreq);
5446         if (!NT_STATUS_IS_OK(status)) {
5447                 tevent_req_nterror(req, status);
5448                 return;
5449         }
5450
5451         /* Copy out parameters */
5452         *state->orig.out.count = *state->tmp.out.count;
5453         *state->orig.out.info = *state->tmp.out.info;
5454         *state->orig.out.needed = *state->tmp.out.needed;
5455
5456         /* Copy result */
5457         state->orig.out.result = state->tmp.out.result;
5458
5459         /* Reset temporary structure */
5460         ZERO_STRUCT(state->tmp);
5461
5462         tevent_req_done(req);
5463 }
5464
5465 NTSTATUS rpccli_spoolss_EnumForms_recv(struct tevent_req *req,
5466                                        TALLOC_CTX *mem_ctx,
5467                                        WERROR *result)
5468 {
5469         struct rpccli_spoolss_EnumForms_state *state = tevent_req_data(
5470                 req, struct rpccli_spoolss_EnumForms_state);
5471         NTSTATUS status;
5472
5473         if (tevent_req_is_nterror(req, &status)) {
5474                 tevent_req_received(req);
5475                 return status;
5476         }
5477
5478         /* Steal possbile out parameters to the callers context */
5479         talloc_steal(mem_ctx, state->out_mem_ctx);
5480
5481         /* Return result */
5482         *result = state->orig.out.result;
5483
5484         tevent_req_received(req);
5485         return NT_STATUS_OK;
5486 }
5487
5488 NTSTATUS rpccli_spoolss_EnumForms(struct rpc_pipe_client *cli,
5489                                   TALLOC_CTX *mem_ctx,
5490                                   struct policy_handle *handle /* [in] [ref] */,
5491                                   uint32_t level /* [in]  */,
5492                                   DATA_BLOB *buffer /* [in] [unique] */,
5493                                   uint32_t offered /* [in]  */,
5494                                   uint32_t *count /* [out] [ref] */,
5495                                   union spoolss_FormInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5496                                   uint32_t *needed /* [out] [ref] */,
5497                                   WERROR *werror)
5498 {
5499         struct spoolss_EnumForms r;
5500         NTSTATUS status;
5501
5502         /* In parameters */
5503         r.in.handle = handle;
5504         r.in.level = level;
5505         r.in.buffer = buffer;
5506         r.in.offered = offered;
5507
5508         status = cli->dispatch(cli,
5509                                 mem_ctx,
5510                                 &ndr_table_spoolss,
5511                                 NDR_SPOOLSS_ENUMFORMS,
5512                                 &r);
5513
5514         if (!NT_STATUS_IS_OK(status)) {
5515                 return status;
5516         }
5517
5518         if (NT_STATUS_IS_ERR(status)) {
5519                 return status;
5520         }
5521
5522         /* Return variables */
5523         *count = *r.out.count;
5524         *info = *r.out.info;
5525         *needed = *r.out.needed;
5526
5527         /* Return result */
5528         if (werror) {
5529                 *werror = r.out.result;
5530         }
5531
5532         return werror_to_ntstatus(r.out.result);
5533 }
5534
5535 struct rpccli_spoolss_EnumPorts_state {
5536         struct spoolss_EnumPorts orig;
5537         struct spoolss_EnumPorts tmp;
5538         TALLOC_CTX *out_mem_ctx;
5539         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5540 };
5541
5542 static void rpccli_spoolss_EnumPorts_done(struct tevent_req *subreq);
5543
5544 struct tevent_req *rpccli_spoolss_EnumPorts_send(TALLOC_CTX *mem_ctx,
5545                                                  struct tevent_context *ev,
5546                                                  struct rpc_pipe_client *cli,
5547                                                  const char *_servername /* [in] [unique,charset(UTF16)] */,
5548                                                  uint32_t _level /* [in]  */,
5549                                                  DATA_BLOB *_buffer /* [in] [unique] */,
5550                                                  uint32_t _offered /* [in]  */,
5551                                                  uint32_t *_count /* [out] [ref] */,
5552                                                  union spoolss_PortInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5553                                                  uint32_t *_needed /* [out] [ref] */)
5554 {
5555         struct tevent_req *req;
5556         struct rpccli_spoolss_EnumPorts_state *state;
5557         struct tevent_req *subreq;
5558
5559         req = tevent_req_create(mem_ctx, &state,
5560                                 struct rpccli_spoolss_EnumPorts_state);
5561         if (req == NULL) {
5562                 return NULL;
5563         }
5564         state->out_mem_ctx = NULL;
5565         state->dispatch_recv = cli->dispatch_recv;
5566
5567         /* In parameters */
5568         state->orig.in.servername = _servername;
5569         state->orig.in.level = _level;
5570         state->orig.in.buffer = _buffer;
5571         state->orig.in.offered = _offered;
5572
5573         /* Out parameters */
5574         state->orig.out.count = _count;
5575         state->orig.out.info = _info;
5576         state->orig.out.needed = _needed;
5577
5578         /* Result */
5579         ZERO_STRUCT(state->orig.out.result);
5580
5581         state->out_mem_ctx = talloc_named_const(state, 0,
5582                              "rpccli_spoolss_EnumPorts_out_memory");
5583         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5584                 return tevent_req_post(req, ev);
5585         }
5586
5587         /* make a temporary copy, that we pass to the dispatch function */
5588         state->tmp = state->orig;
5589
5590         subreq = cli->dispatch_send(state, ev, cli,
5591                                     &ndr_table_spoolss,
5592                                     NDR_SPOOLSS_ENUMPORTS,
5593                                     &state->tmp);
5594         if (tevent_req_nomem(subreq, req)) {
5595                 return tevent_req_post(req, ev);
5596         }
5597         tevent_req_set_callback(subreq, rpccli_spoolss_EnumPorts_done, req);
5598         return req;
5599 }
5600
5601 static void rpccli_spoolss_EnumPorts_done(struct tevent_req *subreq)
5602 {
5603         struct tevent_req *req = tevent_req_callback_data(
5604                 subreq, struct tevent_req);
5605         struct rpccli_spoolss_EnumPorts_state *state = tevent_req_data(
5606                 req, struct rpccli_spoolss_EnumPorts_state);
5607         NTSTATUS status;
5608         TALLOC_CTX *mem_ctx;
5609
5610         if (state->out_mem_ctx) {
5611                 mem_ctx = state->out_mem_ctx;
5612         } else {
5613                 mem_ctx = state;
5614         }
5615
5616         status = state->dispatch_recv(subreq, mem_ctx);
5617         TALLOC_FREE(subreq);
5618         if (!NT_STATUS_IS_OK(status)) {
5619                 tevent_req_nterror(req, status);
5620                 return;
5621         }
5622
5623         /* Copy out parameters */
5624         *state->orig.out.count = *state->tmp.out.count;
5625         *state->orig.out.info = *state->tmp.out.info;
5626         *state->orig.out.needed = *state->tmp.out.needed;
5627
5628         /* Copy result */
5629         state->orig.out.result = state->tmp.out.result;
5630
5631         /* Reset temporary structure */
5632         ZERO_STRUCT(state->tmp);
5633
5634         tevent_req_done(req);
5635 }
5636
5637 NTSTATUS rpccli_spoolss_EnumPorts_recv(struct tevent_req *req,
5638                                        TALLOC_CTX *mem_ctx,
5639                                        WERROR *result)
5640 {
5641         struct rpccli_spoolss_EnumPorts_state *state = tevent_req_data(
5642                 req, struct rpccli_spoolss_EnumPorts_state);
5643         NTSTATUS status;
5644
5645         if (tevent_req_is_nterror(req, &status)) {
5646                 tevent_req_received(req);
5647                 return status;
5648         }
5649
5650         /* Steal possbile out parameters to the callers context */
5651         talloc_steal(mem_ctx, state->out_mem_ctx);
5652
5653         /* Return result */
5654         *result = state->orig.out.result;
5655
5656         tevent_req_received(req);
5657         return NT_STATUS_OK;
5658 }
5659
5660 NTSTATUS rpccli_spoolss_EnumPorts(struct rpc_pipe_client *cli,
5661                                   TALLOC_CTX *mem_ctx,
5662                                   const char *servername /* [in] [unique,charset(UTF16)] */,
5663                                   uint32_t level /* [in]  */,
5664                                   DATA_BLOB *buffer /* [in] [unique] */,
5665                                   uint32_t offered /* [in]  */,
5666                                   uint32_t *count /* [out] [ref] */,
5667                                   union spoolss_PortInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5668                                   uint32_t *needed /* [out] [ref] */,
5669                                   WERROR *werror)
5670 {
5671         struct spoolss_EnumPorts r;
5672         NTSTATUS status;
5673
5674         /* In parameters */
5675         r.in.servername = servername;
5676         r.in.level = level;
5677         r.in.buffer = buffer;
5678         r.in.offered = offered;
5679
5680         status = cli->dispatch(cli,
5681                                 mem_ctx,
5682                                 &ndr_table_spoolss,
5683                                 NDR_SPOOLSS_ENUMPORTS,
5684                                 &r);
5685
5686         if (!NT_STATUS_IS_OK(status)) {
5687                 return status;
5688         }
5689
5690         if (NT_STATUS_IS_ERR(status)) {
5691                 return status;
5692         }
5693
5694         /* Return variables */
5695         *count = *r.out.count;
5696         *info = *r.out.info;
5697         *needed = *r.out.needed;
5698
5699         /* Return result */
5700         if (werror) {
5701                 *werror = r.out.result;
5702         }
5703
5704         return werror_to_ntstatus(r.out.result);
5705 }
5706
5707 struct rpccli_spoolss_EnumMonitors_state {
5708         struct spoolss_EnumMonitors orig;
5709         struct spoolss_EnumMonitors tmp;
5710         TALLOC_CTX *out_mem_ctx;
5711         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5712 };
5713
5714 static void rpccli_spoolss_EnumMonitors_done(struct tevent_req *subreq);
5715
5716 struct tevent_req *rpccli_spoolss_EnumMonitors_send(TALLOC_CTX *mem_ctx,
5717                                                     struct tevent_context *ev,
5718                                                     struct rpc_pipe_client *cli,
5719                                                     const char *_servername /* [in] [unique,charset(UTF16)] */,
5720                                                     uint32_t _level /* [in]  */,
5721                                                     DATA_BLOB *_buffer /* [in] [unique] */,
5722                                                     uint32_t _offered /* [in]  */,
5723                                                     uint32_t *_count /* [out] [ref] */,
5724                                                     union spoolss_MonitorInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5725                                                     uint32_t *_needed /* [out] [ref] */)
5726 {
5727         struct tevent_req *req;
5728         struct rpccli_spoolss_EnumMonitors_state *state;
5729         struct tevent_req *subreq;
5730
5731         req = tevent_req_create(mem_ctx, &state,
5732                                 struct rpccli_spoolss_EnumMonitors_state);
5733         if (req == NULL) {
5734                 return NULL;
5735         }
5736         state->out_mem_ctx = NULL;
5737         state->dispatch_recv = cli->dispatch_recv;
5738
5739         /* In parameters */
5740         state->orig.in.servername = _servername;
5741         state->orig.in.level = _level;
5742         state->orig.in.buffer = _buffer;
5743         state->orig.in.offered = _offered;
5744
5745         /* Out parameters */
5746         state->orig.out.count = _count;
5747         state->orig.out.info = _info;
5748         state->orig.out.needed = _needed;
5749
5750         /* Result */
5751         ZERO_STRUCT(state->orig.out.result);
5752
5753         state->out_mem_ctx = talloc_named_const(state, 0,
5754                              "rpccli_spoolss_EnumMonitors_out_memory");
5755         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5756                 return tevent_req_post(req, ev);
5757         }
5758
5759         /* make a temporary copy, that we pass to the dispatch function */
5760         state->tmp = state->orig;
5761
5762         subreq = cli->dispatch_send(state, ev, cli,
5763                                     &ndr_table_spoolss,
5764                                     NDR_SPOOLSS_ENUMMONITORS,
5765                                     &state->tmp);
5766         if (tevent_req_nomem(subreq, req)) {
5767                 return tevent_req_post(req, ev);
5768         }
5769         tevent_req_set_callback(subreq, rpccli_spoolss_EnumMonitors_done, req);
5770         return req;
5771 }
5772
5773 static void rpccli_spoolss_EnumMonitors_done(struct tevent_req *subreq)
5774 {
5775         struct tevent_req *req = tevent_req_callback_data(
5776                 subreq, struct tevent_req);
5777         struct rpccli_spoolss_EnumMonitors_state *state = tevent_req_data(
5778                 req, struct rpccli_spoolss_EnumMonitors_state);
5779         NTSTATUS status;
5780         TALLOC_CTX *mem_ctx;
5781
5782         if (state->out_mem_ctx) {
5783                 mem_ctx = state->out_mem_ctx;
5784         } else {
5785                 mem_ctx = state;
5786         }
5787
5788         status = state->dispatch_recv(subreq, mem_ctx);
5789         TALLOC_FREE(subreq);
5790         if (!NT_STATUS_IS_OK(status)) {
5791                 tevent_req_nterror(req, status);
5792                 return;
5793         }
5794
5795         /* Copy out parameters */
5796         *state->orig.out.count = *state->tmp.out.count;
5797         *state->orig.out.info = *state->tmp.out.info;
5798         *state->orig.out.needed = *state->tmp.out.needed;
5799
5800         /* Copy result */
5801         state->orig.out.result = state->tmp.out.result;
5802
5803         /* Reset temporary structure */
5804         ZERO_STRUCT(state->tmp);
5805
5806         tevent_req_done(req);
5807 }
5808
5809 NTSTATUS rpccli_spoolss_EnumMonitors_recv(struct tevent_req *req,
5810                                           TALLOC_CTX *mem_ctx,
5811                                           WERROR *result)
5812 {
5813         struct rpccli_spoolss_EnumMonitors_state *state = tevent_req_data(
5814                 req, struct rpccli_spoolss_EnumMonitors_state);
5815         NTSTATUS status;
5816
5817         if (tevent_req_is_nterror(req, &status)) {
5818                 tevent_req_received(req);
5819                 return status;
5820         }
5821
5822         /* Steal possbile out parameters to the callers context */
5823         talloc_steal(mem_ctx, state->out_mem_ctx);
5824
5825         /* Return result */
5826         *result = state->orig.out.result;
5827
5828         tevent_req_received(req);
5829         return NT_STATUS_OK;
5830 }
5831
5832 NTSTATUS rpccli_spoolss_EnumMonitors(struct rpc_pipe_client *cli,
5833                                      TALLOC_CTX *mem_ctx,
5834                                      const char *servername /* [in] [unique,charset(UTF16)] */,
5835                                      uint32_t level /* [in]  */,
5836                                      DATA_BLOB *buffer /* [in] [unique] */,
5837                                      uint32_t offered /* [in]  */,
5838                                      uint32_t *count /* [out] [ref] */,
5839                                      union spoolss_MonitorInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
5840                                      uint32_t *needed /* [out] [ref] */,
5841                                      WERROR *werror)
5842 {
5843         struct spoolss_EnumMonitors r;
5844         NTSTATUS status;
5845
5846         /* In parameters */
5847         r.in.servername = servername;
5848         r.in.level = level;
5849         r.in.buffer = buffer;
5850         r.in.offered = offered;
5851
5852         status = cli->dispatch(cli,
5853                                 mem_ctx,
5854                                 &ndr_table_spoolss,
5855                                 NDR_SPOOLSS_ENUMMONITORS,
5856                                 &r);
5857
5858         if (!NT_STATUS_IS_OK(status)) {
5859                 return status;
5860         }
5861
5862         if (NT_STATUS_IS_ERR(status)) {
5863                 return status;
5864         }
5865
5866         /* Return variables */
5867         *count = *r.out.count;
5868         *info = *r.out.info;
5869         *needed = *r.out.needed;
5870
5871         /* Return result */
5872         if (werror) {
5873                 *werror = r.out.result;
5874         }
5875
5876         return werror_to_ntstatus(r.out.result);
5877 }
5878
5879 struct rpccli_spoolss_AddPort_state {
5880         struct spoolss_AddPort orig;
5881         struct spoolss_AddPort tmp;
5882         TALLOC_CTX *out_mem_ctx;
5883         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5884 };
5885
5886 static void rpccli_spoolss_AddPort_done(struct tevent_req *subreq);
5887
5888 struct tevent_req *rpccli_spoolss_AddPort_send(TALLOC_CTX *mem_ctx,
5889                                                struct tevent_context *ev,
5890                                                struct rpc_pipe_client *cli,
5891                                                const char *_server_name /* [in] [unique,charset(UTF16)] */,
5892                                                uint32_t _unknown /* [in]  */,
5893                                                const char *_monitor_name /* [in] [charset(UTF16)] */)
5894 {
5895         struct tevent_req *req;
5896         struct rpccli_spoolss_AddPort_state *state;
5897         struct tevent_req *subreq;
5898
5899         req = tevent_req_create(mem_ctx, &state,
5900                                 struct rpccli_spoolss_AddPort_state);
5901         if (req == NULL) {
5902                 return NULL;
5903         }
5904         state->out_mem_ctx = NULL;
5905         state->dispatch_recv = cli->dispatch_recv;
5906
5907         /* In parameters */
5908         state->orig.in.server_name = _server_name;
5909         state->orig.in.unknown = _unknown;
5910         state->orig.in.monitor_name = _monitor_name;
5911
5912         /* Out parameters */
5913
5914         /* Result */
5915         ZERO_STRUCT(state->orig.out.result);
5916
5917         /* make a temporary copy, that we pass to the dispatch function */
5918         state->tmp = state->orig;
5919
5920         subreq = cli->dispatch_send(state, ev, cli,
5921                                     &ndr_table_spoolss,
5922                                     NDR_SPOOLSS_ADDPORT,
5923                                     &state->tmp);
5924         if (tevent_req_nomem(subreq, req)) {
5925                 return tevent_req_post(req, ev);
5926         }
5927         tevent_req_set_callback(subreq, rpccli_spoolss_AddPort_done, req);
5928         return req;
5929 }
5930
5931 static void rpccli_spoolss_AddPort_done(struct tevent_req *subreq)
5932 {
5933         struct tevent_req *req = tevent_req_callback_data(
5934                 subreq, struct tevent_req);
5935         struct rpccli_spoolss_AddPort_state *state = tevent_req_data(
5936                 req, struct rpccli_spoolss_AddPort_state);
5937         NTSTATUS status;
5938         TALLOC_CTX *mem_ctx;
5939
5940         if (state->out_mem_ctx) {
5941                 mem_ctx = state->out_mem_ctx;
5942         } else {
5943                 mem_ctx = state;
5944         }
5945
5946         status = state->dispatch_recv(subreq, mem_ctx);
5947         TALLOC_FREE(subreq);
5948         if (!NT_STATUS_IS_OK(status)) {
5949                 tevent_req_nterror(req, status);
5950                 return;
5951         }
5952
5953         /* Copy out parameters */
5954
5955         /* Copy result */
5956         state->orig.out.result = state->tmp.out.result;
5957
5958         /* Reset temporary structure */
5959         ZERO_STRUCT(state->tmp);
5960
5961         tevent_req_done(req);
5962 }
5963
5964 NTSTATUS rpccli_spoolss_AddPort_recv(struct tevent_req *req,
5965                                      TALLOC_CTX *mem_ctx,
5966                                      WERROR *result)
5967 {
5968         struct rpccli_spoolss_AddPort_state *state = tevent_req_data(
5969                 req, struct rpccli_spoolss_AddPort_state);
5970         NTSTATUS status;
5971
5972         if (tevent_req_is_nterror(req, &status)) {
5973                 tevent_req_received(req);
5974                 return status;
5975         }
5976
5977         /* Steal possbile out parameters to the callers context */
5978         talloc_steal(mem_ctx, state->out_mem_ctx);
5979
5980         /* Return result */
5981         *result = state->orig.out.result;
5982
5983         tevent_req_received(req);
5984         return NT_STATUS_OK;
5985 }
5986
5987 NTSTATUS rpccli_spoolss_AddPort(struct rpc_pipe_client *cli,
5988                                 TALLOC_CTX *mem_ctx,
5989                                 const char *server_name /* [in] [unique,charset(UTF16)] */,
5990                                 uint32_t unknown /* [in]  */,
5991                                 const char *monitor_name /* [in] [charset(UTF16)] */,
5992                                 WERROR *werror)
5993 {
5994         struct spoolss_AddPort r;
5995         NTSTATUS status;
5996
5997         /* In parameters */
5998         r.in.server_name = server_name;
5999         r.in.unknown = unknown;
6000         r.in.monitor_name = monitor_name;
6001
6002         status = cli->dispatch(cli,
6003                                 mem_ctx,
6004                                 &ndr_table_spoolss,
6005                                 NDR_SPOOLSS_ADDPORT,
6006                                 &r);
6007
6008         if (!NT_STATUS_IS_OK(status)) {
6009                 return status;
6010         }
6011
6012         if (NT_STATUS_IS_ERR(status)) {
6013                 return status;
6014         }
6015
6016         /* Return variables */
6017
6018         /* Return result */
6019         if (werror) {
6020                 *werror = r.out.result;
6021         }
6022
6023         return werror_to_ntstatus(r.out.result);
6024 }
6025
6026 struct rpccli_spoolss_ConfigurePort_state {
6027         struct spoolss_ConfigurePort orig;
6028         struct spoolss_ConfigurePort tmp;
6029         TALLOC_CTX *out_mem_ctx;
6030         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6031 };
6032
6033 static void rpccli_spoolss_ConfigurePort_done(struct tevent_req *subreq);
6034
6035 struct tevent_req *rpccli_spoolss_ConfigurePort_send(TALLOC_CTX *mem_ctx,
6036                                                      struct tevent_context *ev,
6037                                                      struct rpc_pipe_client *cli)
6038 {
6039         struct tevent_req *req;
6040         struct rpccli_spoolss_ConfigurePort_state *state;
6041         struct tevent_req *subreq;
6042
6043         req = tevent_req_create(mem_ctx, &state,
6044                                 struct rpccli_spoolss_ConfigurePort_state);
6045         if (req == NULL) {
6046                 return NULL;
6047         }
6048         state->out_mem_ctx = NULL;
6049         state->dispatch_recv = cli->dispatch_recv;
6050
6051         /* In parameters */
6052
6053         /* Out parameters */
6054
6055         /* Result */
6056         ZERO_STRUCT(state->orig.out.result);
6057
6058         /* make a temporary copy, that we pass to the dispatch function */
6059         state->tmp = state->orig;
6060
6061         subreq = cli->dispatch_send(state, ev, cli,
6062                                     &ndr_table_spoolss,
6063                                     NDR_SPOOLSS_CONFIGUREPORT,
6064                                     &state->tmp);
6065         if (tevent_req_nomem(subreq, req)) {
6066                 return tevent_req_post(req, ev);
6067         }
6068         tevent_req_set_callback(subreq, rpccli_spoolss_ConfigurePort_done, req);
6069         return req;
6070 }
6071
6072 static void rpccli_spoolss_ConfigurePort_done(struct tevent_req *subreq)
6073 {
6074         struct tevent_req *req = tevent_req_callback_data(
6075                 subreq, struct tevent_req);
6076         struct rpccli_spoolss_ConfigurePort_state *state = tevent_req_data(
6077                 req, struct rpccli_spoolss_ConfigurePort_state);
6078         NTSTATUS status;
6079         TALLOC_CTX *mem_ctx;
6080
6081         if (state->out_mem_ctx) {
6082                 mem_ctx = state->out_mem_ctx;
6083         } else {
6084                 mem_ctx = state;
6085         }
6086
6087         status = state->dispatch_recv(subreq, mem_ctx);
6088         TALLOC_FREE(subreq);
6089         if (!NT_STATUS_IS_OK(status)) {
6090                 tevent_req_nterror(req, status);
6091                 return;
6092         }
6093
6094         /* Copy out parameters */
6095
6096         /* Copy result */
6097         state->orig.out.result = state->tmp.out.result;
6098
6099         /* Reset temporary structure */
6100         ZERO_STRUCT(state->tmp);
6101
6102         tevent_req_done(req);
6103 }
6104
6105 NTSTATUS rpccli_spoolss_ConfigurePort_recv(struct tevent_req *req,
6106                                            TALLOC_CTX *mem_ctx,
6107                                            WERROR *result)
6108 {
6109         struct rpccli_spoolss_ConfigurePort_state *state = tevent_req_data(
6110                 req, struct rpccli_spoolss_ConfigurePort_state);
6111         NTSTATUS status;
6112
6113         if (tevent_req_is_nterror(req, &status)) {
6114                 tevent_req_received(req);
6115                 return status;
6116         }
6117
6118         /* Steal possbile out parameters to the callers context */
6119         talloc_steal(mem_ctx, state->out_mem_ctx);
6120
6121         /* Return result */
6122         *result = state->orig.out.result;
6123
6124         tevent_req_received(req);
6125         return NT_STATUS_OK;
6126 }
6127
6128 NTSTATUS rpccli_spoolss_ConfigurePort(struct rpc_pipe_client *cli,
6129                                       TALLOC_CTX *mem_ctx,
6130                                       WERROR *werror)
6131 {
6132         struct spoolss_ConfigurePort r;
6133         NTSTATUS status;
6134
6135         /* In parameters */
6136
6137         status = cli->dispatch(cli,
6138                                 mem_ctx,
6139                                 &ndr_table_spoolss,
6140                                 NDR_SPOOLSS_CONFIGUREPORT,
6141                                 &r);
6142
6143         if (!NT_STATUS_IS_OK(status)) {
6144                 return status;
6145         }
6146
6147         if (NT_STATUS_IS_ERR(status)) {
6148                 return status;
6149         }
6150
6151         /* Return variables */
6152
6153         /* Return result */
6154         if (werror) {
6155                 *werror = r.out.result;
6156         }
6157
6158         return werror_to_ntstatus(r.out.result);
6159 }
6160
6161 struct rpccli_spoolss_DeletePort_state {
6162         struct spoolss_DeletePort orig;
6163         struct spoolss_DeletePort tmp;
6164         TALLOC_CTX *out_mem_ctx;
6165         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6166 };
6167
6168 static void rpccli_spoolss_DeletePort_done(struct tevent_req *subreq);
6169
6170 struct tevent_req *rpccli_spoolss_DeletePort_send(TALLOC_CTX *mem_ctx,
6171                                                   struct tevent_context *ev,
6172                                                   struct rpc_pipe_client *cli)
6173 {
6174         struct tevent_req *req;
6175         struct rpccli_spoolss_DeletePort_state *state;
6176         struct tevent_req *subreq;
6177
6178         req = tevent_req_create(mem_ctx, &state,
6179                                 struct rpccli_spoolss_DeletePort_state);
6180         if (req == NULL) {
6181                 return NULL;
6182         }
6183         state->out_mem_ctx = NULL;
6184         state->dispatch_recv = cli->dispatch_recv;
6185
6186         /* In parameters */
6187
6188         /* Out parameters */
6189
6190         /* Result */
6191         ZERO_STRUCT(state->orig.out.result);
6192
6193         /* make a temporary copy, that we pass to the dispatch function */
6194         state->tmp = state->orig;
6195
6196         subreq = cli->dispatch_send(state, ev, cli,
6197                                     &ndr_table_spoolss,
6198                                     NDR_SPOOLSS_DELETEPORT,
6199                                     &state->tmp);
6200         if (tevent_req_nomem(subreq, req)) {
6201                 return tevent_req_post(req, ev);
6202         }
6203         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePort_done, req);
6204         return req;
6205 }
6206
6207 static void rpccli_spoolss_DeletePort_done(struct tevent_req *subreq)
6208 {
6209         struct tevent_req *req = tevent_req_callback_data(
6210                 subreq, struct tevent_req);
6211         struct rpccli_spoolss_DeletePort_state *state = tevent_req_data(
6212                 req, struct rpccli_spoolss_DeletePort_state);
6213         NTSTATUS status;
6214         TALLOC_CTX *mem_ctx;
6215
6216         if (state->out_mem_ctx) {
6217                 mem_ctx = state->out_mem_ctx;
6218         } else {
6219                 mem_ctx = state;
6220         }
6221
6222         status = state->dispatch_recv(subreq, mem_ctx);
6223         TALLOC_FREE(subreq);
6224         if (!NT_STATUS_IS_OK(status)) {
6225                 tevent_req_nterror(req, status);
6226                 return;
6227         }
6228
6229         /* Copy out parameters */
6230
6231         /* Copy result */
6232         state->orig.out.result = state->tmp.out.result;
6233
6234         /* Reset temporary structure */
6235         ZERO_STRUCT(state->tmp);
6236
6237         tevent_req_done(req);
6238 }
6239
6240 NTSTATUS rpccli_spoolss_DeletePort_recv(struct tevent_req *req,
6241                                         TALLOC_CTX *mem_ctx,
6242                                         WERROR *result)
6243 {
6244         struct rpccli_spoolss_DeletePort_state *state = tevent_req_data(
6245                 req, struct rpccli_spoolss_DeletePort_state);
6246         NTSTATUS status;
6247
6248         if (tevent_req_is_nterror(req, &status)) {
6249                 tevent_req_received(req);
6250                 return status;
6251         }
6252
6253         /* Steal possbile out parameters to the callers context */
6254         talloc_steal(mem_ctx, state->out_mem_ctx);
6255
6256         /* Return result */
6257         *result = state->orig.out.result;
6258
6259         tevent_req_received(req);
6260         return NT_STATUS_OK;
6261 }
6262
6263 NTSTATUS rpccli_spoolss_DeletePort(struct rpc_pipe_client *cli,
6264                                    TALLOC_CTX *mem_ctx,
6265                                    WERROR *werror)
6266 {
6267         struct spoolss_DeletePort r;
6268         NTSTATUS status;
6269
6270         /* In parameters */
6271
6272         status = cli->dispatch(cli,
6273                                 mem_ctx,
6274                                 &ndr_table_spoolss,
6275                                 NDR_SPOOLSS_DELETEPORT,
6276                                 &r);
6277
6278         if (!NT_STATUS_IS_OK(status)) {
6279                 return status;
6280         }
6281
6282         if (NT_STATUS_IS_ERR(status)) {
6283                 return status;
6284         }
6285
6286         /* Return variables */
6287
6288         /* Return result */
6289         if (werror) {
6290                 *werror = r.out.result;
6291         }
6292
6293         return werror_to_ntstatus(r.out.result);
6294 }
6295
6296 struct rpccli_spoolss_CreatePrinterIC_state {
6297         struct spoolss_CreatePrinterIC orig;
6298         struct spoolss_CreatePrinterIC tmp;
6299         TALLOC_CTX *out_mem_ctx;
6300         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6301 };
6302
6303 static void rpccli_spoolss_CreatePrinterIC_done(struct tevent_req *subreq);
6304
6305 struct tevent_req *rpccli_spoolss_CreatePrinterIC_send(TALLOC_CTX *mem_ctx,
6306                                                        struct tevent_context *ev,
6307                                                        struct rpc_pipe_client *cli,
6308                                                        struct policy_handle *_handle /* [in] [ref] */,
6309                                                        struct policy_handle *_gdi_handle /* [out] [ref] */,
6310                                                        struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */)
6311 {
6312         struct tevent_req *req;
6313         struct rpccli_spoolss_CreatePrinterIC_state *state;
6314         struct tevent_req *subreq;
6315
6316         req = tevent_req_create(mem_ctx, &state,
6317                                 struct rpccli_spoolss_CreatePrinterIC_state);
6318         if (req == NULL) {
6319                 return NULL;
6320         }
6321         state->out_mem_ctx = NULL;
6322         state->dispatch_recv = cli->dispatch_recv;
6323
6324         /* In parameters */
6325         state->orig.in.handle = _handle;
6326         state->orig.in.devmode_ctr = _devmode_ctr;
6327
6328         /* Out parameters */
6329         state->orig.out.gdi_handle = _gdi_handle;
6330
6331         /* Result */
6332         ZERO_STRUCT(state->orig.out.result);
6333
6334         state->out_mem_ctx = talloc_named_const(state, 0,
6335                              "rpccli_spoolss_CreatePrinterIC_out_memory");
6336         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6337                 return tevent_req_post(req, ev);
6338         }
6339
6340         /* make a temporary copy, that we pass to the dispatch function */
6341         state->tmp = state->orig;
6342
6343         subreq = cli->dispatch_send(state, ev, cli,
6344                                     &ndr_table_spoolss,
6345                                     NDR_SPOOLSS_CREATEPRINTERIC,
6346                                     &state->tmp);
6347         if (tevent_req_nomem(subreq, req)) {
6348                 return tevent_req_post(req, ev);
6349         }
6350         tevent_req_set_callback(subreq, rpccli_spoolss_CreatePrinterIC_done, req);
6351         return req;
6352 }
6353
6354 static void rpccli_spoolss_CreatePrinterIC_done(struct tevent_req *subreq)
6355 {
6356         struct tevent_req *req = tevent_req_callback_data(
6357                 subreq, struct tevent_req);
6358         struct rpccli_spoolss_CreatePrinterIC_state *state = tevent_req_data(
6359                 req, struct rpccli_spoolss_CreatePrinterIC_state);
6360         NTSTATUS status;
6361         TALLOC_CTX *mem_ctx;
6362
6363         if (state->out_mem_ctx) {
6364                 mem_ctx = state->out_mem_ctx;
6365         } else {
6366                 mem_ctx = state;
6367         }
6368
6369         status = state->dispatch_recv(subreq, mem_ctx);
6370         TALLOC_FREE(subreq);
6371         if (!NT_STATUS_IS_OK(status)) {
6372                 tevent_req_nterror(req, status);
6373                 return;
6374         }
6375
6376         /* Copy out parameters */
6377         *state->orig.out.gdi_handle = *state->tmp.out.gdi_handle;
6378
6379         /* Copy result */
6380         state->orig.out.result = state->tmp.out.result;
6381
6382         /* Reset temporary structure */
6383         ZERO_STRUCT(state->tmp);
6384
6385         tevent_req_done(req);
6386 }
6387
6388 NTSTATUS rpccli_spoolss_CreatePrinterIC_recv(struct tevent_req *req,
6389                                              TALLOC_CTX *mem_ctx,
6390                                              WERROR *result)
6391 {
6392         struct rpccli_spoolss_CreatePrinterIC_state *state = tevent_req_data(
6393                 req, struct rpccli_spoolss_CreatePrinterIC_state);
6394         NTSTATUS status;
6395
6396         if (tevent_req_is_nterror(req, &status)) {
6397                 tevent_req_received(req);
6398                 return status;
6399         }
6400
6401         /* Steal possbile out parameters to the callers context */
6402         talloc_steal(mem_ctx, state->out_mem_ctx);
6403
6404         /* Return result */
6405         *result = state->orig.out.result;
6406
6407         tevent_req_received(req);
6408         return NT_STATUS_OK;
6409 }
6410
6411 NTSTATUS rpccli_spoolss_CreatePrinterIC(struct rpc_pipe_client *cli,
6412                                         TALLOC_CTX *mem_ctx,
6413                                         struct policy_handle *handle /* [in] [ref] */,
6414                                         struct policy_handle *gdi_handle /* [out] [ref] */,
6415                                         struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
6416                                         WERROR *werror)
6417 {
6418         struct spoolss_CreatePrinterIC r;
6419         NTSTATUS status;
6420
6421         /* In parameters */
6422         r.in.handle = handle;
6423         r.in.devmode_ctr = devmode_ctr;
6424
6425         status = cli->dispatch(cli,
6426                                 mem_ctx,
6427                                 &ndr_table_spoolss,
6428                                 NDR_SPOOLSS_CREATEPRINTERIC,
6429                                 &r);
6430
6431         if (!NT_STATUS_IS_OK(status)) {
6432                 return status;
6433         }
6434
6435         if (NT_STATUS_IS_ERR(status)) {
6436                 return status;
6437         }
6438
6439         /* Return variables */
6440         *gdi_handle = *r.out.gdi_handle;
6441
6442         /* Return result */
6443         if (werror) {
6444                 *werror = r.out.result;
6445         }
6446
6447         return werror_to_ntstatus(r.out.result);
6448 }
6449
6450 struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state {
6451         struct spoolss_PlayGDIScriptOnPrinterIC orig;
6452         struct spoolss_PlayGDIScriptOnPrinterIC tmp;
6453         TALLOC_CTX *out_mem_ctx;
6454         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6455 };
6456
6457 static void rpccli_spoolss_PlayGDIScriptOnPrinterIC_done(struct tevent_req *subreq);
6458
6459 struct tevent_req *rpccli_spoolss_PlayGDIScriptOnPrinterIC_send(TALLOC_CTX *mem_ctx,
6460                                                                 struct tevent_context *ev,
6461                                                                 struct rpc_pipe_client *cli)
6462 {
6463         struct tevent_req *req;
6464         struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state *state;
6465         struct tevent_req *subreq;
6466
6467         req = tevent_req_create(mem_ctx, &state,
6468                                 struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state);
6469         if (req == NULL) {
6470                 return NULL;
6471         }
6472         state->out_mem_ctx = NULL;
6473         state->dispatch_recv = cli->dispatch_recv;
6474
6475         /* In parameters */
6476
6477         /* Out parameters */
6478
6479         /* Result */
6480         ZERO_STRUCT(state->orig.out.result);
6481
6482         /* make a temporary copy, that we pass to the dispatch function */
6483         state->tmp = state->orig;
6484
6485         subreq = cli->dispatch_send(state, ev, cli,
6486                                     &ndr_table_spoolss,
6487                                     NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC,
6488                                     &state->tmp);
6489         if (tevent_req_nomem(subreq, req)) {
6490                 return tevent_req_post(req, ev);
6491         }
6492         tevent_req_set_callback(subreq, rpccli_spoolss_PlayGDIScriptOnPrinterIC_done, req);
6493         return req;
6494 }
6495
6496 static void rpccli_spoolss_PlayGDIScriptOnPrinterIC_done(struct tevent_req *subreq)
6497 {
6498         struct tevent_req *req = tevent_req_callback_data(
6499                 subreq, struct tevent_req);
6500         struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state *state = tevent_req_data(
6501                 req, struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state);
6502         NTSTATUS status;
6503         TALLOC_CTX *mem_ctx;
6504
6505         if (state->out_mem_ctx) {
6506                 mem_ctx = state->out_mem_ctx;
6507         } else {
6508                 mem_ctx = state;
6509         }
6510
6511         status = state->dispatch_recv(subreq, mem_ctx);
6512         TALLOC_FREE(subreq);
6513         if (!NT_STATUS_IS_OK(status)) {
6514                 tevent_req_nterror(req, status);
6515                 return;
6516         }
6517
6518         /* Copy out parameters */
6519
6520         /* Copy result */
6521         state->orig.out.result = state->tmp.out.result;
6522
6523         /* Reset temporary structure */
6524         ZERO_STRUCT(state->tmp);
6525
6526         tevent_req_done(req);
6527 }
6528
6529 NTSTATUS rpccli_spoolss_PlayGDIScriptOnPrinterIC_recv(struct tevent_req *req,
6530                                                       TALLOC_CTX *mem_ctx,
6531                                                       WERROR *result)
6532 {
6533         struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state *state = tevent_req_data(
6534                 req, struct rpccli_spoolss_PlayGDIScriptOnPrinterIC_state);
6535         NTSTATUS status;
6536
6537         if (tevent_req_is_nterror(req, &status)) {
6538                 tevent_req_received(req);
6539                 return status;
6540         }
6541
6542         /* Steal possbile out parameters to the callers context */
6543         talloc_steal(mem_ctx, state->out_mem_ctx);
6544
6545         /* Return result */
6546         *result = state->orig.out.result;
6547
6548         tevent_req_received(req);
6549         return NT_STATUS_OK;
6550 }
6551
6552 NTSTATUS rpccli_spoolss_PlayGDIScriptOnPrinterIC(struct rpc_pipe_client *cli,
6553                                                  TALLOC_CTX *mem_ctx,
6554                                                  WERROR *werror)
6555 {
6556         struct spoolss_PlayGDIScriptOnPrinterIC r;
6557         NTSTATUS status;
6558
6559         /* In parameters */
6560
6561         status = cli->dispatch(cli,
6562                                 mem_ctx,
6563                                 &ndr_table_spoolss,
6564                                 NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC,
6565                                 &r);
6566
6567         if (!NT_STATUS_IS_OK(status)) {
6568                 return status;
6569         }
6570
6571         if (NT_STATUS_IS_ERR(status)) {
6572                 return status;
6573         }
6574
6575         /* Return variables */
6576
6577         /* Return result */
6578         if (werror) {
6579                 *werror = r.out.result;
6580         }
6581
6582         return werror_to_ntstatus(r.out.result);
6583 }
6584
6585 struct rpccli_spoolss_DeletePrinterIC_state {
6586         struct spoolss_DeletePrinterIC orig;
6587         struct spoolss_DeletePrinterIC tmp;
6588         TALLOC_CTX *out_mem_ctx;
6589         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6590 };
6591
6592 static void rpccli_spoolss_DeletePrinterIC_done(struct tevent_req *subreq);
6593
6594 struct tevent_req *rpccli_spoolss_DeletePrinterIC_send(TALLOC_CTX *mem_ctx,
6595                                                        struct tevent_context *ev,
6596                                                        struct rpc_pipe_client *cli,
6597                                                        struct policy_handle *_gdi_handle /* [in,out] [ref] */)
6598 {
6599         struct tevent_req *req;
6600         struct rpccli_spoolss_DeletePrinterIC_state *state;
6601         struct tevent_req *subreq;
6602
6603         req = tevent_req_create(mem_ctx, &state,
6604                                 struct rpccli_spoolss_DeletePrinterIC_state);
6605         if (req == NULL) {
6606                 return NULL;
6607         }
6608         state->out_mem_ctx = NULL;
6609         state->dispatch_recv = cli->dispatch_recv;
6610
6611         /* In parameters */
6612         state->orig.in.gdi_handle = _gdi_handle;
6613
6614         /* Out parameters */
6615         state->orig.out.gdi_handle = _gdi_handle;
6616
6617         /* Result */
6618         ZERO_STRUCT(state->orig.out.result);
6619
6620         state->out_mem_ctx = talloc_named_const(state, 0,
6621                              "rpccli_spoolss_DeletePrinterIC_out_memory");
6622         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6623                 return tevent_req_post(req, ev);
6624         }
6625
6626         /* make a temporary copy, that we pass to the dispatch function */
6627         state->tmp = state->orig;
6628
6629         subreq = cli->dispatch_send(state, ev, cli,
6630                                     &ndr_table_spoolss,
6631                                     NDR_SPOOLSS_DELETEPRINTERIC,
6632                                     &state->tmp);
6633         if (tevent_req_nomem(subreq, req)) {
6634                 return tevent_req_post(req, ev);
6635         }
6636         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterIC_done, req);
6637         return req;
6638 }
6639
6640 static void rpccli_spoolss_DeletePrinterIC_done(struct tevent_req *subreq)
6641 {
6642         struct tevent_req *req = tevent_req_callback_data(
6643                 subreq, struct tevent_req);
6644         struct rpccli_spoolss_DeletePrinterIC_state *state = tevent_req_data(
6645                 req, struct rpccli_spoolss_DeletePrinterIC_state);
6646         NTSTATUS status;
6647         TALLOC_CTX *mem_ctx;
6648
6649         if (state->out_mem_ctx) {
6650                 mem_ctx = state->out_mem_ctx;
6651         } else {
6652                 mem_ctx = state;
6653         }
6654
6655         status = state->dispatch_recv(subreq, mem_ctx);
6656         TALLOC_FREE(subreq);
6657         if (!NT_STATUS_IS_OK(status)) {
6658                 tevent_req_nterror(req, status);
6659                 return;
6660         }
6661
6662         /* Copy out parameters */
6663         *state->orig.out.gdi_handle = *state->tmp.out.gdi_handle;
6664
6665         /* Copy result */
6666         state->orig.out.result = state->tmp.out.result;
6667
6668         /* Reset temporary structure */
6669         ZERO_STRUCT(state->tmp);
6670
6671         tevent_req_done(req);
6672 }
6673
6674 NTSTATUS rpccli_spoolss_DeletePrinterIC_recv(struct tevent_req *req,
6675                                              TALLOC_CTX *mem_ctx,
6676                                              WERROR *result)
6677 {
6678         struct rpccli_spoolss_DeletePrinterIC_state *state = tevent_req_data(
6679                 req, struct rpccli_spoolss_DeletePrinterIC_state);
6680         NTSTATUS status;
6681
6682         if (tevent_req_is_nterror(req, &status)) {
6683                 tevent_req_received(req);
6684                 return status;
6685         }
6686
6687         /* Steal possbile out parameters to the callers context */
6688         talloc_steal(mem_ctx, state->out_mem_ctx);
6689
6690         /* Return result */
6691         *result = state->orig.out.result;
6692
6693         tevent_req_received(req);
6694         return NT_STATUS_OK;
6695 }
6696
6697 NTSTATUS rpccli_spoolss_DeletePrinterIC(struct rpc_pipe_client *cli,
6698                                         TALLOC_CTX *mem_ctx,
6699                                         struct policy_handle *gdi_handle /* [in,out] [ref] */,
6700                                         WERROR *werror)
6701 {
6702         struct spoolss_DeletePrinterIC r;
6703         NTSTATUS status;
6704
6705         /* In parameters */
6706         r.in.gdi_handle = gdi_handle;
6707
6708         status = cli->dispatch(cli,
6709                                 mem_ctx,
6710                                 &ndr_table_spoolss,
6711                                 NDR_SPOOLSS_DELETEPRINTERIC,
6712                                 &r);
6713
6714         if (!NT_STATUS_IS_OK(status)) {
6715                 return status;
6716         }
6717
6718         if (NT_STATUS_IS_ERR(status)) {
6719                 return status;
6720         }
6721
6722         /* Return variables */
6723         *gdi_handle = *r.out.gdi_handle;
6724
6725         /* Return result */
6726         if (werror) {
6727                 *werror = r.out.result;
6728         }
6729
6730         return werror_to_ntstatus(r.out.result);
6731 }
6732
6733 struct rpccli_spoolss_AddPrinterConnection_state {
6734         struct spoolss_AddPrinterConnection orig;
6735         struct spoolss_AddPrinterConnection tmp;
6736         TALLOC_CTX *out_mem_ctx;
6737         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6738 };
6739
6740 static void rpccli_spoolss_AddPrinterConnection_done(struct tevent_req *subreq);
6741
6742 struct tevent_req *rpccli_spoolss_AddPrinterConnection_send(TALLOC_CTX *mem_ctx,
6743                                                             struct tevent_context *ev,
6744                                                             struct rpc_pipe_client *cli)
6745 {
6746         struct tevent_req *req;
6747         struct rpccli_spoolss_AddPrinterConnection_state *state;
6748         struct tevent_req *subreq;
6749
6750         req = tevent_req_create(mem_ctx, &state,
6751                                 struct rpccli_spoolss_AddPrinterConnection_state);
6752         if (req == NULL) {
6753                 return NULL;
6754         }
6755         state->out_mem_ctx = NULL;
6756         state->dispatch_recv = cli->dispatch_recv;
6757
6758         /* In parameters */
6759
6760         /* Out parameters */
6761
6762         /* Result */
6763         ZERO_STRUCT(state->orig.out.result);
6764
6765         /* make a temporary copy, that we pass to the dispatch function */
6766         state->tmp = state->orig;
6767
6768         subreq = cli->dispatch_send(state, ev, cli,
6769                                     &ndr_table_spoolss,
6770                                     NDR_SPOOLSS_ADDPRINTERCONNECTION,
6771                                     &state->tmp);
6772         if (tevent_req_nomem(subreq, req)) {
6773                 return tevent_req_post(req, ev);
6774         }
6775         tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterConnection_done, req);
6776         return req;
6777 }
6778
6779 static void rpccli_spoolss_AddPrinterConnection_done(struct tevent_req *subreq)
6780 {
6781         struct tevent_req *req = tevent_req_callback_data(
6782                 subreq, struct tevent_req);
6783         struct rpccli_spoolss_AddPrinterConnection_state *state = tevent_req_data(
6784                 req, struct rpccli_spoolss_AddPrinterConnection_state);
6785         NTSTATUS status;
6786         TALLOC_CTX *mem_ctx;
6787
6788         if (state->out_mem_ctx) {
6789                 mem_ctx = state->out_mem_ctx;
6790         } else {
6791                 mem_ctx = state;
6792         }
6793
6794         status = state->dispatch_recv(subreq, mem_ctx);
6795         TALLOC_FREE(subreq);
6796         if (!NT_STATUS_IS_OK(status)) {
6797                 tevent_req_nterror(req, status);
6798                 return;
6799         }
6800
6801         /* Copy out parameters */
6802
6803         /* Copy result */
6804         state->orig.out.result = state->tmp.out.result;
6805
6806         /* Reset temporary structure */
6807         ZERO_STRUCT(state->tmp);
6808
6809         tevent_req_done(req);
6810 }
6811
6812 NTSTATUS rpccli_spoolss_AddPrinterConnection_recv(struct tevent_req *req,
6813                                                   TALLOC_CTX *mem_ctx,
6814                                                   WERROR *result)
6815 {
6816         struct rpccli_spoolss_AddPrinterConnection_state *state = tevent_req_data(
6817                 req, struct rpccli_spoolss_AddPrinterConnection_state);
6818         NTSTATUS status;
6819
6820         if (tevent_req_is_nterror(req, &status)) {
6821                 tevent_req_received(req);
6822                 return status;
6823         }
6824
6825         /* Steal possbile out parameters to the callers context */
6826         talloc_steal(mem_ctx, state->out_mem_ctx);
6827
6828         /* Return result */
6829         *result = state->orig.out.result;
6830
6831         tevent_req_received(req);
6832         return NT_STATUS_OK;
6833 }
6834
6835 NTSTATUS rpccli_spoolss_AddPrinterConnection(struct rpc_pipe_client *cli,
6836                                              TALLOC_CTX *mem_ctx,
6837                                              WERROR *werror)
6838 {
6839         struct spoolss_AddPrinterConnection r;
6840         NTSTATUS status;
6841
6842         /* In parameters */
6843
6844         status = cli->dispatch(cli,
6845                                 mem_ctx,
6846                                 &ndr_table_spoolss,
6847                                 NDR_SPOOLSS_ADDPRINTERCONNECTION,
6848                                 &r);
6849
6850         if (!NT_STATUS_IS_OK(status)) {
6851                 return status;
6852         }
6853
6854         if (NT_STATUS_IS_ERR(status)) {
6855                 return status;
6856         }
6857
6858         /* Return variables */
6859
6860         /* Return result */
6861         if (werror) {
6862                 *werror = r.out.result;
6863         }
6864
6865         return werror_to_ntstatus(r.out.result);
6866 }
6867
6868 struct rpccli_spoolss_DeletePrinterConnection_state {
6869         struct spoolss_DeletePrinterConnection orig;
6870         struct spoolss_DeletePrinterConnection tmp;
6871         TALLOC_CTX *out_mem_ctx;
6872         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6873 };
6874
6875 static void rpccli_spoolss_DeletePrinterConnection_done(struct tevent_req *subreq);
6876
6877 struct tevent_req *rpccli_spoolss_DeletePrinterConnection_send(TALLOC_CTX *mem_ctx,
6878                                                                struct tevent_context *ev,
6879                                                                struct rpc_pipe_client *cli)
6880 {
6881         struct tevent_req *req;
6882         struct rpccli_spoolss_DeletePrinterConnection_state *state;
6883         struct tevent_req *subreq;
6884
6885         req = tevent_req_create(mem_ctx, &state,
6886                                 struct rpccli_spoolss_DeletePrinterConnection_state);
6887         if (req == NULL) {
6888                 return NULL;
6889         }
6890         state->out_mem_ctx = NULL;
6891         state->dispatch_recv = cli->dispatch_recv;
6892
6893         /* In parameters */
6894
6895         /* Out parameters */
6896
6897         /* Result */
6898         ZERO_STRUCT(state->orig.out.result);
6899
6900         /* make a temporary copy, that we pass to the dispatch function */
6901         state->tmp = state->orig;
6902
6903         subreq = cli->dispatch_send(state, ev, cli,
6904                                     &ndr_table_spoolss,
6905                                     NDR_SPOOLSS_DELETEPRINTERCONNECTION,
6906                                     &state->tmp);
6907         if (tevent_req_nomem(subreq, req)) {
6908                 return tevent_req_post(req, ev);
6909         }
6910         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterConnection_done, req);
6911         return req;
6912 }
6913
6914 static void rpccli_spoolss_DeletePrinterConnection_done(struct tevent_req *subreq)
6915 {
6916         struct tevent_req *req = tevent_req_callback_data(
6917                 subreq, struct tevent_req);
6918         struct rpccli_spoolss_DeletePrinterConnection_state *state = tevent_req_data(
6919                 req, struct rpccli_spoolss_DeletePrinterConnection_state);
6920         NTSTATUS status;
6921         TALLOC_CTX *mem_ctx;
6922
6923         if (state->out_mem_ctx) {
6924                 mem_ctx = state->out_mem_ctx;
6925         } else {
6926                 mem_ctx = state;
6927         }
6928
6929         status = state->dispatch_recv(subreq, mem_ctx);
6930         TALLOC_FREE(subreq);
6931         if (!NT_STATUS_IS_OK(status)) {
6932                 tevent_req_nterror(req, status);
6933                 return;
6934         }
6935
6936         /* Copy out parameters */
6937
6938         /* Copy result */
6939         state->orig.out.result = state->tmp.out.result;
6940
6941         /* Reset temporary structure */
6942         ZERO_STRUCT(state->tmp);
6943
6944         tevent_req_done(req);
6945 }
6946
6947 NTSTATUS rpccli_spoolss_DeletePrinterConnection_recv(struct tevent_req *req,
6948                                                      TALLOC_CTX *mem_ctx,
6949                                                      WERROR *result)
6950 {
6951         struct rpccli_spoolss_DeletePrinterConnection_state *state = tevent_req_data(
6952                 req, struct rpccli_spoolss_DeletePrinterConnection_state);
6953         NTSTATUS status;
6954
6955         if (tevent_req_is_nterror(req, &status)) {
6956                 tevent_req_received(req);
6957                 return status;
6958         }
6959
6960         /* Steal possbile out parameters to the callers context */
6961         talloc_steal(mem_ctx, state->out_mem_ctx);
6962
6963         /* Return result */
6964         *result = state->orig.out.result;
6965
6966         tevent_req_received(req);
6967         return NT_STATUS_OK;
6968 }
6969
6970 NTSTATUS rpccli_spoolss_DeletePrinterConnection(struct rpc_pipe_client *cli,
6971                                                 TALLOC_CTX *mem_ctx,
6972                                                 WERROR *werror)
6973 {
6974         struct spoolss_DeletePrinterConnection r;
6975         NTSTATUS status;
6976
6977         /* In parameters */
6978
6979         status = cli->dispatch(cli,
6980                                 mem_ctx,
6981                                 &ndr_table_spoolss,
6982                                 NDR_SPOOLSS_DELETEPRINTERCONNECTION,
6983                                 &r);
6984
6985         if (!NT_STATUS_IS_OK(status)) {
6986                 return status;
6987         }
6988
6989         if (NT_STATUS_IS_ERR(status)) {
6990                 return status;
6991         }
6992
6993         /* Return variables */
6994
6995         /* Return result */
6996         if (werror) {
6997                 *werror = r.out.result;
6998         }
6999
7000         return werror_to_ntstatus(r.out.result);
7001 }
7002
7003 struct rpccli_spoolss_PrinterMessageBox_state {
7004         struct spoolss_PrinterMessageBox orig;
7005         struct spoolss_PrinterMessageBox tmp;
7006         TALLOC_CTX *out_mem_ctx;
7007         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7008 };
7009
7010 static void rpccli_spoolss_PrinterMessageBox_done(struct tevent_req *subreq);
7011
7012 struct tevent_req *rpccli_spoolss_PrinterMessageBox_send(TALLOC_CTX *mem_ctx,
7013                                                          struct tevent_context *ev,
7014                                                          struct rpc_pipe_client *cli)
7015 {
7016         struct tevent_req *req;
7017         struct rpccli_spoolss_PrinterMessageBox_state *state;
7018         struct tevent_req *subreq;
7019
7020         req = tevent_req_create(mem_ctx, &state,
7021                                 struct rpccli_spoolss_PrinterMessageBox_state);
7022         if (req == NULL) {
7023                 return NULL;
7024         }
7025         state->out_mem_ctx = NULL;
7026         state->dispatch_recv = cli->dispatch_recv;
7027
7028         /* In parameters */
7029
7030         /* Out parameters */
7031
7032         /* Result */
7033         ZERO_STRUCT(state->orig.out.result);
7034
7035         /* make a temporary copy, that we pass to the dispatch function */
7036         state->tmp = state->orig;
7037
7038         subreq = cli->dispatch_send(state, ev, cli,
7039                                     &ndr_table_spoolss,
7040                                     NDR_SPOOLSS_PRINTERMESSAGEBOX,
7041                                     &state->tmp);
7042         if (tevent_req_nomem(subreq, req)) {
7043                 return tevent_req_post(req, ev);
7044         }
7045         tevent_req_set_callback(subreq, rpccli_spoolss_PrinterMessageBox_done, req);
7046         return req;
7047 }
7048
7049 static void rpccli_spoolss_PrinterMessageBox_done(struct tevent_req *subreq)
7050 {
7051         struct tevent_req *req = tevent_req_callback_data(
7052                 subreq, struct tevent_req);
7053         struct rpccli_spoolss_PrinterMessageBox_state *state = tevent_req_data(
7054                 req, struct rpccli_spoolss_PrinterMessageBox_state);
7055         NTSTATUS status;
7056         TALLOC_CTX *mem_ctx;
7057
7058         if (state->out_mem_ctx) {
7059                 mem_ctx = state->out_mem_ctx;
7060         } else {
7061                 mem_ctx = state;
7062         }
7063
7064         status = state->dispatch_recv(subreq, mem_ctx);
7065         TALLOC_FREE(subreq);
7066         if (!NT_STATUS_IS_OK(status)) {
7067                 tevent_req_nterror(req, status);
7068                 return;
7069         }
7070
7071         /* Copy out parameters */
7072
7073         /* Copy result */
7074         state->orig.out.result = state->tmp.out.result;
7075
7076         /* Reset temporary structure */
7077         ZERO_STRUCT(state->tmp);
7078
7079         tevent_req_done(req);
7080 }
7081
7082 NTSTATUS rpccli_spoolss_PrinterMessageBox_recv(struct tevent_req *req,
7083                                                TALLOC_CTX *mem_ctx,
7084                                                WERROR *result)
7085 {
7086         struct rpccli_spoolss_PrinterMessageBox_state *state = tevent_req_data(
7087                 req, struct rpccli_spoolss_PrinterMessageBox_state);
7088         NTSTATUS status;
7089
7090         if (tevent_req_is_nterror(req, &status)) {
7091                 tevent_req_received(req);
7092                 return status;
7093         }
7094
7095         /* Steal possbile out parameters to the callers context */
7096         talloc_steal(mem_ctx, state->out_mem_ctx);
7097
7098         /* Return result */
7099         *result = state->orig.out.result;
7100
7101         tevent_req_received(req);
7102         return NT_STATUS_OK;
7103 }
7104
7105 NTSTATUS rpccli_spoolss_PrinterMessageBox(struct rpc_pipe_client *cli,
7106                                           TALLOC_CTX *mem_ctx,
7107                                           WERROR *werror)
7108 {
7109         struct spoolss_PrinterMessageBox r;
7110         NTSTATUS status;
7111
7112         /* In parameters */
7113
7114         status = cli->dispatch(cli,
7115                                 mem_ctx,
7116                                 &ndr_table_spoolss,
7117                                 NDR_SPOOLSS_PRINTERMESSAGEBOX,
7118                                 &r);
7119
7120         if (!NT_STATUS_IS_OK(status)) {
7121                 return status;
7122         }
7123
7124         if (NT_STATUS_IS_ERR(status)) {
7125                 return status;
7126         }
7127
7128         /* Return variables */
7129
7130         /* Return result */
7131         if (werror) {
7132                 *werror = r.out.result;
7133         }
7134
7135         return werror_to_ntstatus(r.out.result);
7136 }
7137
7138 struct rpccli_spoolss_AddMonitor_state {
7139         struct spoolss_AddMonitor orig;
7140         struct spoolss_AddMonitor tmp;
7141         TALLOC_CTX *out_mem_ctx;
7142         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7143 };
7144
7145 static void rpccli_spoolss_AddMonitor_done(struct tevent_req *subreq);
7146
7147 struct tevent_req *rpccli_spoolss_AddMonitor_send(TALLOC_CTX *mem_ctx,
7148                                                   struct tevent_context *ev,
7149                                                   struct rpc_pipe_client *cli)
7150 {
7151         struct tevent_req *req;
7152         struct rpccli_spoolss_AddMonitor_state *state;
7153         struct tevent_req *subreq;
7154
7155         req = tevent_req_create(mem_ctx, &state,
7156                                 struct rpccli_spoolss_AddMonitor_state);
7157         if (req == NULL) {
7158                 return NULL;
7159         }
7160         state->out_mem_ctx = NULL;
7161         state->dispatch_recv = cli->dispatch_recv;
7162
7163         /* In parameters */
7164
7165         /* Out parameters */
7166
7167         /* Result */
7168         ZERO_STRUCT(state->orig.out.result);
7169
7170         /* make a temporary copy, that we pass to the dispatch function */
7171         state->tmp = state->orig;
7172
7173         subreq = cli->dispatch_send(state, ev, cli,
7174                                     &ndr_table_spoolss,
7175                                     NDR_SPOOLSS_ADDMONITOR,
7176                                     &state->tmp);
7177         if (tevent_req_nomem(subreq, req)) {
7178                 return tevent_req_post(req, ev);
7179         }
7180         tevent_req_set_callback(subreq, rpccli_spoolss_AddMonitor_done, req);
7181         return req;
7182 }
7183
7184 static void rpccli_spoolss_AddMonitor_done(struct tevent_req *subreq)
7185 {
7186         struct tevent_req *req = tevent_req_callback_data(
7187                 subreq, struct tevent_req);
7188         struct rpccli_spoolss_AddMonitor_state *state = tevent_req_data(
7189                 req, struct rpccli_spoolss_AddMonitor_state);
7190         NTSTATUS status;
7191         TALLOC_CTX *mem_ctx;
7192
7193         if (state->out_mem_ctx) {
7194                 mem_ctx = state->out_mem_ctx;
7195         } else {
7196                 mem_ctx = state;
7197         }
7198
7199         status = state->dispatch_recv(subreq, mem_ctx);
7200         TALLOC_FREE(subreq);
7201         if (!NT_STATUS_IS_OK(status)) {
7202                 tevent_req_nterror(req, status);
7203                 return;
7204         }
7205
7206         /* Copy out parameters */
7207
7208         /* Copy result */
7209         state->orig.out.result = state->tmp.out.result;
7210
7211         /* Reset temporary structure */
7212         ZERO_STRUCT(state->tmp);
7213
7214         tevent_req_done(req);
7215 }
7216
7217 NTSTATUS rpccli_spoolss_AddMonitor_recv(struct tevent_req *req,
7218                                         TALLOC_CTX *mem_ctx,
7219                                         WERROR *result)
7220 {
7221         struct rpccli_spoolss_AddMonitor_state *state = tevent_req_data(
7222                 req, struct rpccli_spoolss_AddMonitor_state);
7223         NTSTATUS status;
7224
7225         if (tevent_req_is_nterror(req, &status)) {
7226                 tevent_req_received(req);
7227                 return status;
7228         }
7229
7230         /* Steal possbile out parameters to the callers context */
7231         talloc_steal(mem_ctx, state->out_mem_ctx);
7232
7233         /* Return result */
7234         *result = state->orig.out.result;
7235
7236         tevent_req_received(req);
7237         return NT_STATUS_OK;
7238 }
7239
7240 NTSTATUS rpccli_spoolss_AddMonitor(struct rpc_pipe_client *cli,
7241                                    TALLOC_CTX *mem_ctx,
7242                                    WERROR *werror)
7243 {
7244         struct spoolss_AddMonitor r;
7245         NTSTATUS status;
7246
7247         /* In parameters */
7248
7249         status = cli->dispatch(cli,
7250                                 mem_ctx,
7251                                 &ndr_table_spoolss,
7252                                 NDR_SPOOLSS_ADDMONITOR,
7253                                 &r);
7254
7255         if (!NT_STATUS_IS_OK(status)) {
7256                 return status;
7257         }
7258
7259         if (NT_STATUS_IS_ERR(status)) {
7260                 return status;
7261         }
7262
7263         /* Return variables */
7264
7265         /* Return result */
7266         if (werror) {
7267                 *werror = r.out.result;
7268         }
7269
7270         return werror_to_ntstatus(r.out.result);
7271 }
7272
7273 struct rpccli_spoolss_DeleteMonitor_state {
7274         struct spoolss_DeleteMonitor orig;
7275         struct spoolss_DeleteMonitor tmp;
7276         TALLOC_CTX *out_mem_ctx;
7277         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7278 };
7279
7280 static void rpccli_spoolss_DeleteMonitor_done(struct tevent_req *subreq);
7281
7282 struct tevent_req *rpccli_spoolss_DeleteMonitor_send(TALLOC_CTX *mem_ctx,
7283                                                      struct tevent_context *ev,
7284                                                      struct rpc_pipe_client *cli)
7285 {
7286         struct tevent_req *req;
7287         struct rpccli_spoolss_DeleteMonitor_state *state;
7288         struct tevent_req *subreq;
7289
7290         req = tevent_req_create(mem_ctx, &state,
7291                                 struct rpccli_spoolss_DeleteMonitor_state);
7292         if (req == NULL) {
7293                 return NULL;
7294         }
7295         state->out_mem_ctx = NULL;
7296         state->dispatch_recv = cli->dispatch_recv;
7297
7298         /* In parameters */
7299
7300         /* Out parameters */
7301
7302         /* Result */
7303         ZERO_STRUCT(state->orig.out.result);
7304
7305         /* make a temporary copy, that we pass to the dispatch function */
7306         state->tmp = state->orig;
7307
7308         subreq = cli->dispatch_send(state, ev, cli,
7309                                     &ndr_table_spoolss,
7310                                     NDR_SPOOLSS_DELETEMONITOR,
7311                                     &state->tmp);
7312         if (tevent_req_nomem(subreq, req)) {
7313                 return tevent_req_post(req, ev);
7314         }
7315         tevent_req_set_callback(subreq, rpccli_spoolss_DeleteMonitor_done, req);
7316         return req;
7317 }
7318
7319 static void rpccli_spoolss_DeleteMonitor_done(struct tevent_req *subreq)
7320 {
7321         struct tevent_req *req = tevent_req_callback_data(
7322                 subreq, struct tevent_req);
7323         struct rpccli_spoolss_DeleteMonitor_state *state = tevent_req_data(
7324                 req, struct rpccli_spoolss_DeleteMonitor_state);
7325         NTSTATUS status;
7326         TALLOC_CTX *mem_ctx;
7327
7328         if (state->out_mem_ctx) {
7329                 mem_ctx = state->out_mem_ctx;
7330         } else {
7331                 mem_ctx = state;
7332         }
7333
7334         status = state->dispatch_recv(subreq, mem_ctx);
7335         TALLOC_FREE(subreq);
7336         if (!NT_STATUS_IS_OK(status)) {
7337                 tevent_req_nterror(req, status);
7338                 return;
7339         }
7340
7341         /* Copy out parameters */
7342
7343         /* Copy result */
7344         state->orig.out.result = state->tmp.out.result;
7345
7346         /* Reset temporary structure */
7347         ZERO_STRUCT(state->tmp);
7348
7349         tevent_req_done(req);
7350 }
7351
7352 NTSTATUS rpccli_spoolss_DeleteMonitor_recv(struct tevent_req *req,
7353                                            TALLOC_CTX *mem_ctx,
7354                                            WERROR *result)
7355 {
7356         struct rpccli_spoolss_DeleteMonitor_state *state = tevent_req_data(
7357                 req, struct rpccli_spoolss_DeleteMonitor_state);
7358         NTSTATUS status;
7359
7360         if (tevent_req_is_nterror(req, &status)) {
7361                 tevent_req_received(req);
7362                 return status;
7363         }
7364
7365         /* Steal possbile out parameters to the callers context */
7366         talloc_steal(mem_ctx, state->out_mem_ctx);
7367
7368         /* Return result */
7369         *result = state->orig.out.result;
7370
7371         tevent_req_received(req);
7372         return NT_STATUS_OK;
7373 }
7374
7375 NTSTATUS rpccli_spoolss_DeleteMonitor(struct rpc_pipe_client *cli,
7376                                       TALLOC_CTX *mem_ctx,
7377                                       WERROR *werror)
7378 {
7379         struct spoolss_DeleteMonitor r;
7380         NTSTATUS status;
7381
7382         /* In parameters */
7383
7384         status = cli->dispatch(cli,
7385                                 mem_ctx,
7386                                 &ndr_table_spoolss,
7387                                 NDR_SPOOLSS_DELETEMONITOR,
7388                                 &r);
7389
7390         if (!NT_STATUS_IS_OK(status)) {
7391                 return status;
7392         }
7393
7394         if (NT_STATUS_IS_ERR(status)) {
7395                 return status;
7396         }
7397
7398         /* Return variables */
7399
7400         /* Return result */
7401         if (werror) {
7402                 *werror = r.out.result;
7403         }
7404
7405         return werror_to_ntstatus(r.out.result);
7406 }
7407
7408 struct rpccli_spoolss_DeletePrintProcessor_state {
7409         struct spoolss_DeletePrintProcessor orig;
7410         struct spoolss_DeletePrintProcessor tmp;
7411         TALLOC_CTX *out_mem_ctx;
7412         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7413 };
7414
7415 static void rpccli_spoolss_DeletePrintProcessor_done(struct tevent_req *subreq);
7416
7417 struct tevent_req *rpccli_spoolss_DeletePrintProcessor_send(TALLOC_CTX *mem_ctx,
7418                                                             struct tevent_context *ev,
7419                                                             struct rpc_pipe_client *cli)
7420 {
7421         struct tevent_req *req;
7422         struct rpccli_spoolss_DeletePrintProcessor_state *state;
7423         struct tevent_req *subreq;
7424
7425         req = tevent_req_create(mem_ctx, &state,
7426                                 struct rpccli_spoolss_DeletePrintProcessor_state);
7427         if (req == NULL) {
7428                 return NULL;
7429         }
7430         state->out_mem_ctx = NULL;
7431         state->dispatch_recv = cli->dispatch_recv;
7432
7433         /* In parameters */
7434
7435         /* Out parameters */
7436
7437         /* Result */
7438         ZERO_STRUCT(state->orig.out.result);
7439
7440         /* make a temporary copy, that we pass to the dispatch function */
7441         state->tmp = state->orig;
7442
7443         subreq = cli->dispatch_send(state, ev, cli,
7444                                     &ndr_table_spoolss,
7445                                     NDR_SPOOLSS_DELETEPRINTPROCESSOR,
7446                                     &state->tmp);
7447         if (tevent_req_nomem(subreq, req)) {
7448                 return tevent_req_post(req, ev);
7449         }
7450         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrintProcessor_done, req);
7451         return req;
7452 }
7453
7454 static void rpccli_spoolss_DeletePrintProcessor_done(struct tevent_req *subreq)
7455 {
7456         struct tevent_req *req = tevent_req_callback_data(
7457                 subreq, struct tevent_req);
7458         struct rpccli_spoolss_DeletePrintProcessor_state *state = tevent_req_data(
7459                 req, struct rpccli_spoolss_DeletePrintProcessor_state);
7460         NTSTATUS status;
7461         TALLOC_CTX *mem_ctx;
7462
7463         if (state->out_mem_ctx) {
7464                 mem_ctx = state->out_mem_ctx;
7465         } else {
7466                 mem_ctx = state;
7467         }
7468
7469         status = state->dispatch_recv(subreq, mem_ctx);
7470         TALLOC_FREE(subreq);
7471         if (!NT_STATUS_IS_OK(status)) {
7472                 tevent_req_nterror(req, status);
7473                 return;
7474         }
7475
7476         /* Copy out parameters */
7477
7478         /* Copy result */
7479         state->orig.out.result = state->tmp.out.result;
7480
7481         /* Reset temporary structure */
7482         ZERO_STRUCT(state->tmp);
7483
7484         tevent_req_done(req);
7485 }
7486
7487 NTSTATUS rpccli_spoolss_DeletePrintProcessor_recv(struct tevent_req *req,
7488                                                   TALLOC_CTX *mem_ctx,
7489                                                   WERROR *result)
7490 {
7491         struct rpccli_spoolss_DeletePrintProcessor_state *state = tevent_req_data(
7492                 req, struct rpccli_spoolss_DeletePrintProcessor_state);
7493         NTSTATUS status;
7494
7495         if (tevent_req_is_nterror(req, &status)) {
7496                 tevent_req_received(req);
7497                 return status;
7498         }
7499
7500         /* Steal possbile out parameters to the callers context */
7501         talloc_steal(mem_ctx, state->out_mem_ctx);
7502
7503         /* Return result */
7504         *result = state->orig.out.result;
7505
7506         tevent_req_received(req);
7507         return NT_STATUS_OK;
7508 }
7509
7510 NTSTATUS rpccli_spoolss_DeletePrintProcessor(struct rpc_pipe_client *cli,
7511                                              TALLOC_CTX *mem_ctx,
7512                                              WERROR *werror)
7513 {
7514         struct spoolss_DeletePrintProcessor r;
7515         NTSTATUS status;
7516
7517         /* In parameters */
7518
7519         status = cli->dispatch(cli,
7520                                 mem_ctx,
7521                                 &ndr_table_spoolss,
7522                                 NDR_SPOOLSS_DELETEPRINTPROCESSOR,
7523                                 &r);
7524
7525         if (!NT_STATUS_IS_OK(status)) {
7526                 return status;
7527         }
7528
7529         if (NT_STATUS_IS_ERR(status)) {
7530                 return status;
7531         }
7532
7533         /* Return variables */
7534
7535         /* Return result */
7536         if (werror) {
7537                 *werror = r.out.result;
7538         }
7539
7540         return werror_to_ntstatus(r.out.result);
7541 }
7542
7543 struct rpccli_spoolss_AddPrintProvidor_state {
7544         struct spoolss_AddPrintProvidor orig;
7545         struct spoolss_AddPrintProvidor tmp;
7546         TALLOC_CTX *out_mem_ctx;
7547         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7548 };
7549
7550 static void rpccli_spoolss_AddPrintProvidor_done(struct tevent_req *subreq);
7551
7552 struct tevent_req *rpccli_spoolss_AddPrintProvidor_send(TALLOC_CTX *mem_ctx,
7553                                                         struct tevent_context *ev,
7554                                                         struct rpc_pipe_client *cli)
7555 {
7556         struct tevent_req *req;
7557         struct rpccli_spoolss_AddPrintProvidor_state *state;
7558         struct tevent_req *subreq;
7559
7560         req = tevent_req_create(mem_ctx, &state,
7561                                 struct rpccli_spoolss_AddPrintProvidor_state);
7562         if (req == NULL) {
7563                 return NULL;
7564         }
7565         state->out_mem_ctx = NULL;
7566         state->dispatch_recv = cli->dispatch_recv;
7567
7568         /* In parameters */
7569
7570         /* Out parameters */
7571
7572         /* Result */
7573         ZERO_STRUCT(state->orig.out.result);
7574
7575         /* make a temporary copy, that we pass to the dispatch function */
7576         state->tmp = state->orig;
7577
7578         subreq = cli->dispatch_send(state, ev, cli,
7579                                     &ndr_table_spoolss,
7580                                     NDR_SPOOLSS_ADDPRINTPROVIDOR,
7581                                     &state->tmp);
7582         if (tevent_req_nomem(subreq, req)) {
7583                 return tevent_req_post(req, ev);
7584         }
7585         tevent_req_set_callback(subreq, rpccli_spoolss_AddPrintProvidor_done, req);
7586         return req;
7587 }
7588
7589 static void rpccli_spoolss_AddPrintProvidor_done(struct tevent_req *subreq)
7590 {
7591         struct tevent_req *req = tevent_req_callback_data(
7592                 subreq, struct tevent_req);
7593         struct rpccli_spoolss_AddPrintProvidor_state *state = tevent_req_data(
7594                 req, struct rpccli_spoolss_AddPrintProvidor_state);
7595         NTSTATUS status;
7596         TALLOC_CTX *mem_ctx;
7597
7598         if (state->out_mem_ctx) {
7599                 mem_ctx = state->out_mem_ctx;
7600         } else {
7601                 mem_ctx = state;
7602         }
7603
7604         status = state->dispatch_recv(subreq, mem_ctx);
7605         TALLOC_FREE(subreq);
7606         if (!NT_STATUS_IS_OK(status)) {
7607                 tevent_req_nterror(req, status);
7608                 return;
7609         }
7610
7611         /* Copy out parameters */
7612
7613         /* Copy result */
7614         state->orig.out.result = state->tmp.out.result;
7615
7616         /* Reset temporary structure */
7617         ZERO_STRUCT(state->tmp);
7618
7619         tevent_req_done(req);
7620 }
7621
7622 NTSTATUS rpccli_spoolss_AddPrintProvidor_recv(struct tevent_req *req,
7623                                               TALLOC_CTX *mem_ctx,
7624                                               WERROR *result)
7625 {
7626         struct rpccli_spoolss_AddPrintProvidor_state *state = tevent_req_data(
7627                 req, struct rpccli_spoolss_AddPrintProvidor_state);
7628         NTSTATUS status;
7629
7630         if (tevent_req_is_nterror(req, &status)) {
7631                 tevent_req_received(req);
7632                 return status;
7633         }
7634
7635         /* Steal possbile out parameters to the callers context */
7636         talloc_steal(mem_ctx, state->out_mem_ctx);
7637
7638         /* Return result */
7639         *result = state->orig.out.result;
7640
7641         tevent_req_received(req);
7642         return NT_STATUS_OK;
7643 }
7644
7645 NTSTATUS rpccli_spoolss_AddPrintProvidor(struct rpc_pipe_client *cli,
7646                                          TALLOC_CTX *mem_ctx,
7647                                          WERROR *werror)
7648 {
7649         struct spoolss_AddPrintProvidor r;
7650         NTSTATUS status;
7651
7652         /* In parameters */
7653
7654         status = cli->dispatch(cli,
7655                                 mem_ctx,
7656                                 &ndr_table_spoolss,
7657                                 NDR_SPOOLSS_ADDPRINTPROVIDOR,
7658                                 &r);
7659
7660         if (!NT_STATUS_IS_OK(status)) {
7661                 return status;
7662         }
7663
7664         if (NT_STATUS_IS_ERR(status)) {
7665                 return status;
7666         }
7667
7668         /* Return variables */
7669
7670         /* Return result */
7671         if (werror) {
7672                 *werror = r.out.result;
7673         }
7674
7675         return werror_to_ntstatus(r.out.result);
7676 }
7677
7678 struct rpccli_spoolss_DeletePrintProvidor_state {
7679         struct spoolss_DeletePrintProvidor orig;
7680         struct spoolss_DeletePrintProvidor tmp;
7681         TALLOC_CTX *out_mem_ctx;
7682         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7683 };
7684
7685 static void rpccli_spoolss_DeletePrintProvidor_done(struct tevent_req *subreq);
7686
7687 struct tevent_req *rpccli_spoolss_DeletePrintProvidor_send(TALLOC_CTX *mem_ctx,
7688                                                            struct tevent_context *ev,
7689                                                            struct rpc_pipe_client *cli)
7690 {
7691         struct tevent_req *req;
7692         struct rpccli_spoolss_DeletePrintProvidor_state *state;
7693         struct tevent_req *subreq;
7694
7695         req = tevent_req_create(mem_ctx, &state,
7696                                 struct rpccli_spoolss_DeletePrintProvidor_state);
7697         if (req == NULL) {
7698                 return NULL;
7699         }
7700         state->out_mem_ctx = NULL;
7701         state->dispatch_recv = cli->dispatch_recv;
7702
7703         /* In parameters */
7704
7705         /* Out parameters */
7706
7707         /* Result */
7708         ZERO_STRUCT(state->orig.out.result);
7709
7710         /* make a temporary copy, that we pass to the dispatch function */
7711         state->tmp = state->orig;
7712
7713         subreq = cli->dispatch_send(state, ev, cli,
7714                                     &ndr_table_spoolss,
7715                                     NDR_SPOOLSS_DELETEPRINTPROVIDOR,
7716                                     &state->tmp);
7717         if (tevent_req_nomem(subreq, req)) {
7718                 return tevent_req_post(req, ev);
7719         }
7720         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrintProvidor_done, req);
7721         return req;
7722 }
7723
7724 static void rpccli_spoolss_DeletePrintProvidor_done(struct tevent_req *subreq)
7725 {
7726         struct tevent_req *req = tevent_req_callback_data(
7727                 subreq, struct tevent_req);
7728         struct rpccli_spoolss_DeletePrintProvidor_state *state = tevent_req_data(
7729                 req, struct rpccli_spoolss_DeletePrintProvidor_state);
7730         NTSTATUS status;
7731         TALLOC_CTX *mem_ctx;
7732
7733         if (state->out_mem_ctx) {
7734                 mem_ctx = state->out_mem_ctx;
7735         } else {
7736                 mem_ctx = state;
7737         }
7738
7739         status = state->dispatch_recv(subreq, mem_ctx);
7740         TALLOC_FREE(subreq);
7741         if (!NT_STATUS_IS_OK(status)) {
7742                 tevent_req_nterror(req, status);
7743                 return;
7744         }
7745
7746         /* Copy out parameters */
7747
7748         /* Copy result */
7749         state->orig.out.result = state->tmp.out.result;
7750
7751         /* Reset temporary structure */
7752         ZERO_STRUCT(state->tmp);
7753
7754         tevent_req_done(req);
7755 }
7756
7757 NTSTATUS rpccli_spoolss_DeletePrintProvidor_recv(struct tevent_req *req,
7758                                                  TALLOC_CTX *mem_ctx,
7759                                                  WERROR *result)
7760 {
7761         struct rpccli_spoolss_DeletePrintProvidor_state *state = tevent_req_data(
7762                 req, struct rpccli_spoolss_DeletePrintProvidor_state);
7763         NTSTATUS status;
7764
7765         if (tevent_req_is_nterror(req, &status)) {
7766                 tevent_req_received(req);
7767                 return status;
7768         }
7769
7770         /* Steal possbile out parameters to the callers context */
7771         talloc_steal(mem_ctx, state->out_mem_ctx);
7772
7773         /* Return result */
7774         *result = state->orig.out.result;
7775
7776         tevent_req_received(req);
7777         return NT_STATUS_OK;
7778 }
7779
7780 NTSTATUS rpccli_spoolss_DeletePrintProvidor(struct rpc_pipe_client *cli,
7781                                             TALLOC_CTX *mem_ctx,
7782                                             WERROR *werror)
7783 {
7784         struct spoolss_DeletePrintProvidor r;
7785         NTSTATUS status;
7786
7787         /* In parameters */
7788
7789         status = cli->dispatch(cli,
7790                                 mem_ctx,
7791                                 &ndr_table_spoolss,
7792                                 NDR_SPOOLSS_DELETEPRINTPROVIDOR,
7793                                 &r);
7794
7795         if (!NT_STATUS_IS_OK(status)) {
7796                 return status;
7797         }
7798
7799         if (NT_STATUS_IS_ERR(status)) {
7800                 return status;
7801         }
7802
7803         /* Return variables */
7804
7805         /* Return result */
7806         if (werror) {
7807                 *werror = r.out.result;
7808         }
7809
7810         return werror_to_ntstatus(r.out.result);
7811 }
7812
7813 struct rpccli_spoolss_EnumPrintProcDataTypes_state {
7814         struct spoolss_EnumPrintProcDataTypes orig;
7815         struct spoolss_EnumPrintProcDataTypes tmp;
7816         TALLOC_CTX *out_mem_ctx;
7817         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7818 };
7819
7820 static void rpccli_spoolss_EnumPrintProcDataTypes_done(struct tevent_req *subreq);
7821
7822 struct tevent_req *rpccli_spoolss_EnumPrintProcDataTypes_send(TALLOC_CTX *mem_ctx,
7823                                                               struct tevent_context *ev,
7824                                                               struct rpc_pipe_client *cli,
7825                                                               const char *_servername /* [in] [unique,charset(UTF16)] */,
7826                                                               const char *_print_processor_name /* [in] [unique,charset(UTF16)] */,
7827                                                               uint32_t _level /* [in]  */,
7828                                                               DATA_BLOB *_buffer /* [in] [unique] */,
7829                                                               uint32_t _offered /* [in]  */,
7830                                                               uint32_t *_count /* [out] [ref] */,
7831                                                               union spoolss_PrintProcDataTypesInfo **_info /* [out] [ref,switch_is(level),size_is(,*count)] */,
7832                                                               uint32_t *_needed /* [out] [ref] */)
7833 {
7834         struct tevent_req *req;
7835         struct rpccli_spoolss_EnumPrintProcDataTypes_state *state;
7836         struct tevent_req *subreq;
7837
7838         req = tevent_req_create(mem_ctx, &state,
7839                                 struct rpccli_spoolss_EnumPrintProcDataTypes_state);
7840         if (req == NULL) {
7841                 return NULL;
7842         }
7843         state->out_mem_ctx = NULL;
7844         state->dispatch_recv = cli->dispatch_recv;
7845
7846         /* In parameters */
7847         state->orig.in.servername = _servername;
7848         state->orig.in.print_processor_name = _print_processor_name;
7849         state->orig.in.level = _level;
7850         state->orig.in.buffer = _buffer;
7851         state->orig.in.offered = _offered;
7852
7853         /* Out parameters */
7854         state->orig.out.count = _count;
7855         state->orig.out.info = _info;
7856         state->orig.out.needed = _needed;
7857
7858         /* Result */
7859         ZERO_STRUCT(state->orig.out.result);
7860
7861         state->out_mem_ctx = talloc_named_const(state, 0,
7862                              "rpccli_spoolss_EnumPrintProcDataTypes_out_memory");
7863         if (tevent_req_nomem(state->out_mem_ctx, req)) {
7864                 return tevent_req_post(req, ev);
7865         }
7866
7867         /* make a temporary copy, that we pass to the dispatch function */
7868         state->tmp = state->orig;
7869
7870         subreq = cli->dispatch_send(state, ev, cli,
7871                                     &ndr_table_spoolss,
7872                                     NDR_SPOOLSS_ENUMPRINTPROCDATATYPES,
7873                                     &state->tmp);
7874         if (tevent_req_nomem(subreq, req)) {
7875                 return tevent_req_post(req, ev);
7876         }
7877         tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrintProcDataTypes_done, req);
7878         return req;
7879 }
7880
7881 static void rpccli_spoolss_EnumPrintProcDataTypes_done(struct tevent_req *subreq)
7882 {
7883         struct tevent_req *req = tevent_req_callback_data(
7884                 subreq, struct tevent_req);
7885         struct rpccli_spoolss_EnumPrintProcDataTypes_state *state = tevent_req_data(
7886                 req, struct rpccli_spoolss_EnumPrintProcDataTypes_state);
7887         NTSTATUS status;
7888         TALLOC_CTX *mem_ctx;
7889
7890         if (state->out_mem_ctx) {
7891                 mem_ctx = state->out_mem_ctx;
7892         } else {
7893                 mem_ctx = state;
7894         }
7895
7896         status = state->dispatch_recv(subreq, mem_ctx);
7897         TALLOC_FREE(subreq);
7898         if (!NT_STATUS_IS_OK(status)) {
7899                 tevent_req_nterror(req, status);
7900                 return;
7901         }
7902
7903         /* Copy out parameters */
7904         *state->orig.out.count = *state->tmp.out.count;
7905         *state->orig.out.info = *state->tmp.out.info;
7906         *state->orig.out.needed = *state->tmp.out.needed;
7907
7908         /* Copy result */
7909         state->orig.out.result = state->tmp.out.result;
7910
7911         /* Reset temporary structure */
7912         ZERO_STRUCT(state->tmp);
7913
7914         tevent_req_done(req);
7915 }
7916
7917 NTSTATUS rpccli_spoolss_EnumPrintProcDataTypes_recv(struct tevent_req *req,
7918                                                     TALLOC_CTX *mem_ctx,
7919                                                     WERROR *result)
7920 {
7921         struct rpccli_spoolss_EnumPrintProcDataTypes_state *state = tevent_req_data(
7922                 req, struct rpccli_spoolss_EnumPrintProcDataTypes_state);
7923         NTSTATUS status;
7924
7925         if (tevent_req_is_nterror(req, &status)) {
7926                 tevent_req_received(req);
7927                 return status;
7928         }
7929
7930         /* Steal possbile out parameters to the callers context */
7931         talloc_steal(mem_ctx, state->out_mem_ctx);
7932
7933         /* Return result */
7934         *result = state->orig.out.result;
7935
7936         tevent_req_received(req);
7937         return NT_STATUS_OK;
7938 }
7939
7940 NTSTATUS rpccli_spoolss_EnumPrintProcDataTypes(struct rpc_pipe_client *cli,
7941                                                TALLOC_CTX *mem_ctx,
7942                                                const char *servername /* [in] [unique,charset(UTF16)] */,
7943                                                const char *print_processor_name /* [in] [unique,charset(UTF16)] */,
7944                                                uint32_t level /* [in]  */,
7945                                                DATA_BLOB *buffer /* [in] [unique] */,
7946                                                uint32_t offered /* [in]  */,
7947                                                uint32_t *count /* [out] [ref] */,
7948                                                union spoolss_PrintProcDataTypesInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
7949                                                uint32_t *needed /* [out] [ref] */,
7950                                                WERROR *werror)
7951 {
7952         struct spoolss_EnumPrintProcDataTypes r;
7953         NTSTATUS status;
7954
7955         /* In parameters */
7956         r.in.servername = servername;
7957         r.in.print_processor_name = print_processor_name;
7958         r.in.level = level;
7959         r.in.buffer = buffer;
7960         r.in.offered = offered;
7961
7962         status = cli->dispatch(cli,
7963                                 mem_ctx,
7964                                 &ndr_table_spoolss,
7965                                 NDR_SPOOLSS_ENUMPRINTPROCDATATYPES,
7966                                 &r);
7967
7968         if (!NT_STATUS_IS_OK(status)) {
7969                 return status;
7970         }
7971
7972         if (NT_STATUS_IS_ERR(status)) {
7973                 return status;
7974         }
7975
7976         /* Return variables */
7977         *count = *r.out.count;
7978         *info = *r.out.info;
7979         *needed = *r.out.needed;
7980
7981         /* Return result */
7982         if (werror) {
7983                 *werror = r.out.result;
7984         }
7985
7986         return werror_to_ntstatus(r.out.result);
7987 }
7988
7989 struct rpccli_spoolss_ResetPrinter_state {
7990         struct spoolss_ResetPrinter orig;
7991         struct spoolss_ResetPrinter tmp;
7992         TALLOC_CTX *out_mem_ctx;
7993         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7994 };
7995
7996 static void rpccli_spoolss_ResetPrinter_done(struct tevent_req *subreq);
7997
7998 struct tevent_req *rpccli_spoolss_ResetPrinter_send(TALLOC_CTX *mem_ctx,
7999                                                     struct tevent_context *ev,
8000                                                     struct rpc_pipe_client *cli,
8001                                                     struct policy_handle *_handle /* [in] [ref] */,
8002                                                     const char *_data_type /* [in] [unique,charset(UTF16)] */,
8003                                                     struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */)
8004 {
8005         struct tevent_req *req;
8006         struct rpccli_spoolss_ResetPrinter_state *state;
8007         struct tevent_req *subreq;
8008
8009         req = tevent_req_create(mem_ctx, &state,
8010                                 struct rpccli_spoolss_ResetPrinter_state);
8011         if (req == NULL) {
8012                 return NULL;
8013         }
8014         state->out_mem_ctx = NULL;
8015         state->dispatch_recv = cli->dispatch_recv;
8016
8017         /* In parameters */
8018         state->orig.in.handle = _handle;
8019         state->orig.in.data_type = _data_type;
8020         state->orig.in.devmode_ctr = _devmode_ctr;
8021
8022         /* Out parameters */
8023
8024         /* Result */
8025         ZERO_STRUCT(state->orig.out.result);
8026
8027         /* make a temporary copy, that we pass to the dispatch function */
8028         state->tmp = state->orig;
8029
8030         subreq = cli->dispatch_send(state, ev, cli,
8031                                     &ndr_table_spoolss,
8032                                     NDR_SPOOLSS_RESETPRINTER,
8033                                     &state->tmp);
8034         if (tevent_req_nomem(subreq, req)) {
8035                 return tevent_req_post(req, ev);
8036         }
8037         tevent_req_set_callback(subreq, rpccli_spoolss_ResetPrinter_done, req);
8038         return req;
8039 }
8040
8041 static void rpccli_spoolss_ResetPrinter_done(struct tevent_req *subreq)
8042 {
8043         struct tevent_req *req = tevent_req_callback_data(
8044                 subreq, struct tevent_req);
8045         struct rpccli_spoolss_ResetPrinter_state *state = tevent_req_data(
8046                 req, struct rpccli_spoolss_ResetPrinter_state);
8047         NTSTATUS status;
8048         TALLOC_CTX *mem_ctx;
8049
8050         if (state->out_mem_ctx) {
8051                 mem_ctx = state->out_mem_ctx;
8052         } else {
8053                 mem_ctx = state;
8054         }
8055
8056         status = state->dispatch_recv(subreq, mem_ctx);
8057         TALLOC_FREE(subreq);
8058         if (!NT_STATUS_IS_OK(status)) {
8059                 tevent_req_nterror(req, status);
8060                 return;
8061         }
8062
8063         /* Copy out parameters */
8064
8065         /* Copy result */
8066         state->orig.out.result = state->tmp.out.result;
8067
8068         /* Reset temporary structure */
8069         ZERO_STRUCT(state->tmp);
8070
8071         tevent_req_done(req);
8072 }
8073
8074 NTSTATUS rpccli_spoolss_ResetPrinter_recv(struct tevent_req *req,
8075                                           TALLOC_CTX *mem_ctx,
8076                                           WERROR *result)
8077 {
8078         struct rpccli_spoolss_ResetPrinter_state *state = tevent_req_data(
8079                 req, struct rpccli_spoolss_ResetPrinter_state);
8080         NTSTATUS status;
8081
8082         if (tevent_req_is_nterror(req, &status)) {
8083                 tevent_req_received(req);
8084                 return status;
8085         }
8086
8087         /* Steal possbile out parameters to the callers context */
8088         talloc_steal(mem_ctx, state->out_mem_ctx);
8089
8090         /* Return result */
8091         *result = state->orig.out.result;
8092
8093         tevent_req_received(req);
8094         return NT_STATUS_OK;
8095 }
8096
8097 NTSTATUS rpccli_spoolss_ResetPrinter(struct rpc_pipe_client *cli,
8098                                      TALLOC_CTX *mem_ctx,
8099                                      struct policy_handle *handle /* [in] [ref] */,
8100                                      const char *data_type /* [in] [unique,charset(UTF16)] */,
8101                                      struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
8102                                      WERROR *werror)
8103 {
8104         struct spoolss_ResetPrinter r;
8105         NTSTATUS status;
8106
8107         /* In parameters */
8108         r.in.handle = handle;
8109         r.in.data_type = data_type;
8110         r.in.devmode_ctr = devmode_ctr;
8111
8112         status = cli->dispatch(cli,
8113                                 mem_ctx,
8114                                 &ndr_table_spoolss,
8115                                 NDR_SPOOLSS_RESETPRINTER,
8116                                 &r);
8117
8118         if (!NT_STATUS_IS_OK(status)) {
8119                 return status;
8120         }
8121
8122         if (NT_STATUS_IS_ERR(status)) {
8123                 return status;
8124         }
8125
8126         /* Return variables */
8127
8128         /* Return result */
8129         if (werror) {
8130                 *werror = r.out.result;
8131         }
8132
8133         return werror_to_ntstatus(r.out.result);
8134 }
8135
8136 struct rpccli_spoolss_GetPrinterDriver2_state {
8137         struct spoolss_GetPrinterDriver2 orig;
8138         struct spoolss_GetPrinterDriver2 tmp;
8139         TALLOC_CTX *out_mem_ctx;
8140         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8141 };
8142
8143 static void rpccli_spoolss_GetPrinterDriver2_done(struct tevent_req *subreq);
8144
8145 struct tevent_req *rpccli_spoolss_GetPrinterDriver2_send(TALLOC_CTX *mem_ctx,
8146                                                          struct tevent_context *ev,
8147                                                          struct rpc_pipe_client *cli,
8148                                                          struct policy_handle *_handle /* [in] [ref] */,
8149                                                          const char *_architecture /* [in] [unique,charset(UTF16)] */,
8150                                                          uint32_t _level /* [in]  */,
8151                                                          DATA_BLOB *_buffer /* [in] [unique] */,
8152                                                          uint32_t _offered /* [in]  */,
8153                                                          uint32_t _client_major_version /* [in]  */,
8154                                                          uint32_t _client_minor_version /* [in]  */,
8155                                                          union spoolss_DriverInfo *_info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
8156                                                          uint32_t *_needed /* [out] [ref] */,
8157                                                          uint32_t *_server_major_version /* [out] [ref] */,
8158                                                          uint32_t *_server_minor_version /* [out] [ref] */)
8159 {
8160         struct tevent_req *req;
8161         struct rpccli_spoolss_GetPrinterDriver2_state *state;
8162         struct tevent_req *subreq;
8163
8164         req = tevent_req_create(mem_ctx, &state,
8165                                 struct rpccli_spoolss_GetPrinterDriver2_state);
8166         if (req == NULL) {
8167                 return NULL;
8168         }
8169         state->out_mem_ctx = NULL;
8170         state->dispatch_recv = cli->dispatch_recv;
8171
8172         /* In parameters */
8173         state->orig.in.handle = _handle;
8174         state->orig.in.architecture = _architecture;
8175         state->orig.in.level = _level;
8176         state->orig.in.buffer = _buffer;
8177         state->orig.in.offered = _offered;
8178         state->orig.in.client_major_version = _client_major_version;
8179         state->orig.in.client_minor_version = _client_minor_version;
8180
8181         /* Out parameters */
8182         state->orig.out.info = _info;
8183         state->orig.out.needed = _needed;
8184         state->orig.out.server_major_version = _server_major_version;
8185         state->orig.out.server_minor_version = _server_minor_version;
8186
8187         /* Result */
8188         ZERO_STRUCT(state->orig.out.result);
8189
8190         state->out_mem_ctx = talloc_named_const(state, 0,
8191                              "rpccli_spoolss_GetPrinterDriver2_out_memory");
8192         if (tevent_req_nomem(state->out_mem_ctx, req)) {
8193                 return tevent_req_post(req, ev);
8194         }
8195
8196         /* make a temporary copy, that we pass to the dispatch function */
8197         state->tmp = state->orig;
8198
8199         subreq = cli->dispatch_send(state, ev, cli,
8200                                     &ndr_table_spoolss,
8201                                     NDR_SPOOLSS_GETPRINTERDRIVER2,
8202                                     &state->tmp);
8203         if (tevent_req_nomem(subreq, req)) {
8204                 return tevent_req_post(req, ev);
8205         }
8206         tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriver2_done, req);
8207         return req;
8208 }
8209
8210 static void rpccli_spoolss_GetPrinterDriver2_done(struct tevent_req *subreq)
8211 {
8212         struct tevent_req *req = tevent_req_callback_data(
8213                 subreq, struct tevent_req);
8214         struct rpccli_spoolss_GetPrinterDriver2_state *state = tevent_req_data(
8215                 req, struct rpccli_spoolss_GetPrinterDriver2_state);
8216         NTSTATUS status;
8217         TALLOC_CTX *mem_ctx;
8218
8219         if (state->out_mem_ctx) {
8220                 mem_ctx = state->out_mem_ctx;
8221         } else {
8222                 mem_ctx = state;
8223         }
8224
8225         status = state->dispatch_recv(subreq, mem_ctx);
8226         TALLOC_FREE(subreq);
8227         if (!NT_STATUS_IS_OK(status)) {
8228                 tevent_req_nterror(req, status);
8229                 return;
8230         }
8231
8232         /* Copy out parameters */
8233         if (state->orig.out.info && state->tmp.out.info) {
8234                 *state->orig.out.info = *state->tmp.out.info;
8235         }
8236         *state->orig.out.needed = *state->tmp.out.needed;
8237         *state->orig.out.server_major_version = *state->tmp.out.server_major_version;
8238         *state->orig.out.server_minor_version = *state->tmp.out.server_minor_version;
8239
8240         /* Copy result */
8241         state->orig.out.result = state->tmp.out.result;
8242
8243         /* Reset temporary structure */
8244         ZERO_STRUCT(state->tmp);
8245
8246         tevent_req_done(req);
8247 }
8248
8249 NTSTATUS rpccli_spoolss_GetPrinterDriver2_recv(struct tevent_req *req,
8250                                                TALLOC_CTX *mem_ctx,
8251                                                WERROR *result)
8252 {
8253         struct rpccli_spoolss_GetPrinterDriver2_state *state = tevent_req_data(
8254                 req, struct rpccli_spoolss_GetPrinterDriver2_state);
8255         NTSTATUS status;
8256
8257         if (tevent_req_is_nterror(req, &status)) {
8258                 tevent_req_received(req);
8259                 return status;
8260         }
8261
8262         /* Steal possbile out parameters to the callers context */
8263         talloc_steal(mem_ctx, state->out_mem_ctx);
8264
8265         /* Return result */
8266         *result = state->orig.out.result;
8267
8268         tevent_req_received(req);
8269         return NT_STATUS_OK;
8270 }
8271
8272 NTSTATUS rpccli_spoolss_GetPrinterDriver2(struct rpc_pipe_client *cli,
8273                                           TALLOC_CTX *mem_ctx,
8274                                           struct policy_handle *handle /* [in] [ref] */,
8275                                           const char *architecture /* [in] [unique,charset(UTF16)] */,
8276                                           uint32_t level /* [in]  */,
8277                                           DATA_BLOB *buffer /* [in] [unique] */,
8278                                           uint32_t offered /* [in]  */,
8279                                           uint32_t client_major_version /* [in]  */,
8280                                           uint32_t client_minor_version /* [in]  */,
8281                                           union spoolss_DriverInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
8282                                           uint32_t *needed /* [out] [ref] */,
8283                                           uint32_t *server_major_version /* [out] [ref] */,
8284                                           uint32_t *server_minor_version /* [out] [ref] */,
8285                                           WERROR *werror)
8286 {
8287         struct spoolss_GetPrinterDriver2 r;
8288         NTSTATUS status;
8289
8290         /* In parameters */
8291         r.in.handle = handle;
8292         r.in.architecture = architecture;
8293         r.in.level = level;
8294         r.in.buffer = buffer;
8295         r.in.offered = offered;
8296         r.in.client_major_version = client_major_version;
8297         r.in.client_minor_version = client_minor_version;
8298
8299         status = cli->dispatch(cli,
8300                                 mem_ctx,
8301                                 &ndr_table_spoolss,
8302                                 NDR_SPOOLSS_GETPRINTERDRIVER2,
8303                                 &r);
8304
8305         if (!NT_STATUS_IS_OK(status)) {
8306                 return status;
8307         }
8308
8309         if (NT_STATUS_IS_ERR(status)) {
8310                 return status;
8311         }
8312
8313         /* Return variables */
8314         if (info && r.out.info) {
8315                 *info = *r.out.info;
8316         }
8317         *needed = *r.out.needed;
8318         *server_major_version = *r.out.server_major_version;
8319         *server_minor_version = *r.out.server_minor_version;
8320
8321         /* Return result */
8322         if (werror) {
8323                 *werror = r.out.result;
8324         }
8325
8326         return werror_to_ntstatus(r.out.result);
8327 }
8328
8329 struct rpccli_spoolss_FindFirstPrinterChangeNotification_state {
8330         struct spoolss_FindFirstPrinterChangeNotification orig;
8331         struct spoolss_FindFirstPrinterChangeNotification tmp;
8332         TALLOC_CTX *out_mem_ctx;
8333         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8334 };
8335
8336 static void rpccli_spoolss_FindFirstPrinterChangeNotification_done(struct tevent_req *subreq);
8337
8338 struct tevent_req *rpccli_spoolss_FindFirstPrinterChangeNotification_send(TALLOC_CTX *mem_ctx,
8339                                                                           struct tevent_context *ev,
8340                                                                           struct rpc_pipe_client *cli)
8341 {
8342         struct tevent_req *req;
8343         struct rpccli_spoolss_FindFirstPrinterChangeNotification_state *state;
8344         struct tevent_req *subreq;
8345
8346         req = tevent_req_create(mem_ctx, &state,
8347                                 struct rpccli_spoolss_FindFirstPrinterChangeNotification_state);
8348         if (req == NULL) {
8349                 return NULL;
8350         }
8351         state->out_mem_ctx = NULL;
8352         state->dispatch_recv = cli->dispatch_recv;
8353
8354         /* In parameters */
8355
8356         /* Out parameters */
8357
8358         /* Result */
8359         ZERO_STRUCT(state->orig.out.result);
8360
8361         /* make a temporary copy, that we pass to the dispatch function */
8362         state->tmp = state->orig;
8363
8364         subreq = cli->dispatch_send(state, ev, cli,
8365                                     &ndr_table_spoolss,
8366                                     NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION,
8367                                     &state->tmp);
8368         if (tevent_req_nomem(subreq, req)) {
8369                 return tevent_req_post(req, ev);
8370         }
8371         tevent_req_set_callback(subreq, rpccli_spoolss_FindFirstPrinterChangeNotification_done, req);
8372         return req;
8373 }
8374
8375 static void rpccli_spoolss_FindFirstPrinterChangeNotification_done(struct tevent_req *subreq)
8376 {
8377         struct tevent_req *req = tevent_req_callback_data(
8378                 subreq, struct tevent_req);
8379         struct rpccli_spoolss_FindFirstPrinterChangeNotification_state *state = tevent_req_data(
8380                 req, struct rpccli_spoolss_FindFirstPrinterChangeNotification_state);
8381         NTSTATUS status;
8382         TALLOC_CTX *mem_ctx;
8383
8384         if (state->out_mem_ctx) {
8385                 mem_ctx = state->out_mem_ctx;
8386         } else {
8387                 mem_ctx = state;
8388         }
8389
8390         status = state->dispatch_recv(subreq, mem_ctx);
8391         TALLOC_FREE(subreq);
8392         if (!NT_STATUS_IS_OK(status)) {
8393                 tevent_req_nterror(req, status);
8394                 return;
8395         }
8396
8397         /* Copy out parameters */
8398
8399         /* Copy result */
8400         state->orig.out.result = state->tmp.out.result;
8401
8402         /* Reset temporary structure */
8403         ZERO_STRUCT(state->tmp);
8404
8405         tevent_req_done(req);
8406 }
8407
8408 NTSTATUS rpccli_spoolss_FindFirstPrinterChangeNotification_recv(struct tevent_req *req,
8409                                                                 TALLOC_CTX *mem_ctx,
8410                                                                 WERROR *result)
8411 {
8412         struct rpccli_spoolss_FindFirstPrinterChangeNotification_state *state = tevent_req_data(
8413                 req, struct rpccli_spoolss_FindFirstPrinterChangeNotification_state);
8414         NTSTATUS status;
8415
8416         if (tevent_req_is_nterror(req, &status)) {
8417                 tevent_req_received(req);
8418                 return status;
8419         }
8420
8421         /* Steal possbile out parameters to the callers context */
8422         talloc_steal(mem_ctx, state->out_mem_ctx);
8423
8424         /* Return result */
8425         *result = state->orig.out.result;
8426
8427         tevent_req_received(req);
8428         return NT_STATUS_OK;
8429 }
8430
8431 NTSTATUS rpccli_spoolss_FindFirstPrinterChangeNotification(struct rpc_pipe_client *cli,
8432                                                            TALLOC_CTX *mem_ctx,
8433                                                            WERROR *werror)
8434 {
8435         struct spoolss_FindFirstPrinterChangeNotification r;
8436         NTSTATUS status;
8437
8438         /* In parameters */
8439
8440         status = cli->dispatch(cli,
8441                                 mem_ctx,
8442                                 &ndr_table_spoolss,
8443                                 NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION,
8444                                 &r);
8445
8446         if (!NT_STATUS_IS_OK(status)) {
8447                 return status;
8448         }
8449
8450         if (NT_STATUS_IS_ERR(status)) {
8451                 return status;
8452         }
8453
8454         /* Return variables */
8455
8456         /* Return result */
8457         if (werror) {
8458                 *werror = r.out.result;
8459         }
8460
8461         return werror_to_ntstatus(r.out.result);
8462 }
8463
8464 struct rpccli_spoolss_FindNextPrinterChangeNotification_state {
8465         struct spoolss_FindNextPrinterChangeNotification orig;
8466         struct spoolss_FindNextPrinterChangeNotification tmp;
8467         TALLOC_CTX *out_mem_ctx;
8468         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8469 };
8470
8471 static void rpccli_spoolss_FindNextPrinterChangeNotification_done(struct tevent_req *subreq);
8472
8473 struct tevent_req *rpccli_spoolss_FindNextPrinterChangeNotification_send(TALLOC_CTX *mem_ctx,
8474                                                                          struct tevent_context *ev,
8475                                                                          struct rpc_pipe_client *cli)
8476 {
8477         struct tevent_req *req;
8478         struct rpccli_spoolss_FindNextPrinterChangeNotification_state *state;
8479         struct tevent_req *subreq;
8480
8481         req = tevent_req_create(mem_ctx, &state,
8482                                 struct rpccli_spoolss_FindNextPrinterChangeNotification_state);
8483         if (req == NULL) {
8484                 return NULL;
8485         }
8486         state->out_mem_ctx = NULL;
8487         state->dispatch_recv = cli->dispatch_recv;
8488
8489         /* In parameters */
8490
8491         /* Out parameters */
8492
8493         /* Result */
8494         ZERO_STRUCT(state->orig.out.result);
8495
8496         /* make a temporary copy, that we pass to the dispatch function */
8497         state->tmp = state->orig;
8498
8499         subreq = cli->dispatch_send(state, ev, cli,
8500                                     &ndr_table_spoolss,
8501                                     NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION,
8502                                     &state->tmp);
8503         if (tevent_req_nomem(subreq, req)) {
8504                 return tevent_req_post(req, ev);
8505         }
8506         tevent_req_set_callback(subreq, rpccli_spoolss_FindNextPrinterChangeNotification_done, req);
8507         return req;
8508 }
8509
8510 static void rpccli_spoolss_FindNextPrinterChangeNotification_done(struct tevent_req *subreq)
8511 {
8512         struct tevent_req *req = tevent_req_callback_data(
8513                 subreq, struct tevent_req);
8514         struct rpccli_spoolss_FindNextPrinterChangeNotification_state *state = tevent_req_data(
8515                 req, struct rpccli_spoolss_FindNextPrinterChangeNotification_state);
8516         NTSTATUS status;
8517         TALLOC_CTX *mem_ctx;
8518
8519         if (state->out_mem_ctx) {
8520                 mem_ctx = state->out_mem_ctx;
8521         } else {
8522                 mem_ctx = state;
8523         }
8524
8525         status = state->dispatch_recv(subreq, mem_ctx);
8526         TALLOC_FREE(subreq);
8527         if (!NT_STATUS_IS_OK(status)) {
8528                 tevent_req_nterror(req, status);
8529                 return;
8530         }
8531
8532         /* Copy out parameters */
8533
8534         /* Copy result */
8535         state->orig.out.result = state->tmp.out.result;
8536
8537         /* Reset temporary structure */
8538         ZERO_STRUCT(state->tmp);
8539
8540         tevent_req_done(req);
8541 }
8542
8543 NTSTATUS rpccli_spoolss_FindNextPrinterChangeNotification_recv(struct tevent_req *req,
8544                                                                TALLOC_CTX *mem_ctx,
8545                                                                WERROR *result)
8546 {
8547         struct rpccli_spoolss_FindNextPrinterChangeNotification_state *state = tevent_req_data(
8548                 req, struct rpccli_spoolss_FindNextPrinterChangeNotification_state);
8549         NTSTATUS status;
8550
8551         if (tevent_req_is_nterror(req, &status)) {
8552                 tevent_req_received(req);
8553                 return status;
8554         }
8555
8556         /* Steal possbile out parameters to the callers context */
8557         talloc_steal(mem_ctx, state->out_mem_ctx);
8558
8559         /* Return result */
8560         *result = state->orig.out.result;
8561
8562         tevent_req_received(req);
8563         return NT_STATUS_OK;
8564 }
8565
8566 NTSTATUS rpccli_spoolss_FindNextPrinterChangeNotification(struct rpc_pipe_client *cli,
8567                                                           TALLOC_CTX *mem_ctx,
8568                                                           WERROR *werror)
8569 {
8570         struct spoolss_FindNextPrinterChangeNotification r;
8571         NTSTATUS status;
8572
8573         /* In parameters */
8574
8575         status = cli->dispatch(cli,
8576                                 mem_ctx,
8577                                 &ndr_table_spoolss,
8578                                 NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION,
8579                                 &r);
8580
8581         if (!NT_STATUS_IS_OK(status)) {
8582                 return status;
8583         }
8584
8585         if (NT_STATUS_IS_ERR(status)) {
8586                 return status;
8587         }
8588
8589         /* Return variables */
8590
8591         /* Return result */
8592         if (werror) {
8593                 *werror = r.out.result;
8594         }
8595
8596         return werror_to_ntstatus(r.out.result);
8597 }
8598
8599 struct rpccli_spoolss_FindClosePrinterNotify_state {
8600         struct spoolss_FindClosePrinterNotify orig;
8601         struct spoolss_FindClosePrinterNotify tmp;
8602         TALLOC_CTX *out_mem_ctx;
8603         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8604 };
8605
8606 static void rpccli_spoolss_FindClosePrinterNotify_done(struct tevent_req *subreq);
8607
8608 struct tevent_req *rpccli_spoolss_FindClosePrinterNotify_send(TALLOC_CTX *mem_ctx,
8609                                                               struct tevent_context *ev,
8610                                                               struct rpc_pipe_client *cli,
8611                                                               struct policy_handle *_handle /* [in] [ref] */)
8612 {
8613         struct tevent_req *req;
8614         struct rpccli_spoolss_FindClosePrinterNotify_state *state;
8615         struct tevent_req *subreq;
8616
8617         req = tevent_req_create(mem_ctx, &state,
8618                                 struct rpccli_spoolss_FindClosePrinterNotify_state);
8619         if (req == NULL) {
8620                 return NULL;
8621         }
8622         state->out_mem_ctx = NULL;
8623         state->dispatch_recv = cli->dispatch_recv;
8624
8625         /* In parameters */
8626         state->orig.in.handle = _handle;
8627
8628         /* Out parameters */
8629
8630         /* Result */
8631         ZERO_STRUCT(state->orig.out.result);
8632
8633         /* make a temporary copy, that we pass to the dispatch function */
8634         state->tmp = state->orig;
8635
8636         subreq = cli->dispatch_send(state, ev, cli,
8637                                     &ndr_table_spoolss,
8638                                     NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY,
8639                                     &state->tmp);
8640         if (tevent_req_nomem(subreq, req)) {
8641                 return tevent_req_post(req, ev);
8642         }
8643         tevent_req_set_callback(subreq, rpccli_spoolss_FindClosePrinterNotify_done, req);
8644         return req;
8645 }
8646
8647 static void rpccli_spoolss_FindClosePrinterNotify_done(struct tevent_req *subreq)
8648 {
8649         struct tevent_req *req = tevent_req_callback_data(
8650                 subreq, struct tevent_req);
8651         struct rpccli_spoolss_FindClosePrinterNotify_state *state = tevent_req_data(
8652                 req, struct rpccli_spoolss_FindClosePrinterNotify_state);
8653         NTSTATUS status;
8654         TALLOC_CTX *mem_ctx;
8655
8656         if (state->out_mem_ctx) {
8657                 mem_ctx = state->out_mem_ctx;
8658         } else {
8659                 mem_ctx = state;
8660         }
8661
8662         status = state->dispatch_recv(subreq, mem_ctx);
8663         TALLOC_FREE(subreq);
8664         if (!NT_STATUS_IS_OK(status)) {
8665                 tevent_req_nterror(req, status);
8666                 return;
8667         }
8668
8669         /* Copy out parameters */
8670
8671         /* Copy result */
8672         state->orig.out.result = state->tmp.out.result;
8673
8674         /* Reset temporary structure */
8675         ZERO_STRUCT(state->tmp);
8676
8677         tevent_req_done(req);
8678 }
8679
8680 NTSTATUS rpccli_spoolss_FindClosePrinterNotify_recv(struct tevent_req *req,
8681                                                     TALLOC_CTX *mem_ctx,
8682                                                     WERROR *result)
8683 {
8684         struct rpccli_spoolss_FindClosePrinterNotify_state *state = tevent_req_data(
8685                 req, struct rpccli_spoolss_FindClosePrinterNotify_state);
8686         NTSTATUS status;
8687
8688         if (tevent_req_is_nterror(req, &status)) {
8689                 tevent_req_received(req);
8690                 return status;
8691         }
8692
8693         /* Steal possbile out parameters to the callers context */
8694         talloc_steal(mem_ctx, state->out_mem_ctx);
8695
8696         /* Return result */
8697         *result = state->orig.out.result;
8698
8699         tevent_req_received(req);
8700         return NT_STATUS_OK;
8701 }
8702
8703 NTSTATUS rpccli_spoolss_FindClosePrinterNotify(struct rpc_pipe_client *cli,
8704                                                TALLOC_CTX *mem_ctx,
8705                                                struct policy_handle *handle /* [in] [ref] */,
8706                                                WERROR *werror)
8707 {
8708         struct spoolss_FindClosePrinterNotify r;
8709         NTSTATUS status;
8710
8711         /* In parameters */
8712         r.in.handle = handle;
8713
8714         status = cli->dispatch(cli,
8715                                 mem_ctx,
8716                                 &ndr_table_spoolss,
8717                                 NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY,
8718                                 &r);
8719
8720         if (!NT_STATUS_IS_OK(status)) {
8721                 return status;
8722         }
8723
8724         if (NT_STATUS_IS_ERR(status)) {
8725                 return status;
8726         }
8727
8728         /* Return variables */
8729
8730         /* Return result */
8731         if (werror) {
8732                 *werror = r.out.result;
8733         }
8734
8735         return werror_to_ntstatus(r.out.result);
8736 }
8737
8738 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state {
8739         struct spoolss_RouterFindFirstPrinterChangeNotificationOld orig;
8740         struct spoolss_RouterFindFirstPrinterChangeNotificationOld tmp;
8741         TALLOC_CTX *out_mem_ctx;
8742         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8743 };
8744
8745 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_done(struct tevent_req *subreq);
8746
8747 struct tevent_req *rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_send(TALLOC_CTX *mem_ctx,
8748                                                                                    struct tevent_context *ev,
8749                                                                                    struct rpc_pipe_client *cli)
8750 {
8751         struct tevent_req *req;
8752         struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state *state;
8753         struct tevent_req *subreq;
8754
8755         req = tevent_req_create(mem_ctx, &state,
8756                                 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state);
8757         if (req == NULL) {
8758                 return NULL;
8759         }
8760         state->out_mem_ctx = NULL;
8761         state->dispatch_recv = cli->dispatch_recv;
8762
8763         /* In parameters */
8764
8765         /* Out parameters */
8766
8767         /* Result */
8768         ZERO_STRUCT(state->orig.out.result);
8769
8770         /* make a temporary copy, that we pass to the dispatch function */
8771         state->tmp = state->orig;
8772
8773         subreq = cli->dispatch_send(state, ev, cli,
8774                                     &ndr_table_spoolss,
8775                                     NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD,
8776                                     &state->tmp);
8777         if (tevent_req_nomem(subreq, req)) {
8778                 return tevent_req_post(req, ev);
8779         }
8780         tevent_req_set_callback(subreq, rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_done, req);
8781         return req;
8782 }
8783
8784 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_done(struct tevent_req *subreq)
8785 {
8786         struct tevent_req *req = tevent_req_callback_data(
8787                 subreq, struct tevent_req);
8788         struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state *state = tevent_req_data(
8789                 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state);
8790         NTSTATUS status;
8791         TALLOC_CTX *mem_ctx;
8792
8793         if (state->out_mem_ctx) {
8794                 mem_ctx = state->out_mem_ctx;
8795         } else {
8796                 mem_ctx = state;
8797         }
8798
8799         status = state->dispatch_recv(subreq, mem_ctx);
8800         TALLOC_FREE(subreq);
8801         if (!NT_STATUS_IS_OK(status)) {
8802                 tevent_req_nterror(req, status);
8803                 return;
8804         }
8805
8806         /* Copy out parameters */
8807
8808         /* Copy result */
8809         state->orig.out.result = state->tmp.out.result;
8810
8811         /* Reset temporary structure */
8812         ZERO_STRUCT(state->tmp);
8813
8814         tevent_req_done(req);
8815 }
8816
8817 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_recv(struct tevent_req *req,
8818                                                                          TALLOC_CTX *mem_ctx,
8819                                                                          WERROR *result)
8820 {
8821         struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state *state = tevent_req_data(
8822                 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld_state);
8823         NTSTATUS status;
8824
8825         if (tevent_req_is_nterror(req, &status)) {
8826                 tevent_req_received(req);
8827                 return status;
8828         }
8829
8830         /* Steal possbile out parameters to the callers context */
8831         talloc_steal(mem_ctx, state->out_mem_ctx);
8832
8833         /* Return result */
8834         *result = state->orig.out.result;
8835
8836         tevent_req_received(req);
8837         return NT_STATUS_OK;
8838 }
8839
8840 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct rpc_pipe_client *cli,
8841                                                                     TALLOC_CTX *mem_ctx,
8842                                                                     WERROR *werror)
8843 {
8844         struct spoolss_RouterFindFirstPrinterChangeNotificationOld r;
8845         NTSTATUS status;
8846
8847         /* In parameters */
8848
8849         status = cli->dispatch(cli,
8850                                 mem_ctx,
8851                                 &ndr_table_spoolss,
8852                                 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD,
8853                                 &r);
8854
8855         if (!NT_STATUS_IS_OK(status)) {
8856                 return status;
8857         }
8858
8859         if (NT_STATUS_IS_ERR(status)) {
8860                 return status;
8861         }
8862
8863         /* Return variables */
8864
8865         /* Return result */
8866         if (werror) {
8867                 *werror = r.out.result;
8868         }
8869
8870         return werror_to_ntstatus(r.out.result);
8871 }
8872
8873 struct rpccli_spoolss_ReplyOpenPrinter_state {
8874         struct spoolss_ReplyOpenPrinter orig;
8875         struct spoolss_ReplyOpenPrinter tmp;
8876         TALLOC_CTX *out_mem_ctx;
8877         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8878 };
8879
8880 static void rpccli_spoolss_ReplyOpenPrinter_done(struct tevent_req *subreq);
8881
8882 struct tevent_req *rpccli_spoolss_ReplyOpenPrinter_send(TALLOC_CTX *mem_ctx,
8883                                                         struct tevent_context *ev,
8884                                                         struct rpc_pipe_client *cli,
8885                                                         const char *_server_name /* [in] [charset(UTF16)] */,
8886                                                         uint32_t _printer_local /* [in]  */,
8887                                                         enum winreg_Type _type /* [in]  */,
8888                                                         uint32_t _bufsize /* [in] [range(0,512)] */,
8889                                                         uint8_t *_buffer /* [in] [unique,size_is(bufsize)] */,
8890                                                         struct policy_handle *_handle /* [out] [ref] */)
8891 {
8892         struct tevent_req *req;
8893         struct rpccli_spoolss_ReplyOpenPrinter_state *state;
8894         struct tevent_req *subreq;
8895
8896         req = tevent_req_create(mem_ctx, &state,
8897                                 struct rpccli_spoolss_ReplyOpenPrinter_state);
8898         if (req == NULL) {
8899                 return NULL;
8900         }
8901         state->out_mem_ctx = NULL;
8902         state->dispatch_recv = cli->dispatch_recv;
8903
8904         /* In parameters */
8905         state->orig.in.server_name = _server_name;
8906         state->orig.in.printer_local = _printer_local;
8907         state->orig.in.type = _type;
8908         state->orig.in.bufsize = _bufsize;
8909         state->orig.in.buffer = _buffer;
8910
8911         /* Out parameters */
8912         state->orig.out.handle = _handle;
8913
8914         /* Result */
8915         ZERO_STRUCT(state->orig.out.result);
8916
8917         state->out_mem_ctx = talloc_named_const(state, 0,
8918                              "rpccli_spoolss_ReplyOpenPrinter_out_memory");
8919         if (tevent_req_nomem(state->out_mem_ctx, req)) {
8920                 return tevent_req_post(req, ev);
8921         }
8922
8923         /* make a temporary copy, that we pass to the dispatch function */
8924         state->tmp = state->orig;
8925
8926         subreq = cli->dispatch_send(state, ev, cli,
8927                                     &ndr_table_spoolss,
8928                                     NDR_SPOOLSS_REPLYOPENPRINTER,
8929                                     &state->tmp);
8930         if (tevent_req_nomem(subreq, req)) {
8931                 return tevent_req_post(req, ev);
8932         }
8933         tevent_req_set_callback(subreq, rpccli_spoolss_ReplyOpenPrinter_done, req);
8934         return req;
8935 }
8936
8937 static void rpccli_spoolss_ReplyOpenPrinter_done(struct tevent_req *subreq)
8938 {
8939         struct tevent_req *req = tevent_req_callback_data(
8940                 subreq, struct tevent_req);
8941         struct rpccli_spoolss_ReplyOpenPrinter_state *state = tevent_req_data(
8942                 req, struct rpccli_spoolss_ReplyOpenPrinter_state);
8943         NTSTATUS status;
8944         TALLOC_CTX *mem_ctx;
8945
8946         if (state->out_mem_ctx) {
8947                 mem_ctx = state->out_mem_ctx;
8948         } else {
8949                 mem_ctx = state;
8950         }
8951
8952         status = state->dispatch_recv(subreq, mem_ctx);
8953         TALLOC_FREE(subreq);
8954         if (!NT_STATUS_IS_OK(status)) {
8955                 tevent_req_nterror(req, status);
8956                 return;
8957         }
8958
8959         /* Copy out parameters */
8960         *state->orig.out.handle = *state->tmp.out.handle;
8961
8962         /* Copy result */
8963         state->orig.out.result = state->tmp.out.result;
8964
8965         /* Reset temporary structure */
8966         ZERO_STRUCT(state->tmp);
8967
8968         tevent_req_done(req);
8969 }
8970
8971 NTSTATUS rpccli_spoolss_ReplyOpenPrinter_recv(struct tevent_req *req,
8972                                               TALLOC_CTX *mem_ctx,
8973                                               WERROR *result)
8974 {
8975         struct rpccli_spoolss_ReplyOpenPrinter_state *state = tevent_req_data(
8976                 req, struct rpccli_spoolss_ReplyOpenPrinter_state);
8977         NTSTATUS status;
8978
8979         if (tevent_req_is_nterror(req, &status)) {
8980                 tevent_req_received(req);
8981                 return status;
8982         }
8983
8984         /* Steal possbile out parameters to the callers context */
8985         talloc_steal(mem_ctx, state->out_mem_ctx);
8986
8987         /* Return result */
8988         *result = state->orig.out.result;
8989
8990         tevent_req_received(req);
8991         return NT_STATUS_OK;
8992 }
8993
8994 NTSTATUS rpccli_spoolss_ReplyOpenPrinter(struct rpc_pipe_client *cli,
8995                                          TALLOC_CTX *mem_ctx,
8996                                          const char *server_name /* [in] [charset(UTF16)] */,
8997                                          uint32_t printer_local /* [in]  */,
8998                                          enum winreg_Type type /* [in]  */,
8999                                          uint32_t bufsize /* [in] [range(0,512)] */,
9000                                          uint8_t *buffer /* [in] [unique,size_is(bufsize)] */,
9001                                          struct policy_handle *handle /* [out] [ref] */,
9002                                          WERROR *werror)
9003 {
9004         struct spoolss_ReplyOpenPrinter r;
9005         NTSTATUS status;
9006
9007         /* In parameters */
9008         r.in.server_name = server_name;
9009         r.in.printer_local = printer_local;
9010         r.in.type = type;
9011         r.in.bufsize = bufsize;
9012         r.in.buffer = buffer;
9013
9014         status = cli->dispatch(cli,
9015                                 mem_ctx,
9016                                 &ndr_table_spoolss,
9017                                 NDR_SPOOLSS_REPLYOPENPRINTER,
9018                                 &r);
9019
9020         if (!NT_STATUS_IS_OK(status)) {
9021                 return status;
9022         }
9023
9024         if (NT_STATUS_IS_ERR(status)) {
9025                 return status;
9026         }
9027
9028         /* Return variables */
9029         *handle = *r.out.handle;
9030
9031         /* Return result */
9032         if (werror) {
9033                 *werror = r.out.result;
9034         }
9035
9036         return werror_to_ntstatus(r.out.result);
9037 }
9038
9039 struct rpccli_spoolss_RouterReplyPrinter_state {
9040         struct spoolss_RouterReplyPrinter orig;
9041         struct spoolss_RouterReplyPrinter tmp;
9042         TALLOC_CTX *out_mem_ctx;
9043         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9044 };
9045
9046 static void rpccli_spoolss_RouterReplyPrinter_done(struct tevent_req *subreq);
9047
9048 struct tevent_req *rpccli_spoolss_RouterReplyPrinter_send(TALLOC_CTX *mem_ctx,
9049                                                           struct tevent_context *ev,
9050                                                           struct rpc_pipe_client *cli,
9051                                                           struct policy_handle *_handle /* [in] [ref] */,
9052                                                           uint32_t _flags /* [in]  */,
9053                                                           uint32_t _bufsize /* [in] [range(0,512)] */,
9054                                                           uint8_t *_buffer /* [in] [unique,size_is(bufsize)] */)
9055 {
9056         struct tevent_req *req;
9057         struct rpccli_spoolss_RouterReplyPrinter_state *state;
9058         struct tevent_req *subreq;
9059
9060         req = tevent_req_create(mem_ctx, &state,
9061                                 struct rpccli_spoolss_RouterReplyPrinter_state);
9062         if (req == NULL) {
9063                 return NULL;
9064         }
9065         state->out_mem_ctx = NULL;
9066         state->dispatch_recv = cli->dispatch_recv;
9067
9068         /* In parameters */
9069         state->orig.in.handle = _handle;
9070         state->orig.in.flags = _flags;
9071         state->orig.in.bufsize = _bufsize;
9072         state->orig.in.buffer = _buffer;
9073
9074         /* Out parameters */
9075
9076         /* Result */
9077         ZERO_STRUCT(state->orig.out.result);
9078
9079         /* make a temporary copy, that we pass to the dispatch function */
9080         state->tmp = state->orig;
9081
9082         subreq = cli->dispatch_send(state, ev, cli,
9083                                     &ndr_table_spoolss,
9084                                     NDR_SPOOLSS_ROUTERREPLYPRINTER,
9085                                     &state->tmp);
9086         if (tevent_req_nomem(subreq, req)) {
9087                 return tevent_req_post(req, ev);
9088         }
9089         tevent_req_set_callback(subreq, rpccli_spoolss_RouterReplyPrinter_done, req);
9090         return req;
9091 }
9092
9093 static void rpccli_spoolss_RouterReplyPrinter_done(struct tevent_req *subreq)
9094 {
9095         struct tevent_req *req = tevent_req_callback_data(
9096                 subreq, struct tevent_req);
9097         struct rpccli_spoolss_RouterReplyPrinter_state *state = tevent_req_data(
9098                 req, struct rpccli_spoolss_RouterReplyPrinter_state);
9099         NTSTATUS status;
9100         TALLOC_CTX *mem_ctx;
9101
9102         if (state->out_mem_ctx) {
9103                 mem_ctx = state->out_mem_ctx;
9104         } else {
9105                 mem_ctx = state;
9106         }
9107
9108         status = state->dispatch_recv(subreq, mem_ctx);
9109         TALLOC_FREE(subreq);
9110         if (!NT_STATUS_IS_OK(status)) {
9111                 tevent_req_nterror(req, status);
9112                 return;
9113         }
9114
9115         /* Copy out parameters */
9116
9117         /* Copy result */
9118         state->orig.out.result = state->tmp.out.result;
9119
9120         /* Reset temporary structure */
9121         ZERO_STRUCT(state->tmp);
9122
9123         tevent_req_done(req);
9124 }
9125
9126 NTSTATUS rpccli_spoolss_RouterReplyPrinter_recv(struct tevent_req *req,
9127                                                 TALLOC_CTX *mem_ctx,
9128                                                 WERROR *result)
9129 {
9130         struct rpccli_spoolss_RouterReplyPrinter_state *state = tevent_req_data(
9131                 req, struct rpccli_spoolss_RouterReplyPrinter_state);
9132         NTSTATUS status;
9133
9134         if (tevent_req_is_nterror(req, &status)) {
9135                 tevent_req_received(req);
9136                 return status;
9137         }
9138
9139         /* Steal possbile out parameters to the callers context */
9140         talloc_steal(mem_ctx, state->out_mem_ctx);
9141
9142         /* Return result */
9143         *result = state->orig.out.result;
9144
9145         tevent_req_received(req);
9146         return NT_STATUS_OK;
9147 }
9148
9149 NTSTATUS rpccli_spoolss_RouterReplyPrinter(struct rpc_pipe_client *cli,
9150                                            TALLOC_CTX *mem_ctx,
9151                                            struct policy_handle *handle /* [in] [ref] */,
9152                                            uint32_t flags /* [in]  */,
9153                                            uint32_t bufsize /* [in] [range(0,512)] */,
9154                                            uint8_t *buffer /* [in] [unique,size_is(bufsize)] */,
9155                                            WERROR *werror)
9156 {
9157         struct spoolss_RouterReplyPrinter r;
9158         NTSTATUS status;
9159
9160         /* In parameters */
9161         r.in.handle = handle;
9162         r.in.flags = flags;
9163         r.in.bufsize = bufsize;
9164         r.in.buffer = buffer;
9165
9166         status = cli->dispatch(cli,
9167                                 mem_ctx,
9168                                 &ndr_table_spoolss,
9169                                 NDR_SPOOLSS_ROUTERREPLYPRINTER,
9170                                 &r);
9171
9172         if (!NT_STATUS_IS_OK(status)) {
9173                 return status;
9174         }
9175
9176         if (NT_STATUS_IS_ERR(status)) {
9177                 return status;
9178         }
9179
9180         /* Return variables */
9181
9182         /* Return result */
9183         if (werror) {
9184                 *werror = r.out.result;
9185         }
9186
9187         return werror_to_ntstatus(r.out.result);
9188 }
9189
9190 struct rpccli_spoolss_ReplyClosePrinter_state {
9191         struct spoolss_ReplyClosePrinter orig;
9192         struct spoolss_ReplyClosePrinter tmp;
9193         TALLOC_CTX *out_mem_ctx;
9194         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9195 };
9196
9197 static void rpccli_spoolss_ReplyClosePrinter_done(struct tevent_req *subreq);
9198
9199 struct tevent_req *rpccli_spoolss_ReplyClosePrinter_send(TALLOC_CTX *mem_ctx,
9200                                                          struct tevent_context *ev,
9201                                                          struct rpc_pipe_client *cli,
9202                                                          struct policy_handle *_handle /* [in,out] [ref] */)
9203 {
9204         struct tevent_req *req;
9205         struct rpccli_spoolss_ReplyClosePrinter_state *state;
9206         struct tevent_req *subreq;
9207
9208         req = tevent_req_create(mem_ctx, &state,
9209                                 struct rpccli_spoolss_ReplyClosePrinter_state);
9210         if (req == NULL) {
9211                 return NULL;
9212         }
9213         state->out_mem_ctx = NULL;
9214         state->dispatch_recv = cli->dispatch_recv;
9215
9216         /* In parameters */
9217         state->orig.in.handle = _handle;
9218
9219         /* Out parameters */
9220         state->orig.out.handle = _handle;
9221
9222         /* Result */
9223         ZERO_STRUCT(state->orig.out.result);
9224
9225         state->out_mem_ctx = talloc_named_const(state, 0,
9226                              "rpccli_spoolss_ReplyClosePrinter_out_memory");
9227         if (tevent_req_nomem(state->out_mem_ctx, req)) {
9228                 return tevent_req_post(req, ev);
9229         }
9230
9231         /* make a temporary copy, that we pass to the dispatch function */
9232         state->tmp = state->orig;
9233
9234         subreq = cli->dispatch_send(state, ev, cli,
9235                                     &ndr_table_spoolss,
9236                                     NDR_SPOOLSS_REPLYCLOSEPRINTER,
9237                                     &state->tmp);
9238         if (tevent_req_nomem(subreq, req)) {
9239                 return tevent_req_post(req, ev);
9240         }
9241         tevent_req_set_callback(subreq, rpccli_spoolss_ReplyClosePrinter_done, req);
9242         return req;
9243 }
9244
9245 static void rpccli_spoolss_ReplyClosePrinter_done(struct tevent_req *subreq)
9246 {
9247         struct tevent_req *req = tevent_req_callback_data(
9248                 subreq, struct tevent_req);
9249         struct rpccli_spoolss_ReplyClosePrinter_state *state = tevent_req_data(
9250                 req, struct rpccli_spoolss_ReplyClosePrinter_state);
9251         NTSTATUS status;
9252         TALLOC_CTX *mem_ctx;
9253
9254         if (state->out_mem_ctx) {
9255                 mem_ctx = state->out_mem_ctx;
9256         } else {
9257                 mem_ctx = state;
9258         }
9259
9260         status = state->dispatch_recv(subreq, mem_ctx);
9261         TALLOC_FREE(subreq);
9262         if (!NT_STATUS_IS_OK(status)) {
9263                 tevent_req_nterror(req, status);
9264                 return;
9265         }
9266
9267         /* Copy out parameters */
9268         *state->orig.out.handle = *state->tmp.out.handle;
9269
9270         /* Copy result */
9271         state->orig.out.result = state->tmp.out.result;
9272
9273         /* Reset temporary structure */
9274         ZERO_STRUCT(state->tmp);
9275
9276         tevent_req_done(req);
9277 }
9278
9279 NTSTATUS rpccli_spoolss_ReplyClosePrinter_recv(struct tevent_req *req,
9280                                                TALLOC_CTX *mem_ctx,
9281                                                WERROR *result)
9282 {
9283         struct rpccli_spoolss_ReplyClosePrinter_state *state = tevent_req_data(
9284                 req, struct rpccli_spoolss_ReplyClosePrinter_state);
9285         NTSTATUS status;
9286
9287         if (tevent_req_is_nterror(req, &status)) {
9288                 tevent_req_received(req);
9289                 return status;
9290         }
9291
9292         /* Steal possbile out parameters to the callers context */
9293         talloc_steal(mem_ctx, state->out_mem_ctx);
9294
9295         /* Return result */
9296         *result = state->orig.out.result;
9297
9298         tevent_req_received(req);
9299         return NT_STATUS_OK;
9300 }
9301
9302 NTSTATUS rpccli_spoolss_ReplyClosePrinter(struct rpc_pipe_client *cli,
9303                                           TALLOC_CTX *mem_ctx,
9304                                           struct policy_handle *handle /* [in,out] [ref] */,
9305                                           WERROR *werror)
9306 {
9307         struct spoolss_ReplyClosePrinter r;
9308         NTSTATUS status;
9309
9310         /* In parameters */
9311         r.in.handle = handle;
9312
9313         status = cli->dispatch(cli,
9314                                 mem_ctx,
9315                                 &ndr_table_spoolss,
9316                                 NDR_SPOOLSS_REPLYCLOSEPRINTER,
9317                                 &r);
9318
9319         if (!NT_STATUS_IS_OK(status)) {
9320                 return status;
9321         }
9322
9323         if (NT_STATUS_IS_ERR(status)) {
9324                 return status;
9325         }
9326
9327         /* Return variables */
9328         *handle = *r.out.handle;
9329
9330         /* Return result */
9331         if (werror) {
9332                 *werror = r.out.result;
9333         }
9334
9335         return werror_to_ntstatus(r.out.result);
9336 }
9337
9338 struct rpccli_spoolss_AddPortEx_state {
9339         struct spoolss_AddPortEx orig;
9340         struct spoolss_AddPortEx tmp;
9341         TALLOC_CTX *out_mem_ctx;
9342         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9343 };
9344
9345 static void rpccli_spoolss_AddPortEx_done(struct tevent_req *subreq);
9346
9347 struct tevent_req *rpccli_spoolss_AddPortEx_send(TALLOC_CTX *mem_ctx,
9348                                                  struct tevent_context *ev,
9349                                                  struct rpc_pipe_client *cli)
9350 {
9351         struct tevent_req *req;
9352         struct rpccli_spoolss_AddPortEx_state *state;
9353         struct tevent_req *subreq;
9354
9355         req = tevent_req_create(mem_ctx, &state,
9356                                 struct rpccli_spoolss_AddPortEx_state);
9357         if (req == NULL) {
9358                 return NULL;
9359         }
9360         state->out_mem_ctx = NULL;
9361         state->dispatch_recv = cli->dispatch_recv;
9362
9363         /* In parameters */
9364
9365         /* Out parameters */
9366
9367         /* Result */
9368         ZERO_STRUCT(state->orig.out.result);
9369
9370         /* make a temporary copy, that we pass to the dispatch function */
9371         state->tmp = state->orig;
9372
9373         subreq = cli->dispatch_send(state, ev, cli,
9374                                     &ndr_table_spoolss,
9375                                     NDR_SPOOLSS_ADDPORTEX,
9376                                     &state->tmp);
9377         if (tevent_req_nomem(subreq, req)) {
9378                 return tevent_req_post(req, ev);
9379         }
9380         tevent_req_set_callback(subreq, rpccli_spoolss_AddPortEx_done, req);
9381         return req;
9382 }
9383
9384 static void rpccli_spoolss_AddPortEx_done(struct tevent_req *subreq)
9385 {
9386         struct tevent_req *req = tevent_req_callback_data(
9387                 subreq, struct tevent_req);
9388         struct rpccli_spoolss_AddPortEx_state *state = tevent_req_data(
9389                 req, struct rpccli_spoolss_AddPortEx_state);
9390         NTSTATUS status;
9391         TALLOC_CTX *mem_ctx;
9392
9393         if (state->out_mem_ctx) {
9394                 mem_ctx = state->out_mem_ctx;
9395         } else {
9396                 mem_ctx = state;
9397         }
9398
9399         status = state->dispatch_recv(subreq, mem_ctx);
9400         TALLOC_FREE(subreq);
9401         if (!NT_STATUS_IS_OK(status)) {
9402                 tevent_req_nterror(req, status);
9403                 return;
9404         }
9405
9406         /* Copy out parameters */
9407
9408         /* Copy result */
9409         state->orig.out.result = state->tmp.out.result;
9410
9411         /* Reset temporary structure */
9412         ZERO_STRUCT(state->tmp);
9413
9414         tevent_req_done(req);
9415 }
9416
9417 NTSTATUS rpccli_spoolss_AddPortEx_recv(struct tevent_req *req,
9418                                        TALLOC_CTX *mem_ctx,
9419                                        WERROR *result)
9420 {
9421         struct rpccli_spoolss_AddPortEx_state *state = tevent_req_data(
9422                 req, struct rpccli_spoolss_AddPortEx_state);
9423         NTSTATUS status;
9424
9425         if (tevent_req_is_nterror(req, &status)) {
9426                 tevent_req_received(req);
9427                 return status;
9428         }
9429
9430         /* Steal possbile out parameters to the callers context */
9431         talloc_steal(mem_ctx, state->out_mem_ctx);
9432
9433         /* Return result */
9434         *result = state->orig.out.result;
9435
9436         tevent_req_received(req);
9437         return NT_STATUS_OK;
9438 }
9439
9440 NTSTATUS rpccli_spoolss_AddPortEx(struct rpc_pipe_client *cli,
9441                                   TALLOC_CTX *mem_ctx,
9442                                   WERROR *werror)
9443 {
9444         struct spoolss_AddPortEx r;
9445         NTSTATUS status;
9446
9447         /* In parameters */
9448
9449         status = cli->dispatch(cli,
9450                                 mem_ctx,
9451                                 &ndr_table_spoolss,
9452                                 NDR_SPOOLSS_ADDPORTEX,
9453                                 &r);
9454
9455         if (!NT_STATUS_IS_OK(status)) {
9456                 return status;
9457         }
9458
9459         if (NT_STATUS_IS_ERR(status)) {
9460                 return status;
9461         }
9462
9463         /* Return variables */
9464
9465         /* Return result */
9466         if (werror) {
9467                 *werror = r.out.result;
9468         }
9469
9470         return werror_to_ntstatus(r.out.result);
9471 }
9472
9473 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state {
9474         struct spoolss_RouterFindFirstPrinterChangeNotification orig;
9475         struct spoolss_RouterFindFirstPrinterChangeNotification tmp;
9476         TALLOC_CTX *out_mem_ctx;
9477         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9478 };
9479
9480 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotification_done(struct tevent_req *subreq);
9481
9482 struct tevent_req *rpccli_spoolss_RouterFindFirstPrinterChangeNotification_send(TALLOC_CTX *mem_ctx,
9483                                                                                 struct tevent_context *ev,
9484                                                                                 struct rpc_pipe_client *cli)
9485 {
9486         struct tevent_req *req;
9487         struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state *state;
9488         struct tevent_req *subreq;
9489
9490         req = tevent_req_create(mem_ctx, &state,
9491                                 struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state);
9492         if (req == NULL) {
9493                 return NULL;
9494         }
9495         state->out_mem_ctx = NULL;
9496         state->dispatch_recv = cli->dispatch_recv;
9497
9498         /* In parameters */
9499
9500         /* Out parameters */
9501
9502         /* Result */
9503         ZERO_STRUCT(state->orig.out.result);
9504
9505         /* make a temporary copy, that we pass to the dispatch function */
9506         state->tmp = state->orig;
9507
9508         subreq = cli->dispatch_send(state, ev, cli,
9509                                     &ndr_table_spoolss,
9510                                     NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION,
9511                                     &state->tmp);
9512         if (tevent_req_nomem(subreq, req)) {
9513                 return tevent_req_post(req, ev);
9514         }
9515         tevent_req_set_callback(subreq, rpccli_spoolss_RouterFindFirstPrinterChangeNotification_done, req);
9516         return req;
9517 }
9518
9519 static void rpccli_spoolss_RouterFindFirstPrinterChangeNotification_done(struct tevent_req *subreq)
9520 {
9521         struct tevent_req *req = tevent_req_callback_data(
9522                 subreq, struct tevent_req);
9523         struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state *state = tevent_req_data(
9524                 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state);
9525         NTSTATUS status;
9526         TALLOC_CTX *mem_ctx;
9527
9528         if (state->out_mem_ctx) {
9529                 mem_ctx = state->out_mem_ctx;
9530         } else {
9531                 mem_ctx = state;
9532         }
9533
9534         status = state->dispatch_recv(subreq, mem_ctx);
9535         TALLOC_FREE(subreq);
9536         if (!NT_STATUS_IS_OK(status)) {
9537                 tevent_req_nterror(req, status);
9538                 return;
9539         }
9540
9541         /* Copy out parameters */
9542
9543         /* Copy result */
9544         state->orig.out.result = state->tmp.out.result;
9545
9546         /* Reset temporary structure */
9547         ZERO_STRUCT(state->tmp);
9548
9549         tevent_req_done(req);
9550 }
9551
9552 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotification_recv(struct tevent_req *req,
9553                                                                       TALLOC_CTX *mem_ctx,
9554                                                                       WERROR *result)
9555 {
9556         struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state *state = tevent_req_data(
9557                 req, struct rpccli_spoolss_RouterFindFirstPrinterChangeNotification_state);
9558         NTSTATUS status;
9559
9560         if (tevent_req_is_nterror(req, &status)) {
9561                 tevent_req_received(req);
9562                 return status;
9563         }
9564
9565         /* Steal possbile out parameters to the callers context */
9566         talloc_steal(mem_ctx, state->out_mem_ctx);
9567
9568         /* Return result */
9569         *result = state->orig.out.result;
9570
9571         tevent_req_received(req);
9572         return NT_STATUS_OK;
9573 }
9574
9575 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotification(struct rpc_pipe_client *cli,
9576                                                                  TALLOC_CTX *mem_ctx,
9577                                                                  WERROR *werror)
9578 {
9579         struct spoolss_RouterFindFirstPrinterChangeNotification r;
9580         NTSTATUS status;
9581
9582         /* In parameters */
9583
9584         status = cli->dispatch(cli,
9585                                 mem_ctx,
9586                                 &ndr_table_spoolss,
9587                                 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION,
9588                                 &r);
9589
9590         if (!NT_STATUS_IS_OK(status)) {
9591                 return status;
9592         }
9593
9594         if (NT_STATUS_IS_ERR(status)) {
9595                 return status;
9596         }
9597
9598         /* Return variables */
9599
9600         /* Return result */
9601         if (werror) {
9602                 *werror = r.out.result;
9603         }
9604
9605         return werror_to_ntstatus(r.out.result);
9606 }
9607
9608 struct rpccli_spoolss_SpoolerInit_state {
9609         struct spoolss_SpoolerInit orig;
9610         struct spoolss_SpoolerInit tmp;
9611         TALLOC_CTX *out_mem_ctx;
9612         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9613 };
9614
9615 static void rpccli_spoolss_SpoolerInit_done(struct tevent_req *subreq);
9616
9617 struct tevent_req *rpccli_spoolss_SpoolerInit_send(TALLOC_CTX *mem_ctx,
9618                                                    struct tevent_context *ev,
9619                                                    struct rpc_pipe_client *cli)
9620 {
9621         struct tevent_req *req;
9622         struct rpccli_spoolss_SpoolerInit_state *state;
9623         struct tevent_req *subreq;
9624
9625         req = tevent_req_create(mem_ctx, &state,
9626                                 struct rpccli_spoolss_SpoolerInit_state);
9627         if (req == NULL) {
9628                 return NULL;
9629         }
9630         state->out_mem_ctx = NULL;
9631         state->dispatch_recv = cli->dispatch_recv;
9632
9633         /* In parameters */
9634
9635         /* Out parameters */
9636
9637         /* Result */
9638         ZERO_STRUCT(state->orig.out.result);
9639
9640         /* make a temporary copy, that we pass to the dispatch function */
9641         state->tmp = state->orig;
9642
9643         subreq = cli->dispatch_send(state, ev, cli,
9644                                     &ndr_table_spoolss,
9645                                     NDR_SPOOLSS_SPOOLERINIT,
9646                                     &state->tmp);
9647         if (tevent_req_nomem(subreq, req)) {
9648                 return tevent_req_post(req, ev);
9649         }
9650         tevent_req_set_callback(subreq, rpccli_spoolss_SpoolerInit_done, req);
9651         return req;
9652 }
9653
9654 static void rpccli_spoolss_SpoolerInit_done(struct tevent_req *subreq)
9655 {
9656         struct tevent_req *req = tevent_req_callback_data(
9657                 subreq, struct tevent_req);
9658         struct rpccli_spoolss_SpoolerInit_state *state = tevent_req_data(
9659                 req, struct rpccli_spoolss_SpoolerInit_state);
9660         NTSTATUS status;
9661         TALLOC_CTX *mem_ctx;
9662
9663         if (state->out_mem_ctx) {
9664                 mem_ctx = state->out_mem_ctx;
9665         } else {
9666                 mem_ctx = state;
9667         }
9668
9669         status = state->dispatch_recv(subreq, mem_ctx);
9670         TALLOC_FREE(subreq);
9671         if (!NT_STATUS_IS_OK(status)) {
9672                 tevent_req_nterror(req, status);
9673                 return;
9674         }
9675
9676         /* Copy out parameters */
9677
9678         /* Copy result */
9679         state->orig.out.result = state->tmp.out.result;
9680
9681         /* Reset temporary structure */
9682         ZERO_STRUCT(state->tmp);
9683
9684         tevent_req_done(req);
9685 }
9686
9687 NTSTATUS rpccli_spoolss_SpoolerInit_recv(struct tevent_req *req,
9688                                          TALLOC_CTX *mem_ctx,
9689                                          WERROR *result)
9690 {
9691         struct rpccli_spoolss_SpoolerInit_state *state = tevent_req_data(
9692                 req, struct rpccli_spoolss_SpoolerInit_state);
9693         NTSTATUS status;
9694
9695         if (tevent_req_is_nterror(req, &status)) {
9696                 tevent_req_received(req);
9697                 return status;
9698         }
9699
9700         /* Steal possbile out parameters to the callers context */
9701         talloc_steal(mem_ctx, state->out_mem_ctx);
9702
9703         /* Return result */
9704         *result = state->orig.out.result;
9705
9706         tevent_req_received(req);
9707         return NT_STATUS_OK;
9708 }
9709
9710 NTSTATUS rpccli_spoolss_SpoolerInit(struct rpc_pipe_client *cli,
9711                                     TALLOC_CTX *mem_ctx,
9712                                     WERROR *werror)
9713 {
9714         struct spoolss_SpoolerInit r;
9715         NTSTATUS status;
9716
9717         /* In parameters */
9718
9719         status = cli->dispatch(cli,
9720                                 mem_ctx,
9721                                 &ndr_table_spoolss,
9722                                 NDR_SPOOLSS_SPOOLERINIT,
9723                                 &r);
9724
9725         if (!NT_STATUS_IS_OK(status)) {
9726                 return status;
9727         }
9728
9729         if (NT_STATUS_IS_ERR(status)) {
9730                 return status;
9731         }
9732
9733         /* Return variables */
9734
9735         /* Return result */
9736         if (werror) {
9737                 *werror = r.out.result;
9738         }
9739
9740         return werror_to_ntstatus(r.out.result);
9741 }
9742
9743 struct rpccli_spoolss_ResetPrinterEx_state {
9744         struct spoolss_ResetPrinterEx orig;
9745         struct spoolss_ResetPrinterEx tmp;
9746         TALLOC_CTX *out_mem_ctx;
9747         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9748 };
9749
9750 static void rpccli_spoolss_ResetPrinterEx_done(struct tevent_req *subreq);
9751
9752 struct tevent_req *rpccli_spoolss_ResetPrinterEx_send(TALLOC_CTX *mem_ctx,
9753                                                       struct tevent_context *ev,
9754                                                       struct rpc_pipe_client *cli)
9755 {
9756         struct tevent_req *req;
9757         struct rpccli_spoolss_ResetPrinterEx_state *state;
9758         struct tevent_req *subreq;
9759
9760         req = tevent_req_create(mem_ctx, &state,
9761                                 struct rpccli_spoolss_ResetPrinterEx_state);
9762         if (req == NULL) {
9763                 return NULL;
9764         }
9765         state->out_mem_ctx = NULL;
9766         state->dispatch_recv = cli->dispatch_recv;
9767
9768         /* In parameters */
9769
9770         /* Out parameters */
9771
9772         /* Result */
9773         ZERO_STRUCT(state->orig.out.result);
9774
9775         /* make a temporary copy, that we pass to the dispatch function */
9776         state->tmp = state->orig;
9777
9778         subreq = cli->dispatch_send(state, ev, cli,
9779                                     &ndr_table_spoolss,
9780                                     NDR_SPOOLSS_RESETPRINTEREX,
9781                                     &state->tmp);
9782         if (tevent_req_nomem(subreq, req)) {
9783                 return tevent_req_post(req, ev);
9784         }
9785         tevent_req_set_callback(subreq, rpccli_spoolss_ResetPrinterEx_done, req);
9786         return req;
9787 }
9788
9789 static void rpccli_spoolss_ResetPrinterEx_done(struct tevent_req *subreq)
9790 {
9791         struct tevent_req *req = tevent_req_callback_data(
9792                 subreq, struct tevent_req);
9793         struct rpccli_spoolss_ResetPrinterEx_state *state = tevent_req_data(
9794                 req, struct rpccli_spoolss_ResetPrinterEx_state);
9795         NTSTATUS status;
9796         TALLOC_CTX *mem_ctx;
9797
9798         if (state->out_mem_ctx) {
9799                 mem_ctx = state->out_mem_ctx;
9800         } else {
9801                 mem_ctx = state;
9802         }
9803
9804         status = state->dispatch_recv(subreq, mem_ctx);
9805         TALLOC_FREE(subreq);
9806         if (!NT_STATUS_IS_OK(status)) {
9807                 tevent_req_nterror(req, status);
9808                 return;
9809         }
9810
9811         /* Copy out parameters */
9812
9813         /* Copy result */
9814         state->orig.out.result = state->tmp.out.result;
9815
9816         /* Reset temporary structure */
9817         ZERO_STRUCT(state->tmp);
9818
9819         tevent_req_done(req);
9820 }
9821
9822 NTSTATUS rpccli_spoolss_ResetPrinterEx_recv(struct tevent_req *req,
9823                                             TALLOC_CTX *mem_ctx,
9824                                             WERROR *result)
9825 {
9826         struct rpccli_spoolss_ResetPrinterEx_state *state = tevent_req_data(
9827                 req, struct rpccli_spoolss_ResetPrinterEx_state);
9828         NTSTATUS status;
9829
9830         if (tevent_req_is_nterror(req, &status)) {
9831                 tevent_req_received(req);
9832                 return status;
9833         }
9834
9835         /* Steal possbile out parameters to the callers context */
9836         talloc_steal(mem_ctx, state->out_mem_ctx);
9837
9838         /* Return result */
9839         *result = state->orig.out.result;
9840
9841         tevent_req_received(req);
9842         return NT_STATUS_OK;
9843 }
9844
9845 NTSTATUS rpccli_spoolss_ResetPrinterEx(struct rpc_pipe_client *cli,
9846                                        TALLOC_CTX *mem_ctx,
9847                                        WERROR *werror)
9848 {
9849         struct spoolss_ResetPrinterEx r;
9850         NTSTATUS status;
9851
9852         /* In parameters */
9853
9854         status = cli->dispatch(cli,
9855                                 mem_ctx,
9856                                 &ndr_table_spoolss,
9857                                 NDR_SPOOLSS_RESETPRINTEREX,
9858                                 &r);
9859
9860         if (!NT_STATUS_IS_OK(status)) {
9861                 return status;
9862         }
9863
9864         if (NT_STATUS_IS_ERR(status)) {
9865                 return status;
9866         }
9867
9868         /* Return variables */
9869
9870         /* Return result */
9871         if (werror) {
9872                 *werror = r.out.result;
9873         }
9874
9875         return werror_to_ntstatus(r.out.result);
9876 }
9877
9878 struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state {
9879         struct spoolss_RemoteFindFirstPrinterChangeNotifyEx orig;
9880         struct spoolss_RemoteFindFirstPrinterChangeNotifyEx tmp;
9881         TALLOC_CTX *out_mem_ctx;
9882         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9883 };
9884
9885 static void rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_done(struct tevent_req *subreq);
9886
9887 struct tevent_req *rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_send(TALLOC_CTX *mem_ctx,
9888                                                                             struct tevent_context *ev,
9889                                                                             struct rpc_pipe_client *cli,
9890                                                                             struct policy_handle *_handle /* [in] [ref] */,
9891                                                                             uint32_t _flags /* [in]  */,
9892                                                                             uint32_t _options /* [in]  */,
9893                                                                             const char *_local_machine /* [in] [unique,charset(UTF16)] */,
9894                                                                             uint32_t _printer_local /* [in]  */,
9895                                                                             struct spoolss_NotifyOption *_notify_options /* [in] [unique] */)
9896 {
9897         struct tevent_req *req;
9898         struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state *state;
9899         struct tevent_req *subreq;
9900
9901         req = tevent_req_create(mem_ctx, &state,
9902                                 struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state);
9903         if (req == NULL) {
9904                 return NULL;
9905         }
9906         state->out_mem_ctx = NULL;
9907         state->dispatch_recv = cli->dispatch_recv;
9908
9909         /* In parameters */
9910         state->orig.in.handle = _handle;
9911         state->orig.in.flags = _flags;
9912         state->orig.in.options = _options;
9913         state->orig.in.local_machine = _local_machine;
9914         state->orig.in.printer_local = _printer_local;
9915         state->orig.in.notify_options = _notify_options;
9916
9917         /* Out parameters */
9918
9919         /* Result */
9920         ZERO_STRUCT(state->orig.out.result);
9921
9922         /* make a temporary copy, that we pass to the dispatch function */
9923         state->tmp = state->orig;
9924
9925         subreq = cli->dispatch_send(state, ev, cli,
9926                                     &ndr_table_spoolss,
9927                                     NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX,
9928                                     &state->tmp);
9929         if (tevent_req_nomem(subreq, req)) {
9930                 return tevent_req_post(req, ev);
9931         }
9932         tevent_req_set_callback(subreq, rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_done, req);
9933         return req;
9934 }
9935
9936 static void rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_done(struct tevent_req *subreq)
9937 {
9938         struct tevent_req *req = tevent_req_callback_data(
9939                 subreq, struct tevent_req);
9940         struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state *state = tevent_req_data(
9941                 req, struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state);
9942         NTSTATUS status;
9943         TALLOC_CTX *mem_ctx;
9944
9945         if (state->out_mem_ctx) {
9946                 mem_ctx = state->out_mem_ctx;
9947         } else {
9948                 mem_ctx = state;
9949         }
9950
9951         status = state->dispatch_recv(subreq, mem_ctx);
9952         TALLOC_FREE(subreq);
9953         if (!NT_STATUS_IS_OK(status)) {
9954                 tevent_req_nterror(req, status);
9955                 return;
9956         }
9957
9958         /* Copy out parameters */
9959
9960         /* Copy result */
9961         state->orig.out.result = state->tmp.out.result;
9962
9963         /* Reset temporary structure */
9964         ZERO_STRUCT(state->tmp);
9965
9966         tevent_req_done(req);
9967 }
9968
9969 NTSTATUS rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_recv(struct tevent_req *req,
9970                                                                   TALLOC_CTX *mem_ctx,
9971                                                                   WERROR *result)
9972 {
9973         struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state *state = tevent_req_data(
9974                 req, struct rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx_state);
9975         NTSTATUS status;
9976
9977         if (tevent_req_is_nterror(req, &status)) {
9978                 tevent_req_received(req);
9979                 return status;
9980         }
9981
9982         /* Steal possbile out parameters to the callers context */
9983         talloc_steal(mem_ctx, state->out_mem_ctx);
9984
9985         /* Return result */
9986         *result = state->orig.out.result;
9987
9988         tevent_req_received(req);
9989         return NT_STATUS_OK;
9990 }
9991
9992 NTSTATUS rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct rpc_pipe_client *cli,
9993                                                              TALLOC_CTX *mem_ctx,
9994                                                              struct policy_handle *handle /* [in] [ref] */,
9995                                                              uint32_t flags /* [in]  */,
9996                                                              uint32_t options /* [in]  */,
9997                                                              const char *local_machine /* [in] [unique,charset(UTF16)] */,
9998                                                              uint32_t printer_local /* [in]  */,
9999                                                              struct spoolss_NotifyOption *notify_options /* [in] [unique] */,
10000                                                              WERROR *werror)
10001 {
10002         struct spoolss_RemoteFindFirstPrinterChangeNotifyEx r;
10003         NTSTATUS status;
10004
10005         /* In parameters */
10006         r.in.handle = handle;
10007         r.in.flags = flags;
10008         r.in.options = options;
10009         r.in.local_machine = local_machine;
10010         r.in.printer_local = printer_local;
10011         r.in.notify_options = notify_options;
10012
10013         status = cli->dispatch(cli,
10014                                 mem_ctx,
10015                                 &ndr_table_spoolss,
10016                                 NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX,
10017                                 &r);
10018
10019         if (!NT_STATUS_IS_OK(status)) {
10020                 return status;
10021         }
10022
10023         if (NT_STATUS_IS_ERR(status)) {
10024                 return status;
10025         }
10026
10027         /* Return variables */
10028
10029         /* Return result */
10030         if (werror) {
10031                 *werror = r.out.result;
10032         }
10033
10034         return werror_to_ntstatus(r.out.result);
10035 }
10036
10037 struct rpccli_spoolss_RouterReplyPrinterEx_state {
10038         struct spoolss_RouterReplyPrinterEx orig;
10039         struct spoolss_RouterReplyPrinterEx tmp;
10040         TALLOC_CTX *out_mem_ctx;
10041         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10042 };
10043
10044 static void rpccli_spoolss_RouterReplyPrinterEx_done(struct tevent_req *subreq);
10045
10046 struct tevent_req *rpccli_spoolss_RouterReplyPrinterEx_send(TALLOC_CTX *mem_ctx,
10047                                                             struct tevent_context *ev,
10048                                                             struct rpc_pipe_client *cli,
10049                                                             struct policy_handle *_handle /* [in] [ref] */,
10050                                                             uint32_t _color /* [in]  */,
10051                                                             uint32_t _flags /* [in]  */,
10052                                                             uint32_t *_reply_result /* [out] [ref] */,
10053                                                             uint32_t _reply_type /* [in]  */,
10054                                                             union spoolss_ReplyPrinterInfo _info /* [in] [switch_is(reply_type)] */)
10055 {
10056         struct tevent_req *req;
10057         struct rpccli_spoolss_RouterReplyPrinterEx_state *state;
10058         struct tevent_req *subreq;
10059
10060         req = tevent_req_create(mem_ctx, &state,
10061                                 struct rpccli_spoolss_RouterReplyPrinterEx_state);
10062         if (req == NULL) {
10063                 return NULL;
10064         }
10065         state->out_mem_ctx = NULL;
10066         state->dispatch_recv = cli->dispatch_recv;
10067
10068         /* In parameters */
10069         state->orig.in.handle = _handle;
10070         state->orig.in.color = _color;
10071         state->orig.in.flags = _flags;
10072         state->orig.in.reply_type = _reply_type;
10073         state->orig.in.info = _info;
10074
10075         /* Out parameters */
10076         state->orig.out.reply_result = _reply_result;
10077
10078         /* Result */
10079         ZERO_STRUCT(state->orig.out.result);
10080
10081         state->out_mem_ctx = talloc_named_const(state, 0,
10082                              "rpccli_spoolss_RouterReplyPrinterEx_out_memory");
10083         if (tevent_req_nomem(state->out_mem_ctx, req)) {
10084                 return tevent_req_post(req, ev);
10085         }
10086
10087         /* make a temporary copy, that we pass to the dispatch function */
10088         state->tmp = state->orig;
10089
10090         subreq = cli->dispatch_send(state, ev, cli,
10091                                     &ndr_table_spoolss,
10092                                     NDR_SPOOLSS_ROUTERREPLYPRINTEREX,
10093                                     &state->tmp);
10094         if (tevent_req_nomem(subreq, req)) {
10095                 return tevent_req_post(req, ev);
10096         }
10097         tevent_req_set_callback(subreq, rpccli_spoolss_RouterReplyPrinterEx_done, req);
10098         return req;
10099 }
10100
10101 static void rpccli_spoolss_RouterReplyPrinterEx_done(struct tevent_req *subreq)
10102 {
10103         struct tevent_req *req = tevent_req_callback_data(
10104                 subreq, struct tevent_req);
10105         struct rpccli_spoolss_RouterReplyPrinterEx_state *state = tevent_req_data(
10106                 req, struct rpccli_spoolss_RouterReplyPrinterEx_state);
10107         NTSTATUS status;
10108         TALLOC_CTX *mem_ctx;
10109
10110         if (state->out_mem_ctx) {
10111                 mem_ctx = state->out_mem_ctx;
10112         } else {
10113                 mem_ctx = state;
10114         }
10115
10116         status = state->dispatch_recv(subreq, mem_ctx);
10117         TALLOC_FREE(subreq);
10118         if (!NT_STATUS_IS_OK(status)) {
10119                 tevent_req_nterror(req, status);
10120                 return;
10121         }
10122
10123         /* Copy out parameters */
10124         *state->orig.out.reply_result = *state->tmp.out.reply_result;
10125
10126         /* Copy result */
10127         state->orig.out.result = state->tmp.out.result;
10128
10129         /* Reset temporary structure */
10130         ZERO_STRUCT(state->tmp);
10131
10132         tevent_req_done(req);
10133 }
10134
10135 NTSTATUS rpccli_spoolss_RouterReplyPrinterEx_recv(struct tevent_req *req,
10136                                                   TALLOC_CTX *mem_ctx,
10137                                                   WERROR *result)
10138 {
10139         struct rpccli_spoolss_RouterReplyPrinterEx_state *state = tevent_req_data(
10140                 req, struct rpccli_spoolss_RouterReplyPrinterEx_state);
10141         NTSTATUS status;
10142
10143         if (tevent_req_is_nterror(req, &status)) {
10144                 tevent_req_received(req);
10145                 return status;
10146         }
10147
10148         /* Steal possbile out parameters to the callers context */
10149         talloc_steal(mem_ctx, state->out_mem_ctx);
10150
10151         /* Return result */
10152         *result = state->orig.out.result;
10153
10154         tevent_req_received(req);
10155         return NT_STATUS_OK;
10156 }
10157
10158 NTSTATUS rpccli_spoolss_RouterReplyPrinterEx(struct rpc_pipe_client *cli,
10159                                              TALLOC_CTX *mem_ctx,
10160                                              struct policy_handle *handle /* [in] [ref] */,
10161                                              uint32_t color /* [in]  */,
10162                                              uint32_t flags /* [in]  */,
10163                                              uint32_t *reply_result /* [out] [ref] */,
10164                                              uint32_t reply_type /* [in]  */,
10165                                              union spoolss_ReplyPrinterInfo info /* [in] [switch_is(reply_type)] */,
10166                                              WERROR *werror)
10167 {
10168         struct spoolss_RouterReplyPrinterEx r;
10169         NTSTATUS status;
10170
10171         /* In parameters */
10172         r.in.handle = handle;
10173         r.in.color = color;
10174         r.in.flags = flags;
10175         r.in.reply_type = reply_type;
10176         r.in.info = info;
10177
10178         status = cli->dispatch(cli,
10179                                 mem_ctx,
10180                                 &ndr_table_spoolss,
10181                                 NDR_SPOOLSS_ROUTERREPLYPRINTEREX,
10182                                 &r);
10183
10184         if (!NT_STATUS_IS_OK(status)) {
10185                 return status;
10186         }
10187
10188         if (NT_STATUS_IS_ERR(status)) {
10189                 return status;
10190         }
10191
10192         /* Return variables */
10193         *reply_result = *r.out.reply_result;
10194
10195         /* Return result */
10196         if (werror) {
10197                 *werror = r.out.result;
10198         }
10199
10200         return werror_to_ntstatus(r.out.result);
10201 }
10202
10203 struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state {
10204         struct spoolss_RouterRefreshPrinterChangeNotify orig;
10205         struct spoolss_RouterRefreshPrinterChangeNotify tmp;
10206         TALLOC_CTX *out_mem_ctx;
10207         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10208 };
10209
10210 static void rpccli_spoolss_RouterRefreshPrinterChangeNotify_done(struct tevent_req *subreq);
10211
10212 struct tevent_req *rpccli_spoolss_RouterRefreshPrinterChangeNotify_send(TALLOC_CTX *mem_ctx,
10213                                                                         struct tevent_context *ev,
10214                                                                         struct rpc_pipe_client *cli,
10215                                                                         struct policy_handle *_handle /* [in] [ref] */,
10216                                                                         uint32_t _change_low /* [in]  */,
10217                                                                         struct spoolss_NotifyOption *_options /* [in] [unique] */,
10218                                                                         struct spoolss_NotifyInfo **_info /* [out] [ref] */)
10219 {
10220         struct tevent_req *req;
10221         struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state *state;
10222         struct tevent_req *subreq;
10223
10224         req = tevent_req_create(mem_ctx, &state,
10225                                 struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state);
10226         if (req == NULL) {
10227                 return NULL;
10228         }
10229         state->out_mem_ctx = NULL;
10230         state->dispatch_recv = cli->dispatch_recv;
10231
10232         /* In parameters */
10233         state->orig.in.handle = _handle;
10234         state->orig.in.change_low = _change_low;
10235         state->orig.in.options = _options;
10236
10237         /* Out parameters */
10238         state->orig.out.info = _info;
10239
10240         /* Result */
10241         ZERO_STRUCT(state->orig.out.result);
10242
10243         state->out_mem_ctx = talloc_named_const(state, 0,
10244                              "rpccli_spoolss_RouterRefreshPrinterChangeNotify_out_memory");
10245         if (tevent_req_nomem(state->out_mem_ctx, req)) {
10246                 return tevent_req_post(req, ev);
10247         }
10248
10249         /* make a temporary copy, that we pass to the dispatch function */
10250         state->tmp = state->orig;
10251
10252         subreq = cli->dispatch_send(state, ev, cli,
10253                                     &ndr_table_spoolss,
10254                                     NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY,
10255                                     &state->tmp);
10256         if (tevent_req_nomem(subreq, req)) {
10257                 return tevent_req_post(req, ev);
10258         }
10259         tevent_req_set_callback(subreq, rpccli_spoolss_RouterRefreshPrinterChangeNotify_done, req);
10260         return req;
10261 }
10262
10263 static void rpccli_spoolss_RouterRefreshPrinterChangeNotify_done(struct tevent_req *subreq)
10264 {
10265         struct tevent_req *req = tevent_req_callback_data(
10266                 subreq, struct tevent_req);
10267         struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state *state = tevent_req_data(
10268                 req, struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state);
10269         NTSTATUS status;
10270         TALLOC_CTX *mem_ctx;
10271
10272         if (state->out_mem_ctx) {
10273                 mem_ctx = state->out_mem_ctx;
10274         } else {
10275                 mem_ctx = state;
10276         }
10277
10278         status = state->dispatch_recv(subreq, mem_ctx);
10279         TALLOC_FREE(subreq);
10280         if (!NT_STATUS_IS_OK(status)) {
10281                 tevent_req_nterror(req, status);
10282                 return;
10283         }
10284
10285         /* Copy out parameters */
10286         *state->orig.out.info = *state->tmp.out.info;
10287
10288         /* Copy result */
10289         state->orig.out.result = state->tmp.out.result;
10290
10291         /* Reset temporary structure */
10292         ZERO_STRUCT(state->tmp);
10293
10294         tevent_req_done(req);
10295 }
10296
10297 NTSTATUS rpccli_spoolss_RouterRefreshPrinterChangeNotify_recv(struct tevent_req *req,
10298                                                               TALLOC_CTX *mem_ctx,
10299                                                               WERROR *result)
10300 {
10301         struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state *state = tevent_req_data(
10302                 req, struct rpccli_spoolss_RouterRefreshPrinterChangeNotify_state);
10303         NTSTATUS status;
10304
10305         if (tevent_req_is_nterror(req, &status)) {
10306                 tevent_req_received(req);
10307                 return status;
10308         }
10309
10310         /* Steal possbile out parameters to the callers context */
10311         talloc_steal(mem_ctx, state->out_mem_ctx);
10312
10313         /* Return result */
10314         *result = state->orig.out.result;
10315
10316         tevent_req_received(req);
10317         return NT_STATUS_OK;
10318 }
10319
10320 NTSTATUS rpccli_spoolss_RouterRefreshPrinterChangeNotify(struct rpc_pipe_client *cli,
10321                                                          TALLOC_CTX *mem_ctx,
10322                                                          struct policy_handle *handle /* [in] [ref] */,
10323                                                          uint32_t change_low /* [in]  */,
10324                                                          struct spoolss_NotifyOption *options /* [in] [unique] */,
10325                                                          struct spoolss_NotifyInfo **info /* [out] [ref] */,
10326                                                          WERROR *werror)
10327 {
10328         struct spoolss_RouterRefreshPrinterChangeNotify r;
10329         NTSTATUS status;
10330
10331         /* In parameters */
10332         r.in.handle = handle;
10333         r.in.change_low = change_low;
10334         r.in.options = options;
10335
10336         status = cli->dispatch(cli,
10337                                 mem_ctx,
10338                                 &ndr_table_spoolss,
10339                                 NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY,
10340                                 &r);
10341
10342         if (!NT_STATUS_IS_OK(status)) {
10343                 return status;
10344         }
10345
10346         if (NT_STATUS_IS_ERR(status)) {
10347                 return status;
10348         }
10349
10350         /* Return variables */
10351         *info = *r.out.info;
10352
10353         /* Return result */
10354         if (werror) {
10355                 *werror = r.out.result;
10356         }
10357
10358         return werror_to_ntstatus(r.out.result);
10359 }
10360
10361 struct rpccli_spoolss_44_state {
10362         struct spoolss_44 orig;
10363         struct spoolss_44 tmp;
10364         TALLOC_CTX *out_mem_ctx;
10365         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10366 };
10367
10368 static void rpccli_spoolss_44_done(struct tevent_req *subreq);
10369
10370 struct tevent_req *rpccli_spoolss_44_send(TALLOC_CTX *mem_ctx,
10371                                           struct tevent_context *ev,
10372                                           struct rpc_pipe_client *cli)
10373 {
10374         struct tevent_req *req;
10375         struct rpccli_spoolss_44_state *state;
10376         struct tevent_req *subreq;
10377
10378         req = tevent_req_create(mem_ctx, &state,
10379                                 struct rpccli_spoolss_44_state);
10380         if (req == NULL) {
10381                 return NULL;
10382         }
10383         state->out_mem_ctx = NULL;
10384         state->dispatch_recv = cli->dispatch_recv;
10385
10386         /* In parameters */
10387
10388         /* Out parameters */
10389
10390         /* Result */
10391         ZERO_STRUCT(state->orig.out.result);
10392
10393         /* make a temporary copy, that we pass to the dispatch function */
10394         state->tmp = state->orig;
10395
10396         subreq = cli->dispatch_send(state, ev, cli,
10397                                     &ndr_table_spoolss,
10398                                     NDR_SPOOLSS_44,
10399                                     &state->tmp);
10400         if (tevent_req_nomem(subreq, req)) {
10401                 return tevent_req_post(req, ev);
10402         }
10403         tevent_req_set_callback(subreq, rpccli_spoolss_44_done, req);
10404         return req;
10405 }
10406
10407 static void rpccli_spoolss_44_done(struct tevent_req *subreq)
10408 {
10409         struct tevent_req *req = tevent_req_callback_data(
10410                 subreq, struct tevent_req);
10411         struct rpccli_spoolss_44_state *state = tevent_req_data(
10412                 req, struct rpccli_spoolss_44_state);
10413         NTSTATUS status;
10414         TALLOC_CTX *mem_ctx;
10415
10416         if (state->out_mem_ctx) {
10417                 mem_ctx = state->out_mem_ctx;
10418         } else {
10419                 mem_ctx = state;
10420         }
10421
10422         status = state->dispatch_recv(subreq, mem_ctx);
10423         TALLOC_FREE(subreq);
10424         if (!NT_STATUS_IS_OK(status)) {
10425                 tevent_req_nterror(req, status);
10426                 return;
10427         }
10428
10429         /* Copy out parameters */
10430
10431         /* Copy result */
10432         state->orig.out.result = state->tmp.out.result;
10433
10434         /* Reset temporary structure */
10435         ZERO_STRUCT(state->tmp);
10436
10437         tevent_req_done(req);
10438 }
10439
10440 NTSTATUS rpccli_spoolss_44_recv(struct tevent_req *req,
10441                                 TALLOC_CTX *mem_ctx,
10442                                 WERROR *result)
10443 {
10444         struct rpccli_spoolss_44_state *state = tevent_req_data(
10445                 req, struct rpccli_spoolss_44_state);
10446         NTSTATUS status;
10447
10448         if (tevent_req_is_nterror(req, &status)) {
10449                 tevent_req_received(req);
10450                 return status;
10451         }
10452
10453         /* Steal possbile out parameters to the callers context */
10454         talloc_steal(mem_ctx, state->out_mem_ctx);
10455
10456         /* Return result */
10457         *result = state->orig.out.result;
10458
10459         tevent_req_received(req);
10460         return NT_STATUS_OK;
10461 }
10462
10463 NTSTATUS rpccli_spoolss_44(struct rpc_pipe_client *cli,
10464                            TALLOC_CTX *mem_ctx,
10465                            WERROR *werror)
10466 {
10467         struct spoolss_44 r;
10468         NTSTATUS status;
10469
10470         /* In parameters */
10471
10472         status = cli->dispatch(cli,
10473                                 mem_ctx,
10474                                 &ndr_table_spoolss,
10475                                 NDR_SPOOLSS_44,
10476                                 &r);
10477
10478         if (!NT_STATUS_IS_OK(status)) {
10479                 return status;
10480         }
10481
10482         if (NT_STATUS_IS_ERR(status)) {
10483                 return status;
10484         }
10485
10486         /* Return variables */
10487
10488         /* Return result */
10489         if (werror) {
10490                 *werror = r.out.result;
10491         }
10492
10493         return werror_to_ntstatus(r.out.result);
10494 }
10495
10496 struct rpccli_spoolss_OpenPrinterEx_state {
10497         struct spoolss_OpenPrinterEx orig;
10498         struct spoolss_OpenPrinterEx tmp;
10499         TALLOC_CTX *out_mem_ctx;
10500         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10501 };
10502
10503 static void rpccli_spoolss_OpenPrinterEx_done(struct tevent_req *subreq);
10504
10505 struct tevent_req *rpccli_spoolss_OpenPrinterEx_send(TALLOC_CTX *mem_ctx,
10506                                                      struct tevent_context *ev,
10507                                                      struct rpc_pipe_client *cli,
10508                                                      const char *_printername /* [in] [unique,charset(UTF16)] */,
10509                                                      const char *_datatype /* [in] [unique,charset(UTF16)] */,
10510                                                      struct spoolss_DevmodeContainer _devmode_ctr /* [in]  */,
10511                                                      uint32_t _access_mask /* [in]  */,
10512                                                      uint32_t _level /* [in]  */,
10513                                                      union spoolss_UserLevel _userlevel /* [in] [switch_is(level)] */,
10514                                                      struct policy_handle *_handle /* [out] [ref] */)
10515 {
10516         struct tevent_req *req;
10517         struct rpccli_spoolss_OpenPrinterEx_state *state;
10518         struct tevent_req *subreq;
10519
10520         req = tevent_req_create(mem_ctx, &state,
10521                                 struct rpccli_spoolss_OpenPrinterEx_state);
10522         if (req == NULL) {
10523                 return NULL;
10524         }
10525         state->out_mem_ctx = NULL;
10526         state->dispatch_recv = cli->dispatch_recv;
10527
10528         /* In parameters */
10529         state->orig.in.printername = _printername;
10530         state->orig.in.datatype = _datatype;
10531         state->orig.in.devmode_ctr = _devmode_ctr;
10532         state->orig.in.access_mask = _access_mask;
10533         state->orig.in.level = _level;
10534         state->orig.in.userlevel = _userlevel;
10535
10536         /* Out parameters */
10537         state->orig.out.handle = _handle;
10538
10539         /* Result */
10540         ZERO_STRUCT(state->orig.out.result);
10541
10542         state->out_mem_ctx = talloc_named_const(state, 0,
10543                              "rpccli_spoolss_OpenPrinterEx_out_memory");
10544         if (tevent_req_nomem(state->out_mem_ctx, req)) {
10545                 return tevent_req_post(req, ev);
10546         }
10547
10548         /* make a temporary copy, that we pass to the dispatch function */
10549         state->tmp = state->orig;
10550
10551         subreq = cli->dispatch_send(state, ev, cli,
10552                                     &ndr_table_spoolss,
10553                                     NDR_SPOOLSS_OPENPRINTEREX,
10554                                     &state->tmp);
10555         if (tevent_req_nomem(subreq, req)) {
10556                 return tevent_req_post(req, ev);
10557         }
10558         tevent_req_set_callback(subreq, rpccli_spoolss_OpenPrinterEx_done, req);
10559         return req;
10560 }
10561
10562 static void rpccli_spoolss_OpenPrinterEx_done(struct tevent_req *subreq)
10563 {
10564         struct tevent_req *req = tevent_req_callback_data(
10565                 subreq, struct tevent_req);
10566         struct rpccli_spoolss_OpenPrinterEx_state *state = tevent_req_data(
10567                 req, struct rpccli_spoolss_OpenPrinterEx_state);
10568         NTSTATUS status;
10569         TALLOC_CTX *mem_ctx;
10570
10571         if (state->out_mem_ctx) {
10572                 mem_ctx = state->out_mem_ctx;
10573         } else {
10574                 mem_ctx = state;
10575         }
10576
10577         status = state->dispatch_recv(subreq, mem_ctx);
10578         TALLOC_FREE(subreq);
10579         if (!NT_STATUS_IS_OK(status)) {
10580                 tevent_req_nterror(req, status);
10581                 return;
10582         }
10583
10584         /* Copy out parameters */
10585         *state->orig.out.handle = *state->tmp.out.handle;
10586
10587         /* Copy result */
10588         state->orig.out.result = state->tmp.out.result;
10589
10590         /* Reset temporary structure */
10591         ZERO_STRUCT(state->tmp);
10592
10593         tevent_req_done(req);
10594 }
10595
10596 NTSTATUS rpccli_spoolss_OpenPrinterEx_recv(struct tevent_req *req,
10597                                            TALLOC_CTX *mem_ctx,
10598                                            WERROR *result)
10599 {
10600         struct rpccli_spoolss_OpenPrinterEx_state *state = tevent_req_data(
10601                 req, struct rpccli_spoolss_OpenPrinterEx_state);
10602         NTSTATUS status;
10603
10604         if (tevent_req_is_nterror(req, &status)) {
10605                 tevent_req_received(req);
10606                 return status;
10607         }
10608
10609         /* Steal possbile out parameters to the callers context */
10610         talloc_steal(mem_ctx, state->out_mem_ctx);
10611
10612         /* Return result */
10613         *result = state->orig.out.result;
10614
10615         tevent_req_received(req);
10616         return NT_STATUS_OK;
10617 }
10618
10619 NTSTATUS rpccli_spoolss_OpenPrinterEx(struct rpc_pipe_client *cli,
10620                                       TALLOC_CTX *mem_ctx,
10621                                       const char *printername /* [in] [unique,charset(UTF16)] */,
10622                                       const char *datatype /* [in] [unique,charset(UTF16)] */,
10623                                       struct spoolss_DevmodeContainer devmode_ctr /* [in]  */,
10624                                       uint32_t access_mask /* [in]  */,
10625                                       uint32_t level /* [in]  */,
10626                                       union spoolss_UserLevel userlevel /* [in] [switch_is(level)] */,
10627                                       struct policy_handle *handle /* [out] [ref] */,
10628                                       WERROR *werror)
10629 {
10630         struct spoolss_OpenPrinterEx r;
10631         NTSTATUS status;
10632
10633         /* In parameters */
10634         r.in.printername = printername;
10635         r.in.datatype = datatype;
10636         r.in.devmode_ctr = devmode_ctr;
10637         r.in.access_mask = access_mask;
10638         r.in.level = level;
10639         r.in.userlevel = userlevel;
10640
10641         status = cli->dispatch(cli,
10642                                 mem_ctx,
10643                                 &ndr_table_spoolss,
10644                                 NDR_SPOOLSS_OPENPRINTEREX,
10645                                 &r);
10646
10647         if (!NT_STATUS_IS_OK(status)) {
10648                 return status;
10649         }
10650
10651         if (NT_STATUS_IS_ERR(status)) {
10652                 return status;
10653         }
10654
10655         /* Return variables */
10656         *handle = *r.out.handle;
10657
10658         /* Return result */
10659         if (werror) {
10660                 *werror = r.out.result;
10661         }
10662
10663         return werror_to_ntstatus(r.out.result);
10664 }
10665
10666 struct rpccli_spoolss_AddPrinterEx_state {
10667         struct spoolss_AddPrinterEx orig;
10668         struct spoolss_AddPrinterEx tmp;
10669         TALLOC_CTX *out_mem_ctx;
10670         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10671 };
10672
10673 static void rpccli_spoolss_AddPrinterEx_done(struct tevent_req *subreq);
10674
10675 struct tevent_req *rpccli_spoolss_AddPrinterEx_send(TALLOC_CTX *mem_ctx,
10676                                                     struct tevent_context *ev,
10677                                                     struct rpc_pipe_client *cli,
10678                                                     const char *_server /* [in] [unique,charset(UTF16)] */,
10679                                                     struct spoolss_SetPrinterInfoCtr *_info_ctr /* [in] [ref] */,
10680                                                     struct spoolss_DevmodeContainer *_devmode_ctr /* [in] [ref] */,
10681                                                     struct sec_desc_buf *_secdesc_ctr /* [in] [ref] */,
10682                                                     struct spoolss_UserLevelCtr *_userlevel_ctr /* [in] [ref] */,
10683                                                     struct policy_handle *_handle /* [out] [ref] */)
10684 {
10685         struct tevent_req *req;
10686         struct rpccli_spoolss_AddPrinterEx_state *state;
10687         struct tevent_req *subreq;
10688
10689         req = tevent_req_create(mem_ctx, &state,
10690                                 struct rpccli_spoolss_AddPrinterEx_state);
10691         if (req == NULL) {
10692                 return NULL;
10693         }
10694         state->out_mem_ctx = NULL;
10695         state->dispatch_recv = cli->dispatch_recv;
10696
10697         /* In parameters */
10698         state->orig.in.server = _server;
10699         state->orig.in.info_ctr = _info_ctr;
10700         state->orig.in.devmode_ctr = _devmode_ctr;
10701         state->orig.in.secdesc_ctr = _secdesc_ctr;
10702         state->orig.in.userlevel_ctr = _userlevel_ctr;
10703
10704         /* Out parameters */
10705         state->orig.out.handle = _handle;
10706
10707         /* Result */
10708         ZERO_STRUCT(state->orig.out.result);
10709
10710         state->out_mem_ctx = talloc_named_const(state, 0,
10711                              "rpccli_spoolss_AddPrinterEx_out_memory");
10712         if (tevent_req_nomem(state->out_mem_ctx, req)) {
10713                 return tevent_req_post(req, ev);
10714         }
10715
10716         /* make a temporary copy, that we pass to the dispatch function */
10717         state->tmp = state->orig;
10718
10719         subreq = cli->dispatch_send(state, ev, cli,
10720                                     &ndr_table_spoolss,
10721                                     NDR_SPOOLSS_ADDPRINTEREX,
10722                                     &state->tmp);
10723         if (tevent_req_nomem(subreq, req)) {
10724                 return tevent_req_post(req, ev);
10725         }
10726         tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterEx_done, req);
10727         return req;
10728 }
10729
10730 static void rpccli_spoolss_AddPrinterEx_done(struct tevent_req *subreq)
10731 {
10732         struct tevent_req *req = tevent_req_callback_data(
10733                 subreq, struct tevent_req);
10734         struct rpccli_spoolss_AddPrinterEx_state *state = tevent_req_data(
10735                 req, struct rpccli_spoolss_AddPrinterEx_state);
10736         NTSTATUS status;
10737         TALLOC_CTX *mem_ctx;
10738
10739         if (state->out_mem_ctx) {
10740                 mem_ctx = state->out_mem_ctx;
10741         } else {
10742                 mem_ctx = state;
10743         }
10744
10745         status = state->dispatch_recv(subreq, mem_ctx);
10746         TALLOC_FREE(subreq);
10747         if (!NT_STATUS_IS_OK(status)) {
10748                 tevent_req_nterror(req, status);
10749                 return;
10750         }
10751
10752         /* Copy out parameters */
10753         *state->orig.out.handle = *state->tmp.out.handle;
10754
10755         /* Copy result */
10756         state->orig.out.result = state->tmp.out.result;
10757
10758         /* Reset temporary structure */
10759         ZERO_STRUCT(state->tmp);
10760
10761         tevent_req_done(req);
10762 }
10763
10764 NTSTATUS rpccli_spoolss_AddPrinterEx_recv(struct tevent_req *req,
10765                                           TALLOC_CTX *mem_ctx,
10766                                           WERROR *result)
10767 {
10768         struct rpccli_spoolss_AddPrinterEx_state *state = tevent_req_data(
10769                 req, struct rpccli_spoolss_AddPrinterEx_state);
10770         NTSTATUS status;
10771
10772         if (tevent_req_is_nterror(req, &status)) {
10773                 tevent_req_received(req);
10774                 return status;
10775         }
10776
10777         /* Steal possbile out parameters to the callers context */
10778         talloc_steal(mem_ctx, state->out_mem_ctx);
10779
10780         /* Return result */
10781         *result = state->orig.out.result;
10782
10783         tevent_req_received(req);
10784         return NT_STATUS_OK;
10785 }
10786
10787 NTSTATUS rpccli_spoolss_AddPrinterEx(struct rpc_pipe_client *cli,
10788                                      TALLOC_CTX *mem_ctx,
10789                                      const char *server /* [in] [unique,charset(UTF16)] */,
10790                                      struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */,
10791                                      struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
10792                                      struct sec_desc_buf *secdesc_ctr /* [in] [ref] */,
10793                                      struct spoolss_UserLevelCtr *userlevel_ctr /* [in] [ref] */,
10794                                      struct policy_handle *handle /* [out] [ref] */,
10795                                      WERROR *werror)
10796 {
10797         struct spoolss_AddPrinterEx r;
10798         NTSTATUS status;
10799
10800         /* In parameters */
10801         r.in.server = server;
10802         r.in.info_ctr = info_ctr;
10803         r.in.devmode_ctr = devmode_ctr;
10804         r.in.secdesc_ctr = secdesc_ctr;
10805         r.in.userlevel_ctr = userlevel_ctr;
10806
10807         status = cli->dispatch(cli,
10808                                 mem_ctx,
10809                                 &ndr_table_spoolss,
10810                                 NDR_SPOOLSS_ADDPRINTEREX,
10811                                 &r);
10812
10813         if (!NT_STATUS_IS_OK(status)) {
10814                 return status;
10815         }
10816
10817         if (NT_STATUS_IS_ERR(status)) {
10818                 return status;
10819         }
10820
10821         /* Return variables */
10822         *handle = *r.out.handle;
10823
10824         /* Return result */
10825         if (werror) {
10826                 *werror = r.out.result;
10827         }
10828
10829         return werror_to_ntstatus(r.out.result);
10830 }
10831
10832 struct rpccli_spoolss_47_state {
10833         struct spoolss_47 orig;
10834         struct spoolss_47 tmp;
10835         TALLOC_CTX *out_mem_ctx;
10836         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10837 };
10838
10839 static void rpccli_spoolss_47_done(struct tevent_req *subreq);
10840
10841 struct tevent_req *rpccli_spoolss_47_send(TALLOC_CTX *mem_ctx,
10842                                           struct tevent_context *ev,
10843                                           struct rpc_pipe_client *cli)
10844 {
10845         struct tevent_req *req;
10846         struct rpccli_spoolss_47_state *state;
10847         struct tevent_req *subreq;
10848
10849         req = tevent_req_create(mem_ctx, &state,
10850                                 struct rpccli_spoolss_47_state);
10851         if (req == NULL) {
10852                 return NULL;
10853         }
10854         state->out_mem_ctx = NULL;
10855         state->dispatch_recv = cli->dispatch_recv;
10856
10857         /* In parameters */
10858
10859         /* Out parameters */
10860
10861         /* Result */
10862         ZERO_STRUCT(state->orig.out.result);
10863
10864         /* make a temporary copy, that we pass to the dispatch function */
10865         state->tmp = state->orig;
10866
10867         subreq = cli->dispatch_send(state, ev, cli,
10868                                     &ndr_table_spoolss,
10869                                     NDR_SPOOLSS_47,
10870                                     &state->tmp);
10871         if (tevent_req_nomem(subreq, req)) {
10872                 return tevent_req_post(req, ev);
10873         }
10874         tevent_req_set_callback(subreq, rpccli_spoolss_47_done, req);
10875         return req;
10876 }
10877
10878 static void rpccli_spoolss_47_done(struct tevent_req *subreq)
10879 {
10880         struct tevent_req *req = tevent_req_callback_data(
10881                 subreq, struct tevent_req);
10882         struct rpccli_spoolss_47_state *state = tevent_req_data(
10883                 req, struct rpccli_spoolss_47_state);
10884         NTSTATUS status;
10885         TALLOC_CTX *mem_ctx;
10886
10887         if (state->out_mem_ctx) {
10888                 mem_ctx = state->out_mem_ctx;
10889         } else {
10890                 mem_ctx = state;
10891         }
10892
10893         status = state->dispatch_recv(subreq, mem_ctx);
10894         TALLOC_FREE(subreq);
10895         if (!NT_STATUS_IS_OK(status)) {
10896                 tevent_req_nterror(req, status);
10897                 return;
10898         }
10899
10900         /* Copy out parameters */
10901
10902         /* Copy result */
10903         state->orig.out.result = state->tmp.out.result;
10904
10905         /* Reset temporary structure */
10906         ZERO_STRUCT(state->tmp);
10907
10908         tevent_req_done(req);
10909 }
10910
10911 NTSTATUS rpccli_spoolss_47_recv(struct tevent_req *req,
10912                                 TALLOC_CTX *mem_ctx,
10913                                 WERROR *result)
10914 {
10915         struct rpccli_spoolss_47_state *state = tevent_req_data(
10916                 req, struct rpccli_spoolss_47_state);
10917         NTSTATUS status;
10918
10919         if (tevent_req_is_nterror(req, &status)) {
10920                 tevent_req_received(req);
10921                 return status;
10922         }
10923
10924         /* Steal possbile out parameters to the callers context */
10925         talloc_steal(mem_ctx, state->out_mem_ctx);
10926
10927         /* Return result */
10928         *result = state->orig.out.result;
10929
10930         tevent_req_received(req);
10931         return NT_STATUS_OK;
10932 }
10933
10934 NTSTATUS rpccli_spoolss_47(struct rpc_pipe_client *cli,
10935                            TALLOC_CTX *mem_ctx,
10936                            WERROR *werror)
10937 {
10938         struct spoolss_47 r;
10939         NTSTATUS status;
10940
10941         /* In parameters */
10942
10943         status = cli->dispatch(cli,
10944                                 mem_ctx,
10945                                 &ndr_table_spoolss,
10946                                 NDR_SPOOLSS_47,
10947                                 &r);
10948
10949         if (!NT_STATUS_IS_OK(status)) {
10950                 return status;
10951         }
10952
10953         if (NT_STATUS_IS_ERR(status)) {
10954                 return status;
10955         }
10956
10957         /* Return variables */
10958
10959         /* Return result */
10960         if (werror) {
10961                 *werror = r.out.result;
10962         }
10963
10964         return werror_to_ntstatus(r.out.result);
10965 }
10966
10967 struct rpccli_spoolss_EnumPrinterData_state {
10968         struct spoolss_EnumPrinterData orig;
10969         struct spoolss_EnumPrinterData tmp;
10970         TALLOC_CTX *out_mem_ctx;
10971         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10972 };
10973
10974 static void rpccli_spoolss_EnumPrinterData_done(struct tevent_req *subreq);
10975
10976 struct tevent_req *rpccli_spoolss_EnumPrinterData_send(TALLOC_CTX *mem_ctx,
10977                                                        struct tevent_context *ev,
10978                                                        struct rpc_pipe_client *cli,
10979                                                        struct policy_handle *_handle /* [in] [ref] */,
10980                                                        uint32_t _enum_index /* [in]  */,
10981                                                        const char *_value_name /* [out] [charset(UTF16),size_is(value_offered/2)] */,
10982                                                        uint32_t _value_offered /* [in]  */,
10983                                                        uint32_t *_value_needed /* [out] [ref] */,
10984                                                        enum winreg_Type *_type /* [out] [ref] */,
10985                                                        uint8_t *_data /* [out] [ref,flag(LIBNDR_PRINT_ARRAY_HEX),size_is(data_offered)] */,
10986                                                        uint32_t _data_offered /* [in]  */,
10987                                                        uint32_t *_data_needed /* [out] [ref] */)
10988 {
10989         struct tevent_req *req;
10990         struct rpccli_spoolss_EnumPrinterData_state *state;
10991         struct tevent_req *subreq;
10992
10993         req = tevent_req_create(mem_ctx, &state,
10994                                 struct rpccli_spoolss_EnumPrinterData_state);
10995         if (req == NULL) {
10996                 return NULL;
10997         }
10998         state->out_mem_ctx = NULL;
10999         state->dispatch_recv = cli->dispatch_recv;
11000
11001         /* In parameters */
11002         state->orig.in.handle = _handle;
11003         state->orig.in.enum_index = _enum_index;
11004         state->orig.in.value_offered = _value_offered;
11005         state->orig.in.data_offered = _data_offered;
11006
11007         /* Out parameters */
11008         state->orig.out.value_name = _value_name;
11009         state->orig.out.value_needed = _value_needed;
11010         state->orig.out.type = _type;
11011         state->orig.out.data = _data;
11012         state->orig.out.data_needed = _data_needed;
11013
11014         /* Result */
11015         ZERO_STRUCT(state->orig.out.result);
11016
11017         state->out_mem_ctx = talloc_named_const(state, 0,
11018                              "rpccli_spoolss_EnumPrinterData_out_memory");
11019         if (tevent_req_nomem(state->out_mem_ctx, req)) {
11020                 return tevent_req_post(req, ev);
11021         }
11022
11023         /* make a temporary copy, that we pass to the dispatch function */
11024         state->tmp = state->orig;
11025
11026         subreq = cli->dispatch_send(state, ev, cli,
11027                                     &ndr_table_spoolss,
11028                                     NDR_SPOOLSS_ENUMPRINTERDATA,
11029                                     &state->tmp);
11030         if (tevent_req_nomem(subreq, req)) {
11031                 return tevent_req_post(req, ev);
11032         }
11033         tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinterData_done, req);
11034         return req;
11035 }
11036
11037 static void rpccli_spoolss_EnumPrinterData_done(struct tevent_req *subreq)
11038 {
11039         struct tevent_req *req = tevent_req_callback_data(
11040                 subreq, struct tevent_req);
11041         struct rpccli_spoolss_EnumPrinterData_state *state = tevent_req_data(
11042                 req, struct rpccli_spoolss_EnumPrinterData_state);
11043         NTSTATUS status;
11044         TALLOC_CTX *mem_ctx;
11045
11046         if (state->out_mem_ctx) {
11047                 mem_ctx = state->out_mem_ctx;
11048         } else {
11049                 mem_ctx = state;
11050         }
11051
11052         status = state->dispatch_recv(subreq, mem_ctx);
11053         TALLOC_FREE(subreq);
11054         if (!NT_STATUS_IS_OK(status)) {
11055                 tevent_req_nterror(req, status);
11056                 return;
11057         }
11058
11059         /* Copy out parameters */
11060         memcpy(discard_const_p(uint8_t *, state->orig.out.value_name), state->tmp.out.value_name, (state->tmp.in.value_offered / 2) * sizeof(*state->orig.out.value_name));
11061         *state->orig.out.value_needed = *state->tmp.out.value_needed;
11062         *state->orig.out.type = *state->tmp.out.type;
11063         memcpy(state->orig.out.data, state->tmp.out.data, (state->tmp.in.data_offered) * sizeof(*state->orig.out.data));
11064         *state->orig.out.data_needed = *state->tmp.out.data_needed;
11065
11066         /* Copy result */
11067         state->orig.out.result = state->tmp.out.result;
11068
11069         /* Reset temporary structure */
11070         ZERO_STRUCT(state->tmp);
11071
11072         tevent_req_done(req);
11073 }
11074
11075 NTSTATUS rpccli_spoolss_EnumPrinterData_recv(struct tevent_req *req,
11076                                              TALLOC_CTX *mem_ctx,
11077                                              WERROR *result)
11078 {
11079         struct rpccli_spoolss_EnumPrinterData_state *state = tevent_req_data(
11080                 req, struct rpccli_spoolss_EnumPrinterData_state);
11081         NTSTATUS status;
11082
11083         if (tevent_req_is_nterror(req, &status)) {
11084                 tevent_req_received(req);
11085                 return status;
11086         }
11087
11088         /* Steal possbile out parameters to the callers context */
11089         talloc_steal(mem_ctx, state->out_mem_ctx);
11090
11091         /* Return result */
11092         *result = state->orig.out.result;
11093
11094         tevent_req_received(req);
11095         return NT_STATUS_OK;
11096 }
11097
11098 NTSTATUS rpccli_spoolss_EnumPrinterData(struct rpc_pipe_client *cli,
11099                                         TALLOC_CTX *mem_ctx,
11100                                         struct policy_handle *handle /* [in] [ref] */,
11101                                         uint32_t enum_index /* [in]  */,
11102                                         const char *value_name /* [out] [charset(UTF16),size_is(value_offered/2)] */,
11103                                         uint32_t value_offered /* [in]  */,
11104                                         uint32_t *value_needed /* [out] [ref] */,
11105                                         enum winreg_Type *type /* [out] [ref] */,
11106                                         uint8_t *data /* [out] [ref,flag(LIBNDR_PRINT_ARRAY_HEX),size_is(data_offered)] */,
11107                                         uint32_t data_offered /* [in]  */,
11108                                         uint32_t *data_needed /* [out] [ref] */,
11109                                         WERROR *werror)
11110 {
11111         struct spoolss_EnumPrinterData r;
11112         NTSTATUS status;
11113
11114         /* In parameters */
11115         r.in.handle = handle;
11116         r.in.enum_index = enum_index;
11117         r.in.value_offered = value_offered;
11118         r.in.data_offered = data_offered;
11119
11120         status = cli->dispatch(cli,
11121                                 mem_ctx,
11122                                 &ndr_table_spoolss,
11123                                 NDR_SPOOLSS_ENUMPRINTERDATA,
11124                                 &r);
11125
11126         if (!NT_STATUS_IS_OK(status)) {
11127                 return status;
11128         }
11129
11130         if (NT_STATUS_IS_ERR(status)) {
11131                 return status;
11132         }
11133
11134         /* Return variables */
11135         memcpy(discard_const_p(uint8_t *, value_name), r.out.value_name, (r.in.value_offered / 2) * sizeof(*value_name));
11136         *value_needed = *r.out.value_needed;
11137         *type = *r.out.type;
11138         memcpy(data, r.out.data, (r.in.data_offered) * sizeof(*data));
11139         *data_needed = *r.out.data_needed;
11140
11141         /* Return result */
11142         if (werror) {
11143                 *werror = r.out.result;
11144         }
11145
11146         return werror_to_ntstatus(r.out.result);
11147 }
11148
11149 struct rpccli_spoolss_DeletePrinterData_state {
11150         struct spoolss_DeletePrinterData orig;
11151         struct spoolss_DeletePrinterData tmp;
11152         TALLOC_CTX *out_mem_ctx;
11153         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11154 };
11155
11156 static void rpccli_spoolss_DeletePrinterData_done(struct tevent_req *subreq);
11157
11158 struct tevent_req *rpccli_spoolss_DeletePrinterData_send(TALLOC_CTX *mem_ctx,
11159                                                          struct tevent_context *ev,
11160                                                          struct rpc_pipe_client *cli,
11161                                                          struct policy_handle *_handle /* [in] [ref] */,
11162                                                          const char *_value_name /* [in] [charset(UTF16)] */)
11163 {
11164         struct tevent_req *req;
11165         struct rpccli_spoolss_DeletePrinterData_state *state;
11166         struct tevent_req *subreq;
11167
11168         req = tevent_req_create(mem_ctx, &state,
11169                                 struct rpccli_spoolss_DeletePrinterData_state);
11170         if (req == NULL) {
11171                 return NULL;
11172         }
11173         state->out_mem_ctx = NULL;
11174         state->dispatch_recv = cli->dispatch_recv;
11175
11176         /* In parameters */
11177         state->orig.in.handle = _handle;
11178         state->orig.in.value_name = _value_name;
11179
11180         /* Out parameters */
11181
11182         /* Result */
11183         ZERO_STRUCT(state->orig.out.result);
11184
11185         /* make a temporary copy, that we pass to the dispatch function */
11186         state->tmp = state->orig;
11187
11188         subreq = cli->dispatch_send(state, ev, cli,
11189                                     &ndr_table_spoolss,
11190                                     NDR_SPOOLSS_DELETEPRINTERDATA,
11191                                     &state->tmp);
11192         if (tevent_req_nomem(subreq, req)) {
11193                 return tevent_req_post(req, ev);
11194         }
11195         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterData_done, req);
11196         return req;
11197 }
11198
11199 static void rpccli_spoolss_DeletePrinterData_done(struct tevent_req *subreq)
11200 {
11201         struct tevent_req *req = tevent_req_callback_data(
11202                 subreq, struct tevent_req);
11203         struct rpccli_spoolss_DeletePrinterData_state *state = tevent_req_data(
11204                 req, struct rpccli_spoolss_DeletePrinterData_state);
11205         NTSTATUS status;
11206         TALLOC_CTX *mem_ctx;
11207
11208         if (state->out_mem_ctx) {
11209                 mem_ctx = state->out_mem_ctx;
11210         } else {
11211                 mem_ctx = state;
11212         }
11213
11214         status = state->dispatch_recv(subreq, mem_ctx);
11215         TALLOC_FREE(subreq);
11216         if (!NT_STATUS_IS_OK(status)) {
11217                 tevent_req_nterror(req, status);
11218                 return;
11219         }
11220
11221         /* Copy out parameters */
11222
11223         /* Copy result */
11224         state->orig.out.result = state->tmp.out.result;
11225
11226         /* Reset temporary structure */
11227         ZERO_STRUCT(state->tmp);
11228
11229         tevent_req_done(req);
11230 }
11231
11232 NTSTATUS rpccli_spoolss_DeletePrinterData_recv(struct tevent_req *req,
11233                                                TALLOC_CTX *mem_ctx,
11234                                                WERROR *result)
11235 {
11236         struct rpccli_spoolss_DeletePrinterData_state *state = tevent_req_data(
11237                 req, struct rpccli_spoolss_DeletePrinterData_state);
11238         NTSTATUS status;
11239
11240         if (tevent_req_is_nterror(req, &status)) {
11241                 tevent_req_received(req);
11242                 return status;
11243         }
11244
11245         /* Steal possbile out parameters to the callers context */
11246         talloc_steal(mem_ctx, state->out_mem_ctx);
11247
11248         /* Return result */
11249         *result = state->orig.out.result;
11250
11251         tevent_req_received(req);
11252         return NT_STATUS_OK;
11253 }
11254
11255 NTSTATUS rpccli_spoolss_DeletePrinterData(struct rpc_pipe_client *cli,
11256                                           TALLOC_CTX *mem_ctx,
11257                                           struct policy_handle *handle /* [in] [ref] */,
11258                                           const char *value_name /* [in] [charset(UTF16)] */,
11259                                           WERROR *werror)
11260 {
11261         struct spoolss_DeletePrinterData r;
11262         NTSTATUS status;
11263
11264         /* In parameters */
11265         r.in.handle = handle;
11266         r.in.value_name = value_name;
11267
11268         status = cli->dispatch(cli,
11269                                 mem_ctx,
11270                                 &ndr_table_spoolss,
11271                                 NDR_SPOOLSS_DELETEPRINTERDATA,
11272                                 &r);
11273
11274         if (!NT_STATUS_IS_OK(status)) {
11275                 return status;
11276         }
11277
11278         if (NT_STATUS_IS_ERR(status)) {
11279                 return status;
11280         }
11281
11282         /* Return variables */
11283
11284         /* Return result */
11285         if (werror) {
11286                 *werror = r.out.result;
11287         }
11288
11289         return werror_to_ntstatus(r.out.result);
11290 }
11291
11292 struct rpccli_spoolss_4a_state {
11293         struct spoolss_4a orig;
11294         struct spoolss_4a tmp;
11295         TALLOC_CTX *out_mem_ctx;
11296         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11297 };
11298
11299 static void rpccli_spoolss_4a_done(struct tevent_req *subreq);
11300
11301 struct tevent_req *rpccli_spoolss_4a_send(TALLOC_CTX *mem_ctx,
11302                                           struct tevent_context *ev,
11303                                           struct rpc_pipe_client *cli)
11304 {
11305         struct tevent_req *req;
11306         struct rpccli_spoolss_4a_state *state;
11307         struct tevent_req *subreq;
11308
11309         req = tevent_req_create(mem_ctx, &state,
11310                                 struct rpccli_spoolss_4a_state);
11311         if (req == NULL) {
11312                 return NULL;
11313         }
11314         state->out_mem_ctx = NULL;
11315         state->dispatch_recv = cli->dispatch_recv;
11316
11317         /* In parameters */
11318
11319         /* Out parameters */
11320
11321         /* Result */
11322         ZERO_STRUCT(state->orig.out.result);
11323
11324         /* make a temporary copy, that we pass to the dispatch function */
11325         state->tmp = state->orig;
11326
11327         subreq = cli->dispatch_send(state, ev, cli,
11328                                     &ndr_table_spoolss,
11329                                     NDR_SPOOLSS_4A,
11330                                     &state->tmp);
11331         if (tevent_req_nomem(subreq, req)) {
11332                 return tevent_req_post(req, ev);
11333         }
11334         tevent_req_set_callback(subreq, rpccli_spoolss_4a_done, req);
11335         return req;
11336 }
11337
11338 static void rpccli_spoolss_4a_done(struct tevent_req *subreq)
11339 {
11340         struct tevent_req *req = tevent_req_callback_data(
11341                 subreq, struct tevent_req);
11342         struct rpccli_spoolss_4a_state *state = tevent_req_data(
11343                 req, struct rpccli_spoolss_4a_state);
11344         NTSTATUS status;
11345         TALLOC_CTX *mem_ctx;
11346
11347         if (state->out_mem_ctx) {
11348                 mem_ctx = state->out_mem_ctx;
11349         } else {
11350                 mem_ctx = state;
11351         }
11352
11353         status = state->dispatch_recv(subreq, mem_ctx);
11354         TALLOC_FREE(subreq);
11355         if (!NT_STATUS_IS_OK(status)) {
11356                 tevent_req_nterror(req, status);
11357                 return;
11358         }
11359
11360         /* Copy out parameters */
11361
11362         /* Copy result */
11363         state->orig.out.result = state->tmp.out.result;
11364
11365         /* Reset temporary structure */
11366         ZERO_STRUCT(state->tmp);
11367
11368         tevent_req_done(req);
11369 }
11370
11371 NTSTATUS rpccli_spoolss_4a_recv(struct tevent_req *req,
11372                                 TALLOC_CTX *mem_ctx,
11373                                 WERROR *result)
11374 {
11375         struct rpccli_spoolss_4a_state *state = tevent_req_data(
11376                 req, struct rpccli_spoolss_4a_state);
11377         NTSTATUS status;
11378
11379         if (tevent_req_is_nterror(req, &status)) {
11380                 tevent_req_received(req);
11381                 return status;
11382         }
11383
11384         /* Steal possbile out parameters to the callers context */
11385         talloc_steal(mem_ctx, state->out_mem_ctx);
11386
11387         /* Return result */
11388         *result = state->orig.out.result;
11389
11390         tevent_req_received(req);
11391         return NT_STATUS_OK;
11392 }
11393
11394 NTSTATUS rpccli_spoolss_4a(struct rpc_pipe_client *cli,
11395                            TALLOC_CTX *mem_ctx,
11396                            WERROR *werror)
11397 {
11398         struct spoolss_4a r;
11399         NTSTATUS status;
11400
11401         /* In parameters */
11402
11403         status = cli->dispatch(cli,
11404                                 mem_ctx,
11405                                 &ndr_table_spoolss,
11406                                 NDR_SPOOLSS_4A,
11407                                 &r);
11408
11409         if (!NT_STATUS_IS_OK(status)) {
11410                 return status;
11411         }
11412
11413         if (NT_STATUS_IS_ERR(status)) {
11414                 return status;
11415         }
11416
11417         /* Return variables */
11418
11419         /* Return result */
11420         if (werror) {
11421                 *werror = r.out.result;
11422         }
11423
11424         return werror_to_ntstatus(r.out.result);
11425 }
11426
11427 struct rpccli_spoolss_4b_state {
11428         struct spoolss_4b orig;
11429         struct spoolss_4b tmp;
11430         TALLOC_CTX *out_mem_ctx;
11431         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11432 };
11433
11434 static void rpccli_spoolss_4b_done(struct tevent_req *subreq);
11435
11436 struct tevent_req *rpccli_spoolss_4b_send(TALLOC_CTX *mem_ctx,
11437                                           struct tevent_context *ev,
11438                                           struct rpc_pipe_client *cli)
11439 {
11440         struct tevent_req *req;
11441         struct rpccli_spoolss_4b_state *state;
11442         struct tevent_req *subreq;
11443
11444         req = tevent_req_create(mem_ctx, &state,
11445                                 struct rpccli_spoolss_4b_state);
11446         if (req == NULL) {
11447                 return NULL;
11448         }
11449         state->out_mem_ctx = NULL;
11450         state->dispatch_recv = cli->dispatch_recv;
11451
11452         /* In parameters */
11453
11454         /* Out parameters */
11455
11456         /* Result */
11457         ZERO_STRUCT(state->orig.out.result);
11458
11459         /* make a temporary copy, that we pass to the dispatch function */
11460         state->tmp = state->orig;
11461
11462         subreq = cli->dispatch_send(state, ev, cli,
11463                                     &ndr_table_spoolss,
11464                                     NDR_SPOOLSS_4B,
11465                                     &state->tmp);
11466         if (tevent_req_nomem(subreq, req)) {
11467                 return tevent_req_post(req, ev);
11468         }
11469         tevent_req_set_callback(subreq, rpccli_spoolss_4b_done, req);
11470         return req;
11471 }
11472
11473 static void rpccli_spoolss_4b_done(struct tevent_req *subreq)
11474 {
11475         struct tevent_req *req = tevent_req_callback_data(
11476                 subreq, struct tevent_req);
11477         struct rpccli_spoolss_4b_state *state = tevent_req_data(
11478                 req, struct rpccli_spoolss_4b_state);
11479         NTSTATUS status;
11480         TALLOC_CTX *mem_ctx;
11481
11482         if (state->out_mem_ctx) {
11483                 mem_ctx = state->out_mem_ctx;
11484         } else {
11485                 mem_ctx = state;
11486         }
11487
11488         status = state->dispatch_recv(subreq, mem_ctx);
11489         TALLOC_FREE(subreq);
11490         if (!NT_STATUS_IS_OK(status)) {
11491                 tevent_req_nterror(req, status);
11492                 return;
11493         }
11494
11495         /* Copy out parameters */
11496
11497         /* Copy result */
11498         state->orig.out.result = state->tmp.out.result;
11499
11500         /* Reset temporary structure */
11501         ZERO_STRUCT(state->tmp);
11502
11503         tevent_req_done(req);
11504 }
11505
11506 NTSTATUS rpccli_spoolss_4b_recv(struct tevent_req *req,
11507                                 TALLOC_CTX *mem_ctx,
11508                                 WERROR *result)
11509 {
11510         struct rpccli_spoolss_4b_state *state = tevent_req_data(
11511                 req, struct rpccli_spoolss_4b_state);
11512         NTSTATUS status;
11513
11514         if (tevent_req_is_nterror(req, &status)) {
11515                 tevent_req_received(req);
11516                 return status;
11517         }
11518
11519         /* Steal possbile out parameters to the callers context */
11520         talloc_steal(mem_ctx, state->out_mem_ctx);
11521
11522         /* Return result */
11523         *result = state->orig.out.result;
11524
11525         tevent_req_received(req);
11526         return NT_STATUS_OK;
11527 }
11528
11529 NTSTATUS rpccli_spoolss_4b(struct rpc_pipe_client *cli,
11530                            TALLOC_CTX *mem_ctx,
11531                            WERROR *werror)
11532 {
11533         struct spoolss_4b r;
11534         NTSTATUS status;
11535
11536         /* In parameters */
11537
11538         status = cli->dispatch(cli,
11539                                 mem_ctx,
11540                                 &ndr_table_spoolss,
11541                                 NDR_SPOOLSS_4B,
11542                                 &r);
11543
11544         if (!NT_STATUS_IS_OK(status)) {
11545                 return status;
11546         }
11547
11548         if (NT_STATUS_IS_ERR(status)) {
11549                 return status;
11550         }
11551
11552         /* Return variables */
11553
11554         /* Return result */
11555         if (werror) {
11556                 *werror = r.out.result;
11557         }
11558
11559         return werror_to_ntstatus(r.out.result);
11560 }
11561
11562 struct rpccli_spoolss_4c_state {
11563         struct spoolss_4c orig;
11564         struct spoolss_4c tmp;
11565         TALLOC_CTX *out_mem_ctx;
11566         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11567 };
11568
11569 static void rpccli_spoolss_4c_done(struct tevent_req *subreq);
11570
11571 struct tevent_req *rpccli_spoolss_4c_send(TALLOC_CTX *mem_ctx,
11572                                           struct tevent_context *ev,
11573                                           struct rpc_pipe_client *cli)
11574 {
11575         struct tevent_req *req;
11576         struct rpccli_spoolss_4c_state *state;
11577         struct tevent_req *subreq;
11578
11579         req = tevent_req_create(mem_ctx, &state,
11580                                 struct rpccli_spoolss_4c_state);
11581         if (req == NULL) {
11582                 return NULL;
11583         }
11584         state->out_mem_ctx = NULL;
11585         state->dispatch_recv = cli->dispatch_recv;
11586
11587         /* In parameters */
11588
11589         /* Out parameters */
11590
11591         /* Result */
11592         ZERO_STRUCT(state->orig.out.result);
11593
11594         /* make a temporary copy, that we pass to the dispatch function */
11595         state->tmp = state->orig;
11596
11597         subreq = cli->dispatch_send(state, ev, cli,
11598                                     &ndr_table_spoolss,
11599                                     NDR_SPOOLSS_4C,
11600                                     &state->tmp);
11601         if (tevent_req_nomem(subreq, req)) {
11602                 return tevent_req_post(req, ev);
11603         }
11604         tevent_req_set_callback(subreq, rpccli_spoolss_4c_done, req);
11605         return req;
11606 }
11607
11608 static void rpccli_spoolss_4c_done(struct tevent_req *subreq)
11609 {
11610         struct tevent_req *req = tevent_req_callback_data(
11611                 subreq, struct tevent_req);
11612         struct rpccli_spoolss_4c_state *state = tevent_req_data(
11613                 req, struct rpccli_spoolss_4c_state);
11614         NTSTATUS status;
11615         TALLOC_CTX *mem_ctx;
11616
11617         if (state->out_mem_ctx) {
11618                 mem_ctx = state->out_mem_ctx;
11619         } else {
11620                 mem_ctx = state;
11621         }
11622
11623         status = state->dispatch_recv(subreq, mem_ctx);
11624         TALLOC_FREE(subreq);
11625         if (!NT_STATUS_IS_OK(status)) {
11626                 tevent_req_nterror(req, status);
11627                 return;
11628         }
11629
11630         /* Copy out parameters */
11631
11632         /* Copy result */
11633         state->orig.out.result = state->tmp.out.result;
11634
11635         /* Reset temporary structure */
11636         ZERO_STRUCT(state->tmp);
11637
11638         tevent_req_done(req);
11639 }
11640
11641 NTSTATUS rpccli_spoolss_4c_recv(struct tevent_req *req,
11642                                 TALLOC_CTX *mem_ctx,
11643                                 WERROR *result)
11644 {
11645         struct rpccli_spoolss_4c_state *state = tevent_req_data(
11646                 req, struct rpccli_spoolss_4c_state);
11647         NTSTATUS status;
11648
11649         if (tevent_req_is_nterror(req, &status)) {
11650                 tevent_req_received(req);
11651                 return status;
11652         }
11653
11654         /* Steal possbile out parameters to the callers context */
11655         talloc_steal(mem_ctx, state->out_mem_ctx);
11656
11657         /* Return result */
11658         *result = state->orig.out.result;
11659
11660         tevent_req_received(req);
11661         return NT_STATUS_OK;
11662 }
11663
11664 NTSTATUS rpccli_spoolss_4c(struct rpc_pipe_client *cli,
11665                            TALLOC_CTX *mem_ctx,
11666                            WERROR *werror)
11667 {
11668         struct spoolss_4c r;
11669         NTSTATUS status;
11670
11671         /* In parameters */
11672
11673         status = cli->dispatch(cli,
11674                                 mem_ctx,
11675                                 &ndr_table_spoolss,
11676                                 NDR_SPOOLSS_4C,
11677                                 &r);
11678
11679         if (!NT_STATUS_IS_OK(status)) {
11680                 return status;
11681         }
11682
11683         if (NT_STATUS_IS_ERR(status)) {
11684                 return status;
11685         }
11686
11687         /* Return variables */
11688
11689         /* Return result */
11690         if (werror) {
11691                 *werror = r.out.result;
11692         }
11693
11694         return werror_to_ntstatus(r.out.result);
11695 }
11696
11697 struct rpccli_spoolss_SetPrinterDataEx_state {
11698         struct spoolss_SetPrinterDataEx orig;
11699         struct spoolss_SetPrinterDataEx tmp;
11700         TALLOC_CTX *out_mem_ctx;
11701         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11702 };
11703
11704 static void rpccli_spoolss_SetPrinterDataEx_done(struct tevent_req *subreq);
11705
11706 struct tevent_req *rpccli_spoolss_SetPrinterDataEx_send(TALLOC_CTX *mem_ctx,
11707                                                         struct tevent_context *ev,
11708                                                         struct rpc_pipe_client *cli,
11709                                                         struct policy_handle *_handle /* [in] [ref] */,
11710                                                         const char *_key_name /* [in] [charset(UTF16)] */,
11711                                                         const char *_value_name /* [in] [charset(UTF16)] */,
11712                                                         enum winreg_Type _type /* [in]  */,
11713                                                         union spoolss_PrinterData _data /* [in] [subcontext(4),switch_is(type)] */,
11714                                                         uint32_t __offered /* [in] [value(ndr_size_spoolss_PrinterData(&data,type,ndr->iconv_convenience,flags))] */)
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                                          union spoolss_PrinterData data /* [in] [subcontext(4),switch_is(type)] */,
11818                                          uint32_t _offered /* [in] [value(ndr_size_spoolss_PrinterData(&data,type,ndr->iconv_convenience,flags))] */,
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                                                         uint32_t _offered /* [in]  */,
11872                                                         enum winreg_Type *_type /* [out] [ref] */,
11873                                                         union spoolss_PrinterData *_data /* [out] [subcontext_size(offered),ref,subcontext(4),switch_is(*type)] */,
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         *state->orig.out.data = *state->tmp.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                                          uint32_t offered /* [in]  */,
11987                                          enum winreg_Type *type /* [out] [ref] */,
11988                                          union spoolss_PrinterData *data /* [out] [subcontext_size(offered),ref,subcontext(4),switch_is(*type)] */,
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         *data = *r.out.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                                                       struct spoolss_StringArray2 *_key_buffer /* [out] [ref] */,
12211                                                       uint32_t _offered /* [in]  */,
12212                                                       uint32_t *_needed /* [out] [ref] */)
12213 {
12214         struct tevent_req *req;
12215         struct rpccli_spoolss_EnumPrinterKey_state *state;
12216         struct tevent_req *subreq;
12217
12218         req = tevent_req_create(mem_ctx, &state,
12219                                 struct rpccli_spoolss_EnumPrinterKey_state);
12220         if (req == NULL) {
12221                 return NULL;
12222         }
12223         state->out_mem_ctx = NULL;
12224         state->dispatch_recv = cli->dispatch_recv;
12225
12226         /* In parameters */
12227         state->orig.in.handle = _handle;
12228         state->orig.in.key_name = _key_name;
12229         state->orig.in.offered = _offered;
12230
12231         /* Out parameters */
12232         state->orig.out.key_buffer = _key_buffer;
12233         state->orig.out.needed = _needed;
12234
12235         /* Result */
12236         ZERO_STRUCT(state->orig.out.result);
12237
12238         state->out_mem_ctx = talloc_named_const(state, 0,
12239                              "rpccli_spoolss_EnumPrinterKey_out_memory");
12240         if (tevent_req_nomem(state->out_mem_ctx, req)) {
12241                 return tevent_req_post(req, ev);
12242         }
12243
12244         /* make a temporary copy, that we pass to the dispatch function */
12245         state->tmp = state->orig;
12246
12247         subreq = cli->dispatch_send(state, ev, cli,
12248                                     &ndr_table_spoolss,
12249                                     NDR_SPOOLSS_ENUMPRINTERKEY,
12250                                     &state->tmp);
12251         if (tevent_req_nomem(subreq, req)) {
12252                 return tevent_req_post(req, ev);
12253         }
12254         tevent_req_set_callback(subreq, rpccli_spoolss_EnumPrinterKey_done, req);
12255         return req;
12256 }
12257
12258 static void rpccli_spoolss_EnumPrinterKey_done(struct tevent_req *subreq)
12259 {
12260         struct tevent_req *req = tevent_req_callback_data(
12261                 subreq, struct tevent_req);
12262         struct rpccli_spoolss_EnumPrinterKey_state *state = tevent_req_data(
12263                 req, struct rpccli_spoolss_EnumPrinterKey_state);
12264         NTSTATUS status;
12265         TALLOC_CTX *mem_ctx;
12266
12267         if (state->out_mem_ctx) {
12268                 mem_ctx = state->out_mem_ctx;
12269         } else {
12270                 mem_ctx = state;
12271         }
12272
12273         status = state->dispatch_recv(subreq, mem_ctx);
12274         TALLOC_FREE(subreq);
12275         if (!NT_STATUS_IS_OK(status)) {
12276                 tevent_req_nterror(req, status);
12277                 return;
12278         }
12279
12280         /* Copy out parameters */
12281         *state->orig.out.key_buffer = *state->tmp.out.key_buffer;
12282         *state->orig.out.needed = *state->tmp.out.needed;
12283
12284         /* Copy result */
12285         state->orig.out.result = state->tmp.out.result;
12286
12287         /* Reset temporary structure */
12288         ZERO_STRUCT(state->tmp);
12289
12290         tevent_req_done(req);
12291 }
12292
12293 NTSTATUS rpccli_spoolss_EnumPrinterKey_recv(struct tevent_req *req,
12294                                             TALLOC_CTX *mem_ctx,
12295                                             WERROR *result)
12296 {
12297         struct rpccli_spoolss_EnumPrinterKey_state *state = tevent_req_data(
12298                 req, struct rpccli_spoolss_EnumPrinterKey_state);
12299         NTSTATUS status;
12300
12301         if (tevent_req_is_nterror(req, &status)) {
12302                 tevent_req_received(req);
12303                 return status;
12304         }
12305
12306         /* Steal possbile out parameters to the callers context */
12307         talloc_steal(mem_ctx, state->out_mem_ctx);
12308
12309         /* Return result */
12310         *result = state->orig.out.result;
12311
12312         tevent_req_received(req);
12313         return NT_STATUS_OK;
12314 }
12315
12316 NTSTATUS rpccli_spoolss_EnumPrinterKey(struct rpc_pipe_client *cli,
12317                                        TALLOC_CTX *mem_ctx,
12318                                        struct policy_handle *handle /* [in] [ref] */,
12319                                        const char *key_name /* [in] [charset(UTF16)] */,
12320                                        struct spoolss_StringArray2 *key_buffer /* [out] [ref] */,
12321                                        uint32_t offered /* [in]  */,
12322                                        uint32_t *needed /* [out] [ref] */,
12323                                        WERROR *werror)
12324 {
12325         struct spoolss_EnumPrinterKey r;
12326         NTSTATUS status;
12327
12328         /* In parameters */
12329         r.in.handle = handle;
12330         r.in.key_name = key_name;
12331         r.in.offered = offered;
12332
12333         status = cli->dispatch(cli,
12334                                 mem_ctx,
12335                                 &ndr_table_spoolss,
12336                                 NDR_SPOOLSS_ENUMPRINTERKEY,
12337                                 &r);
12338
12339         if (!NT_STATUS_IS_OK(status)) {
12340                 return status;
12341         }
12342
12343         if (NT_STATUS_IS_ERR(status)) {
12344                 return status;
12345         }
12346
12347         /* Return variables */
12348         *key_buffer = *r.out.key_buffer;
12349         *needed = *r.out.needed;
12350
12351         /* Return result */
12352         if (werror) {
12353                 *werror = r.out.result;
12354         }
12355
12356         return werror_to_ntstatus(r.out.result);
12357 }
12358
12359 struct rpccli_spoolss_DeletePrinterDataEx_state {
12360         struct spoolss_DeletePrinterDataEx orig;
12361         struct spoolss_DeletePrinterDataEx tmp;
12362         TALLOC_CTX *out_mem_ctx;
12363         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12364 };
12365
12366 static void rpccli_spoolss_DeletePrinterDataEx_done(struct tevent_req *subreq);
12367
12368 struct tevent_req *rpccli_spoolss_DeletePrinterDataEx_send(TALLOC_CTX *mem_ctx,
12369                                                            struct tevent_context *ev,
12370                                                            struct rpc_pipe_client *cli,
12371                                                            struct policy_handle *_handle /* [in] [ref] */,
12372                                                            const char *_key_name /* [in] [charset(UTF16)] */,
12373                                                            const char *_value_name /* [in] [charset(UTF16)] */)
12374 {
12375         struct tevent_req *req;
12376         struct rpccli_spoolss_DeletePrinterDataEx_state *state;
12377         struct tevent_req *subreq;
12378
12379         req = tevent_req_create(mem_ctx, &state,
12380                                 struct rpccli_spoolss_DeletePrinterDataEx_state);
12381         if (req == NULL) {
12382                 return NULL;
12383         }
12384         state->out_mem_ctx = NULL;
12385         state->dispatch_recv = cli->dispatch_recv;
12386
12387         /* In parameters */
12388         state->orig.in.handle = _handle;
12389         state->orig.in.key_name = _key_name;
12390         state->orig.in.value_name = _value_name;
12391
12392         /* Out parameters */
12393
12394         /* Result */
12395         ZERO_STRUCT(state->orig.out.result);
12396
12397         /* make a temporary copy, that we pass to the dispatch function */
12398         state->tmp = state->orig;
12399
12400         subreq = cli->dispatch_send(state, ev, cli,
12401                                     &ndr_table_spoolss,
12402                                     NDR_SPOOLSS_DELETEPRINTERDATAEX,
12403                                     &state->tmp);
12404         if (tevent_req_nomem(subreq, req)) {
12405                 return tevent_req_post(req, ev);
12406         }
12407         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterDataEx_done, req);
12408         return req;
12409 }
12410
12411 static void rpccli_spoolss_DeletePrinterDataEx_done(struct tevent_req *subreq)
12412 {
12413         struct tevent_req *req = tevent_req_callback_data(
12414                 subreq, struct tevent_req);
12415         struct rpccli_spoolss_DeletePrinterDataEx_state *state = tevent_req_data(
12416                 req, struct rpccli_spoolss_DeletePrinterDataEx_state);
12417         NTSTATUS status;
12418         TALLOC_CTX *mem_ctx;
12419
12420         if (state->out_mem_ctx) {
12421                 mem_ctx = state->out_mem_ctx;
12422         } else {
12423                 mem_ctx = state;
12424         }
12425
12426         status = state->dispatch_recv(subreq, mem_ctx);
12427         TALLOC_FREE(subreq);
12428         if (!NT_STATUS_IS_OK(status)) {
12429                 tevent_req_nterror(req, status);
12430                 return;
12431         }
12432
12433         /* Copy out parameters */
12434
12435         /* Copy result */
12436         state->orig.out.result = state->tmp.out.result;
12437
12438         /* Reset temporary structure */
12439         ZERO_STRUCT(state->tmp);
12440
12441         tevent_req_done(req);
12442 }
12443
12444 NTSTATUS rpccli_spoolss_DeletePrinterDataEx_recv(struct tevent_req *req,
12445                                                  TALLOC_CTX *mem_ctx,
12446                                                  WERROR *result)
12447 {
12448         struct rpccli_spoolss_DeletePrinterDataEx_state *state = tevent_req_data(
12449                 req, struct rpccli_spoolss_DeletePrinterDataEx_state);
12450         NTSTATUS status;
12451
12452         if (tevent_req_is_nterror(req, &status)) {
12453                 tevent_req_received(req);
12454                 return status;
12455         }
12456
12457         /* Steal possbile out parameters to the callers context */
12458         talloc_steal(mem_ctx, state->out_mem_ctx);
12459
12460         /* Return result */
12461         *result = state->orig.out.result;
12462
12463         tevent_req_received(req);
12464         return NT_STATUS_OK;
12465 }
12466
12467 NTSTATUS rpccli_spoolss_DeletePrinterDataEx(struct rpc_pipe_client *cli,
12468                                             TALLOC_CTX *mem_ctx,
12469                                             struct policy_handle *handle /* [in] [ref] */,
12470                                             const char *key_name /* [in] [charset(UTF16)] */,
12471                                             const char *value_name /* [in] [charset(UTF16)] */,
12472                                             WERROR *werror)
12473 {
12474         struct spoolss_DeletePrinterDataEx r;
12475         NTSTATUS status;
12476
12477         /* In parameters */
12478         r.in.handle = handle;
12479         r.in.key_name = key_name;
12480         r.in.value_name = value_name;
12481
12482         status = cli->dispatch(cli,
12483                                 mem_ctx,
12484                                 &ndr_table_spoolss,
12485                                 NDR_SPOOLSS_DELETEPRINTERDATAEX,
12486                                 &r);
12487
12488         if (!NT_STATUS_IS_OK(status)) {
12489                 return status;
12490         }
12491
12492         if (NT_STATUS_IS_ERR(status)) {
12493                 return status;
12494         }
12495
12496         /* Return variables */
12497
12498         /* Return result */
12499         if (werror) {
12500                 *werror = r.out.result;
12501         }
12502
12503         return werror_to_ntstatus(r.out.result);
12504 }
12505
12506 struct rpccli_spoolss_DeletePrinterKey_state {
12507         struct spoolss_DeletePrinterKey orig;
12508         struct spoolss_DeletePrinterKey tmp;
12509         TALLOC_CTX *out_mem_ctx;
12510         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12511 };
12512
12513 static void rpccli_spoolss_DeletePrinterKey_done(struct tevent_req *subreq);
12514
12515 struct tevent_req *rpccli_spoolss_DeletePrinterKey_send(TALLOC_CTX *mem_ctx,
12516                                                         struct tevent_context *ev,
12517                                                         struct rpc_pipe_client *cli,
12518                                                         struct policy_handle *_handle /* [in] [ref] */,
12519                                                         const char *_key_name /* [in] [charset(UTF16)] */)
12520 {
12521         struct tevent_req *req;
12522         struct rpccli_spoolss_DeletePrinterKey_state *state;
12523         struct tevent_req *subreq;
12524
12525         req = tevent_req_create(mem_ctx, &state,
12526                                 struct rpccli_spoolss_DeletePrinterKey_state);
12527         if (req == NULL) {
12528                 return NULL;
12529         }
12530         state->out_mem_ctx = NULL;
12531         state->dispatch_recv = cli->dispatch_recv;
12532
12533         /* In parameters */
12534         state->orig.in.handle = _handle;
12535         state->orig.in.key_name = _key_name;
12536
12537         /* Out parameters */
12538
12539         /* Result */
12540         ZERO_STRUCT(state->orig.out.result);
12541
12542         /* make a temporary copy, that we pass to the dispatch function */
12543         state->tmp = state->orig;
12544
12545         subreq = cli->dispatch_send(state, ev, cli,
12546                                     &ndr_table_spoolss,
12547                                     NDR_SPOOLSS_DELETEPRINTERKEY,
12548                                     &state->tmp);
12549         if (tevent_req_nomem(subreq, req)) {
12550                 return tevent_req_post(req, ev);
12551         }
12552         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterKey_done, req);
12553         return req;
12554 }
12555
12556 static void rpccli_spoolss_DeletePrinterKey_done(struct tevent_req *subreq)
12557 {
12558         struct tevent_req *req = tevent_req_callback_data(
12559                 subreq, struct tevent_req);
12560         struct rpccli_spoolss_DeletePrinterKey_state *state = tevent_req_data(
12561                 req, struct rpccli_spoolss_DeletePrinterKey_state);
12562         NTSTATUS status;
12563         TALLOC_CTX *mem_ctx;
12564
12565         if (state->out_mem_ctx) {
12566                 mem_ctx = state->out_mem_ctx;
12567         } else {
12568                 mem_ctx = state;
12569         }
12570
12571         status = state->dispatch_recv(subreq, mem_ctx);
12572         TALLOC_FREE(subreq);
12573         if (!NT_STATUS_IS_OK(status)) {
12574                 tevent_req_nterror(req, status);
12575                 return;
12576         }
12577
12578         /* Copy out parameters */
12579
12580         /* Copy result */
12581         state->orig.out.result = state->tmp.out.result;
12582
12583         /* Reset temporary structure */
12584         ZERO_STRUCT(state->tmp);
12585
12586         tevent_req_done(req);
12587 }
12588
12589 NTSTATUS rpccli_spoolss_DeletePrinterKey_recv(struct tevent_req *req,
12590                                               TALLOC_CTX *mem_ctx,
12591                                               WERROR *result)
12592 {
12593         struct rpccli_spoolss_DeletePrinterKey_state *state = tevent_req_data(
12594                 req, struct rpccli_spoolss_DeletePrinterKey_state);
12595         NTSTATUS status;
12596
12597         if (tevent_req_is_nterror(req, &status)) {
12598                 tevent_req_received(req);
12599                 return status;
12600         }
12601
12602         /* Steal possbile out parameters to the callers context */
12603         talloc_steal(mem_ctx, state->out_mem_ctx);
12604
12605         /* Return result */
12606         *result = state->orig.out.result;
12607
12608         tevent_req_received(req);
12609         return NT_STATUS_OK;
12610 }
12611
12612 NTSTATUS rpccli_spoolss_DeletePrinterKey(struct rpc_pipe_client *cli,
12613                                          TALLOC_CTX *mem_ctx,
12614                                          struct policy_handle *handle /* [in] [ref] */,
12615                                          const char *key_name /* [in] [charset(UTF16)] */,
12616                                          WERROR *werror)
12617 {
12618         struct spoolss_DeletePrinterKey r;
12619         NTSTATUS status;
12620
12621         /* In parameters */
12622         r.in.handle = handle;
12623         r.in.key_name = key_name;
12624
12625         status = cli->dispatch(cli,
12626                                 mem_ctx,
12627                                 &ndr_table_spoolss,
12628                                 NDR_SPOOLSS_DELETEPRINTERKEY,
12629                                 &r);
12630
12631         if (!NT_STATUS_IS_OK(status)) {
12632                 return status;
12633         }
12634
12635         if (NT_STATUS_IS_ERR(status)) {
12636                 return status;
12637         }
12638
12639         /* Return variables */
12640
12641         /* Return result */
12642         if (werror) {
12643                 *werror = r.out.result;
12644         }
12645
12646         return werror_to_ntstatus(r.out.result);
12647 }
12648
12649 struct rpccli_spoolss_53_state {
12650         struct spoolss_53 orig;
12651         struct spoolss_53 tmp;
12652         TALLOC_CTX *out_mem_ctx;
12653         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12654 };
12655
12656 static void rpccli_spoolss_53_done(struct tevent_req *subreq);
12657
12658 struct tevent_req *rpccli_spoolss_53_send(TALLOC_CTX *mem_ctx,
12659                                           struct tevent_context *ev,
12660                                           struct rpc_pipe_client *cli)
12661 {
12662         struct tevent_req *req;
12663         struct rpccli_spoolss_53_state *state;
12664         struct tevent_req *subreq;
12665
12666         req = tevent_req_create(mem_ctx, &state,
12667                                 struct rpccli_spoolss_53_state);
12668         if (req == NULL) {
12669                 return NULL;
12670         }
12671         state->out_mem_ctx = NULL;
12672         state->dispatch_recv = cli->dispatch_recv;
12673
12674         /* In parameters */
12675
12676         /* Out parameters */
12677
12678         /* Result */
12679         ZERO_STRUCT(state->orig.out.result);
12680
12681         /* make a temporary copy, that we pass to the dispatch function */
12682         state->tmp = state->orig;
12683
12684         subreq = cli->dispatch_send(state, ev, cli,
12685                                     &ndr_table_spoolss,
12686                                     NDR_SPOOLSS_53,
12687                                     &state->tmp);
12688         if (tevent_req_nomem(subreq, req)) {
12689                 return tevent_req_post(req, ev);
12690         }
12691         tevent_req_set_callback(subreq, rpccli_spoolss_53_done, req);
12692         return req;
12693 }
12694
12695 static void rpccli_spoolss_53_done(struct tevent_req *subreq)
12696 {
12697         struct tevent_req *req = tevent_req_callback_data(
12698                 subreq, struct tevent_req);
12699         struct rpccli_spoolss_53_state *state = tevent_req_data(
12700                 req, struct rpccli_spoolss_53_state);
12701         NTSTATUS status;
12702         TALLOC_CTX *mem_ctx;
12703
12704         if (state->out_mem_ctx) {
12705                 mem_ctx = state->out_mem_ctx;
12706         } else {
12707                 mem_ctx = state;
12708         }
12709
12710         status = state->dispatch_recv(subreq, mem_ctx);
12711         TALLOC_FREE(subreq);
12712         if (!NT_STATUS_IS_OK(status)) {
12713                 tevent_req_nterror(req, status);
12714                 return;
12715         }
12716
12717         /* Copy out parameters */
12718
12719         /* Copy result */
12720         state->orig.out.result = state->tmp.out.result;
12721
12722         /* Reset temporary structure */
12723         ZERO_STRUCT(state->tmp);
12724
12725         tevent_req_done(req);
12726 }
12727
12728 NTSTATUS rpccli_spoolss_53_recv(struct tevent_req *req,
12729                                 TALLOC_CTX *mem_ctx,
12730                                 WERROR *result)
12731 {
12732         struct rpccli_spoolss_53_state *state = tevent_req_data(
12733                 req, struct rpccli_spoolss_53_state);
12734         NTSTATUS status;
12735
12736         if (tevent_req_is_nterror(req, &status)) {
12737                 tevent_req_received(req);
12738                 return status;
12739         }
12740
12741         /* Steal possbile out parameters to the callers context */
12742         talloc_steal(mem_ctx, state->out_mem_ctx);
12743
12744         /* Return result */
12745         *result = state->orig.out.result;
12746
12747         tevent_req_received(req);
12748         return NT_STATUS_OK;
12749 }
12750
12751 NTSTATUS rpccli_spoolss_53(struct rpc_pipe_client *cli,
12752                            TALLOC_CTX *mem_ctx,
12753                            WERROR *werror)
12754 {
12755         struct spoolss_53 r;
12756         NTSTATUS status;
12757
12758         /* In parameters */
12759
12760         status = cli->dispatch(cli,
12761                                 mem_ctx,
12762                                 &ndr_table_spoolss,
12763                                 NDR_SPOOLSS_53,
12764                                 &r);
12765
12766         if (!NT_STATUS_IS_OK(status)) {
12767                 return status;
12768         }
12769
12770         if (NT_STATUS_IS_ERR(status)) {
12771                 return status;
12772         }
12773
12774         /* Return variables */
12775
12776         /* Return result */
12777         if (werror) {
12778                 *werror = r.out.result;
12779         }
12780
12781         return werror_to_ntstatus(r.out.result);
12782 }
12783
12784 struct rpccli_spoolss_DeletePrinterDriverEx_state {
12785         struct spoolss_DeletePrinterDriverEx orig;
12786         struct spoolss_DeletePrinterDriverEx tmp;
12787         TALLOC_CTX *out_mem_ctx;
12788         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12789 };
12790
12791 static void rpccli_spoolss_DeletePrinterDriverEx_done(struct tevent_req *subreq);
12792
12793 struct tevent_req *rpccli_spoolss_DeletePrinterDriverEx_send(TALLOC_CTX *mem_ctx,
12794                                                              struct tevent_context *ev,
12795                                                              struct rpc_pipe_client *cli,
12796                                                              const char *_server /* [in] [unique,charset(UTF16)] */,
12797                                                              const char *_architecture /* [in] [charset(UTF16)] */,
12798                                                              const char *_driver /* [in] [charset(UTF16)] */,
12799                                                              uint32_t _delete_flags /* [in]  */,
12800                                                              uint32_t _version /* [in]  */)
12801 {
12802         struct tevent_req *req;
12803         struct rpccli_spoolss_DeletePrinterDriverEx_state *state;
12804         struct tevent_req *subreq;
12805
12806         req = tevent_req_create(mem_ctx, &state,
12807                                 struct rpccli_spoolss_DeletePrinterDriverEx_state);
12808         if (req == NULL) {
12809                 return NULL;
12810         }
12811         state->out_mem_ctx = NULL;
12812         state->dispatch_recv = cli->dispatch_recv;
12813
12814         /* In parameters */
12815         state->orig.in.server = _server;
12816         state->orig.in.architecture = _architecture;
12817         state->orig.in.driver = _driver;
12818         state->orig.in.delete_flags = _delete_flags;
12819         state->orig.in.version = _version;
12820
12821         /* Out parameters */
12822
12823         /* Result */
12824         ZERO_STRUCT(state->orig.out.result);
12825
12826         /* make a temporary copy, that we pass to the dispatch function */
12827         state->tmp = state->orig;
12828
12829         subreq = cli->dispatch_send(state, ev, cli,
12830                                     &ndr_table_spoolss,
12831                                     NDR_SPOOLSS_DELETEPRINTERDRIVEREX,
12832                                     &state->tmp);
12833         if (tevent_req_nomem(subreq, req)) {
12834                 return tevent_req_post(req, ev);
12835         }
12836         tevent_req_set_callback(subreq, rpccli_spoolss_DeletePrinterDriverEx_done, req);
12837         return req;
12838 }
12839
12840 static void rpccli_spoolss_DeletePrinterDriverEx_done(struct tevent_req *subreq)
12841 {
12842         struct tevent_req *req = tevent_req_callback_data(
12843                 subreq, struct tevent_req);
12844         struct rpccli_spoolss_DeletePrinterDriverEx_state *state = tevent_req_data(
12845                 req, struct rpccli_spoolss_DeletePrinterDriverEx_state);
12846         NTSTATUS status;
12847         TALLOC_CTX *mem_ctx;
12848
12849         if (state->out_mem_ctx) {
12850                 mem_ctx = state->out_mem_ctx;
12851         } else {
12852                 mem_ctx = state;
12853         }
12854
12855         status = state->dispatch_recv(subreq, mem_ctx);
12856         TALLOC_FREE(subreq);
12857         if (!NT_STATUS_IS_OK(status)) {
12858                 tevent_req_nterror(req, status);
12859                 return;
12860         }
12861
12862         /* Copy out parameters */
12863
12864         /* Copy result */
12865         state->orig.out.result = state->tmp.out.result;
12866
12867         /* Reset temporary structure */
12868         ZERO_STRUCT(state->tmp);
12869
12870         tevent_req_done(req);
12871 }
12872
12873 NTSTATUS rpccli_spoolss_DeletePrinterDriverEx_recv(struct tevent_req *req,
12874                                                    TALLOC_CTX *mem_ctx,
12875                                                    WERROR *result)
12876 {
12877         struct rpccli_spoolss_DeletePrinterDriverEx_state *state = tevent_req_data(
12878                 req, struct rpccli_spoolss_DeletePrinterDriverEx_state);
12879         NTSTATUS status;
12880
12881         if (tevent_req_is_nterror(req, &status)) {
12882                 tevent_req_received(req);
12883                 return status;
12884         }
12885
12886         /* Steal possbile out parameters to the callers context */
12887         talloc_steal(mem_ctx, state->out_mem_ctx);
12888
12889         /* Return result */
12890         *result = state->orig.out.result;
12891
12892         tevent_req_received(req);
12893         return NT_STATUS_OK;
12894 }
12895
12896 NTSTATUS rpccli_spoolss_DeletePrinterDriverEx(struct rpc_pipe_client *cli,
12897                                               TALLOC_CTX *mem_ctx,
12898                                               const char *server /* [in] [unique,charset(UTF16)] */,
12899                                               const char *architecture /* [in] [charset(UTF16)] */,
12900                                               const char *driver /* [in] [charset(UTF16)] */,
12901                                               uint32_t delete_flags /* [in]  */,
12902                                               uint32_t version /* [in]  */,
12903                                               WERROR *werror)
12904 {
12905         struct spoolss_DeletePrinterDriverEx r;
12906         NTSTATUS status;
12907
12908         /* In parameters */
12909         r.in.server = server;
12910         r.in.architecture = architecture;
12911         r.in.driver = driver;
12912         r.in.delete_flags = delete_flags;
12913         r.in.version = version;
12914
12915         status = cli->dispatch(cli,
12916                                 mem_ctx,
12917                                 &ndr_table_spoolss,
12918                                 NDR_SPOOLSS_DELETEPRINTERDRIVEREX,
12919                                 &r);
12920
12921         if (!NT_STATUS_IS_OK(status)) {
12922                 return status;
12923         }
12924
12925         if (NT_STATUS_IS_ERR(status)) {
12926                 return status;
12927         }
12928
12929         /* Return variables */
12930
12931         /* Return result */
12932         if (werror) {
12933                 *werror = r.out.result;
12934         }
12935
12936         return werror_to_ntstatus(r.out.result);
12937 }
12938
12939 struct rpccli_spoolss_55_state {
12940         struct spoolss_55 orig;
12941         struct spoolss_55 tmp;
12942         TALLOC_CTX *out_mem_ctx;
12943         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
12944 };
12945
12946 static void rpccli_spoolss_55_done(struct tevent_req *subreq);
12947
12948 struct tevent_req *rpccli_spoolss_55_send(TALLOC_CTX *mem_ctx,
12949                                           struct tevent_context *ev,
12950                                           struct rpc_pipe_client *cli)
12951 {
12952         struct tevent_req *req;
12953         struct rpccli_spoolss_55_state *state;
12954         struct tevent_req *subreq;
12955
12956         req = tevent_req_create(mem_ctx, &state,
12957                                 struct rpccli_spoolss_55_state);
12958         if (req == NULL) {
12959                 return NULL;
12960         }
12961         state->out_mem_ctx = NULL;
12962         state->dispatch_recv = cli->dispatch_recv;
12963
12964         /* In parameters */
12965
12966         /* Out parameters */
12967
12968         /* Result */
12969         ZERO_STRUCT(state->orig.out.result);
12970
12971         /* make a temporary copy, that we pass to the dispatch function */
12972         state->tmp = state->orig;
12973
12974         subreq = cli->dispatch_send(state, ev, cli,
12975                                     &ndr_table_spoolss,
12976                                     NDR_SPOOLSS_55,
12977                                     &state->tmp);
12978         if (tevent_req_nomem(subreq, req)) {
12979                 return tevent_req_post(req, ev);
12980         }
12981         tevent_req_set_callback(subreq, rpccli_spoolss_55_done, req);
12982         return req;
12983 }
12984
12985 static void rpccli_spoolss_55_done(struct tevent_req *subreq)
12986 {
12987         struct tevent_req *req = tevent_req_callback_data(
12988                 subreq, struct tevent_req);
12989         struct rpccli_spoolss_55_state *state = tevent_req_data(
12990                 req, struct rpccli_spoolss_55_state);
12991         NTSTATUS status;
12992         TALLOC_CTX *mem_ctx;
12993
12994         if (state->out_mem_ctx) {
12995                 mem_ctx = state->out_mem_ctx;
12996         } else {
12997                 mem_ctx = state;
12998         }
12999
13000         status = state->dispatch_recv(subreq, mem_ctx);
13001         TALLOC_FREE(subreq);
13002         if (!NT_STATUS_IS_OK(status)) {
13003                 tevent_req_nterror(req, status);
13004                 return;
13005         }
13006
13007         /* Copy out parameters */
13008
13009         /* Copy result */
13010         state->orig.out.result = state->tmp.out.result;
13011
13012         /* Reset temporary structure */
13013         ZERO_STRUCT(state->tmp);
13014
13015         tevent_req_done(req);
13016 }
13017
13018 NTSTATUS rpccli_spoolss_55_recv(struct tevent_req *req,
13019                                 TALLOC_CTX *mem_ctx,
13020                                 WERROR *result)
13021 {
13022         struct rpccli_spoolss_55_state *state = tevent_req_data(
13023                 req, struct rpccli_spoolss_55_state);
13024         NTSTATUS status;
13025
13026         if (tevent_req_is_nterror(req, &status)) {
13027                 tevent_req_received(req);
13028                 return status;
13029         }
13030
13031         /* Steal possbile out parameters to the callers context */
13032         talloc_steal(mem_ctx, state->out_mem_ctx);
13033
13034         /* Return result */
13035         *result = state->orig.out.result;
13036
13037         tevent_req_received(req);
13038         return NT_STATUS_OK;
13039 }
13040
13041 NTSTATUS rpccli_spoolss_55(struct rpc_pipe_client *cli,
13042                            TALLOC_CTX *mem_ctx,
13043                            WERROR *werror)
13044 {
13045         struct spoolss_55 r;
13046         NTSTATUS status;
13047
13048         /* In parameters */
13049
13050         status = cli->dispatch(cli,
13051                                 mem_ctx,
13052                                 &ndr_table_spoolss,
13053                                 NDR_SPOOLSS_55,
13054                                 &r);
13055
13056         if (!NT_STATUS_IS_OK(status)) {
13057                 return status;
13058         }
13059
13060         if (NT_STATUS_IS_ERR(status)) {
13061                 return status;
13062         }
13063
13064         /* Return variables */
13065
13066         /* Return result */
13067         if (werror) {
13068                 *werror = r.out.result;
13069         }
13070
13071         return werror_to_ntstatus(r.out.result);
13072 }
13073
13074 struct rpccli_spoolss_56_state {
13075         struct spoolss_56 orig;
13076         struct spoolss_56 tmp;
13077         TALLOC_CTX *out_mem_ctx;
13078         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13079 };
13080
13081 static void rpccli_spoolss_56_done(struct tevent_req *subreq);
13082
13083 struct tevent_req *rpccli_spoolss_56_send(TALLOC_CTX *mem_ctx,
13084                                           struct tevent_context *ev,
13085                                           struct rpc_pipe_client *cli)
13086 {
13087         struct tevent_req *req;
13088         struct rpccli_spoolss_56_state *state;
13089         struct tevent_req *subreq;
13090
13091         req = tevent_req_create(mem_ctx, &state,
13092                                 struct rpccli_spoolss_56_state);
13093         if (req == NULL) {
13094                 return NULL;
13095         }
13096         state->out_mem_ctx = NULL;
13097         state->dispatch_recv = cli->dispatch_recv;
13098
13099         /* In parameters */
13100
13101         /* Out parameters */
13102
13103         /* Result */
13104         ZERO_STRUCT(state->orig.out.result);
13105
13106         /* make a temporary copy, that we pass to the dispatch function */
13107         state->tmp = state->orig;
13108
13109         subreq = cli->dispatch_send(state, ev, cli,
13110                                     &ndr_table_spoolss,
13111                                     NDR_SPOOLSS_56,
13112                                     &state->tmp);
13113         if (tevent_req_nomem(subreq, req)) {
13114                 return tevent_req_post(req, ev);
13115         }
13116         tevent_req_set_callback(subreq, rpccli_spoolss_56_done, req);
13117         return req;
13118 }
13119
13120 static void rpccli_spoolss_56_done(struct tevent_req *subreq)
13121 {
13122         struct tevent_req *req = tevent_req_callback_data(
13123                 subreq, struct tevent_req);
13124         struct rpccli_spoolss_56_state *state = tevent_req_data(
13125                 req, struct rpccli_spoolss_56_state);
13126         NTSTATUS status;
13127         TALLOC_CTX *mem_ctx;
13128
13129         if (state->out_mem_ctx) {
13130                 mem_ctx = state->out_mem_ctx;
13131         } else {
13132                 mem_ctx = state;
13133         }
13134
13135         status = state->dispatch_recv(subreq, mem_ctx);
13136         TALLOC_FREE(subreq);
13137         if (!NT_STATUS_IS_OK(status)) {
13138                 tevent_req_nterror(req, status);
13139                 return;
13140         }
13141
13142         /* Copy out parameters */
13143
13144         /* Copy result */
13145         state->orig.out.result = state->tmp.out.result;
13146
13147         /* Reset temporary structure */
13148         ZERO_STRUCT(state->tmp);
13149
13150         tevent_req_done(req);
13151 }
13152
13153 NTSTATUS rpccli_spoolss_56_recv(struct tevent_req *req,
13154                                 TALLOC_CTX *mem_ctx,
13155                                 WERROR *result)
13156 {
13157         struct rpccli_spoolss_56_state *state = tevent_req_data(
13158                 req, struct rpccli_spoolss_56_state);
13159         NTSTATUS status;
13160
13161         if (tevent_req_is_nterror(req, &status)) {
13162                 tevent_req_received(req);
13163                 return status;
13164         }
13165
13166         /* Steal possbile out parameters to the callers context */
13167         talloc_steal(mem_ctx, state->out_mem_ctx);
13168
13169         /* Return result */
13170         *result = state->orig.out.result;
13171
13172         tevent_req_received(req);
13173         return NT_STATUS_OK;
13174 }
13175
13176 NTSTATUS rpccli_spoolss_56(struct rpc_pipe_client *cli,
13177                            TALLOC_CTX *mem_ctx,
13178                            WERROR *werror)
13179 {
13180         struct spoolss_56 r;
13181         NTSTATUS status;
13182
13183         /* In parameters */
13184
13185         status = cli->dispatch(cli,
13186                                 mem_ctx,
13187                                 &ndr_table_spoolss,
13188                                 NDR_SPOOLSS_56,
13189                                 &r);
13190
13191         if (!NT_STATUS_IS_OK(status)) {
13192                 return status;
13193         }
13194
13195         if (NT_STATUS_IS_ERR(status)) {
13196                 return status;
13197         }
13198
13199         /* Return variables */
13200
13201         /* Return result */
13202         if (werror) {
13203                 *werror = r.out.result;
13204         }
13205
13206         return werror_to_ntstatus(r.out.result);
13207 }
13208
13209 struct rpccli_spoolss_57_state {
13210         struct spoolss_57 orig;
13211         struct spoolss_57 tmp;
13212         TALLOC_CTX *out_mem_ctx;
13213         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13214 };
13215
13216 static void rpccli_spoolss_57_done(struct tevent_req *subreq);
13217
13218 struct tevent_req *rpccli_spoolss_57_send(TALLOC_CTX *mem_ctx,
13219                                           struct tevent_context *ev,
13220                                           struct rpc_pipe_client *cli)
13221 {
13222         struct tevent_req *req;
13223         struct rpccli_spoolss_57_state *state;
13224         struct tevent_req *subreq;
13225
13226         req = tevent_req_create(mem_ctx, &state,
13227                                 struct rpccli_spoolss_57_state);
13228         if (req == NULL) {
13229                 return NULL;
13230         }
13231         state->out_mem_ctx = NULL;
13232         state->dispatch_recv = cli->dispatch_recv;
13233
13234         /* In parameters */
13235
13236         /* Out parameters */
13237
13238         /* Result */
13239         ZERO_STRUCT(state->orig.out.result);
13240
13241         /* make a temporary copy, that we pass to the dispatch function */
13242         state->tmp = state->orig;
13243
13244         subreq = cli->dispatch_send(state, ev, cli,
13245                                     &ndr_table_spoolss,
13246                                     NDR_SPOOLSS_57,
13247                                     &state->tmp);
13248         if (tevent_req_nomem(subreq, req)) {
13249                 return tevent_req_post(req, ev);
13250         }
13251         tevent_req_set_callback(subreq, rpccli_spoolss_57_done, req);
13252         return req;
13253 }
13254
13255 static void rpccli_spoolss_57_done(struct tevent_req *subreq)
13256 {
13257         struct tevent_req *req = tevent_req_callback_data(
13258                 subreq, struct tevent_req);
13259         struct rpccli_spoolss_57_state *state = tevent_req_data(
13260                 req, struct rpccli_spoolss_57_state);
13261         NTSTATUS status;
13262         TALLOC_CTX *mem_ctx;
13263
13264         if (state->out_mem_ctx) {
13265                 mem_ctx = state->out_mem_ctx;
13266         } else {
13267                 mem_ctx = state;
13268         }
13269
13270         status = state->dispatch_recv(subreq, mem_ctx);
13271         TALLOC_FREE(subreq);
13272         if (!NT_STATUS_IS_OK(status)) {
13273                 tevent_req_nterror(req, status);
13274                 return;
13275         }
13276
13277         /* Copy out parameters */
13278
13279         /* Copy result */
13280         state->orig.out.result = state->tmp.out.result;
13281
13282         /* Reset temporary structure */
13283         ZERO_STRUCT(state->tmp);
13284
13285         tevent_req_done(req);
13286 }
13287
13288 NTSTATUS rpccli_spoolss_57_recv(struct tevent_req *req,
13289                                 TALLOC_CTX *mem_ctx,
13290                                 WERROR *result)
13291 {
13292         struct rpccli_spoolss_57_state *state = tevent_req_data(
13293                 req, struct rpccli_spoolss_57_state);
13294         NTSTATUS status;
13295
13296         if (tevent_req_is_nterror(req, &status)) {
13297                 tevent_req_received(req);
13298                 return status;
13299         }
13300
13301         /* Steal possbile out parameters to the callers context */
13302         talloc_steal(mem_ctx, state->out_mem_ctx);
13303
13304         /* Return result */
13305         *result = state->orig.out.result;
13306
13307         tevent_req_received(req);
13308         return NT_STATUS_OK;
13309 }
13310
13311 NTSTATUS rpccli_spoolss_57(struct rpc_pipe_client *cli,
13312                            TALLOC_CTX *mem_ctx,
13313                            WERROR *werror)
13314 {
13315         struct spoolss_57 r;
13316         NTSTATUS status;
13317
13318         /* In parameters */
13319
13320         status = cli->dispatch(cli,
13321                                 mem_ctx,
13322                                 &ndr_table_spoolss,
13323                                 NDR_SPOOLSS_57,
13324                                 &r);
13325
13326         if (!NT_STATUS_IS_OK(status)) {
13327                 return status;
13328         }
13329
13330         if (NT_STATUS_IS_ERR(status)) {
13331                 return status;
13332         }
13333
13334         /* Return variables */
13335
13336         /* Return result */
13337         if (werror) {
13338                 *werror = r.out.result;
13339         }
13340
13341         return werror_to_ntstatus(r.out.result);
13342 }
13343
13344 struct rpccli_spoolss_XcvData_state {
13345         struct spoolss_XcvData orig;
13346         struct spoolss_XcvData tmp;
13347         TALLOC_CTX *out_mem_ctx;
13348         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13349 };
13350
13351 static void rpccli_spoolss_XcvData_done(struct tevent_req *subreq);
13352
13353 struct tevent_req *rpccli_spoolss_XcvData_send(TALLOC_CTX *mem_ctx,
13354                                                struct tevent_context *ev,
13355                                                struct rpc_pipe_client *cli,
13356                                                struct policy_handle *_handle /* [in] [ref] */,
13357                                                const char *_function_name /* [in] [charset(UTF16)] */,
13358                                                DATA_BLOB _in_data /* [in]  */,
13359                                                uint32_t __in_data_length /* [in] [value(r->in.in_data.length)] */,
13360                                                uint8_t *_out_data /* [out] [ref,size_is(out_data_size)] */,
13361                                                uint32_t _out_data_size /* [in]  */,
13362                                                uint32_t *_needed /* [out] [ref] */,
13363                                                uint32_t *_status_code /* [in,out] [ref] */)
13364 {
13365         struct tevent_req *req;
13366         struct rpccli_spoolss_XcvData_state *state;
13367         struct tevent_req *subreq;
13368
13369         req = tevent_req_create(mem_ctx, &state,
13370                                 struct rpccli_spoolss_XcvData_state);
13371         if (req == NULL) {
13372                 return NULL;
13373         }
13374         state->out_mem_ctx = NULL;
13375         state->dispatch_recv = cli->dispatch_recv;
13376
13377         /* In parameters */
13378         state->orig.in.handle = _handle;
13379         state->orig.in.function_name = _function_name;
13380         state->orig.in.in_data = _in_data;
13381         state->orig.in._in_data_length = __in_data_length;
13382         state->orig.in.out_data_size = _out_data_size;
13383         state->orig.in.status_code = _status_code;
13384
13385         /* Out parameters */
13386         state->orig.out.out_data = _out_data;
13387         state->orig.out.needed = _needed;
13388         state->orig.out.status_code = _status_code;
13389
13390         /* Result */
13391         ZERO_STRUCT(state->orig.out.result);
13392
13393         state->out_mem_ctx = talloc_named_const(state, 0,
13394                              "rpccli_spoolss_XcvData_out_memory");
13395         if (tevent_req_nomem(state->out_mem_ctx, req)) {
13396                 return tevent_req_post(req, ev);
13397         }
13398
13399         /* make a temporary copy, that we pass to the dispatch function */
13400         state->tmp = state->orig;
13401
13402         subreq = cli->dispatch_send(state, ev, cli,
13403                                     &ndr_table_spoolss,
13404                                     NDR_SPOOLSS_XCVDATA,
13405                                     &state->tmp);
13406         if (tevent_req_nomem(subreq, req)) {
13407                 return tevent_req_post(req, ev);
13408         }
13409         tevent_req_set_callback(subreq, rpccli_spoolss_XcvData_done, req);
13410         return req;
13411 }
13412
13413 static void rpccli_spoolss_XcvData_done(struct tevent_req *subreq)
13414 {
13415         struct tevent_req *req = tevent_req_callback_data(
13416                 subreq, struct tevent_req);
13417         struct rpccli_spoolss_XcvData_state *state = tevent_req_data(
13418                 req, struct rpccli_spoolss_XcvData_state);
13419         NTSTATUS status;
13420         TALLOC_CTX *mem_ctx;
13421
13422         if (state->out_mem_ctx) {
13423                 mem_ctx = state->out_mem_ctx;
13424         } else {
13425                 mem_ctx = state;
13426         }
13427
13428         status = state->dispatch_recv(subreq, mem_ctx);
13429         TALLOC_FREE(subreq);
13430         if (!NT_STATUS_IS_OK(status)) {
13431                 tevent_req_nterror(req, status);
13432                 return;
13433         }
13434
13435         /* Copy out parameters */
13436         memcpy(state->orig.out.out_data, state->tmp.out.out_data, (state->tmp.in.out_data_size) * sizeof(*state->orig.out.out_data));
13437         *state->orig.out.needed = *state->tmp.out.needed;
13438         *state->orig.out.status_code = *state->tmp.out.status_code;
13439
13440         /* Copy result */
13441         state->orig.out.result = state->tmp.out.result;
13442
13443         /* Reset temporary structure */
13444         ZERO_STRUCT(state->tmp);
13445
13446         tevent_req_done(req);
13447 }
13448
13449 NTSTATUS rpccli_spoolss_XcvData_recv(struct tevent_req *req,
13450                                      TALLOC_CTX *mem_ctx,
13451                                      WERROR *result)
13452 {
13453         struct rpccli_spoolss_XcvData_state *state = tevent_req_data(
13454                 req, struct rpccli_spoolss_XcvData_state);
13455         NTSTATUS status;
13456
13457         if (tevent_req_is_nterror(req, &status)) {
13458                 tevent_req_received(req);
13459                 return status;
13460         }
13461
13462         /* Steal possbile out parameters to the callers context */
13463         talloc_steal(mem_ctx, state->out_mem_ctx);
13464
13465         /* Return result */
13466         *result = state->orig.out.result;
13467
13468         tevent_req_received(req);
13469         return NT_STATUS_OK;
13470 }
13471
13472 NTSTATUS rpccli_spoolss_XcvData(struct rpc_pipe_client *cli,
13473                                 TALLOC_CTX *mem_ctx,
13474                                 struct policy_handle *handle /* [in] [ref] */,
13475                                 const char *function_name /* [in] [charset(UTF16)] */,
13476                                 DATA_BLOB in_data /* [in]  */,
13477                                 uint32_t _in_data_length /* [in] [value(r->in.in_data.length)] */,
13478                                 uint8_t *out_data /* [out] [ref,size_is(out_data_size)] */,
13479                                 uint32_t out_data_size /* [in]  */,
13480                                 uint32_t *needed /* [out] [ref] */,
13481                                 uint32_t *status_code /* [in,out] [ref] */,
13482                                 WERROR *werror)
13483 {
13484         struct spoolss_XcvData r;
13485         NTSTATUS status;
13486
13487         /* In parameters */
13488         r.in.handle = handle;
13489         r.in.function_name = function_name;
13490         r.in.in_data = in_data;
13491         r.in._in_data_length = _in_data_length;
13492         r.in.out_data_size = out_data_size;
13493         r.in.status_code = status_code;
13494
13495         status = cli->dispatch(cli,
13496                                 mem_ctx,
13497                                 &ndr_table_spoolss,
13498                                 NDR_SPOOLSS_XCVDATA,
13499                                 &r);
13500
13501         if (!NT_STATUS_IS_OK(status)) {
13502                 return status;
13503         }
13504
13505         if (NT_STATUS_IS_ERR(status)) {
13506                 return status;
13507         }
13508
13509         /* Return variables */
13510         memcpy(out_data, r.out.out_data, (r.in.out_data_size) * sizeof(*out_data));
13511         *needed = *r.out.needed;
13512         *status_code = *r.out.status_code;
13513
13514         /* Return result */
13515         if (werror) {
13516                 *werror = r.out.result;
13517         }
13518
13519         return werror_to_ntstatus(r.out.result);
13520 }
13521
13522 struct rpccli_spoolss_AddPrinterDriverEx_state {
13523         struct spoolss_AddPrinterDriverEx orig;
13524         struct spoolss_AddPrinterDriverEx tmp;
13525         TALLOC_CTX *out_mem_ctx;
13526         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13527 };
13528
13529 static void rpccli_spoolss_AddPrinterDriverEx_done(struct tevent_req *subreq);
13530
13531 struct tevent_req *rpccli_spoolss_AddPrinterDriverEx_send(TALLOC_CTX *mem_ctx,
13532                                                           struct tevent_context *ev,
13533                                                           struct rpc_pipe_client *cli,
13534                                                           const char *_servername /* [in] [unique,charset(UTF16)] */,
13535                                                           struct spoolss_AddDriverInfoCtr *_info_ctr /* [in] [ref] */,
13536                                                           uint32_t _flags /* [in]  */)
13537 {
13538         struct tevent_req *req;
13539         struct rpccli_spoolss_AddPrinterDriverEx_state *state;
13540         struct tevent_req *subreq;
13541
13542         req = tevent_req_create(mem_ctx, &state,
13543                                 struct rpccli_spoolss_AddPrinterDriverEx_state);
13544         if (req == NULL) {
13545                 return NULL;
13546         }
13547         state->out_mem_ctx = NULL;
13548         state->dispatch_recv = cli->dispatch_recv;
13549
13550         /* In parameters */
13551         state->orig.in.servername = _servername;
13552         state->orig.in.info_ctr = _info_ctr;
13553         state->orig.in.flags = _flags;
13554
13555         /* Out parameters */
13556
13557         /* Result */
13558         ZERO_STRUCT(state->orig.out.result);
13559
13560         /* make a temporary copy, that we pass to the dispatch function */
13561         state->tmp = state->orig;
13562
13563         subreq = cli->dispatch_send(state, ev, cli,
13564                                     &ndr_table_spoolss,
13565                                     NDR_SPOOLSS_ADDPRINTERDRIVEREX,
13566                                     &state->tmp);
13567         if (tevent_req_nomem(subreq, req)) {
13568                 return tevent_req_post(req, ev);
13569         }
13570         tevent_req_set_callback(subreq, rpccli_spoolss_AddPrinterDriverEx_done, req);
13571         return req;
13572 }
13573
13574 static void rpccli_spoolss_AddPrinterDriverEx_done(struct tevent_req *subreq)
13575 {
13576         struct tevent_req *req = tevent_req_callback_data(
13577                 subreq, struct tevent_req);
13578         struct rpccli_spoolss_AddPrinterDriverEx_state *state = tevent_req_data(
13579                 req, struct rpccli_spoolss_AddPrinterDriverEx_state);
13580         NTSTATUS status;
13581         TALLOC_CTX *mem_ctx;
13582
13583         if (state->out_mem_ctx) {
13584                 mem_ctx = state->out_mem_ctx;
13585         } else {
13586                 mem_ctx = state;
13587         }
13588
13589         status = state->dispatch_recv(subreq, mem_ctx);
13590         TALLOC_FREE(subreq);
13591         if (!NT_STATUS_IS_OK(status)) {
13592                 tevent_req_nterror(req, status);
13593                 return;
13594         }
13595
13596         /* Copy out parameters */
13597
13598         /* Copy result */
13599         state->orig.out.result = state->tmp.out.result;
13600
13601         /* Reset temporary structure */
13602         ZERO_STRUCT(state->tmp);
13603
13604         tevent_req_done(req);
13605 }
13606
13607 NTSTATUS rpccli_spoolss_AddPrinterDriverEx_recv(struct tevent_req *req,
13608                                                 TALLOC_CTX *mem_ctx,
13609                                                 WERROR *result)
13610 {
13611         struct rpccli_spoolss_AddPrinterDriverEx_state *state = tevent_req_data(
13612                 req, struct rpccli_spoolss_AddPrinterDriverEx_state);
13613         NTSTATUS status;
13614
13615         if (tevent_req_is_nterror(req, &status)) {
13616                 tevent_req_received(req);
13617                 return status;
13618         }
13619
13620         /* Steal possbile out parameters to the callers context */
13621         talloc_steal(mem_ctx, state->out_mem_ctx);
13622
13623         /* Return result */
13624         *result = state->orig.out.result;
13625
13626         tevent_req_received(req);
13627         return NT_STATUS_OK;
13628 }
13629
13630 NTSTATUS rpccli_spoolss_AddPrinterDriverEx(struct rpc_pipe_client *cli,
13631                                            TALLOC_CTX *mem_ctx,
13632                                            const char *servername /* [in] [unique,charset(UTF16)] */,
13633                                            struct spoolss_AddDriverInfoCtr *info_ctr /* [in] [ref] */,
13634                                            uint32_t flags /* [in]  */,
13635                                            WERROR *werror)
13636 {
13637         struct spoolss_AddPrinterDriverEx r;
13638         NTSTATUS status;
13639
13640         /* In parameters */
13641         r.in.servername = servername;
13642         r.in.info_ctr = info_ctr;
13643         r.in.flags = flags;
13644
13645         status = cli->dispatch(cli,
13646                                 mem_ctx,
13647                                 &ndr_table_spoolss,
13648                                 NDR_SPOOLSS_ADDPRINTERDRIVEREX,
13649                                 &r);
13650
13651         if (!NT_STATUS_IS_OK(status)) {
13652                 return status;
13653         }
13654
13655         if (NT_STATUS_IS_ERR(status)) {
13656                 return status;
13657         }
13658
13659         /* Return variables */
13660
13661         /* Return result */
13662         if (werror) {
13663                 *werror = r.out.result;
13664         }
13665
13666         return werror_to_ntstatus(r.out.result);
13667 }
13668
13669 struct rpccli_spoolss_5a_state {
13670         struct spoolss_5a orig;
13671         struct spoolss_5a tmp;
13672         TALLOC_CTX *out_mem_ctx;
13673         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13674 };
13675
13676 static void rpccli_spoolss_5a_done(struct tevent_req *subreq);
13677
13678 struct tevent_req *rpccli_spoolss_5a_send(TALLOC_CTX *mem_ctx,
13679                                           struct tevent_context *ev,
13680                                           struct rpc_pipe_client *cli)
13681 {
13682         struct tevent_req *req;
13683         struct rpccli_spoolss_5a_state *state;
13684         struct tevent_req *subreq;
13685
13686         req = tevent_req_create(mem_ctx, &state,
13687                                 struct rpccli_spoolss_5a_state);
13688         if (req == NULL) {
13689                 return NULL;
13690         }
13691         state->out_mem_ctx = NULL;
13692         state->dispatch_recv = cli->dispatch_recv;
13693
13694         /* In parameters */
13695
13696         /* Out parameters */
13697
13698         /* Result */
13699         ZERO_STRUCT(state->orig.out.result);
13700
13701         /* make a temporary copy, that we pass to the dispatch function */
13702         state->tmp = state->orig;
13703
13704         subreq = cli->dispatch_send(state, ev, cli,
13705                                     &ndr_table_spoolss,
13706                                     NDR_SPOOLSS_5A,
13707                                     &state->tmp);
13708         if (tevent_req_nomem(subreq, req)) {
13709                 return tevent_req_post(req, ev);
13710         }
13711         tevent_req_set_callback(subreq, rpccli_spoolss_5a_done, req);
13712         return req;
13713 }
13714
13715 static void rpccli_spoolss_5a_done(struct tevent_req *subreq)
13716 {
13717         struct tevent_req *req = tevent_req_callback_data(
13718                 subreq, struct tevent_req);
13719         struct rpccli_spoolss_5a_state *state = tevent_req_data(
13720                 req, struct rpccli_spoolss_5a_state);
13721         NTSTATUS status;
13722         TALLOC_CTX *mem_ctx;
13723
13724         if (state->out_mem_ctx) {
13725                 mem_ctx = state->out_mem_ctx;
13726         } else {
13727                 mem_ctx = state;
13728         }
13729
13730         status = state->dispatch_recv(subreq, mem_ctx);
13731         TALLOC_FREE(subreq);
13732         if (!NT_STATUS_IS_OK(status)) {
13733                 tevent_req_nterror(req, status);
13734                 return;
13735         }
13736
13737         /* Copy out parameters */
13738
13739         /* Copy result */
13740         state->orig.out.result = state->tmp.out.result;
13741
13742         /* Reset temporary structure */
13743         ZERO_STRUCT(state->tmp);
13744
13745         tevent_req_done(req);
13746 }
13747
13748 NTSTATUS rpccli_spoolss_5a_recv(struct tevent_req *req,
13749                                 TALLOC_CTX *mem_ctx,
13750                                 WERROR *result)
13751 {
13752         struct rpccli_spoolss_5a_state *state = tevent_req_data(
13753                 req, struct rpccli_spoolss_5a_state);
13754         NTSTATUS status;
13755
13756         if (tevent_req_is_nterror(req, &status)) {
13757                 tevent_req_received(req);
13758                 return status;
13759         }
13760
13761         /* Steal possbile out parameters to the callers context */
13762         talloc_steal(mem_ctx, state->out_mem_ctx);
13763
13764         /* Return result */
13765         *result = state->orig.out.result;
13766
13767         tevent_req_received(req);
13768         return NT_STATUS_OK;
13769 }
13770
13771 NTSTATUS rpccli_spoolss_5a(struct rpc_pipe_client *cli,
13772                            TALLOC_CTX *mem_ctx,
13773                            WERROR *werror)
13774 {
13775         struct spoolss_5a r;
13776         NTSTATUS status;
13777
13778         /* In parameters */
13779
13780         status = cli->dispatch(cli,
13781                                 mem_ctx,
13782                                 &ndr_table_spoolss,
13783                                 NDR_SPOOLSS_5A,
13784                                 &r);
13785
13786         if (!NT_STATUS_IS_OK(status)) {
13787                 return status;
13788         }
13789
13790         if (NT_STATUS_IS_ERR(status)) {
13791                 return status;
13792         }
13793
13794         /* Return variables */
13795
13796         /* Return result */
13797         if (werror) {
13798                 *werror = r.out.result;
13799         }
13800
13801         return werror_to_ntstatus(r.out.result);
13802 }
13803
13804 struct rpccli_spoolss_5b_state {
13805         struct spoolss_5b orig;
13806         struct spoolss_5b tmp;
13807         TALLOC_CTX *out_mem_ctx;
13808         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13809 };
13810
13811 static void rpccli_spoolss_5b_done(struct tevent_req *subreq);
13812
13813 struct tevent_req *rpccli_spoolss_5b_send(TALLOC_CTX *mem_ctx,
13814                                           struct tevent_context *ev,
13815                                           struct rpc_pipe_client *cli)
13816 {
13817         struct tevent_req *req;
13818         struct rpccli_spoolss_5b_state *state;
13819         struct tevent_req *subreq;
13820
13821         req = tevent_req_create(mem_ctx, &state,
13822                                 struct rpccli_spoolss_5b_state);
13823         if (req == NULL) {
13824                 return NULL;
13825         }
13826         state->out_mem_ctx = NULL;
13827         state->dispatch_recv = cli->dispatch_recv;
13828
13829         /* In parameters */
13830
13831         /* Out parameters */
13832
13833         /* Result */
13834         ZERO_STRUCT(state->orig.out.result);
13835
13836         /* make a temporary copy, that we pass to the dispatch function */
13837         state->tmp = state->orig;
13838
13839         subreq = cli->dispatch_send(state, ev, cli,
13840                                     &ndr_table_spoolss,
13841                                     NDR_SPOOLSS_5B,
13842                                     &state->tmp);
13843         if (tevent_req_nomem(subreq, req)) {
13844                 return tevent_req_post(req, ev);
13845         }
13846         tevent_req_set_callback(subreq, rpccli_spoolss_5b_done, req);
13847         return req;
13848 }
13849
13850 static void rpccli_spoolss_5b_done(struct tevent_req *subreq)
13851 {
13852         struct tevent_req *req = tevent_req_callback_data(
13853                 subreq, struct tevent_req);
13854         struct rpccli_spoolss_5b_state *state = tevent_req_data(
13855                 req, struct rpccli_spoolss_5b_state);
13856         NTSTATUS status;
13857         TALLOC_CTX *mem_ctx;
13858
13859         if (state->out_mem_ctx) {
13860                 mem_ctx = state->out_mem_ctx;
13861         } else {
13862                 mem_ctx = state;
13863         }
13864
13865         status = state->dispatch_recv(subreq, mem_ctx);
13866         TALLOC_FREE(subreq);
13867         if (!NT_STATUS_IS_OK(status)) {
13868                 tevent_req_nterror(req, status);
13869                 return;
13870         }
13871
13872         /* Copy out parameters */
13873
13874         /* Copy result */
13875         state->orig.out.result = state->tmp.out.result;
13876
13877         /* Reset temporary structure */
13878         ZERO_STRUCT(state->tmp);
13879
13880         tevent_req_done(req);
13881 }
13882
13883 NTSTATUS rpccli_spoolss_5b_recv(struct tevent_req *req,
13884                                 TALLOC_CTX *mem_ctx,
13885                                 WERROR *result)
13886 {
13887         struct rpccli_spoolss_5b_state *state = tevent_req_data(
13888                 req, struct rpccli_spoolss_5b_state);
13889         NTSTATUS status;
13890
13891         if (tevent_req_is_nterror(req, &status)) {
13892                 tevent_req_received(req);
13893                 return status;
13894         }
13895
13896         /* Steal possbile out parameters to the callers context */
13897         talloc_steal(mem_ctx, state->out_mem_ctx);
13898
13899         /* Return result */
13900         *result = state->orig.out.result;
13901
13902         tevent_req_received(req);
13903         return NT_STATUS_OK;
13904 }
13905
13906 NTSTATUS rpccli_spoolss_5b(struct rpc_pipe_client *cli,
13907                            TALLOC_CTX *mem_ctx,
13908                            WERROR *werror)
13909 {
13910         struct spoolss_5b r;
13911         NTSTATUS status;
13912
13913         /* In parameters */
13914
13915         status = cli->dispatch(cli,
13916                                 mem_ctx,
13917                                 &ndr_table_spoolss,
13918                                 NDR_SPOOLSS_5B,
13919                                 &r);
13920
13921         if (!NT_STATUS_IS_OK(status)) {
13922                 return status;
13923         }
13924
13925         if (NT_STATUS_IS_ERR(status)) {
13926                 return status;
13927         }
13928
13929         /* Return variables */
13930
13931         /* Return result */
13932         if (werror) {
13933                 *werror = r.out.result;
13934         }
13935
13936         return werror_to_ntstatus(r.out.result);
13937 }
13938
13939 struct rpccli_spoolss_5c_state {
13940         struct spoolss_5c orig;
13941         struct spoolss_5c tmp;
13942         TALLOC_CTX *out_mem_ctx;
13943         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
13944 };
13945
13946 static void rpccli_spoolss_5c_done(struct tevent_req *subreq);
13947
13948 struct tevent_req *rpccli_spoolss_5c_send(TALLOC_CTX *mem_ctx,
13949                                           struct tevent_context *ev,
13950                                           struct rpc_pipe_client *cli)
13951 {
13952         struct tevent_req *req;
13953         struct rpccli_spoolss_5c_state *state;
13954         struct tevent_req *subreq;
13955
13956         req = tevent_req_create(mem_ctx, &state,
13957                                 struct rpccli_spoolss_5c_state);
13958         if (req == NULL) {
13959                 return NULL;
13960         }
13961         state->out_mem_ctx = NULL;
13962         state->dispatch_recv = cli->dispatch_recv;
13963
13964         /* In parameters */
13965
13966         /* Out parameters */
13967
13968         /* Result */
13969         ZERO_STRUCT(state->orig.out.result);
13970
13971         /* make a temporary copy, that we pass to the dispatch function */
13972         state->tmp = state->orig;
13973
13974         subreq = cli->dispatch_send(state, ev, cli,
13975                                     &ndr_table_spoolss,
13976                                     NDR_SPOOLSS_5C,
13977                                     &state->tmp);
13978         if (tevent_req_nomem(subreq, req)) {
13979                 return tevent_req_post(req, ev);
13980         }
13981         tevent_req_set_callback(subreq, rpccli_spoolss_5c_done, req);
13982         return req;
13983 }
13984
13985 static void rpccli_spoolss_5c_done(struct tevent_req *subreq)
13986 {
13987         struct tevent_req *req = tevent_req_callback_data(
13988                 subreq, struct tevent_req);
13989         struct rpccli_spoolss_5c_state *state = tevent_req_data(
13990                 req, struct rpccli_spoolss_5c_state);
13991         NTSTATUS status;
13992         TALLOC_CTX *mem_ctx;
13993
13994         if (state->out_mem_ctx) {
13995                 mem_ctx = state->out_mem_ctx;
13996         } else {
13997                 mem_ctx = state;
13998         }
13999
14000         status = state->dispatch_recv(subreq, mem_ctx);
14001         TALLOC_FREE(subreq);
14002         if (!NT_STATUS_IS_OK(status)) {
14003                 tevent_req_nterror(req, status);
14004                 return;
14005         }
14006
14007         /* Copy out parameters */
14008
14009         /* Copy result */
14010         state->orig.out.result = state->tmp.out.result;
14011
14012         /* Reset temporary structure */
14013         ZERO_STRUCT(state->tmp);
14014
14015         tevent_req_done(req);
14016 }
14017
14018 NTSTATUS rpccli_spoolss_5c_recv(struct tevent_req *req,
14019                                 TALLOC_CTX *mem_ctx,
14020                                 WERROR *result)
14021 {
14022         struct rpccli_spoolss_5c_state *state = tevent_req_data(
14023                 req, struct rpccli_spoolss_5c_state);
14024         NTSTATUS status;
14025
14026         if (tevent_req_is_nterror(req, &status)) {
14027                 tevent_req_received(req);
14028                 return status;
14029         }
14030
14031         /* Steal possbile out parameters to the callers context */
14032         talloc_steal(mem_ctx, state->out_mem_ctx);
14033
14034         /* Return result */
14035         *result = state->orig.out.result;
14036
14037         tevent_req_received(req);
14038         return NT_STATUS_OK;
14039 }
14040
14041 NTSTATUS rpccli_spoolss_5c(struct rpc_pipe_client *cli,
14042                            TALLOC_CTX *mem_ctx,
14043                            WERROR *werror)
14044 {
14045         struct spoolss_5c r;
14046         NTSTATUS status;
14047
14048         /* In parameters */
14049
14050         status = cli->dispatch(cli,
14051                                 mem_ctx,
14052                                 &ndr_table_spoolss,
14053                                 NDR_SPOOLSS_5C,
14054                                 &r);
14055
14056         if (!NT_STATUS_IS_OK(status)) {
14057                 return status;
14058         }
14059
14060         if (NT_STATUS_IS_ERR(status)) {
14061                 return status;
14062         }
14063
14064         /* Return variables */
14065
14066         /* Return result */
14067         if (werror) {
14068                 *werror = r.out.result;
14069         }
14070
14071         return werror_to_ntstatus(r.out.result);
14072 }
14073
14074 struct rpccli_spoolss_5d_state {
14075         struct spoolss_5d orig;
14076         struct spoolss_5d tmp;
14077         TALLOC_CTX *out_mem_ctx;
14078         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14079 };
14080
14081 static void rpccli_spoolss_5d_done(struct tevent_req *subreq);
14082
14083 struct tevent_req *rpccli_spoolss_5d_send(TALLOC_CTX *mem_ctx,
14084                                           struct tevent_context *ev,
14085                                           struct rpc_pipe_client *cli)
14086 {
14087         struct tevent_req *req;
14088         struct rpccli_spoolss_5d_state *state;
14089         struct tevent_req *subreq;
14090
14091         req = tevent_req_create(mem_ctx, &state,
14092                                 struct rpccli_spoolss_5d_state);
14093         if (req == NULL) {
14094                 return NULL;
14095         }
14096         state->out_mem_ctx = NULL;
14097         state->dispatch_recv = cli->dispatch_recv;
14098
14099         /* In parameters */
14100
14101         /* Out parameters */
14102
14103         /* Result */
14104         ZERO_STRUCT(state->orig.out.result);
14105
14106         /* make a temporary copy, that we pass to the dispatch function */
14107         state->tmp = state->orig;
14108
14109         subreq = cli->dispatch_send(state, ev, cli,
14110                                     &ndr_table_spoolss,
14111                                     NDR_SPOOLSS_5D,
14112                                     &state->tmp);
14113         if (tevent_req_nomem(subreq, req)) {
14114                 return tevent_req_post(req, ev);
14115         }
14116         tevent_req_set_callback(subreq, rpccli_spoolss_5d_done, req);
14117         return req;
14118 }
14119
14120 static void rpccli_spoolss_5d_done(struct tevent_req *subreq)
14121 {
14122         struct tevent_req *req = tevent_req_callback_data(
14123                 subreq, struct tevent_req);
14124         struct rpccli_spoolss_5d_state *state = tevent_req_data(
14125                 req, struct rpccli_spoolss_5d_state);
14126         NTSTATUS status;
14127         TALLOC_CTX *mem_ctx;
14128
14129         if (state->out_mem_ctx) {
14130                 mem_ctx = state->out_mem_ctx;
14131         } else {
14132                 mem_ctx = state;
14133         }
14134
14135         status = state->dispatch_recv(subreq, mem_ctx);
14136         TALLOC_FREE(subreq);
14137         if (!NT_STATUS_IS_OK(status)) {
14138                 tevent_req_nterror(req, status);
14139                 return;
14140         }
14141
14142         /* Copy out parameters */
14143
14144         /* Copy result */
14145         state->orig.out.result = state->tmp.out.result;
14146
14147         /* Reset temporary structure */
14148         ZERO_STRUCT(state->tmp);
14149
14150         tevent_req_done(req);
14151 }
14152
14153 NTSTATUS rpccli_spoolss_5d_recv(struct tevent_req *req,
14154                                 TALLOC_CTX *mem_ctx,
14155                                 WERROR *result)
14156 {
14157         struct rpccli_spoolss_5d_state *state = tevent_req_data(
14158                 req, struct rpccli_spoolss_5d_state);
14159         NTSTATUS status;
14160
14161         if (tevent_req_is_nterror(req, &status)) {
14162                 tevent_req_received(req);
14163                 return status;
14164         }
14165
14166         /* Steal possbile out parameters to the callers context */
14167         talloc_steal(mem_ctx, state->out_mem_ctx);
14168
14169         /* Return result */
14170         *result = state->orig.out.result;
14171
14172         tevent_req_received(req);
14173         return NT_STATUS_OK;
14174 }
14175
14176 NTSTATUS rpccli_spoolss_5d(struct rpc_pipe_client *cli,
14177                            TALLOC_CTX *mem_ctx,
14178                            WERROR *werror)
14179 {
14180         struct spoolss_5d r;
14181         NTSTATUS status;
14182
14183         /* In parameters */
14184
14185         status = cli->dispatch(cli,
14186                                 mem_ctx,
14187                                 &ndr_table_spoolss,
14188                                 NDR_SPOOLSS_5D,
14189                                 &r);
14190
14191         if (!NT_STATUS_IS_OK(status)) {
14192                 return status;
14193         }
14194
14195         if (NT_STATUS_IS_ERR(status)) {
14196                 return status;
14197         }
14198
14199         /* Return variables */
14200
14201         /* Return result */
14202         if (werror) {
14203                 *werror = r.out.result;
14204         }
14205
14206         return werror_to_ntstatus(r.out.result);
14207 }
14208
14209 struct rpccli_spoolss_5e_state {
14210         struct spoolss_5e orig;
14211         struct spoolss_5e tmp;
14212         TALLOC_CTX *out_mem_ctx;
14213         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14214 };
14215
14216 static void rpccli_spoolss_5e_done(struct tevent_req *subreq);
14217
14218 struct tevent_req *rpccli_spoolss_5e_send(TALLOC_CTX *mem_ctx,
14219                                           struct tevent_context *ev,
14220                                           struct rpc_pipe_client *cli)
14221 {
14222         struct tevent_req *req;
14223         struct rpccli_spoolss_5e_state *state;
14224         struct tevent_req *subreq;
14225
14226         req = tevent_req_create(mem_ctx, &state,
14227                                 struct rpccli_spoolss_5e_state);
14228         if (req == NULL) {
14229                 return NULL;
14230         }
14231         state->out_mem_ctx = NULL;
14232         state->dispatch_recv = cli->dispatch_recv;
14233
14234         /* In parameters */
14235
14236         /* Out parameters */
14237
14238         /* Result */
14239         ZERO_STRUCT(state->orig.out.result);
14240
14241         /* make a temporary copy, that we pass to the dispatch function */
14242         state->tmp = state->orig;
14243
14244         subreq = cli->dispatch_send(state, ev, cli,
14245                                     &ndr_table_spoolss,
14246                                     NDR_SPOOLSS_5E,
14247                                     &state->tmp);
14248         if (tevent_req_nomem(subreq, req)) {
14249                 return tevent_req_post(req, ev);
14250         }
14251         tevent_req_set_callback(subreq, rpccli_spoolss_5e_done, req);
14252         return req;
14253 }
14254
14255 static void rpccli_spoolss_5e_done(struct tevent_req *subreq)
14256 {
14257         struct tevent_req *req = tevent_req_callback_data(
14258                 subreq, struct tevent_req);
14259         struct rpccli_spoolss_5e_state *state = tevent_req_data(
14260                 req, struct rpccli_spoolss_5e_state);
14261         NTSTATUS status;
14262         TALLOC_CTX *mem_ctx;
14263
14264         if (state->out_mem_ctx) {
14265                 mem_ctx = state->out_mem_ctx;
14266         } else {
14267                 mem_ctx = state;
14268         }
14269
14270         status = state->dispatch_recv(subreq, mem_ctx);
14271         TALLOC_FREE(subreq);
14272         if (!NT_STATUS_IS_OK(status)) {
14273                 tevent_req_nterror(req, status);
14274                 return;
14275         }
14276
14277         /* Copy out parameters */
14278
14279         /* Copy result */
14280         state->orig.out.result = state->tmp.out.result;
14281
14282         /* Reset temporary structure */
14283         ZERO_STRUCT(state->tmp);
14284
14285         tevent_req_done(req);
14286 }
14287
14288 NTSTATUS rpccli_spoolss_5e_recv(struct tevent_req *req,
14289                                 TALLOC_CTX *mem_ctx,
14290                                 WERROR *result)
14291 {
14292         struct rpccli_spoolss_5e_state *state = tevent_req_data(
14293                 req, struct rpccli_spoolss_5e_state);
14294         NTSTATUS status;
14295
14296         if (tevent_req_is_nterror(req, &status)) {
14297                 tevent_req_received(req);
14298                 return status;
14299         }
14300
14301         /* Steal possbile out parameters to the callers context */
14302         talloc_steal(mem_ctx, state->out_mem_ctx);
14303
14304         /* Return result */
14305         *result = state->orig.out.result;
14306
14307         tevent_req_received(req);
14308         return NT_STATUS_OK;
14309 }
14310
14311 NTSTATUS rpccli_spoolss_5e(struct rpc_pipe_client *cli,
14312                            TALLOC_CTX *mem_ctx,
14313                            WERROR *werror)
14314 {
14315         struct spoolss_5e r;
14316         NTSTATUS status;
14317
14318         /* In parameters */
14319
14320         status = cli->dispatch(cli,
14321                                 mem_ctx,
14322                                 &ndr_table_spoolss,
14323                                 NDR_SPOOLSS_5E,
14324                                 &r);
14325
14326         if (!NT_STATUS_IS_OK(status)) {
14327                 return status;
14328         }
14329
14330         if (NT_STATUS_IS_ERR(status)) {
14331                 return status;
14332         }
14333
14334         /* Return variables */
14335
14336         /* Return result */
14337         if (werror) {
14338                 *werror = r.out.result;
14339         }
14340
14341         return werror_to_ntstatus(r.out.result);
14342 }
14343
14344 struct rpccli_spoolss_5f_state {
14345         struct spoolss_5f orig;
14346         struct spoolss_5f tmp;
14347         TALLOC_CTX *out_mem_ctx;
14348         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14349 };
14350
14351 static void rpccli_spoolss_5f_done(struct tevent_req *subreq);
14352
14353 struct tevent_req *rpccli_spoolss_5f_send(TALLOC_CTX *mem_ctx,
14354                                           struct tevent_context *ev,
14355                                           struct rpc_pipe_client *cli)
14356 {
14357         struct tevent_req *req;
14358         struct rpccli_spoolss_5f_state *state;
14359         struct tevent_req *subreq;
14360
14361         req = tevent_req_create(mem_ctx, &state,
14362                                 struct rpccli_spoolss_5f_state);
14363         if (req == NULL) {
14364                 return NULL;
14365         }
14366         state->out_mem_ctx = NULL;
14367         state->dispatch_recv = cli->dispatch_recv;
14368
14369         /* In parameters */
14370
14371         /* Out parameters */
14372
14373         /* Result */
14374         ZERO_STRUCT(state->orig.out.result);
14375
14376         /* make a temporary copy, that we pass to the dispatch function */
14377         state->tmp = state->orig;
14378
14379         subreq = cli->dispatch_send(state, ev, cli,
14380                                     &ndr_table_spoolss,
14381                                     NDR_SPOOLSS_5F,
14382                                     &state->tmp);
14383         if (tevent_req_nomem(subreq, req)) {
14384                 return tevent_req_post(req, ev);
14385         }
14386         tevent_req_set_callback(subreq, rpccli_spoolss_5f_done, req);
14387         return req;
14388 }
14389
14390 static void rpccli_spoolss_5f_done(struct tevent_req *subreq)
14391 {
14392         struct tevent_req *req = tevent_req_callback_data(
14393                 subreq, struct tevent_req);
14394         struct rpccli_spoolss_5f_state *state = tevent_req_data(
14395                 req, struct rpccli_spoolss_5f_state);
14396         NTSTATUS status;
14397         TALLOC_CTX *mem_ctx;
14398
14399         if (state->out_mem_ctx) {
14400                 mem_ctx = state->out_mem_ctx;
14401         } else {
14402                 mem_ctx = state;
14403         }
14404
14405         status = state->dispatch_recv(subreq, mem_ctx);
14406         TALLOC_FREE(subreq);
14407         if (!NT_STATUS_IS_OK(status)) {
14408                 tevent_req_nterror(req, status);
14409                 return;
14410         }
14411
14412         /* Copy out parameters */
14413
14414         /* Copy result */
14415         state->orig.out.result = state->tmp.out.result;
14416
14417         /* Reset temporary structure */
14418         ZERO_STRUCT(state->tmp);
14419
14420         tevent_req_done(req);
14421 }
14422
14423 NTSTATUS rpccli_spoolss_5f_recv(struct tevent_req *req,
14424                                 TALLOC_CTX *mem_ctx,
14425                                 WERROR *result)
14426 {
14427         struct rpccli_spoolss_5f_state *state = tevent_req_data(
14428                 req, struct rpccli_spoolss_5f_state);
14429         NTSTATUS status;
14430
14431         if (tevent_req_is_nterror(req, &status)) {
14432                 tevent_req_received(req);
14433                 return status;
14434         }
14435
14436         /* Steal possbile out parameters to the callers context */
14437         talloc_steal(mem_ctx, state->out_mem_ctx);
14438
14439         /* Return result */
14440         *result = state->orig.out.result;
14441
14442         tevent_req_received(req);
14443         return NT_STATUS_OK;
14444 }
14445
14446 NTSTATUS rpccli_spoolss_5f(struct rpc_pipe_client *cli,
14447                            TALLOC_CTX *mem_ctx,
14448                            WERROR *werror)
14449 {
14450         struct spoolss_5f r;
14451         NTSTATUS status;
14452
14453         /* In parameters */
14454
14455         status = cli->dispatch(cli,
14456                                 mem_ctx,
14457                                 &ndr_table_spoolss,
14458                                 NDR_SPOOLSS_5F,
14459                                 &r);
14460
14461         if (!NT_STATUS_IS_OK(status)) {
14462                 return status;
14463         }
14464
14465         if (NT_STATUS_IS_ERR(status)) {
14466                 return status;
14467         }
14468
14469         /* Return variables */
14470
14471         /* Return result */
14472         if (werror) {
14473                 *werror = r.out.result;
14474         }
14475
14476         return werror_to_ntstatus(r.out.result);
14477 }
14478
14479 struct rpccli_spoolss_60_state {
14480         struct spoolss_60 orig;
14481         struct spoolss_60 tmp;
14482         TALLOC_CTX *out_mem_ctx;
14483         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14484 };
14485
14486 static void rpccli_spoolss_60_done(struct tevent_req *subreq);
14487
14488 struct tevent_req *rpccli_spoolss_60_send(TALLOC_CTX *mem_ctx,
14489                                           struct tevent_context *ev,
14490                                           struct rpc_pipe_client *cli)
14491 {
14492         struct tevent_req *req;
14493         struct rpccli_spoolss_60_state *state;
14494         struct tevent_req *subreq;
14495
14496         req = tevent_req_create(mem_ctx, &state,
14497                                 struct rpccli_spoolss_60_state);
14498         if (req == NULL) {
14499                 return NULL;
14500         }
14501         state->out_mem_ctx = NULL;
14502         state->dispatch_recv = cli->dispatch_recv;
14503
14504         /* In parameters */
14505
14506         /* Out parameters */
14507
14508         /* Result */
14509         ZERO_STRUCT(state->orig.out.result);
14510
14511         /* make a temporary copy, that we pass to the dispatch function */
14512         state->tmp = state->orig;
14513
14514         subreq = cli->dispatch_send(state, ev, cli,
14515                                     &ndr_table_spoolss,
14516                                     NDR_SPOOLSS_60,
14517                                     &state->tmp);
14518         if (tevent_req_nomem(subreq, req)) {
14519                 return tevent_req_post(req, ev);
14520         }
14521         tevent_req_set_callback(subreq, rpccli_spoolss_60_done, req);
14522         return req;
14523 }
14524
14525 static void rpccli_spoolss_60_done(struct tevent_req *subreq)
14526 {
14527         struct tevent_req *req = tevent_req_callback_data(
14528                 subreq, struct tevent_req);
14529         struct rpccli_spoolss_60_state *state = tevent_req_data(
14530                 req, struct rpccli_spoolss_60_state);
14531         NTSTATUS status;
14532         TALLOC_CTX *mem_ctx;
14533
14534         if (state->out_mem_ctx) {
14535                 mem_ctx = state->out_mem_ctx;
14536         } else {
14537                 mem_ctx = state;
14538         }
14539
14540         status = state->dispatch_recv(subreq, mem_ctx);
14541         TALLOC_FREE(subreq);
14542         if (!NT_STATUS_IS_OK(status)) {
14543                 tevent_req_nterror(req, status);
14544                 return;
14545         }
14546
14547         /* Copy out parameters */
14548
14549         /* Copy result */
14550         state->orig.out.result = state->tmp.out.result;
14551
14552         /* Reset temporary structure */
14553         ZERO_STRUCT(state->tmp);
14554
14555         tevent_req_done(req);
14556 }
14557
14558 NTSTATUS rpccli_spoolss_60_recv(struct tevent_req *req,
14559                                 TALLOC_CTX *mem_ctx,
14560                                 WERROR *result)
14561 {
14562         struct rpccli_spoolss_60_state *state = tevent_req_data(
14563                 req, struct rpccli_spoolss_60_state);
14564         NTSTATUS status;
14565
14566         if (tevent_req_is_nterror(req, &status)) {
14567                 tevent_req_received(req);
14568                 return status;
14569         }
14570
14571         /* Steal possbile out parameters to the callers context */
14572         talloc_steal(mem_ctx, state->out_mem_ctx);
14573
14574         /* Return result */
14575         *result = state->orig.out.result;
14576
14577         tevent_req_received(req);
14578         return NT_STATUS_OK;
14579 }
14580
14581 NTSTATUS rpccli_spoolss_60(struct rpc_pipe_client *cli,
14582                            TALLOC_CTX *mem_ctx,
14583                            WERROR *werror)
14584 {
14585         struct spoolss_60 r;
14586         NTSTATUS status;
14587
14588         /* In parameters */
14589
14590         status = cli->dispatch(cli,
14591                                 mem_ctx,
14592                                 &ndr_table_spoolss,
14593                                 NDR_SPOOLSS_60,
14594                                 &r);
14595
14596         if (!NT_STATUS_IS_OK(status)) {
14597                 return status;
14598         }
14599
14600         if (NT_STATUS_IS_ERR(status)) {
14601                 return status;
14602         }
14603
14604         /* Return variables */
14605
14606         /* Return result */
14607         if (werror) {
14608                 *werror = r.out.result;
14609         }
14610
14611         return werror_to_ntstatus(r.out.result);
14612 }
14613
14614 struct rpccli_spoolss_61_state {
14615         struct spoolss_61 orig;
14616         struct spoolss_61 tmp;
14617         TALLOC_CTX *out_mem_ctx;
14618         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14619 };
14620
14621 static void rpccli_spoolss_61_done(struct tevent_req *subreq);
14622
14623 struct tevent_req *rpccli_spoolss_61_send(TALLOC_CTX *mem_ctx,
14624                                           struct tevent_context *ev,
14625                                           struct rpc_pipe_client *cli)
14626 {
14627         struct tevent_req *req;
14628         struct rpccli_spoolss_61_state *state;
14629         struct tevent_req *subreq;
14630
14631         req = tevent_req_create(mem_ctx, &state,
14632                                 struct rpccli_spoolss_61_state);
14633         if (req == NULL) {
14634                 return NULL;
14635         }
14636         state->out_mem_ctx = NULL;
14637         state->dispatch_recv = cli->dispatch_recv;
14638
14639         /* In parameters */
14640
14641         /* Out parameters */
14642
14643         /* Result */
14644         ZERO_STRUCT(state->orig.out.result);
14645
14646         /* make a temporary copy, that we pass to the dispatch function */
14647         state->tmp = state->orig;
14648
14649         subreq = cli->dispatch_send(state, ev, cli,
14650                                     &ndr_table_spoolss,
14651                                     NDR_SPOOLSS_61,
14652                                     &state->tmp);
14653         if (tevent_req_nomem(subreq, req)) {
14654                 return tevent_req_post(req, ev);
14655         }
14656         tevent_req_set_callback(subreq, rpccli_spoolss_61_done, req);
14657         return req;
14658 }
14659
14660 static void rpccli_spoolss_61_done(struct tevent_req *subreq)
14661 {
14662         struct tevent_req *req = tevent_req_callback_data(
14663                 subreq, struct tevent_req);
14664         struct rpccli_spoolss_61_state *state = tevent_req_data(
14665                 req, struct rpccli_spoolss_61_state);
14666         NTSTATUS status;
14667         TALLOC_CTX *mem_ctx;
14668
14669         if (state->out_mem_ctx) {
14670                 mem_ctx = state->out_mem_ctx;
14671         } else {
14672                 mem_ctx = state;
14673         }
14674
14675         status = state->dispatch_recv(subreq, mem_ctx);
14676         TALLOC_FREE(subreq);
14677         if (!NT_STATUS_IS_OK(status)) {
14678                 tevent_req_nterror(req, status);
14679                 return;
14680         }
14681
14682         /* Copy out parameters */
14683
14684         /* Copy result */
14685         state->orig.out.result = state->tmp.out.result;
14686
14687         /* Reset temporary structure */
14688         ZERO_STRUCT(state->tmp);
14689
14690         tevent_req_done(req);
14691 }
14692
14693 NTSTATUS rpccli_spoolss_61_recv(struct tevent_req *req,
14694                                 TALLOC_CTX *mem_ctx,
14695                                 WERROR *result)
14696 {
14697         struct rpccli_spoolss_61_state *state = tevent_req_data(
14698                 req, struct rpccli_spoolss_61_state);
14699         NTSTATUS status;
14700
14701         if (tevent_req_is_nterror(req, &status)) {
14702                 tevent_req_received(req);
14703                 return status;
14704         }
14705
14706         /* Steal possbile out parameters to the callers context */
14707         talloc_steal(mem_ctx, state->out_mem_ctx);
14708
14709         /* Return result */
14710         *result = state->orig.out.result;
14711
14712         tevent_req_received(req);
14713         return NT_STATUS_OK;
14714 }
14715
14716 NTSTATUS rpccli_spoolss_61(struct rpc_pipe_client *cli,
14717                            TALLOC_CTX *mem_ctx,
14718                            WERROR *werror)
14719 {
14720         struct spoolss_61 r;
14721         NTSTATUS status;
14722
14723         /* In parameters */
14724
14725         status = cli->dispatch(cli,
14726                                 mem_ctx,
14727                                 &ndr_table_spoolss,
14728                                 NDR_SPOOLSS_61,
14729                                 &r);
14730
14731         if (!NT_STATUS_IS_OK(status)) {
14732                 return status;
14733         }
14734
14735         if (NT_STATUS_IS_ERR(status)) {
14736                 return status;
14737         }
14738
14739         /* Return variables */
14740
14741         /* Return result */
14742         if (werror) {
14743                 *werror = r.out.result;
14744         }
14745
14746         return werror_to_ntstatus(r.out.result);
14747 }
14748
14749 struct rpccli_spoolss_62_state {
14750         struct spoolss_62 orig;
14751         struct spoolss_62 tmp;
14752         TALLOC_CTX *out_mem_ctx;
14753         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14754 };
14755
14756 static void rpccli_spoolss_62_done(struct tevent_req *subreq);
14757
14758 struct tevent_req *rpccli_spoolss_62_send(TALLOC_CTX *mem_ctx,
14759                                           struct tevent_context *ev,
14760                                           struct rpc_pipe_client *cli)
14761 {
14762         struct tevent_req *req;
14763         struct rpccli_spoolss_62_state *state;
14764         struct tevent_req *subreq;
14765
14766         req = tevent_req_create(mem_ctx, &state,
14767                                 struct rpccli_spoolss_62_state);
14768         if (req == NULL) {
14769                 return NULL;
14770         }
14771         state->out_mem_ctx = NULL;
14772         state->dispatch_recv = cli->dispatch_recv;
14773
14774         /* In parameters */
14775
14776         /* Out parameters */
14777
14778         /* Result */
14779         ZERO_STRUCT(state->orig.out.result);
14780
14781         /* make a temporary copy, that we pass to the dispatch function */
14782         state->tmp = state->orig;
14783
14784         subreq = cli->dispatch_send(state, ev, cli,
14785                                     &ndr_table_spoolss,
14786                                     NDR_SPOOLSS_62,
14787                                     &state->tmp);
14788         if (tevent_req_nomem(subreq, req)) {
14789                 return tevent_req_post(req, ev);
14790         }
14791         tevent_req_set_callback(subreq, rpccli_spoolss_62_done, req);
14792         return req;
14793 }
14794
14795 static void rpccli_spoolss_62_done(struct tevent_req *subreq)
14796 {
14797         struct tevent_req *req = tevent_req_callback_data(
14798                 subreq, struct tevent_req);
14799         struct rpccli_spoolss_62_state *state = tevent_req_data(
14800                 req, struct rpccli_spoolss_62_state);
14801         NTSTATUS status;
14802         TALLOC_CTX *mem_ctx;
14803
14804         if (state->out_mem_ctx) {
14805                 mem_ctx = state->out_mem_ctx;
14806         } else {
14807                 mem_ctx = state;
14808         }
14809
14810         status = state->dispatch_recv(subreq, mem_ctx);
14811         TALLOC_FREE(subreq);
14812         if (!NT_STATUS_IS_OK(status)) {
14813                 tevent_req_nterror(req, status);
14814                 return;
14815         }
14816
14817         /* Copy out parameters */
14818
14819         /* Copy result */
14820         state->orig.out.result = state->tmp.out.result;
14821
14822         /* Reset temporary structure */
14823         ZERO_STRUCT(state->tmp);
14824
14825         tevent_req_done(req);
14826 }
14827
14828 NTSTATUS rpccli_spoolss_62_recv(struct tevent_req *req,
14829                                 TALLOC_CTX *mem_ctx,
14830                                 WERROR *result)
14831 {
14832         struct rpccli_spoolss_62_state *state = tevent_req_data(
14833                 req, struct rpccli_spoolss_62_state);
14834         NTSTATUS status;
14835
14836         if (tevent_req_is_nterror(req, &status)) {
14837                 tevent_req_received(req);
14838                 return status;
14839         }
14840
14841         /* Steal possbile out parameters to the callers context */
14842         talloc_steal(mem_ctx, state->out_mem_ctx);
14843
14844         /* Return result */
14845         *result = state->orig.out.result;
14846
14847         tevent_req_received(req);
14848         return NT_STATUS_OK;
14849 }
14850
14851 NTSTATUS rpccli_spoolss_62(struct rpc_pipe_client *cli,
14852                            TALLOC_CTX *mem_ctx,
14853                            WERROR *werror)
14854 {
14855         struct spoolss_62 r;
14856         NTSTATUS status;
14857
14858         /* In parameters */
14859
14860         status = cli->dispatch(cli,
14861                                 mem_ctx,
14862                                 &ndr_table_spoolss,
14863                                 NDR_SPOOLSS_62,
14864                                 &r);
14865
14866         if (!NT_STATUS_IS_OK(status)) {
14867                 return status;
14868         }
14869
14870         if (NT_STATUS_IS_ERR(status)) {
14871                 return status;
14872         }
14873
14874         /* Return variables */
14875
14876         /* Return result */
14877         if (werror) {
14878                 *werror = r.out.result;
14879         }
14880
14881         return werror_to_ntstatus(r.out.result);
14882 }
14883
14884 struct rpccli_spoolss_63_state {
14885         struct spoolss_63 orig;
14886         struct spoolss_63 tmp;
14887         TALLOC_CTX *out_mem_ctx;
14888         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14889 };
14890
14891 static void rpccli_spoolss_63_done(struct tevent_req *subreq);
14892
14893 struct tevent_req *rpccli_spoolss_63_send(TALLOC_CTX *mem_ctx,
14894                                           struct tevent_context *ev,
14895                                           struct rpc_pipe_client *cli)
14896 {
14897         struct tevent_req *req;
14898         struct rpccli_spoolss_63_state *state;
14899         struct tevent_req *subreq;
14900
14901         req = tevent_req_create(mem_ctx, &state,
14902                                 struct rpccli_spoolss_63_state);
14903         if (req == NULL) {
14904                 return NULL;
14905         }
14906         state->out_mem_ctx = NULL;
14907         state->dispatch_recv = cli->dispatch_recv;
14908
14909         /* In parameters */
14910
14911         /* Out parameters */
14912
14913         /* Result */
14914         ZERO_STRUCT(state->orig.out.result);
14915
14916         /* make a temporary copy, that we pass to the dispatch function */
14917         state->tmp = state->orig;
14918
14919         subreq = cli->dispatch_send(state, ev, cli,
14920                                     &ndr_table_spoolss,
14921                                     NDR_SPOOLSS_63,
14922                                     &state->tmp);
14923         if (tevent_req_nomem(subreq, req)) {
14924                 return tevent_req_post(req, ev);
14925         }
14926         tevent_req_set_callback(subreq, rpccli_spoolss_63_done, req);
14927         return req;
14928 }
14929
14930 static void rpccli_spoolss_63_done(struct tevent_req *subreq)
14931 {
14932         struct tevent_req *req = tevent_req_callback_data(
14933                 subreq, struct tevent_req);
14934         struct rpccli_spoolss_63_state *state = tevent_req_data(
14935                 req, struct rpccli_spoolss_63_state);
14936         NTSTATUS status;
14937         TALLOC_CTX *mem_ctx;
14938
14939         if (state->out_mem_ctx) {
14940                 mem_ctx = state->out_mem_ctx;
14941         } else {
14942                 mem_ctx = state;
14943         }
14944
14945         status = state->dispatch_recv(subreq, mem_ctx);
14946         TALLOC_FREE(subreq);
14947         if (!NT_STATUS_IS_OK(status)) {
14948                 tevent_req_nterror(req, status);
14949                 return;
14950         }
14951
14952         /* Copy out parameters */
14953
14954         /* Copy result */
14955         state->orig.out.result = state->tmp.out.result;
14956
14957         /* Reset temporary structure */
14958         ZERO_STRUCT(state->tmp);
14959
14960         tevent_req_done(req);
14961 }
14962
14963 NTSTATUS rpccli_spoolss_63_recv(struct tevent_req *req,
14964                                 TALLOC_CTX *mem_ctx,
14965                                 WERROR *result)
14966 {
14967         struct rpccli_spoolss_63_state *state = tevent_req_data(
14968                 req, struct rpccli_spoolss_63_state);
14969         NTSTATUS status;
14970
14971         if (tevent_req_is_nterror(req, &status)) {
14972                 tevent_req_received(req);
14973                 return status;
14974         }
14975
14976         /* Steal possbile out parameters to the callers context */
14977         talloc_steal(mem_ctx, state->out_mem_ctx);
14978
14979         /* Return result */
14980         *result = state->orig.out.result;
14981
14982         tevent_req_received(req);
14983         return NT_STATUS_OK;
14984 }
14985
14986 NTSTATUS rpccli_spoolss_63(struct rpc_pipe_client *cli,
14987                            TALLOC_CTX *mem_ctx,
14988                            WERROR *werror)
14989 {
14990         struct spoolss_63 r;
14991         NTSTATUS status;
14992
14993         /* In parameters */
14994
14995         status = cli->dispatch(cli,
14996                                 mem_ctx,
14997                                 &ndr_table_spoolss,
14998                                 NDR_SPOOLSS_63,
14999                                 &r);
15000
15001         if (!NT_STATUS_IS_OK(status)) {
15002                 return status;
15003         }
15004
15005         if (NT_STATUS_IS_ERR(status)) {
15006                 return status;
15007         }
15008
15009         /* Return variables */
15010
15011         /* Return result */
15012         if (werror) {
15013                 *werror = r.out.result;
15014         }
15015
15016         return werror_to_ntstatus(r.out.result);
15017 }
15018
15019 struct rpccli_spoolss_64_state {
15020         struct spoolss_64 orig;
15021         struct spoolss_64 tmp;
15022         TALLOC_CTX *out_mem_ctx;
15023         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15024 };
15025
15026 static void rpccli_spoolss_64_done(struct tevent_req *subreq);
15027
15028 struct tevent_req *rpccli_spoolss_64_send(TALLOC_CTX *mem_ctx,
15029                                           struct tevent_context *ev,
15030                                           struct rpc_pipe_client *cli)
15031 {
15032         struct tevent_req *req;
15033         struct rpccli_spoolss_64_state *state;
15034         struct tevent_req *subreq;
15035
15036         req = tevent_req_create(mem_ctx, &state,
15037                                 struct rpccli_spoolss_64_state);
15038         if (req == NULL) {
15039                 return NULL;
15040         }
15041         state->out_mem_ctx = NULL;
15042         state->dispatch_recv = cli->dispatch_recv;
15043
15044         /* In parameters */
15045
15046         /* Out parameters */
15047
15048         /* Result */
15049         ZERO_STRUCT(state->orig.out.result);
15050
15051         /* make a temporary copy, that we pass to the dispatch function */
15052         state->tmp = state->orig;
15053
15054         subreq = cli->dispatch_send(state, ev, cli,
15055                                     &ndr_table_spoolss,
15056                                     NDR_SPOOLSS_64,
15057                                     &state->tmp);
15058         if (tevent_req_nomem(subreq, req)) {
15059                 return tevent_req_post(req, ev);
15060         }
15061         tevent_req_set_callback(subreq, rpccli_spoolss_64_done, req);
15062         return req;
15063 }
15064
15065 static void rpccli_spoolss_64_done(struct tevent_req *subreq)
15066 {
15067         struct tevent_req *req = tevent_req_callback_data(
15068                 subreq, struct tevent_req);
15069         struct rpccli_spoolss_64_state *state = tevent_req_data(
15070                 req, struct rpccli_spoolss_64_state);
15071         NTSTATUS status;
15072         TALLOC_CTX *mem_ctx;
15073
15074         if (state->out_mem_ctx) {
15075                 mem_ctx = state->out_mem_ctx;
15076         } else {
15077                 mem_ctx = state;
15078         }
15079
15080         status = state->dispatch_recv(subreq, mem_ctx);
15081         TALLOC_FREE(subreq);
15082         if (!NT_STATUS_IS_OK(status)) {
15083                 tevent_req_nterror(req, status);
15084                 return;
15085         }
15086
15087         /* Copy out parameters */
15088
15089         /* Copy result */
15090         state->orig.out.result = state->tmp.out.result;
15091
15092         /* Reset temporary structure */
15093         ZERO_STRUCT(state->tmp);
15094
15095         tevent_req_done(req);
15096 }
15097
15098 NTSTATUS rpccli_spoolss_64_recv(struct tevent_req *req,
15099                                 TALLOC_CTX *mem_ctx,
15100                                 WERROR *result)
15101 {
15102         struct rpccli_spoolss_64_state *state = tevent_req_data(
15103                 req, struct rpccli_spoolss_64_state);
15104         NTSTATUS status;
15105
15106         if (tevent_req_is_nterror(req, &status)) {
15107                 tevent_req_received(req);
15108                 return status;
15109         }
15110
15111         /* Steal possbile out parameters to the callers context */
15112         talloc_steal(mem_ctx, state->out_mem_ctx);
15113
15114         /* Return result */
15115         *result = state->orig.out.result;
15116
15117         tevent_req_received(req);
15118         return NT_STATUS_OK;
15119 }
15120
15121 NTSTATUS rpccli_spoolss_64(struct rpc_pipe_client *cli,
15122                            TALLOC_CTX *mem_ctx,
15123                            WERROR *werror)
15124 {
15125         struct spoolss_64 r;
15126         NTSTATUS status;
15127
15128         /* In parameters */
15129
15130         status = cli->dispatch(cli,
15131                                 mem_ctx,
15132                                 &ndr_table_spoolss,
15133                                 NDR_SPOOLSS_64,
15134                                 &r);
15135
15136         if (!NT_STATUS_IS_OK(status)) {
15137                 return status;
15138         }
15139
15140         if (NT_STATUS_IS_ERR(status)) {
15141                 return status;
15142         }
15143
15144         /* Return variables */
15145
15146         /* Return result */
15147         if (werror) {
15148                 *werror = r.out.result;
15149         }
15150
15151         return werror_to_ntstatus(r.out.result);
15152 }
15153
15154 struct rpccli_spoolss_65_state {
15155         struct spoolss_65 orig;
15156         struct spoolss_65 tmp;
15157         TALLOC_CTX *out_mem_ctx;
15158         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15159 };
15160
15161 static void rpccli_spoolss_65_done(struct tevent_req *subreq);
15162
15163 struct tevent_req *rpccli_spoolss_65_send(TALLOC_CTX *mem_ctx,
15164                                           struct tevent_context *ev,
15165                                           struct rpc_pipe_client *cli)
15166 {
15167         struct tevent_req *req;
15168         struct rpccli_spoolss_65_state *state;
15169         struct tevent_req *subreq;
15170
15171         req = tevent_req_create(mem_ctx, &state,
15172                                 struct rpccli_spoolss_65_state);
15173         if (req == NULL) {
15174                 return NULL;
15175         }
15176         state->out_mem_ctx = NULL;
15177         state->dispatch_recv = cli->dispatch_recv;
15178
15179         /* In parameters */
15180
15181         /* Out parameters */
15182
15183         /* Result */
15184         ZERO_STRUCT(state->orig.out.result);
15185
15186         /* make a temporary copy, that we pass to the dispatch function */
15187         state->tmp = state->orig;
15188
15189         subreq = cli->dispatch_send(state, ev, cli,
15190                                     &ndr_table_spoolss,
15191                                     NDR_SPOOLSS_65,
15192                                     &state->tmp);
15193         if (tevent_req_nomem(subreq, req)) {
15194                 return tevent_req_post(req, ev);
15195         }
15196         tevent_req_set_callback(subreq, rpccli_spoolss_65_done, req);
15197         return req;
15198 }
15199
15200 static void rpccli_spoolss_65_done(struct tevent_req *subreq)
15201 {
15202         struct tevent_req *req = tevent_req_callback_data(
15203                 subreq, struct tevent_req);
15204         struct rpccli_spoolss_65_state *state = tevent_req_data(
15205                 req, struct rpccli_spoolss_65_state);
15206         NTSTATUS status;
15207         TALLOC_CTX *mem_ctx;
15208
15209         if (state->out_mem_ctx) {
15210                 mem_ctx = state->out_mem_ctx;
15211         } else {
15212                 mem_ctx = state;
15213         }
15214
15215         status = state->dispatch_recv(subreq, mem_ctx);
15216         TALLOC_FREE(subreq);
15217         if (!NT_STATUS_IS_OK(status)) {
15218                 tevent_req_nterror(req, status);
15219                 return;
15220         }
15221
15222         /* Copy out parameters */
15223
15224         /* Copy result */
15225         state->orig.out.result = state->tmp.out.result;
15226
15227         /* Reset temporary structure */
15228         ZERO_STRUCT(state->tmp);
15229
15230         tevent_req_done(req);
15231 }
15232
15233 NTSTATUS rpccli_spoolss_65_recv(struct tevent_req *req,
15234                                 TALLOC_CTX *mem_ctx,
15235                                 WERROR *result)
15236 {
15237         struct rpccli_spoolss_65_state *state = tevent_req_data(
15238                 req, struct rpccli_spoolss_65_state);
15239         NTSTATUS status;
15240
15241         if (tevent_req_is_nterror(req, &status)) {
15242                 tevent_req_received(req);
15243                 return status;
15244         }
15245
15246         /* Steal possbile out parameters to the callers context */
15247         talloc_steal(mem_ctx, state->out_mem_ctx);
15248
15249         /* Return result */
15250         *result = state->orig.out.result;
15251
15252         tevent_req_received(req);
15253         return NT_STATUS_OK;
15254 }
15255
15256 NTSTATUS rpccli_spoolss_65(struct rpc_pipe_client *cli,
15257                            TALLOC_CTX *mem_ctx,
15258                            WERROR *werror)
15259 {
15260         struct spoolss_65 r;
15261         NTSTATUS status;
15262
15263         /* In parameters */
15264
15265         status = cli->dispatch(cli,
15266                                 mem_ctx,
15267                                 &ndr_table_spoolss,
15268                                 NDR_SPOOLSS_65,
15269                                 &r);
15270
15271         if (!NT_STATUS_IS_OK(status)) {
15272                 return status;
15273         }
15274
15275         if (NT_STATUS_IS_ERR(status)) {
15276                 return status;
15277         }
15278
15279         /* Return variables */
15280
15281         /* Return result */
15282         if (werror) {
15283                 *werror = r.out.result;
15284         }
15285
15286         return werror_to_ntstatus(r.out.result);
15287 }
15288
15289 struct rpccli_spoolss_GetCorePrinterDrivers_state {
15290         struct spoolss_GetCorePrinterDrivers orig;
15291         struct spoolss_GetCorePrinterDrivers tmp;
15292         TALLOC_CTX *out_mem_ctx;
15293         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15294 };
15295
15296 static void rpccli_spoolss_GetCorePrinterDrivers_done(struct tevent_req *subreq);
15297
15298 struct tevent_req *rpccli_spoolss_GetCorePrinterDrivers_send(TALLOC_CTX *mem_ctx,
15299                                                              struct tevent_context *ev,
15300                                                              struct rpc_pipe_client *cli,
15301                                                              const char *_servername /* [in] [unique,charset(UTF16)] */,
15302                                                              const char *_architecture /* [in] [ref,charset(UTF16)] */,
15303                                                              uint32_t _core_driver_size /* [in]  */,
15304                                                              const char *_core_driver_dependencies /* [in] [ref,charset(UTF16),size_is(core_driver_size)] */,
15305                                                              uint32_t _core_printer_driver_count /* [in]  */,
15306                                                              struct spoolss_CorePrinterDriver *_core_printer_drivers /* [out] [ref,size_is(core_printer_driver_count)] */)
15307 {
15308         struct tevent_req *req;
15309         struct rpccli_spoolss_GetCorePrinterDrivers_state *state;
15310         struct tevent_req *subreq;
15311
15312         req = tevent_req_create(mem_ctx, &state,
15313                                 struct rpccli_spoolss_GetCorePrinterDrivers_state);
15314         if (req == NULL) {
15315                 return NULL;
15316         }
15317         state->out_mem_ctx = NULL;
15318         state->dispatch_recv = cli->dispatch_recv;
15319
15320         /* In parameters */
15321         state->orig.in.servername = _servername;
15322         state->orig.in.architecture = _architecture;
15323         state->orig.in.core_driver_size = _core_driver_size;
15324         state->orig.in.core_driver_dependencies = _core_driver_dependencies;
15325         state->orig.in.core_printer_driver_count = _core_printer_driver_count;
15326
15327         /* Out parameters */
15328         state->orig.out.core_printer_drivers = _core_printer_drivers;
15329
15330         /* Result */
15331         ZERO_STRUCT(state->orig.out.result);
15332
15333         state->out_mem_ctx = talloc_named_const(state, 0,
15334                              "rpccli_spoolss_GetCorePrinterDrivers_out_memory");
15335         if (tevent_req_nomem(state->out_mem_ctx, req)) {
15336                 return tevent_req_post(req, ev);
15337         }
15338
15339         /* make a temporary copy, that we pass to the dispatch function */
15340         state->tmp = state->orig;
15341
15342         subreq = cli->dispatch_send(state, ev, cli,
15343                                     &ndr_table_spoolss,
15344                                     NDR_SPOOLSS_GETCOREPRINTERDRIVERS,
15345                                     &state->tmp);
15346         if (tevent_req_nomem(subreq, req)) {
15347                 return tevent_req_post(req, ev);
15348         }
15349         tevent_req_set_callback(subreq, rpccli_spoolss_GetCorePrinterDrivers_done, req);
15350         return req;
15351 }
15352
15353 static void rpccli_spoolss_GetCorePrinterDrivers_done(struct tevent_req *subreq)
15354 {
15355         struct tevent_req *req = tevent_req_callback_data(
15356                 subreq, struct tevent_req);
15357         struct rpccli_spoolss_GetCorePrinterDrivers_state *state = tevent_req_data(
15358                 req, struct rpccli_spoolss_GetCorePrinterDrivers_state);
15359         NTSTATUS status;
15360         TALLOC_CTX *mem_ctx;
15361
15362         if (state->out_mem_ctx) {
15363                 mem_ctx = state->out_mem_ctx;
15364         } else {
15365                 mem_ctx = state;
15366         }
15367
15368         status = state->dispatch_recv(subreq, mem_ctx);
15369         TALLOC_FREE(subreq);
15370         if (!NT_STATUS_IS_OK(status)) {
15371                 tevent_req_nterror(req, status);
15372                 return;
15373         }
15374
15375         /* Copy out parameters */
15376         memcpy(state->orig.out.core_printer_drivers, state->tmp.out.core_printer_drivers, (state->tmp.in.core_printer_driver_count) * sizeof(*state->orig.out.core_printer_drivers));
15377
15378         /* Copy result */
15379         state->orig.out.result = state->tmp.out.result;
15380
15381         /* Reset temporary structure */
15382         ZERO_STRUCT(state->tmp);
15383
15384         tevent_req_done(req);
15385 }
15386
15387 NTSTATUS rpccli_spoolss_GetCorePrinterDrivers_recv(struct tevent_req *req,
15388                                                    TALLOC_CTX *mem_ctx,
15389                                                    WERROR *result)
15390 {
15391         struct rpccli_spoolss_GetCorePrinterDrivers_state *state = tevent_req_data(
15392                 req, struct rpccli_spoolss_GetCorePrinterDrivers_state);
15393         NTSTATUS status;
15394
15395         if (tevent_req_is_nterror(req, &status)) {
15396                 tevent_req_received(req);
15397                 return status;
15398         }
15399
15400         /* Steal possbile out parameters to the callers context */
15401         talloc_steal(mem_ctx, state->out_mem_ctx);
15402
15403         /* Return result */
15404         *result = state->orig.out.result;
15405
15406         tevent_req_received(req);
15407         return NT_STATUS_OK;
15408 }
15409
15410 NTSTATUS rpccli_spoolss_GetCorePrinterDrivers(struct rpc_pipe_client *cli,
15411                                               TALLOC_CTX *mem_ctx,
15412                                               const char *servername /* [in] [unique,charset(UTF16)] */,
15413                                               const char *architecture /* [in] [ref,charset(UTF16)] */,
15414                                               uint32_t core_driver_size /* [in]  */,
15415                                               const char *core_driver_dependencies /* [in] [ref,charset(UTF16),size_is(core_driver_size)] */,
15416                                               uint32_t core_printer_driver_count /* [in]  */,
15417                                               struct spoolss_CorePrinterDriver *core_printer_drivers /* [out] [ref,size_is(core_printer_driver_count)] */,
15418                                               WERROR *werror)
15419 {
15420         struct spoolss_GetCorePrinterDrivers r;
15421         NTSTATUS status;
15422
15423         /* In parameters */
15424         r.in.servername = servername;
15425         r.in.architecture = architecture;
15426         r.in.core_driver_size = core_driver_size;
15427         r.in.core_driver_dependencies = core_driver_dependencies;
15428         r.in.core_printer_driver_count = core_printer_driver_count;
15429
15430         status = cli->dispatch(cli,
15431                                 mem_ctx,
15432                                 &ndr_table_spoolss,
15433                                 NDR_SPOOLSS_GETCOREPRINTERDRIVERS,
15434                                 &r);
15435
15436         if (!NT_STATUS_IS_OK(status)) {
15437                 return status;
15438         }
15439
15440         if (NT_STATUS_IS_ERR(status)) {
15441                 return status;
15442         }
15443
15444         /* Return variables */
15445         memcpy(core_printer_drivers, r.out.core_printer_drivers, (r.in.core_printer_driver_count) * sizeof(*core_printer_drivers));
15446
15447         /* Return result */
15448         if (werror) {
15449                 *werror = r.out.result;
15450         }
15451
15452         return werror_to_ntstatus(r.out.result);
15453 }
15454
15455 struct rpccli_spoolss_67_state {
15456         struct spoolss_67 orig;
15457         struct spoolss_67 tmp;
15458         TALLOC_CTX *out_mem_ctx;
15459         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15460 };
15461
15462 static void rpccli_spoolss_67_done(struct tevent_req *subreq);
15463
15464 struct tevent_req *rpccli_spoolss_67_send(TALLOC_CTX *mem_ctx,
15465                                           struct tevent_context *ev,
15466                                           struct rpc_pipe_client *cli)
15467 {
15468         struct tevent_req *req;
15469         struct rpccli_spoolss_67_state *state;
15470         struct tevent_req *subreq;
15471
15472         req = tevent_req_create(mem_ctx, &state,
15473                                 struct rpccli_spoolss_67_state);
15474         if (req == NULL) {
15475                 return NULL;
15476         }
15477         state->out_mem_ctx = NULL;
15478         state->dispatch_recv = cli->dispatch_recv;
15479
15480         /* In parameters */
15481
15482         /* Out parameters */
15483
15484         /* Result */
15485         ZERO_STRUCT(state->orig.out.result);
15486
15487         /* make a temporary copy, that we pass to the dispatch function */
15488         state->tmp = state->orig;
15489
15490         subreq = cli->dispatch_send(state, ev, cli,
15491                                     &ndr_table_spoolss,
15492                                     NDR_SPOOLSS_67,
15493                                     &state->tmp);
15494         if (tevent_req_nomem(subreq, req)) {
15495                 return tevent_req_post(req, ev);
15496         }
15497         tevent_req_set_callback(subreq, rpccli_spoolss_67_done, req);
15498         return req;
15499 }
15500
15501 static void rpccli_spoolss_67_done(struct tevent_req *subreq)
15502 {
15503         struct tevent_req *req = tevent_req_callback_data(
15504                 subreq, struct tevent_req);
15505         struct rpccli_spoolss_67_state *state = tevent_req_data(
15506                 req, struct rpccli_spoolss_67_state);
15507         NTSTATUS status;
15508         TALLOC_CTX *mem_ctx;
15509
15510         if (state->out_mem_ctx) {
15511                 mem_ctx = state->out_mem_ctx;
15512         } else {
15513                 mem_ctx = state;
15514         }
15515
15516         status = state->dispatch_recv(subreq, mem_ctx);
15517         TALLOC_FREE(subreq);
15518         if (!NT_STATUS_IS_OK(status)) {
15519                 tevent_req_nterror(req, status);
15520                 return;
15521         }
15522
15523         /* Copy out parameters */
15524
15525         /* Copy result */
15526         state->orig.out.result = state->tmp.out.result;
15527
15528         /* Reset temporary structure */
15529         ZERO_STRUCT(state->tmp);
15530
15531         tevent_req_done(req);
15532 }
15533
15534 NTSTATUS rpccli_spoolss_67_recv(struct tevent_req *req,
15535                                 TALLOC_CTX *mem_ctx,
15536                                 WERROR *result)
15537 {
15538         struct rpccli_spoolss_67_state *state = tevent_req_data(
15539                 req, struct rpccli_spoolss_67_state);
15540         NTSTATUS status;
15541
15542         if (tevent_req_is_nterror(req, &status)) {
15543                 tevent_req_received(req);
15544                 return status;
15545         }
15546
15547         /* Steal possbile out parameters to the callers context */
15548         talloc_steal(mem_ctx, state->out_mem_ctx);
15549
15550         /* Return result */
15551         *result = state->orig.out.result;
15552
15553         tevent_req_received(req);
15554         return NT_STATUS_OK;
15555 }
15556
15557 NTSTATUS rpccli_spoolss_67(struct rpc_pipe_client *cli,
15558                            TALLOC_CTX *mem_ctx,
15559                            WERROR *werror)
15560 {
15561         struct spoolss_67 r;
15562         NTSTATUS status;
15563
15564         /* In parameters */
15565
15566         status = cli->dispatch(cli,
15567                                 mem_ctx,
15568                                 &ndr_table_spoolss,
15569                                 NDR_SPOOLSS_67,
15570                                 &r);
15571
15572         if (!NT_STATUS_IS_OK(status)) {
15573                 return status;
15574         }
15575
15576         if (NT_STATUS_IS_ERR(status)) {
15577                 return status;
15578         }
15579
15580         /* Return variables */
15581
15582         /* Return result */
15583         if (werror) {
15584                 *werror = r.out.result;
15585         }
15586
15587         return werror_to_ntstatus(r.out.result);
15588 }
15589
15590 struct rpccli_spoolss_GetPrinterDriverPackagePath_state {
15591         struct spoolss_GetPrinterDriverPackagePath orig;
15592         struct spoolss_GetPrinterDriverPackagePath tmp;
15593         TALLOC_CTX *out_mem_ctx;
15594         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15595 };
15596
15597 static void rpccli_spoolss_GetPrinterDriverPackagePath_done(struct tevent_req *subreq);
15598
15599 struct tevent_req *rpccli_spoolss_GetPrinterDriverPackagePath_send(TALLOC_CTX *mem_ctx,
15600                                                                    struct tevent_context *ev,
15601                                                                    struct rpc_pipe_client *cli,
15602                                                                    const char *_servername /* [in] [unique,charset(UTF16)] */,
15603                                                                    const char *_architecture /* [in] [ref,charset(UTF16)] */,
15604                                                                    const char *_language /* [in] [unique,charset(UTF16)] */,
15605                                                                    const char *_package_id /* [in] [ref,charset(UTF16)] */,
15606                                                                    const char *_driver_package_cab /* [in,out] [unique,charset(UTF16),size_is(driver_package_cab_size)] */,
15607                                                                    uint32_t _driver_package_cab_size /* [in]  */,
15608                                                                    uint32_t *_required /* [out] [ref] */)
15609 {
15610         struct tevent_req *req;
15611         struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state;
15612         struct tevent_req *subreq;
15613
15614         req = tevent_req_create(mem_ctx, &state,
15615                                 struct rpccli_spoolss_GetPrinterDriverPackagePath_state);
15616         if (req == NULL) {
15617                 return NULL;
15618         }
15619         state->out_mem_ctx = NULL;
15620         state->dispatch_recv = cli->dispatch_recv;
15621
15622         /* In parameters */
15623         state->orig.in.servername = _servername;
15624         state->orig.in.architecture = _architecture;
15625         state->orig.in.language = _language;
15626         state->orig.in.package_id = _package_id;
15627         state->orig.in.driver_package_cab = _driver_package_cab;
15628         state->orig.in.driver_package_cab_size = _driver_package_cab_size;
15629
15630         /* Out parameters */
15631         state->orig.out.driver_package_cab = _driver_package_cab;
15632         state->orig.out.required = _required;
15633
15634         /* Result */
15635         ZERO_STRUCT(state->orig.out.result);
15636
15637         state->out_mem_ctx = talloc_named_const(state, 0,
15638                              "rpccli_spoolss_GetPrinterDriverPackagePath_out_memory");
15639         if (tevent_req_nomem(state->out_mem_ctx, req)) {
15640                 return tevent_req_post(req, ev);
15641         }
15642
15643         /* make a temporary copy, that we pass to the dispatch function */
15644         state->tmp = state->orig;
15645
15646         subreq = cli->dispatch_send(state, ev, cli,
15647                                     &ndr_table_spoolss,
15648                                     NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH,
15649                                     &state->tmp);
15650         if (tevent_req_nomem(subreq, req)) {
15651                 return tevent_req_post(req, ev);
15652         }
15653         tevent_req_set_callback(subreq, rpccli_spoolss_GetPrinterDriverPackagePath_done, req);
15654         return req;
15655 }
15656
15657 static void rpccli_spoolss_GetPrinterDriverPackagePath_done(struct tevent_req *subreq)
15658 {
15659         struct tevent_req *req = tevent_req_callback_data(
15660                 subreq, struct tevent_req);
15661         struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state = tevent_req_data(
15662                 req, struct rpccli_spoolss_GetPrinterDriverPackagePath_state);
15663         NTSTATUS status;
15664         TALLOC_CTX *mem_ctx;
15665
15666         if (state->out_mem_ctx) {
15667                 mem_ctx = state->out_mem_ctx;
15668         } else {
15669                 mem_ctx = state;
15670         }
15671
15672         status = state->dispatch_recv(subreq, mem_ctx);
15673         TALLOC_FREE(subreq);
15674         if (!NT_STATUS_IS_OK(status)) {
15675                 tevent_req_nterror(req, status);
15676                 return;
15677         }
15678
15679         /* Copy out parameters */
15680         if (state->orig.out.driver_package_cab && state->tmp.out.driver_package_cab) {
15681                 memcpy(discard_const_p(uint8_t *, state->orig.out.driver_package_cab), state->tmp.out.driver_package_cab, (state->tmp.in.driver_package_cab_size) * sizeof(*state->orig.out.driver_package_cab));
15682         }
15683         *state->orig.out.required = *state->tmp.out.required;
15684
15685         /* Copy result */
15686         state->orig.out.result = state->tmp.out.result;
15687
15688         /* Reset temporary structure */
15689         ZERO_STRUCT(state->tmp);
15690
15691         tevent_req_done(req);
15692 }
15693
15694 NTSTATUS rpccli_spoolss_GetPrinterDriverPackagePath_recv(struct tevent_req *req,
15695                                                          TALLOC_CTX *mem_ctx,
15696                                                          WERROR *result)
15697 {
15698         struct rpccli_spoolss_GetPrinterDriverPackagePath_state *state = tevent_req_data(
15699                 req, struct rpccli_spoolss_GetPrinterDriverPackagePath_state);
15700         NTSTATUS status;
15701
15702         if (tevent_req_is_nterror(req, &status)) {
15703                 tevent_req_received(req);
15704                 return status;
15705         }
15706
15707         /* Steal possbile out parameters to the callers context */
15708         talloc_steal(mem_ctx, state->out_mem_ctx);
15709
15710         /* Return result */
15711         *result = state->orig.out.result;
15712
15713         tevent_req_received(req);
15714         return NT_STATUS_OK;
15715 }
15716
15717 NTSTATUS rpccli_spoolss_GetPrinterDriverPackagePath(struct rpc_pipe_client *cli,
15718                                                     TALLOC_CTX *mem_ctx,
15719                                                     const char *servername /* [in] [unique,charset(UTF16)] */,
15720                                                     const char *architecture /* [in] [ref,charset(UTF16)] */,
15721                                                     const char *language /* [in] [unique,charset(UTF16)] */,
15722                                                     const char *package_id /* [in] [ref,charset(UTF16)] */,
15723                                                     const char *driver_package_cab /* [in,out] [unique,charset(UTF16),size_is(driver_package_cab_size)] */,
15724                                                     uint32_t driver_package_cab_size /* [in]  */,
15725                                                     uint32_t *required /* [out] [ref] */,
15726                                                     WERROR *werror)
15727 {
15728         struct spoolss_GetPrinterDriverPackagePath r;
15729         NTSTATUS status;
15730
15731         /* In parameters */
15732         r.in.servername = servername;
15733         r.in.architecture = architecture;
15734         r.in.language = language;
15735         r.in.package_id = package_id;
15736         r.in.driver_package_cab = driver_package_cab;
15737         r.in.driver_package_cab_size = driver_package_cab_size;
15738
15739         status = cli->dispatch(cli,
15740                                 mem_ctx,
15741                                 &ndr_table_spoolss,
15742                                 NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH,
15743                                 &r);
15744
15745         if (!NT_STATUS_IS_OK(status)) {
15746                 return status;
15747         }
15748
15749         if (NT_STATUS_IS_ERR(status)) {
15750                 return status;
15751         }
15752
15753         /* Return variables */
15754         if (driver_package_cab && r.out.driver_package_cab) {
15755                 memcpy(discard_const_p(uint8_t *, driver_package_cab), r.out.driver_package_cab, (r.in.driver_package_cab_size) * sizeof(*driver_package_cab));
15756         }
15757         *required = *r.out.required;
15758
15759         /* Return result */
15760         if (werror) {
15761                 *werror = r.out.result;
15762         }
15763
15764         return werror_to_ntstatus(r.out.result);
15765 }
15766
15767 struct rpccli_spoolss_69_state {
15768         struct spoolss_69 orig;
15769         struct spoolss_69 tmp;
15770         TALLOC_CTX *out_mem_ctx;
15771         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15772 };
15773
15774 static void rpccli_spoolss_69_done(struct tevent_req *subreq);
15775
15776 struct tevent_req *rpccli_spoolss_69_send(TALLOC_CTX *mem_ctx,
15777                                           struct tevent_context *ev,
15778                                           struct rpc_pipe_client *cli)
15779 {
15780         struct tevent_req *req;
15781         struct rpccli_spoolss_69_state *state;
15782         struct tevent_req *subreq;
15783
15784         req = tevent_req_create(mem_ctx, &state,
15785                                 struct rpccli_spoolss_69_state);
15786         if (req == NULL) {
15787                 return NULL;
15788         }
15789         state->out_mem_ctx = NULL;
15790         state->dispatch_recv = cli->dispatch_recv;
15791
15792         /* In parameters */
15793
15794         /* Out parameters */
15795
15796         /* Result */
15797         ZERO_STRUCT(state->orig.out.result);
15798
15799         /* make a temporary copy, that we pass to the dispatch function */
15800         state->tmp = state->orig;
15801
15802         subreq = cli->dispatch_send(state, ev, cli,
15803                                     &ndr_table_spoolss,
15804                                     NDR_SPOOLSS_69,
15805                                     &state->tmp);
15806         if (tevent_req_nomem(subreq, req)) {
15807                 return tevent_req_post(req, ev);
15808         }
15809         tevent_req_set_callback(subreq, rpccli_spoolss_69_done, req);
15810         return req;
15811 }
15812
15813 static void rpccli_spoolss_69_done(struct tevent_req *subreq)
15814 {
15815         struct tevent_req *req = tevent_req_callback_data(
15816                 subreq, struct tevent_req);
15817         struct rpccli_spoolss_69_state *state = tevent_req_data(
15818                 req, struct rpccli_spoolss_69_state);
15819         NTSTATUS status;
15820         TALLOC_CTX *mem_ctx;
15821
15822         if (state->out_mem_ctx) {
15823                 mem_ctx = state->out_mem_ctx;
15824         } else {
15825                 mem_ctx = state;
15826         }
15827
15828         status = state->dispatch_recv(subreq, mem_ctx);
15829         TALLOC_FREE(subreq);
15830         if (!NT_STATUS_IS_OK(status)) {
15831                 tevent_req_nterror(req, status);
15832                 return;
15833         }
15834
15835         /* Copy out parameters */
15836
15837         /* Copy result */
15838         state->orig.out.result = state->tmp.out.result;
15839
15840         /* Reset temporary structure */
15841         ZERO_STRUCT(state->tmp);
15842
15843         tevent_req_done(req);
15844 }
15845
15846 NTSTATUS rpccli_spoolss_69_recv(struct tevent_req *req,
15847                                 TALLOC_CTX *mem_ctx,
15848                                 WERROR *result)
15849 {
15850         struct rpccli_spoolss_69_state *state = tevent_req_data(
15851                 req, struct rpccli_spoolss_69_state);
15852         NTSTATUS status;
15853
15854         if (tevent_req_is_nterror(req, &status)) {
15855                 tevent_req_received(req);
15856                 return status;
15857         }
15858
15859         /* Steal possbile out parameters to the callers context */
15860         talloc_steal(mem_ctx, state->out_mem_ctx);
15861
15862         /* Return result */
15863         *result = state->orig.out.result;
15864
15865         tevent_req_received(req);
15866         return NT_STATUS_OK;
15867 }
15868
15869 NTSTATUS rpccli_spoolss_69(struct rpc_pipe_client *cli,
15870                            TALLOC_CTX *mem_ctx,
15871                            WERROR *werror)
15872 {
15873         struct spoolss_69 r;
15874         NTSTATUS status;
15875
15876         /* In parameters */
15877
15878         status = cli->dispatch(cli,
15879                                 mem_ctx,
15880                                 &ndr_table_spoolss,
15881                                 NDR_SPOOLSS_69,
15882                                 &r);
15883
15884         if (!NT_STATUS_IS_OK(status)) {
15885                 return status;
15886         }
15887
15888         if (NT_STATUS_IS_ERR(status)) {
15889                 return status;
15890         }
15891
15892         /* Return variables */
15893
15894         /* Return result */
15895         if (werror) {
15896                 *werror = r.out.result;
15897         }
15898
15899         return werror_to_ntstatus(r.out.result);
15900 }
15901
15902 struct rpccli_spoolss_6a_state {
15903         struct spoolss_6a orig;
15904         struct spoolss_6a tmp;
15905         TALLOC_CTX *out_mem_ctx;
15906         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
15907 };
15908
15909 static void rpccli_spoolss_6a_done(struct tevent_req *subreq);
15910
15911 struct tevent_req *rpccli_spoolss_6a_send(TALLOC_CTX *mem_ctx,
15912                                           struct tevent_context *ev,
15913                                           struct rpc_pipe_client *cli)
15914 {
15915         struct tevent_req *req;
15916         struct rpccli_spoolss_6a_state *state;
15917         struct tevent_req *subreq;
15918
15919         req = tevent_req_create(mem_ctx, &state,
15920                                 struct rpccli_spoolss_6a_state);
15921         if (req == NULL) {
15922                 return NULL;
15923         }
15924         state->out_mem_ctx = NULL;
15925         state->dispatch_recv = cli->dispatch_recv;
15926
15927         /* In parameters */
15928
15929         /* Out parameters */
15930
15931         /* Result */
15932         ZERO_STRUCT(state->orig.out.result);
15933
15934         /* make a temporary copy, that we pass to the dispatch function */
15935         state->tmp = state->orig;
15936
15937         subreq = cli->dispatch_send(state, ev, cli,
15938                                     &ndr_table_spoolss,
15939                                     NDR_SPOOLSS_6A,
15940                                     &state->tmp);
15941         if (tevent_req_nomem(subreq, req)) {
15942                 return tevent_req_post(req, ev);
15943         }
15944         tevent_req_set_callback(subreq, rpccli_spoolss_6a_done, req);
15945         return req;
15946 }
15947
15948 static void rpccli_spoolss_6a_done(struct tevent_req *subreq)
15949 {
15950         struct tevent_req *req = tevent_req_callback_data(
15951                 subreq, struct tevent_req);
15952         struct rpccli_spoolss_6a_state *state = tevent_req_data(
15953                 req, struct rpccli_spoolss_6a_state);
15954         NTSTATUS status;
15955         TALLOC_CTX *mem_ctx;
15956
15957         if (state->out_mem_ctx) {
15958                 mem_ctx = state->out_mem_ctx;
15959         } else {
15960                 mem_ctx = state;
15961         }
15962
15963         status = state->dispatch_recv(subreq, mem_ctx);
15964         TALLOC_FREE(subreq);
15965         if (!NT_STATUS_IS_OK(status)) {
15966                 tevent_req_nterror(req, status);
15967                 return;
15968         }
15969
15970         /* Copy out parameters */
15971
15972         /* Copy result */
15973         state->orig.out.result = state->tmp.out.result;
15974
15975         /* Reset temporary structure */
15976         ZERO_STRUCT(state->tmp);
15977
15978         tevent_req_done(req);
15979 }
15980
15981 NTSTATUS rpccli_spoolss_6a_recv(struct tevent_req *req,
15982                                 TALLOC_CTX *mem_ctx,
15983                                 WERROR *result)
15984 {
15985         struct rpccli_spoolss_6a_state *state = tevent_req_data(
15986                 req, struct rpccli_spoolss_6a_state);
15987         NTSTATUS status;
15988
15989         if (tevent_req_is_nterror(req, &status)) {
15990                 tevent_req_received(req);
15991                 return status;
15992         }
15993
15994         /* Steal possbile out parameters to the callers context */
15995         talloc_steal(mem_ctx, state->out_mem_ctx);
15996
15997         /* Return result */
15998         *result = state->orig.out.result;
15999
16000         tevent_req_received(req);
16001         return NT_STATUS_OK;
16002 }
16003
16004 NTSTATUS rpccli_spoolss_6a(struct rpc_pipe_client *cli,
16005                            TALLOC_CTX *mem_ctx,
16006                            WERROR *werror)
16007 {
16008         struct spoolss_6a r;
16009         NTSTATUS status;
16010
16011         /* In parameters */
16012
16013         status = cli->dispatch(cli,
16014                                 mem_ctx,
16015                                 &ndr_table_spoolss,
16016                                 NDR_SPOOLSS_6A,
16017                                 &r);
16018
16019         if (!NT_STATUS_IS_OK(status)) {
16020                 return status;
16021         }
16022
16023         if (NT_STATUS_IS_ERR(status)) {
16024                 return status;
16025         }
16026
16027         /* Return variables */
16028
16029         /* Return result */
16030         if (werror) {
16031                 *werror = r.out.result;
16032         }
16033
16034         return werror_to_ntstatus(r.out.result);
16035 }
16036
16037 struct rpccli_spoolss_6b_state {
16038         struct spoolss_6b orig;
16039         struct spoolss_6b tmp;
16040         TALLOC_CTX *out_mem_ctx;
16041         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16042 };
16043
16044 static void rpccli_spoolss_6b_done(struct tevent_req *subreq);
16045
16046 struct tevent_req *rpccli_spoolss_6b_send(TALLOC_CTX *mem_ctx,
16047                                           struct tevent_context *ev,
16048                                           struct rpc_pipe_client *cli)
16049 {
16050         struct tevent_req *req;
16051         struct rpccli_spoolss_6b_state *state;
16052         struct tevent_req *subreq;
16053
16054         req = tevent_req_create(mem_ctx, &state,
16055                                 struct rpccli_spoolss_6b_state);
16056         if (req == NULL) {
16057                 return NULL;
16058         }
16059         state->out_mem_ctx = NULL;
16060         state->dispatch_recv = cli->dispatch_recv;
16061
16062         /* In parameters */
16063
16064         /* Out parameters */
16065
16066         /* Result */
16067         ZERO_STRUCT(state->orig.out.result);
16068
16069         /* make a temporary copy, that we pass to the dispatch function */
16070         state->tmp = state->orig;
16071
16072         subreq = cli->dispatch_send(state, ev, cli,
16073                                     &ndr_table_spoolss,
16074                                     NDR_SPOOLSS_6B,
16075                                     &state->tmp);
16076         if (tevent_req_nomem(subreq, req)) {
16077                 return tevent_req_post(req, ev);
16078         }
16079         tevent_req_set_callback(subreq, rpccli_spoolss_6b_done, req);
16080         return req;
16081 }
16082
16083 static void rpccli_spoolss_6b_done(struct tevent_req *subreq)
16084 {
16085         struct tevent_req *req = tevent_req_callback_data(
16086                 subreq, struct tevent_req);
16087         struct rpccli_spoolss_6b_state *state = tevent_req_data(
16088                 req, struct rpccli_spoolss_6b_state);
16089         NTSTATUS status;
16090         TALLOC_CTX *mem_ctx;
16091
16092         if (state->out_mem_ctx) {
16093                 mem_ctx = state->out_mem_ctx;
16094         } else {
16095                 mem_ctx = state;
16096         }
16097
16098         status = state->dispatch_recv(subreq, mem_ctx);
16099         TALLOC_FREE(subreq);
16100         if (!NT_STATUS_IS_OK(status)) {
16101                 tevent_req_nterror(req, status);
16102                 return;
16103         }
16104
16105         /* Copy out parameters */
16106
16107         /* Copy result */
16108         state->orig.out.result = state->tmp.out.result;
16109
16110         /* Reset temporary structure */
16111         ZERO_STRUCT(state->tmp);
16112
16113         tevent_req_done(req);
16114 }
16115
16116 NTSTATUS rpccli_spoolss_6b_recv(struct tevent_req *req,
16117                                 TALLOC_CTX *mem_ctx,
16118                                 WERROR *result)
16119 {
16120         struct rpccli_spoolss_6b_state *state = tevent_req_data(
16121                 req, struct rpccli_spoolss_6b_state);
16122         NTSTATUS status;
16123
16124         if (tevent_req_is_nterror(req, &status)) {
16125                 tevent_req_received(req);
16126                 return status;
16127         }
16128
16129         /* Steal possbile out parameters to the callers context */
16130         talloc_steal(mem_ctx, state->out_mem_ctx);
16131
16132         /* Return result */
16133         *result = state->orig.out.result;
16134
16135         tevent_req_received(req);
16136         return NT_STATUS_OK;
16137 }
16138
16139 NTSTATUS rpccli_spoolss_6b(struct rpc_pipe_client *cli,
16140                            TALLOC_CTX *mem_ctx,
16141                            WERROR *werror)
16142 {
16143         struct spoolss_6b r;
16144         NTSTATUS status;
16145
16146         /* In parameters */
16147
16148         status = cli->dispatch(cli,
16149                                 mem_ctx,
16150                                 &ndr_table_spoolss,
16151                                 NDR_SPOOLSS_6B,
16152                                 &r);
16153
16154         if (!NT_STATUS_IS_OK(status)) {
16155                 return status;
16156         }
16157
16158         if (NT_STATUS_IS_ERR(status)) {
16159                 return status;
16160         }
16161
16162         /* Return variables */
16163
16164         /* Return result */
16165         if (werror) {
16166                 *werror = r.out.result;
16167         }
16168
16169         return werror_to_ntstatus(r.out.result);
16170 }
16171
16172 struct rpccli_spoolss_6c_state {
16173         struct spoolss_6c orig;
16174         struct spoolss_6c tmp;
16175         TALLOC_CTX *out_mem_ctx;
16176         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16177 };
16178
16179 static void rpccli_spoolss_6c_done(struct tevent_req *subreq);
16180
16181 struct tevent_req *rpccli_spoolss_6c_send(TALLOC_CTX *mem_ctx,
16182                                           struct tevent_context *ev,
16183                                           struct rpc_pipe_client *cli)
16184 {
16185         struct tevent_req *req;
16186         struct rpccli_spoolss_6c_state *state;
16187         struct tevent_req *subreq;
16188
16189         req = tevent_req_create(mem_ctx, &state,
16190                                 struct rpccli_spoolss_6c_state);
16191         if (req == NULL) {
16192                 return NULL;
16193         }
16194         state->out_mem_ctx = NULL;
16195         state->dispatch_recv = cli->dispatch_recv;
16196
16197         /* In parameters */
16198
16199         /* Out parameters */
16200
16201         /* Result */
16202         ZERO_STRUCT(state->orig.out.result);
16203
16204         /* make a temporary copy, that we pass to the dispatch function */
16205         state->tmp = state->orig;
16206
16207         subreq = cli->dispatch_send(state, ev, cli,
16208                                     &ndr_table_spoolss,
16209                                     NDR_SPOOLSS_6C,
16210                                     &state->tmp);
16211         if (tevent_req_nomem(subreq, req)) {
16212                 return tevent_req_post(req, ev);
16213         }
16214         tevent_req_set_callback(subreq, rpccli_spoolss_6c_done, req);
16215         return req;
16216 }
16217
16218 static void rpccli_spoolss_6c_done(struct tevent_req *subreq)
16219 {
16220         struct tevent_req *req = tevent_req_callback_data(
16221                 subreq, struct tevent_req);
16222         struct rpccli_spoolss_6c_state *state = tevent_req_data(
16223                 req, struct rpccli_spoolss_6c_state);
16224         NTSTATUS status;
16225         TALLOC_CTX *mem_ctx;
16226
16227         if (state->out_mem_ctx) {
16228                 mem_ctx = state->out_mem_ctx;
16229         } else {
16230                 mem_ctx = state;
16231         }
16232
16233         status = state->dispatch_recv(subreq, mem_ctx);
16234         TALLOC_FREE(subreq);
16235         if (!NT_STATUS_IS_OK(status)) {
16236                 tevent_req_nterror(req, status);
16237                 return;
16238         }
16239
16240         /* Copy out parameters */
16241
16242         /* Copy result */
16243         state->orig.out.result = state->tmp.out.result;
16244
16245         /* Reset temporary structure */
16246         ZERO_STRUCT(state->tmp);
16247
16248         tevent_req_done(req);
16249 }
16250
16251 NTSTATUS rpccli_spoolss_6c_recv(struct tevent_req *req,
16252                                 TALLOC_CTX *mem_ctx,
16253                                 WERROR *result)
16254 {
16255         struct rpccli_spoolss_6c_state *state = tevent_req_data(
16256                 req, struct rpccli_spoolss_6c_state);
16257         NTSTATUS status;
16258
16259         if (tevent_req_is_nterror(req, &status)) {
16260                 tevent_req_received(req);
16261                 return status;
16262         }
16263
16264         /* Steal possbile out parameters to the callers context */
16265         talloc_steal(mem_ctx, state->out_mem_ctx);
16266
16267         /* Return result */
16268         *result = state->orig.out.result;
16269
16270         tevent_req_received(req);
16271         return NT_STATUS_OK;
16272 }
16273
16274 NTSTATUS rpccli_spoolss_6c(struct rpc_pipe_client *cli,
16275                            TALLOC_CTX *mem_ctx,
16276                            WERROR *werror)
16277 {
16278         struct spoolss_6c r;
16279         NTSTATUS status;
16280
16281         /* In parameters */
16282
16283         status = cli->dispatch(cli,
16284                                 mem_ctx,
16285                                 &ndr_table_spoolss,
16286                                 NDR_SPOOLSS_6C,
16287                                 &r);
16288
16289         if (!NT_STATUS_IS_OK(status)) {
16290                 return status;
16291         }
16292
16293         if (NT_STATUS_IS_ERR(status)) {
16294                 return status;
16295         }
16296
16297         /* Return variables */
16298
16299         /* Return result */
16300         if (werror) {
16301                 *werror = r.out.result;
16302         }
16303
16304         return werror_to_ntstatus(r.out.result);
16305 }
16306
16307 struct rpccli_spoolss_6d_state {
16308         struct spoolss_6d orig;
16309         struct spoolss_6d tmp;
16310         TALLOC_CTX *out_mem_ctx;
16311         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
16312 };
16313
16314 static void rpccli_spoolss_6d_done(struct tevent_req *subreq);
16315
16316 struct tevent_req *rpccli_spoolss_6d_send(TALLOC_CTX *mem_ctx,
16317                                           struct tevent_context *ev,
16318                                           struct rpc_pipe_client *cli)
16319 {
16320         struct tevent_req *req;
16321         struct rpccli_spoolss_6d_state *state;
16322         struct tevent_req *subreq;
16323
16324         req = tevent_req_create(mem_ctx, &state,
16325                                 struct rpccli_spoolss_6d_state);
16326         if (req == NULL) {
16327                 return NULL;
16328         }
16329         state->out_mem_ctx = NULL;
16330         state->dispatch_recv = cli->dispatch_recv;
16331
16332         /* In parameters */
16333
16334         /* Out parameters */
16335
16336         /* Result */
16337         ZERO_STRUCT(state->orig.out.result);
16338
16339         /* make a temporary copy, that we pass to the dispatch function */
16340         state->tmp = state->orig;
16341
16342         subreq = cli->dispatch_send(state, ev, cli,
16343                                     &ndr_table_spoolss,
16344                                     NDR_SPOOLSS_6D,
16345                                     &state->tmp);
16346         if (tevent_req_nomem(subreq, req)) {
16347                 return tevent_req_post(req, ev);
16348         }
16349         tevent_req_set_callback(subreq, rpccli_spoolss_6d_done, req);
16350         return req;
16351 }
16352
16353 static void rpccli_spoolss_6d_done(struct tevent_req *subreq)
16354 {
16355         struct tevent_req *req = tevent_req_callback_data(
16356                 subreq, struct tevent_req);
16357         struct rpccli_spoolss_6d_state *state = tevent_req_data(
16358                 req, struct rpccli_spoolss_6d_state);
16359         NTSTATUS status;
16360         TALLOC_CTX *mem_ctx;
16361
16362         if (state->out_mem_ctx) {
16363                 mem_ctx = state->out_mem_ctx;
16364         } else {
16365                 mem_ctx = state;
16366         }
16367
16368         status = state->dispatch_recv(subreq, mem_ctx);
16369         TALLOC_FREE(subreq);
16370         if (!NT_STATUS_IS_OK(status)) {
16371                 tevent_req_nterror(req, status);
16372                 return;
16373         }
16374
16375         /* Copy out parameters */
16376
16377         /* Copy result */
16378         state->orig.out.result = state->tmp.out.result;
16379
16380         /* Reset temporary structure */
16381         ZERO_STRUCT(state->tmp);
16382
16383         tevent_req_done(req);
16384 }
16385
16386 NTSTATUS rpccli_spoolss_6d_recv(struct tevent_req *req,
16387                                 TALLOC_CTX *mem_ctx,
16388                                 WERROR *result)
16389 {
16390         struct rpccli_spoolss_6d_state *state = tevent_req_data(
16391                 req, struct rpccli_spoolss_6d_state);
16392         NTSTATUS status;
16393
16394         if (tevent_req_is_nterror(req, &status)) {
16395                 tevent_req_received(req);
16396                 return status;
16397         }
16398
16399         /* Steal possbile out parameters to the callers context */
16400         talloc_steal(mem_ctx, state->out_mem_ctx);
16401
16402         /* Return result */
16403         *result = state->orig.out.result;
16404
16405         tevent_req_received(req);
16406         return NT_STATUS_OK;
16407 }
16408
16409 NTSTATUS rpccli_spoolss_6d(struct rpc_pipe_client *cli,
16410                            TALLOC_CTX *mem_ctx,
16411                            WERROR *werror)
16412 {
16413         struct spoolss_6d r;
16414         NTSTATUS status;
16415
16416         /* In parameters */
16417
16418         status = cli->dispatch(cli,
16419                                 mem_ctx,
16420                                 &ndr_table_spoolss,
16421                                 NDR_SPOOLSS_6D,
16422                                 &r);
16423
16424         if (!NT_STATUS_IS_OK(status)) {
16425                 return status;
16426         }
16427
16428         if (NT_STATUS_IS_ERR(status)) {
16429                 return status;
16430         }
16431
16432         /* Return variables */
16433
16434         /* Return result */
16435         if (werror) {
16436                 *werror = r.out.result;
16437         }
16438
16439         return werror_to_ntstatus(r.out.result);
16440 }
16441