librpc/gen_ndr/cli_winreg.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_winreg.h"
   8
   9 struct rpccli_winreg_OpenHKCR_state {
  10         struct winreg_OpenHKCR orig;
  11         struct winreg_OpenHKCR 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_winreg_OpenHKCR_done(struct tevent_req *subreq);
  17
  18 struct tevent_req *rpccli_winreg_OpenHKCR_send(TALLOC_CTX *mem_ctx,
  19                                                struct tevent_context *ev,
  20                                                struct rpc_pipe_client *cli,
  21                                                uint16_t *_system_name /* [in] [unique] */,
  22                                                uint32_t _access_mask /* [in]  */,
  23                                                struct policy_handle *_handle /* [out] [ref] */)
  24 {
  25         struct tevent_req *req;
  26         struct rpccli_winreg_OpenHKCR_state *state;
  27         struct tevent_req *subreq;
  28
  29         req = tevent_req_create(mem_ctx, &state,
  30                                 struct rpccli_winreg_OpenHKCR_state);
  31         if (req == NULL) {
  32                 return NULL;
  33         }
  34         state->out_mem_ctx = NULL;
  35         state->dispatch_recv = cli->dispatch_recv;
  36
  37         /* In parameters */
  38         state->orig.in.system_name = _system_name;
  39         state->orig.in.access_mask = _access_mask;
  40
  41         /* Out parameters */
  42         state->orig.out.handle = _handle;
  43
  44         /* Result */
  45         ZERO_STRUCT(state->orig.out.result);
  46
  47         if (DEBUGLEVEL >= 10) {
  48                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCR, &state->orig);
  49         }
  50
  51         state->out_mem_ctx = talloc_named_const(state, 0,
  52                              "rpccli_winreg_OpenHKCR_out_memory");
  53         if (tevent_req_nomem(state->out_mem_ctx, req)) {
  54                 return tevent_req_post(req, ev);
  55         }
  56
  57         /* make a temporary copy, that we pass to the dispatch function */
  58         state->tmp = state->orig;
  59
  60         subreq = cli->dispatch_send(state, ev, cli,
  61                                     &ndr_table_winreg,
  62                                     NDR_WINREG_OPENHKCR,
  63                                     &state->tmp);
  64         if (tevent_req_nomem(subreq, req)) {
  65                 return tevent_req_post(req, ev);
  66         }
  67         tevent_req_set_callback(subreq, rpccli_winreg_OpenHKCR_done, req);
  68         return req;
  69 }
  70
  71 static void rpccli_winreg_OpenHKCR_done(struct tevent_req *subreq)
  72 {
  73         struct tevent_req *req = tevent_req_callback_data(
  74                 subreq, struct tevent_req);
  75         struct rpccli_winreg_OpenHKCR_state *state = tevent_req_data(
  76                 req, struct rpccli_winreg_OpenHKCR_state);
  77         NTSTATUS status;
  78         TALLOC_CTX *mem_ctx;
  79
  80         if (state->out_mem_ctx) {
  81                 mem_ctx = state->out_mem_ctx;
  82         } else {
  83                 mem_ctx = state;
  84         }
  85
  86         status = state->dispatch_recv(subreq, mem_ctx);
  87         TALLOC_FREE(subreq);
  88         if (!NT_STATUS_IS_OK(status)) {
  89                 tevent_req_nterror(req, status);
  90                 return;
  91         }
  92
  93         /* Copy out parameters */
  94         *state->orig.out.handle = *state->tmp.out.handle;
  95
  96         /* Copy result */
  97         state->orig.out.result = state->tmp.out.result;
  98
  99         /* Reset temporary structure */
 100         ZERO_STRUCT(state->tmp);
 101
 102         if (DEBUGLEVEL >= 10) {
 103                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCR, &state->orig);
 104         }
 105
 106         tevent_req_done(req);
 107 }
 108
 109 NTSTATUS rpccli_winreg_OpenHKCR_recv(struct tevent_req *req,
 110                                      TALLOC_CTX *mem_ctx,
 111                                      WERROR *result)
 112 {
 113         struct rpccli_winreg_OpenHKCR_state *state = tevent_req_data(
 114                 req, struct rpccli_winreg_OpenHKCR_state);
 115         NTSTATUS status;
 116
 117         if (tevent_req_is_nterror(req, &status)) {
 118                 tevent_req_received(req);
 119                 return status;
 120         }
 121
 122         /* Steal possbile out parameters to the callers context */
 123         talloc_steal(mem_ctx, state->out_mem_ctx);
 124
 125         /* Return result */
 126         *result = state->orig.out.result;
 127
 128         tevent_req_received(req);
 129         return NT_STATUS_OK;
 130 }
 131
 132 NTSTATUS rpccli_winreg_OpenHKCR(struct rpc_pipe_client *cli,
 133                                 TALLOC_CTX *mem_ctx,
 134                                 uint16_t *system_name /* [in] [unique] */,
 135                                 uint32_t access_mask /* [in]  */,
 136                                 struct policy_handle *handle /* [out] [ref] */,
 137                                 WERROR *werror)
 138 {
 139         struct winreg_OpenHKCR r;
 140         NTSTATUS status;
 141
 142         /* In parameters */
 143         r.in.system_name = system_name;
 144         r.in.access_mask = access_mask;
 145
 146         if (DEBUGLEVEL >= 10) {
 147                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCR, &r);
 148         }
 149
 150         status = cli->dispatch(cli,
 151                                 mem_ctx,
 152                                 &ndr_table_winreg,
 153                                 NDR_WINREG_OPENHKCR,
 154                                 &r);
 155
 156         if (!NT_STATUS_IS_OK(status)) {
 157                 return status;
 158         }
 159
 160         if (DEBUGLEVEL >= 10) {
 161                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCR, &r);
 162         }
 163
 164         if (NT_STATUS_IS_ERR(status)) {
 165                 return status;
 166         }
 167
 168         /* Return variables */
 169         *handle = *r.out.handle;
 170
 171         /* Return result */
 172         if (werror) {
 173                 *werror = r.out.result;
 174         }
 175
 176         return werror_to_ntstatus(r.out.result);
 177 }
 178
 179 struct rpccli_winreg_OpenHKCU_state {
 180         struct winreg_OpenHKCU orig;
 181         struct winreg_OpenHKCU tmp;
 182         TALLOC_CTX *out_mem_ctx;
 183         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 184 };
 185
 186 static void rpccli_winreg_OpenHKCU_done(struct tevent_req *subreq);
 187
 188 struct tevent_req *rpccli_winreg_OpenHKCU_send(TALLOC_CTX *mem_ctx,
 189                                                struct tevent_context *ev,
 190                                                struct rpc_pipe_client *cli,
 191                                                uint16_t *_system_name /* [in] [unique] */,
 192                                                uint32_t _access_mask /* [in]  */,
 193                                                struct policy_handle *_handle /* [out] [ref] */)
 194 {
 195         struct tevent_req *req;
 196         struct rpccli_winreg_OpenHKCU_state *state;
 197         struct tevent_req *subreq;
 198
 199         req = tevent_req_create(mem_ctx, &state,
 200                                 struct rpccli_winreg_OpenHKCU_state);
 201         if (req == NULL) {
 202                 return NULL;
 203         }
 204         state->out_mem_ctx = NULL;
 205         state->dispatch_recv = cli->dispatch_recv;
 206
 207         /* In parameters */
 208         state->orig.in.system_name = _system_name;
 209         state->orig.in.access_mask = _access_mask;
 210
 211         /* Out parameters */
 212         state->orig.out.handle = _handle;
 213
 214         /* Result */
 215         ZERO_STRUCT(state->orig.out.result);
 216
 217         if (DEBUGLEVEL >= 10) {
 218                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCU, &state->orig);
 219         }
 220
 221         state->out_mem_ctx = talloc_named_const(state, 0,
 222                              "rpccli_winreg_OpenHKCU_out_memory");
 223         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 224                 return tevent_req_post(req, ev);
 225         }
 226
 227         /* make a temporary copy, that we pass to the dispatch function */
 228         state->tmp = state->orig;
 229
 230         subreq = cli->dispatch_send(state, ev, cli,
 231                                     &ndr_table_winreg,
 232                                     NDR_WINREG_OPENHKCU,
 233                                     &state->tmp);
 234         if (tevent_req_nomem(subreq, req)) {
 235                 return tevent_req_post(req, ev);
 236         }
 237         tevent_req_set_callback(subreq, rpccli_winreg_OpenHKCU_done, req);
 238         return req;
 239 }
 240
 241 static void rpccli_winreg_OpenHKCU_done(struct tevent_req *subreq)
 242 {
 243         struct tevent_req *req = tevent_req_callback_data(
 244                 subreq, struct tevent_req);
 245         struct rpccli_winreg_OpenHKCU_state *state = tevent_req_data(
 246                 req, struct rpccli_winreg_OpenHKCU_state);
 247         NTSTATUS status;
 248         TALLOC_CTX *mem_ctx;
 249
 250         if (state->out_mem_ctx) {
 251                 mem_ctx = state->out_mem_ctx;
 252         } else {
 253                 mem_ctx = state;
 254         }
 255
 256         status = state->dispatch_recv(subreq, mem_ctx);
 257         TALLOC_FREE(subreq);
 258         if (!NT_STATUS_IS_OK(status)) {
 259                 tevent_req_nterror(req, status);
 260                 return;
 261         }
 262
 263         /* Copy out parameters */
 264         *state->orig.out.handle = *state->tmp.out.handle;
 265
 266         /* Copy result */
 267         state->orig.out.result = state->tmp.out.result;
 268
 269         /* Reset temporary structure */
 270         ZERO_STRUCT(state->tmp);
 271
 272         if (DEBUGLEVEL >= 10) {
 273                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCU, &state->orig);
 274         }
 275
 276         tevent_req_done(req);
 277 }
 278
 279 NTSTATUS rpccli_winreg_OpenHKCU_recv(struct tevent_req *req,
 280                                      TALLOC_CTX *mem_ctx,
 281                                      WERROR *result)
 282 {
 283         struct rpccli_winreg_OpenHKCU_state *state = tevent_req_data(
 284                 req, struct rpccli_winreg_OpenHKCU_state);
 285         NTSTATUS status;
 286
 287         if (tevent_req_is_nterror(req, &status)) {
 288                 tevent_req_received(req);
 289                 return status;
 290         }
 291
 292         /* Steal possbile out parameters to the callers context */
 293         talloc_steal(mem_ctx, state->out_mem_ctx);
 294
 295         /* Return result */
 296         *result = state->orig.out.result;
 297
 298         tevent_req_received(req);
 299         return NT_STATUS_OK;
 300 }
 301
 302 NTSTATUS rpccli_winreg_OpenHKCU(struct rpc_pipe_client *cli,
 303                                 TALLOC_CTX *mem_ctx,
 304                                 uint16_t *system_name /* [in] [unique] */,
 305                                 uint32_t access_mask /* [in]  */,
 306                                 struct policy_handle *handle /* [out] [ref] */,
 307                                 WERROR *werror)
 308 {
 309         struct winreg_OpenHKCU r;
 310         NTSTATUS status;
 311
 312         /* In parameters */
 313         r.in.system_name = system_name;
 314         r.in.access_mask = access_mask;
 315
 316         if (DEBUGLEVEL >= 10) {
 317                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCU, &r);
 318         }
 319
 320         status = cli->dispatch(cli,
 321                                 mem_ctx,
 322                                 &ndr_table_winreg,
 323                                 NDR_WINREG_OPENHKCU,
 324                                 &r);
 325
 326         if (!NT_STATUS_IS_OK(status)) {
 327                 return status;
 328         }
 329
 330         if (DEBUGLEVEL >= 10) {
 331                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCU, &r);
 332         }
 333
 334         if (NT_STATUS_IS_ERR(status)) {
 335                 return status;
 336         }
 337
 338         /* Return variables */
 339         *handle = *r.out.handle;
 340
 341         /* Return result */
 342         if (werror) {
 343                 *werror = r.out.result;
 344         }
 345
 346         return werror_to_ntstatus(r.out.result);
 347 }
 348
 349 struct rpccli_winreg_OpenHKLM_state {
 350         struct winreg_OpenHKLM orig;
 351         struct winreg_OpenHKLM tmp;
 352         TALLOC_CTX *out_mem_ctx;
 353         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 354 };
 355
 356 static void rpccli_winreg_OpenHKLM_done(struct tevent_req *subreq);
 357
 358 struct tevent_req *rpccli_winreg_OpenHKLM_send(TALLOC_CTX *mem_ctx,
 359                                                struct tevent_context *ev,
 360                                                struct rpc_pipe_client *cli,
 361                                                uint16_t *_system_name /* [in] [unique] */,
 362                                                uint32_t _access_mask /* [in]  */,
 363                                                struct policy_handle *_handle /* [out] [ref] */)
 364 {
 365         struct tevent_req *req;
 366         struct rpccli_winreg_OpenHKLM_state *state;
 367         struct tevent_req *subreq;
 368
 369         req = tevent_req_create(mem_ctx, &state,
 370                                 struct rpccli_winreg_OpenHKLM_state);
 371         if (req == NULL) {
 372                 return NULL;
 373         }
 374         state->out_mem_ctx = NULL;
 375         state->dispatch_recv = cli->dispatch_recv;
 376
 377         /* In parameters */
 378         state->orig.in.system_name = _system_name;
 379         state->orig.in.access_mask = _access_mask;
 380
 381         /* Out parameters */
 382         state->orig.out.handle = _handle;
 383
 384         /* Result */
 385         ZERO_STRUCT(state->orig.out.result);
 386
 387         if (DEBUGLEVEL >= 10) {
 388                 NDR_PRINT_IN_DEBUG(winreg_OpenHKLM, &state->orig);
 389         }
 390
 391         state->out_mem_ctx = talloc_named_const(state, 0,
 392                              "rpccli_winreg_OpenHKLM_out_memory");
 393         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 394                 return tevent_req_post(req, ev);
 395         }
 396
 397         /* make a temporary copy, that we pass to the dispatch function */
 398         state->tmp = state->orig;
 399
 400         subreq = cli->dispatch_send(state, ev, cli,
 401                                     &ndr_table_winreg,
 402                                     NDR_WINREG_OPENHKLM,
 403                                     &state->tmp);
 404         if (tevent_req_nomem(subreq, req)) {
 405                 return tevent_req_post(req, ev);
 406         }
 407         tevent_req_set_callback(subreq, rpccli_winreg_OpenHKLM_done, req);
 408         return req;
 409 }
 410
 411 static void rpccli_winreg_OpenHKLM_done(struct tevent_req *subreq)
 412 {
 413         struct tevent_req *req = tevent_req_callback_data(
 414                 subreq, struct tevent_req);
 415         struct rpccli_winreg_OpenHKLM_state *state = tevent_req_data(
 416                 req, struct rpccli_winreg_OpenHKLM_state);
 417         NTSTATUS status;
 418         TALLOC_CTX *mem_ctx;
 419
 420         if (state->out_mem_ctx) {
 421                 mem_ctx = state->out_mem_ctx;
 422         } else {
 423                 mem_ctx = state;
 424         }
 425
 426         status = state->dispatch_recv(subreq, mem_ctx);
 427         TALLOC_FREE(subreq);
 428         if (!NT_STATUS_IS_OK(status)) {
 429                 tevent_req_nterror(req, status);
 430                 return;
 431         }
 432
 433         /* Copy out parameters */
 434         *state->orig.out.handle = *state->tmp.out.handle;
 435
 436         /* Copy result */
 437         state->orig.out.result = state->tmp.out.result;
 438
 439         /* Reset temporary structure */
 440         ZERO_STRUCT(state->tmp);
 441
 442         if (DEBUGLEVEL >= 10) {
 443                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKLM, &state->orig);
 444         }
 445
 446         tevent_req_done(req);
 447 }
 448
 449 NTSTATUS rpccli_winreg_OpenHKLM_recv(struct tevent_req *req,
 450                                      TALLOC_CTX *mem_ctx,
 451                                      WERROR *result)
 452 {
 453         struct rpccli_winreg_OpenHKLM_state *state = tevent_req_data(
 454                 req, struct rpccli_winreg_OpenHKLM_state);
 455         NTSTATUS status;
 456
 457         if (tevent_req_is_nterror(req, &status)) {
 458                 tevent_req_received(req);
 459                 return status;
 460         }
 461
 462         /* Steal possbile out parameters to the callers context */
 463         talloc_steal(mem_ctx, state->out_mem_ctx);
 464
 465         /* Return result */
 466         *result = state->orig.out.result;
 467
 468         tevent_req_received(req);
 469         return NT_STATUS_OK;
 470 }
 471
 472 NTSTATUS rpccli_winreg_OpenHKLM(struct rpc_pipe_client *cli,
 473                                 TALLOC_CTX *mem_ctx,
 474                                 uint16_t *system_name /* [in] [unique] */,
 475                                 uint32_t access_mask /* [in]  */,
 476                                 struct policy_handle *handle /* [out] [ref] */,
 477                                 WERROR *werror)
 478 {
 479         struct winreg_OpenHKLM r;
 480         NTSTATUS status;
 481
 482         /* In parameters */
 483         r.in.system_name = system_name;
 484         r.in.access_mask = access_mask;
 485
 486         if (DEBUGLEVEL >= 10) {
 487                 NDR_PRINT_IN_DEBUG(winreg_OpenHKLM, &r);
 488         }
 489
 490         status = cli->dispatch(cli,
 491                                 mem_ctx,
 492                                 &ndr_table_winreg,
 493                                 NDR_WINREG_OPENHKLM,
 494                                 &r);
 495
 496         if (!NT_STATUS_IS_OK(status)) {
 497                 return status;
 498         }
 499
 500         if (DEBUGLEVEL >= 10) {
 501                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKLM, &r);
 502         }
 503
 504         if (NT_STATUS_IS_ERR(status)) {
 505                 return status;
 506         }
 507
 508         /* Return variables */
 509         *handle = *r.out.handle;
 510
 511         /* Return result */
 512         if (werror) {
 513                 *werror = r.out.result;
 514         }
 515
 516         return werror_to_ntstatus(r.out.result);
 517 }
 518
 519 struct rpccli_winreg_OpenHKPD_state {
 520         struct winreg_OpenHKPD orig;
 521         struct winreg_OpenHKPD tmp;
 522         TALLOC_CTX *out_mem_ctx;
 523         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 524 };
 525
 526 static void rpccli_winreg_OpenHKPD_done(struct tevent_req *subreq);
 527
 528 struct tevent_req *rpccli_winreg_OpenHKPD_send(TALLOC_CTX *mem_ctx,
 529                                                struct tevent_context *ev,
 530                                                struct rpc_pipe_client *cli,
 531                                                uint16_t *_system_name /* [in] [unique] */,
 532                                                uint32_t _access_mask /* [in]  */,
 533                                                struct policy_handle *_handle /* [out] [ref] */)
 534 {
 535         struct tevent_req *req;
 536         struct rpccli_winreg_OpenHKPD_state *state;
 537         struct tevent_req *subreq;
 538
 539         req = tevent_req_create(mem_ctx, &state,
 540                                 struct rpccli_winreg_OpenHKPD_state);
 541         if (req == NULL) {
 542                 return NULL;
 543         }
 544         state->out_mem_ctx = NULL;
 545         state->dispatch_recv = cli->dispatch_recv;
 546
 547         /* In parameters */
 548         state->orig.in.system_name = _system_name;
 549         state->orig.in.access_mask = _access_mask;
 550
 551         /* Out parameters */
 552         state->orig.out.handle = _handle;
 553
 554         /* Result */
 555         ZERO_STRUCT(state->orig.out.result);
 556
 557         if (DEBUGLEVEL >= 10) {
 558                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPD, &state->orig);
 559         }
 560
 561         state->out_mem_ctx = talloc_named_const(state, 0,
 562                              "rpccli_winreg_OpenHKPD_out_memory");
 563         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 564                 return tevent_req_post(req, ev);
 565         }
 566
 567         /* make a temporary copy, that we pass to the dispatch function */
 568         state->tmp = state->orig;
 569
 570         subreq = cli->dispatch_send(state, ev, cli,
 571                                     &ndr_table_winreg,
 572                                     NDR_WINREG_OPENHKPD,
 573                                     &state->tmp);
 574         if (tevent_req_nomem(subreq, req)) {
 575                 return tevent_req_post(req, ev);
 576         }
 577         tevent_req_set_callback(subreq, rpccli_winreg_OpenHKPD_done, req);
 578         return req;
 579 }
 580
 581 static void rpccli_winreg_OpenHKPD_done(struct tevent_req *subreq)
 582 {
 583         struct tevent_req *req = tevent_req_callback_data(
 584                 subreq, struct tevent_req);
 585         struct rpccli_winreg_OpenHKPD_state *state = tevent_req_data(
 586                 req, struct rpccli_winreg_OpenHKPD_state);
 587         NTSTATUS status;
 588         TALLOC_CTX *mem_ctx;
 589
 590         if (state->out_mem_ctx) {
 591                 mem_ctx = state->out_mem_ctx;
 592         } else {
 593                 mem_ctx = state;
 594         }
 595
 596         status = state->dispatch_recv(subreq, mem_ctx);
 597         TALLOC_FREE(subreq);
 598         if (!NT_STATUS_IS_OK(status)) {
 599                 tevent_req_nterror(req, status);
 600                 return;
 601         }
 602
 603         /* Copy out parameters */
 604         *state->orig.out.handle = *state->tmp.out.handle;
 605
 606         /* Copy result */
 607         state->orig.out.result = state->tmp.out.result;
 608
 609         /* Reset temporary structure */
 610         ZERO_STRUCT(state->tmp);
 611
 612         if (DEBUGLEVEL >= 10) {
 613                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPD, &state->orig);
 614         }
 615
 616         tevent_req_done(req);
 617 }
 618
 619 NTSTATUS rpccli_winreg_OpenHKPD_recv(struct tevent_req *req,
 620                                      TALLOC_CTX *mem_ctx,
 621                                      WERROR *result)
 622 {
 623         struct rpccli_winreg_OpenHKPD_state *state = tevent_req_data(
 624                 req, struct rpccli_winreg_OpenHKPD_state);
 625         NTSTATUS status;
 626
 627         if (tevent_req_is_nterror(req, &status)) {
 628                 tevent_req_received(req);
 629                 return status;
 630         }
 631
 632         /* Steal possbile out parameters to the callers context */
 633         talloc_steal(mem_ctx, state->out_mem_ctx);
 634
 635         /* Return result */
 636         *result = state->orig.out.result;
 637
 638         tevent_req_received(req);
 639         return NT_STATUS_OK;
 640 }
 641
 642 NTSTATUS rpccli_winreg_OpenHKPD(struct rpc_pipe_client *cli,
 643                                 TALLOC_CTX *mem_ctx,
 644                                 uint16_t *system_name /* [in] [unique] */,
 645                                 uint32_t access_mask /* [in]  */,
 646                                 struct policy_handle *handle /* [out] [ref] */,
 647                                 WERROR *werror)
 648 {
 649         struct winreg_OpenHKPD r;
 650         NTSTATUS status;
 651
 652         /* In parameters */
 653         r.in.system_name = system_name;
 654         r.in.access_mask = access_mask;
 655
 656         if (DEBUGLEVEL >= 10) {
 657                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPD, &r);
 658         }
 659
 660         status = cli->dispatch(cli,
 661                                 mem_ctx,
 662                                 &ndr_table_winreg,
 663                                 NDR_WINREG_OPENHKPD,
 664                                 &r);
 665
 666         if (!NT_STATUS_IS_OK(status)) {
 667                 return status;
 668         }
 669
 670         if (DEBUGLEVEL >= 10) {
 671                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPD, &r);
 672         }
 673
 674         if (NT_STATUS_IS_ERR(status)) {
 675                 return status;
 676         }
 677
 678         /* Return variables */
 679         *handle = *r.out.handle;
 680
 681         /* Return result */
 682         if (werror) {
 683                 *werror = r.out.result;
 684         }
 685
 686         return werror_to_ntstatus(r.out.result);
 687 }
 688
 689 struct rpccli_winreg_OpenHKU_state {
 690         struct winreg_OpenHKU orig;
 691         struct winreg_OpenHKU tmp;
 692         TALLOC_CTX *out_mem_ctx;
 693         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 694 };
 695
 696 static void rpccli_winreg_OpenHKU_done(struct tevent_req *subreq);
 697
 698 struct tevent_req *rpccli_winreg_OpenHKU_send(TALLOC_CTX *mem_ctx,
 699                                               struct tevent_context *ev,
 700                                               struct rpc_pipe_client *cli,
 701                                               uint16_t *_system_name /* [in] [unique] */,
 702                                               uint32_t _access_mask /* [in]  */,
 703                                               struct policy_handle *_handle /* [out] [ref] */)
 704 {
 705         struct tevent_req *req;
 706         struct rpccli_winreg_OpenHKU_state *state;
 707         struct tevent_req *subreq;
 708
 709         req = tevent_req_create(mem_ctx, &state,
 710                                 struct rpccli_winreg_OpenHKU_state);
 711         if (req == NULL) {
 712                 return NULL;
 713         }
 714         state->out_mem_ctx = NULL;
 715         state->dispatch_recv = cli->dispatch_recv;
 716
 717         /* In parameters */
 718         state->orig.in.system_name = _system_name;
 719         state->orig.in.access_mask = _access_mask;
 720
 721         /* Out parameters */
 722         state->orig.out.handle = _handle;
 723
 724         /* Result */
 725         ZERO_STRUCT(state->orig.out.result);
 726
 727         if (DEBUGLEVEL >= 10) {
 728                 NDR_PRINT_IN_DEBUG(winreg_OpenHKU, &state->orig);
 729         }
 730
 731         state->out_mem_ctx = talloc_named_const(state, 0,
 732                              "rpccli_winreg_OpenHKU_out_memory");
 733         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 734                 return tevent_req_post(req, ev);
 735         }
 736
 737         /* make a temporary copy, that we pass to the dispatch function */
 738         state->tmp = state->orig;
 739
 740         subreq = cli->dispatch_send(state, ev, cli,
 741                                     &ndr_table_winreg,
 742                                     NDR_WINREG_OPENHKU,
 743                                     &state->tmp);
 744         if (tevent_req_nomem(subreq, req)) {
 745                 return tevent_req_post(req, ev);
 746         }
 747         tevent_req_set_callback(subreq, rpccli_winreg_OpenHKU_done, req);
 748         return req;
 749 }
 750
 751 static void rpccli_winreg_OpenHKU_done(struct tevent_req *subreq)
 752 {
 753         struct tevent_req *req = tevent_req_callback_data(
 754                 subreq, struct tevent_req);
 755         struct rpccli_winreg_OpenHKU_state *state = tevent_req_data(
 756                 req, struct rpccli_winreg_OpenHKU_state);
 757         NTSTATUS status;
 758         TALLOC_CTX *mem_ctx;
 759
 760         if (state->out_mem_ctx) {
 761                 mem_ctx = state->out_mem_ctx;
 762         } else {
 763                 mem_ctx = state;
 764         }
 765
 766         status = state->dispatch_recv(subreq, mem_ctx);
 767         TALLOC_FREE(subreq);
 768         if (!NT_STATUS_IS_OK(status)) {
 769                 tevent_req_nterror(req, status);
 770                 return;
 771         }
 772
 773         /* Copy out parameters */
 774         *state->orig.out.handle = *state->tmp.out.handle;
 775
 776         /* Copy result */
 777         state->orig.out.result = state->tmp.out.result;
 778
 779         /* Reset temporary structure */
 780         ZERO_STRUCT(state->tmp);
 781
 782         if (DEBUGLEVEL >= 10) {
 783                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKU, &state->orig);
 784         }
 785
 786         tevent_req_done(req);
 787 }
 788
 789 NTSTATUS rpccli_winreg_OpenHKU_recv(struct tevent_req *req,
 790                                     TALLOC_CTX *mem_ctx,
 791                                     WERROR *result)
 792 {
 793         struct rpccli_winreg_OpenHKU_state *state = tevent_req_data(
 794                 req, struct rpccli_winreg_OpenHKU_state);
 795         NTSTATUS status;
 796
 797         if (tevent_req_is_nterror(req, &status)) {
 798                 tevent_req_received(req);
 799                 return status;
 800         }
 801
 802         /* Steal possbile out parameters to the callers context */
 803         talloc_steal(mem_ctx, state->out_mem_ctx);
 804
 805         /* Return result */
 806         *result = state->orig.out.result;
 807
 808         tevent_req_received(req);
 809         return NT_STATUS_OK;
 810 }
 811
 812 NTSTATUS rpccli_winreg_OpenHKU(struct rpc_pipe_client *cli,
 813                                TALLOC_CTX *mem_ctx,
 814                                uint16_t *system_name /* [in] [unique] */,
 815                                uint32_t access_mask /* [in]  */,
 816                                struct policy_handle *handle /* [out] [ref] */,
 817                                WERROR *werror)
 818 {
 819         struct winreg_OpenHKU r;
 820         NTSTATUS status;
 821
 822         /* In parameters */
 823         r.in.system_name = system_name;
 824         r.in.access_mask = access_mask;
 825
 826         if (DEBUGLEVEL >= 10) {
 827                 NDR_PRINT_IN_DEBUG(winreg_OpenHKU, &r);
 828         }
 829
 830         status = cli->dispatch(cli,
 831                                 mem_ctx,
 832                                 &ndr_table_winreg,
 833                                 NDR_WINREG_OPENHKU,
 834                                 &r);
 835
 836         if (!NT_STATUS_IS_OK(status)) {
 837                 return status;
 838         }
 839
 840         if (DEBUGLEVEL >= 10) {
 841                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKU, &r);
 842         }
 843
 844         if (NT_STATUS_IS_ERR(status)) {
 845                 return status;
 846         }
 847
 848         /* Return variables */
 849         *handle = *r.out.handle;
 850
 851         /* Return result */
 852         if (werror) {
 853                 *werror = r.out.result;
 854         }
 855
 856         return werror_to_ntstatus(r.out.result);
 857 }
 858
 859 struct rpccli_winreg_CloseKey_state {
 860         struct winreg_CloseKey orig;
 861         struct winreg_CloseKey tmp;
 862         TALLOC_CTX *out_mem_ctx;
 863         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 864 };
 865
 866 static void rpccli_winreg_CloseKey_done(struct tevent_req *subreq);
 867
 868 struct tevent_req *rpccli_winreg_CloseKey_send(TALLOC_CTX *mem_ctx,
 869                                                struct tevent_context *ev,
 870                                                struct rpc_pipe_client *cli,
 871                                                struct policy_handle *_handle /* [in,out] [ref] */)
 872 {
 873         struct tevent_req *req;
 874         struct rpccli_winreg_CloseKey_state *state;
 875         struct tevent_req *subreq;
 876
 877         req = tevent_req_create(mem_ctx, &state,
 878                                 struct rpccli_winreg_CloseKey_state);
 879         if (req == NULL) {
 880                 return NULL;
 881         }
 882         state->out_mem_ctx = NULL;
 883         state->dispatch_recv = cli->dispatch_recv;
 884
 885         /* In parameters */
 886         state->orig.in.handle = _handle;
 887
 888         /* Out parameters */
 889         state->orig.out.handle = _handle;
 890
 891         /* Result */
 892         ZERO_STRUCT(state->orig.out.result);
 893
 894         if (DEBUGLEVEL >= 10) {
 895                 NDR_PRINT_IN_DEBUG(winreg_CloseKey, &state->orig);
 896         }
 897
 898         state->out_mem_ctx = talloc_named_const(state, 0,
 899                              "rpccli_winreg_CloseKey_out_memory");
 900         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 901                 return tevent_req_post(req, ev);
 902         }
 903
 904         /* make a temporary copy, that we pass to the dispatch function */
 905         state->tmp = state->orig;
 906
 907         subreq = cli->dispatch_send(state, ev, cli,
 908                                     &ndr_table_winreg,
 909                                     NDR_WINREG_CLOSEKEY,
 910                                     &state->tmp);
 911         if (tevent_req_nomem(subreq, req)) {
 912                 return tevent_req_post(req, ev);
 913         }
 914         tevent_req_set_callback(subreq, rpccli_winreg_CloseKey_done, req);
 915         return req;
 916 }
 917
 918 static void rpccli_winreg_CloseKey_done(struct tevent_req *subreq)
 919 {
 920         struct tevent_req *req = tevent_req_callback_data(
 921                 subreq, struct tevent_req);
 922         struct rpccli_winreg_CloseKey_state *state = tevent_req_data(
 923                 req, struct rpccli_winreg_CloseKey_state);
 924         NTSTATUS status;
 925         TALLOC_CTX *mem_ctx;
 926
 927         if (state->out_mem_ctx) {
 928                 mem_ctx = state->out_mem_ctx;
 929         } else {
 930                 mem_ctx = state;
 931         }
 932
 933         status = state->dispatch_recv(subreq, mem_ctx);
 934         TALLOC_FREE(subreq);
 935         if (!NT_STATUS_IS_OK(status)) {
 936                 tevent_req_nterror(req, status);
 937                 return;
 938         }
 939
 940         /* Copy out parameters */
 941         *state->orig.out.handle = *state->tmp.out.handle;
 942
 943         /* Copy result */
 944         state->orig.out.result = state->tmp.out.result;
 945
 946         /* Reset temporary structure */
 947         ZERO_STRUCT(state->tmp);
 948
 949         if (DEBUGLEVEL >= 10) {
 950                 NDR_PRINT_OUT_DEBUG(winreg_CloseKey, &state->orig);
 951         }
 952
 953         tevent_req_done(req);
 954 }
 955
 956 NTSTATUS rpccli_winreg_CloseKey_recv(struct tevent_req *req,
 957                                      TALLOC_CTX *mem_ctx,
 958                                      WERROR *result)
 959 {
 960         struct rpccli_winreg_CloseKey_state *state = tevent_req_data(
 961                 req, struct rpccli_winreg_CloseKey_state);
 962         NTSTATUS status;
 963
 964         if (tevent_req_is_nterror(req, &status)) {
 965                 tevent_req_received(req);
 966                 return status;
 967         }
 968
 969         /* Steal possbile out parameters to the callers context */
 970         talloc_steal(mem_ctx, state->out_mem_ctx);
 971
 972         /* Return result */
 973         *result = state->orig.out.result;
 974
 975         tevent_req_received(req);
 976         return NT_STATUS_OK;
 977 }
 978
 979 NTSTATUS rpccli_winreg_CloseKey(struct rpc_pipe_client *cli,
 980                                 TALLOC_CTX *mem_ctx,
 981                                 struct policy_handle *handle /* [in,out] [ref] */,
 982                                 WERROR *werror)
 983 {
 984         struct winreg_CloseKey r;
 985         NTSTATUS status;
 986
 987         /* In parameters */
 988         r.in.handle = handle;
 989
 990         if (DEBUGLEVEL >= 10) {
 991                 NDR_PRINT_IN_DEBUG(winreg_CloseKey, &r);
 992         }
 993
 994         status = cli->dispatch(cli,
 995                                 mem_ctx,
 996                                 &ndr_table_winreg,
 997                                 NDR_WINREG_CLOSEKEY,
 998                                 &r);
 999
1000         if (!NT_STATUS_IS_OK(status)) {
1001                 return status;
1002         }
1003
1004         if (DEBUGLEVEL >= 10) {
1005                 NDR_PRINT_OUT_DEBUG(winreg_CloseKey, &r);
1006         }
1007
1008         if (NT_STATUS_IS_ERR(status)) {
1009                 return status;
1010         }
1011
1012         /* Return variables */
1013         *handle = *r.out.handle;
1014
1015         /* Return result */
1016         if (werror) {
1017                 *werror = r.out.result;
1018         }
1019
1020         return werror_to_ntstatus(r.out.result);
1021 }
1022
1023 struct rpccli_winreg_CreateKey_state {
1024         struct winreg_CreateKey orig;
1025         struct winreg_CreateKey tmp;
1026         TALLOC_CTX *out_mem_ctx;
1027         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1028 };
1029
1030 static void rpccli_winreg_CreateKey_done(struct tevent_req *subreq);
1031
1032 struct tevent_req *rpccli_winreg_CreateKey_send(TALLOC_CTX *mem_ctx,
1033                                                 struct tevent_context *ev,
1034                                                 struct rpc_pipe_client *cli,
1035                                                 struct policy_handle *_handle /* [in] [ref] */,
1036                                                 struct winreg_String _name /* [in]  */,
1037                                                 struct winreg_String _keyclass /* [in]  */,
1038                                                 uint32_t _options /* [in]  */,
1039                                                 uint32_t _access_mask /* [in]  */,
1040                                                 struct winreg_SecBuf *_secdesc /* [in] [unique] */,
1041                                                 struct policy_handle *_new_handle /* [out] [ref] */,
1042                                                 enum winreg_CreateAction *_action_taken /* [in,out] [unique] */)
1043 {
1044         struct tevent_req *req;
1045         struct rpccli_winreg_CreateKey_state *state;
1046         struct tevent_req *subreq;
1047
1048         req = tevent_req_create(mem_ctx, &state,
1049                                 struct rpccli_winreg_CreateKey_state);
1050         if (req == NULL) {
1051                 return NULL;
1052         }
1053         state->out_mem_ctx = NULL;
1054         state->dispatch_recv = cli->dispatch_recv;
1055
1056         /* In parameters */
1057         state->orig.in.handle = _handle;
1058         state->orig.in.name = _name;
1059         state->orig.in.keyclass = _keyclass;
1060         state->orig.in.options = _options;
1061         state->orig.in.access_mask = _access_mask;
1062         state->orig.in.secdesc = _secdesc;
1063         state->orig.in.action_taken = _action_taken;
1064
1065         /* Out parameters */
1066         state->orig.out.new_handle = _new_handle;
1067         state->orig.out.action_taken = _action_taken;
1068
1069         /* Result */
1070         ZERO_STRUCT(state->orig.out.result);
1071
1072         if (DEBUGLEVEL >= 10) {
1073                 NDR_PRINT_IN_DEBUG(winreg_CreateKey, &state->orig);
1074         }
1075
1076         state->out_mem_ctx = talloc_named_const(state, 0,
1077                              "rpccli_winreg_CreateKey_out_memory");
1078         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1079                 return tevent_req_post(req, ev);
1080         }
1081
1082         /* make a temporary copy, that we pass to the dispatch function */
1083         state->tmp = state->orig;
1084
1085         subreq = cli->dispatch_send(state, ev, cli,
1086                                     &ndr_table_winreg,
1087                                     NDR_WINREG_CREATEKEY,
1088                                     &state->tmp);
1089         if (tevent_req_nomem(subreq, req)) {
1090                 return tevent_req_post(req, ev);
1091         }
1092         tevent_req_set_callback(subreq, rpccli_winreg_CreateKey_done, req);
1093         return req;
1094 }
1095
1096 static void rpccli_winreg_CreateKey_done(struct tevent_req *subreq)
1097 {
1098         struct tevent_req *req = tevent_req_callback_data(
1099                 subreq, struct tevent_req);
1100         struct rpccli_winreg_CreateKey_state *state = tevent_req_data(
1101                 req, struct rpccli_winreg_CreateKey_state);
1102         NTSTATUS status;
1103         TALLOC_CTX *mem_ctx;
1104
1105         if (state->out_mem_ctx) {
1106                 mem_ctx = state->out_mem_ctx;
1107         } else {
1108                 mem_ctx = state;
1109         }
1110
1111         status = state->dispatch_recv(subreq, mem_ctx);
1112         TALLOC_FREE(subreq);
1113         if (!NT_STATUS_IS_OK(status)) {
1114                 tevent_req_nterror(req, status);
1115                 return;
1116         }
1117
1118         /* Copy out parameters */
1119         *state->orig.out.new_handle = *state->tmp.out.new_handle;
1120         if (state->orig.out.action_taken && state->tmp.out.action_taken) {
1121                 *state->orig.out.action_taken = *state->tmp.out.action_taken;
1122         }
1123
1124         /* Copy result */
1125         state->orig.out.result = state->tmp.out.result;
1126
1127         /* Reset temporary structure */
1128         ZERO_STRUCT(state->tmp);
1129
1130         if (DEBUGLEVEL >= 10) {
1131                 NDR_PRINT_OUT_DEBUG(winreg_CreateKey, &state->orig);
1132         }
1133
1134         tevent_req_done(req);
1135 }
1136
1137 NTSTATUS rpccli_winreg_CreateKey_recv(struct tevent_req *req,
1138                                       TALLOC_CTX *mem_ctx,
1139                                       WERROR *result)
1140 {
1141         struct rpccli_winreg_CreateKey_state *state = tevent_req_data(
1142                 req, struct rpccli_winreg_CreateKey_state);
1143         NTSTATUS status;
1144
1145         if (tevent_req_is_nterror(req, &status)) {
1146                 tevent_req_received(req);
1147                 return status;
1148         }
1149
1150         /* Steal possbile out parameters to the callers context */
1151         talloc_steal(mem_ctx, state->out_mem_ctx);
1152
1153         /* Return result */
1154         *result = state->orig.out.result;
1155
1156         tevent_req_received(req);
1157         return NT_STATUS_OK;
1158 }
1159
1160 NTSTATUS rpccli_winreg_CreateKey(struct rpc_pipe_client *cli,
1161                                  TALLOC_CTX *mem_ctx,
1162                                  struct policy_handle *handle /* [in] [ref] */,
1163                                  struct winreg_String name /* [in]  */,
1164                                  struct winreg_String keyclass /* [in]  */,
1165                                  uint32_t options /* [in]  */,
1166                                  uint32_t access_mask /* [in]  */,
1167                                  struct winreg_SecBuf *secdesc /* [in] [unique] */,
1168                                  struct policy_handle *new_handle /* [out] [ref] */,
1169                                  enum winreg_CreateAction *action_taken /* [in,out] [unique] */,
1170                                  WERROR *werror)
1171 {
1172         struct winreg_CreateKey r;
1173         NTSTATUS status;
1174
1175         /* In parameters */
1176         r.in.handle = handle;
1177         r.in.name = name;
1178         r.in.keyclass = keyclass;
1179         r.in.options = options;
1180         r.in.access_mask = access_mask;
1181         r.in.secdesc = secdesc;
1182         r.in.action_taken = action_taken;
1183
1184         if (DEBUGLEVEL >= 10) {
1185                 NDR_PRINT_IN_DEBUG(winreg_CreateKey, &r);
1186         }
1187
1188         status = cli->dispatch(cli,
1189                                 mem_ctx,
1190                                 &ndr_table_winreg,
1191                                 NDR_WINREG_CREATEKEY,
1192                                 &r);
1193
1194         if (!NT_STATUS_IS_OK(status)) {
1195                 return status;
1196         }
1197
1198         if (DEBUGLEVEL >= 10) {
1199                 NDR_PRINT_OUT_DEBUG(winreg_CreateKey, &r);
1200         }
1201
1202         if (NT_STATUS_IS_ERR(status)) {
1203                 return status;
1204         }
1205
1206         /* Return variables */
1207         *new_handle = *r.out.new_handle;
1208         if (action_taken && r.out.action_taken) {
1209                 *action_taken = *r.out.action_taken;
1210         }
1211
1212         /* Return result */
1213         if (werror) {
1214                 *werror = r.out.result;
1215         }
1216
1217         return werror_to_ntstatus(r.out.result);
1218 }
1219
1220 struct rpccli_winreg_DeleteKey_state {
1221         struct winreg_DeleteKey orig;
1222         struct winreg_DeleteKey tmp;
1223         TALLOC_CTX *out_mem_ctx;
1224         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1225 };
1226
1227 static void rpccli_winreg_DeleteKey_done(struct tevent_req *subreq);
1228
1229 struct tevent_req *rpccli_winreg_DeleteKey_send(TALLOC_CTX *mem_ctx,
1230                                                 struct tevent_context *ev,
1231                                                 struct rpc_pipe_client *cli,
1232                                                 struct policy_handle *_handle /* [in] [ref] */,
1233                                                 struct winreg_String _key /* [in]  */)
1234 {
1235         struct tevent_req *req;
1236         struct rpccli_winreg_DeleteKey_state *state;
1237         struct tevent_req *subreq;
1238
1239         req = tevent_req_create(mem_ctx, &state,
1240                                 struct rpccli_winreg_DeleteKey_state);
1241         if (req == NULL) {
1242                 return NULL;
1243         }
1244         state->out_mem_ctx = NULL;
1245         state->dispatch_recv = cli->dispatch_recv;
1246
1247         /* In parameters */
1248         state->orig.in.handle = _handle;
1249         state->orig.in.key = _key;
1250
1251         /* Out parameters */
1252
1253         /* Result */
1254         ZERO_STRUCT(state->orig.out.result);
1255
1256         if (DEBUGLEVEL >= 10) {
1257                 NDR_PRINT_IN_DEBUG(winreg_DeleteKey, &state->orig);
1258         }
1259
1260         /* make a temporary copy, that we pass to the dispatch function */
1261         state->tmp = state->orig;
1262
1263         subreq = cli->dispatch_send(state, ev, cli,
1264                                     &ndr_table_winreg,
1265                                     NDR_WINREG_DELETEKEY,
1266                                     &state->tmp);
1267         if (tevent_req_nomem(subreq, req)) {
1268                 return tevent_req_post(req, ev);
1269         }
1270         tevent_req_set_callback(subreq, rpccli_winreg_DeleteKey_done, req);
1271         return req;
1272 }
1273
1274 static void rpccli_winreg_DeleteKey_done(struct tevent_req *subreq)
1275 {
1276         struct tevent_req *req = tevent_req_callback_data(
1277                 subreq, struct tevent_req);
1278         struct rpccli_winreg_DeleteKey_state *state = tevent_req_data(
1279                 req, struct rpccli_winreg_DeleteKey_state);
1280         NTSTATUS status;
1281         TALLOC_CTX *mem_ctx;
1282
1283         if (state->out_mem_ctx) {
1284                 mem_ctx = state->out_mem_ctx;
1285         } else {
1286                 mem_ctx = state;
1287         }
1288
1289         status = state->dispatch_recv(subreq, mem_ctx);
1290         TALLOC_FREE(subreq);
1291         if (!NT_STATUS_IS_OK(status)) {
1292                 tevent_req_nterror(req, status);
1293                 return;
1294         }
1295
1296         /* Copy out parameters */
1297
1298         /* Copy result */
1299         state->orig.out.result = state->tmp.out.result;
1300
1301         /* Reset temporary structure */
1302         ZERO_STRUCT(state->tmp);
1303
1304         if (DEBUGLEVEL >= 10) {
1305                 NDR_PRINT_OUT_DEBUG(winreg_DeleteKey, &state->orig);
1306         }
1307
1308         tevent_req_done(req);
1309 }
1310
1311 NTSTATUS rpccli_winreg_DeleteKey_recv(struct tevent_req *req,
1312                                       TALLOC_CTX *mem_ctx,
1313                                       WERROR *result)
1314 {
1315         struct rpccli_winreg_DeleteKey_state *state = tevent_req_data(
1316                 req, struct rpccli_winreg_DeleteKey_state);
1317         NTSTATUS status;
1318
1319         if (tevent_req_is_nterror(req, &status)) {
1320                 tevent_req_received(req);
1321                 return status;
1322         }
1323
1324         /* Steal possbile out parameters to the callers context */
1325         talloc_steal(mem_ctx, state->out_mem_ctx);
1326
1327         /* Return result */
1328         *result = state->orig.out.result;
1329
1330         tevent_req_received(req);
1331         return NT_STATUS_OK;
1332 }
1333
1334 NTSTATUS rpccli_winreg_DeleteKey(struct rpc_pipe_client *cli,
1335                                  TALLOC_CTX *mem_ctx,
1336                                  struct policy_handle *handle /* [in] [ref] */,
1337                                  struct winreg_String key /* [in]  */,
1338                                  WERROR *werror)
1339 {
1340         struct winreg_DeleteKey r;
1341         NTSTATUS status;
1342
1343         /* In parameters */
1344         r.in.handle = handle;
1345         r.in.key = key;
1346
1347         if (DEBUGLEVEL >= 10) {
1348                 NDR_PRINT_IN_DEBUG(winreg_DeleteKey, &r);
1349         }
1350
1351         status = cli->dispatch(cli,
1352                                 mem_ctx,
1353                                 &ndr_table_winreg,
1354                                 NDR_WINREG_DELETEKEY,
1355                                 &r);
1356
1357         if (!NT_STATUS_IS_OK(status)) {
1358                 return status;
1359         }
1360
1361         if (DEBUGLEVEL >= 10) {
1362                 NDR_PRINT_OUT_DEBUG(winreg_DeleteKey, &r);
1363         }
1364
1365         if (NT_STATUS_IS_ERR(status)) {
1366                 return status;
1367         }
1368
1369         /* Return variables */
1370
1371         /* Return result */
1372         if (werror) {
1373                 *werror = r.out.result;
1374         }
1375
1376         return werror_to_ntstatus(r.out.result);
1377 }
1378
1379 struct rpccli_winreg_DeleteValue_state {
1380         struct winreg_DeleteValue orig;
1381         struct winreg_DeleteValue tmp;
1382         TALLOC_CTX *out_mem_ctx;
1383         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1384 };
1385
1386 static void rpccli_winreg_DeleteValue_done(struct tevent_req *subreq);
1387
1388 struct tevent_req *rpccli_winreg_DeleteValue_send(TALLOC_CTX *mem_ctx,
1389                                                   struct tevent_context *ev,
1390                                                   struct rpc_pipe_client *cli,
1391                                                   struct policy_handle *_handle /* [in] [ref] */,
1392                                                   struct winreg_String _value /* [in]  */)
1393 {
1394         struct tevent_req *req;
1395         struct rpccli_winreg_DeleteValue_state *state;
1396         struct tevent_req *subreq;
1397
1398         req = tevent_req_create(mem_ctx, &state,
1399                                 struct rpccli_winreg_DeleteValue_state);
1400         if (req == NULL) {
1401                 return NULL;
1402         }
1403         state->out_mem_ctx = NULL;
1404         state->dispatch_recv = cli->dispatch_recv;
1405
1406         /* In parameters */
1407         state->orig.in.handle = _handle;
1408         state->orig.in.value = _value;
1409
1410         /* Out parameters */
1411
1412         /* Result */
1413         ZERO_STRUCT(state->orig.out.result);
1414
1415         if (DEBUGLEVEL >= 10) {
1416                 NDR_PRINT_IN_DEBUG(winreg_DeleteValue, &state->orig);
1417         }
1418
1419         /* make a temporary copy, that we pass to the dispatch function */
1420         state->tmp = state->orig;
1421
1422         subreq = cli->dispatch_send(state, ev, cli,
1423                                     &ndr_table_winreg,
1424                                     NDR_WINREG_DELETEVALUE,
1425                                     &state->tmp);
1426         if (tevent_req_nomem(subreq, req)) {
1427                 return tevent_req_post(req, ev);
1428         }
1429         tevent_req_set_callback(subreq, rpccli_winreg_DeleteValue_done, req);
1430         return req;
1431 }
1432
1433 static void rpccli_winreg_DeleteValue_done(struct tevent_req *subreq)
1434 {
1435         struct tevent_req *req = tevent_req_callback_data(
1436                 subreq, struct tevent_req);
1437         struct rpccli_winreg_DeleteValue_state *state = tevent_req_data(
1438                 req, struct rpccli_winreg_DeleteValue_state);
1439         NTSTATUS status;
1440         TALLOC_CTX *mem_ctx;
1441
1442         if (state->out_mem_ctx) {
1443                 mem_ctx = state->out_mem_ctx;
1444         } else {
1445                 mem_ctx = state;
1446         }
1447
1448         status = state->dispatch_recv(subreq, mem_ctx);
1449         TALLOC_FREE(subreq);
1450         if (!NT_STATUS_IS_OK(status)) {
1451                 tevent_req_nterror(req, status);
1452                 return;
1453         }
1454
1455         /* Copy out parameters */
1456
1457         /* Copy result */
1458         state->orig.out.result = state->tmp.out.result;
1459
1460         /* Reset temporary structure */
1461         ZERO_STRUCT(state->tmp);
1462
1463         if (DEBUGLEVEL >= 10) {
1464                 NDR_PRINT_OUT_DEBUG(winreg_DeleteValue, &state->orig);
1465         }
1466
1467         tevent_req_done(req);
1468 }
1469
1470 NTSTATUS rpccli_winreg_DeleteValue_recv(struct tevent_req *req,
1471                                         TALLOC_CTX *mem_ctx,
1472                                         WERROR *result)
1473 {
1474         struct rpccli_winreg_DeleteValue_state *state = tevent_req_data(
1475                 req, struct rpccli_winreg_DeleteValue_state);
1476         NTSTATUS status;
1477
1478         if (tevent_req_is_nterror(req, &status)) {
1479                 tevent_req_received(req);
1480                 return status;
1481         }
1482
1483         /* Steal possbile out parameters to the callers context */
1484         talloc_steal(mem_ctx, state->out_mem_ctx);
1485
1486         /* Return result */
1487         *result = state->orig.out.result;
1488
1489         tevent_req_received(req);
1490         return NT_STATUS_OK;
1491 }
1492
1493 NTSTATUS rpccli_winreg_DeleteValue(struct rpc_pipe_client *cli,
1494                                    TALLOC_CTX *mem_ctx,
1495                                    struct policy_handle *handle /* [in] [ref] */,
1496                                    struct winreg_String value /* [in]  */,
1497                                    WERROR *werror)
1498 {
1499         struct winreg_DeleteValue r;
1500         NTSTATUS status;
1501
1502         /* In parameters */
1503         r.in.handle = handle;
1504         r.in.value = value;
1505
1506         if (DEBUGLEVEL >= 10) {
1507                 NDR_PRINT_IN_DEBUG(winreg_DeleteValue, &r);
1508         }
1509
1510         status = cli->dispatch(cli,
1511                                 mem_ctx,
1512                                 &ndr_table_winreg,
1513                                 NDR_WINREG_DELETEVALUE,
1514                                 &r);
1515
1516         if (!NT_STATUS_IS_OK(status)) {
1517                 return status;
1518         }
1519
1520         if (DEBUGLEVEL >= 10) {
1521                 NDR_PRINT_OUT_DEBUG(winreg_DeleteValue, &r);
1522         }
1523
1524         if (NT_STATUS_IS_ERR(status)) {
1525                 return status;
1526         }
1527
1528         /* Return variables */
1529
1530         /* Return result */
1531         if (werror) {
1532                 *werror = r.out.result;
1533         }
1534
1535         return werror_to_ntstatus(r.out.result);
1536 }
1537
1538 struct rpccli_winreg_EnumKey_state {
1539         struct winreg_EnumKey orig;
1540         struct winreg_EnumKey tmp;
1541         TALLOC_CTX *out_mem_ctx;
1542         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1543 };
1544
1545 static void rpccli_winreg_EnumKey_done(struct tevent_req *subreq);
1546
1547 struct tevent_req *rpccli_winreg_EnumKey_send(TALLOC_CTX *mem_ctx,
1548                                               struct tevent_context *ev,
1549                                               struct rpc_pipe_client *cli,
1550                                               struct policy_handle *_handle /* [in] [ref] */,
1551                                               uint32_t _enum_index /* [in]  */,
1552                                               struct winreg_StringBuf *_name /* [in,out] [ref] */,
1553                                               struct winreg_StringBuf *_keyclass /* [in,out] [unique] */,
1554                                               NTTIME *_last_changed_time /* [in,out] [unique] */)
1555 {
1556         struct tevent_req *req;
1557         struct rpccli_winreg_EnumKey_state *state;
1558         struct tevent_req *subreq;
1559
1560         req = tevent_req_create(mem_ctx, &state,
1561                                 struct rpccli_winreg_EnumKey_state);
1562         if (req == NULL) {
1563                 return NULL;
1564         }
1565         state->out_mem_ctx = NULL;
1566         state->dispatch_recv = cli->dispatch_recv;
1567
1568         /* In parameters */
1569         state->orig.in.handle = _handle;
1570         state->orig.in.enum_index = _enum_index;
1571         state->orig.in.name = _name;
1572         state->orig.in.keyclass = _keyclass;
1573         state->orig.in.last_changed_time = _last_changed_time;
1574
1575         /* Out parameters */
1576         state->orig.out.name = _name;
1577         state->orig.out.keyclass = _keyclass;
1578         state->orig.out.last_changed_time = _last_changed_time;
1579
1580         /* Result */
1581         ZERO_STRUCT(state->orig.out.result);
1582
1583         if (DEBUGLEVEL >= 10) {
1584                 NDR_PRINT_IN_DEBUG(winreg_EnumKey, &state->orig);
1585         }
1586
1587         state->out_mem_ctx = talloc_named_const(state, 0,
1588                              "rpccli_winreg_EnumKey_out_memory");
1589         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1590                 return tevent_req_post(req, ev);
1591         }
1592
1593         /* make a temporary copy, that we pass to the dispatch function */
1594         state->tmp = state->orig;
1595
1596         subreq = cli->dispatch_send(state, ev, cli,
1597                                     &ndr_table_winreg,
1598                                     NDR_WINREG_ENUMKEY,
1599                                     &state->tmp);
1600         if (tevent_req_nomem(subreq, req)) {
1601                 return tevent_req_post(req, ev);
1602         }
1603         tevent_req_set_callback(subreq, rpccli_winreg_EnumKey_done, req);
1604         return req;
1605 }
1606
1607 static void rpccli_winreg_EnumKey_done(struct tevent_req *subreq)
1608 {
1609         struct tevent_req *req = tevent_req_callback_data(
1610                 subreq, struct tevent_req);
1611         struct rpccli_winreg_EnumKey_state *state = tevent_req_data(
1612                 req, struct rpccli_winreg_EnumKey_state);
1613         NTSTATUS status;
1614         TALLOC_CTX *mem_ctx;
1615
1616         if (state->out_mem_ctx) {
1617                 mem_ctx = state->out_mem_ctx;
1618         } else {
1619                 mem_ctx = state;
1620         }
1621
1622         status = state->dispatch_recv(subreq, mem_ctx);
1623         TALLOC_FREE(subreq);
1624         if (!NT_STATUS_IS_OK(status)) {
1625                 tevent_req_nterror(req, status);
1626                 return;
1627         }
1628
1629         /* Copy out parameters */
1630         *state->orig.out.name = *state->tmp.out.name;
1631         if (state->orig.out.keyclass && state->tmp.out.keyclass) {
1632                 *state->orig.out.keyclass = *state->tmp.out.keyclass;
1633         }
1634         if (state->orig.out.last_changed_time && state->tmp.out.last_changed_time) {
1635                 *state->orig.out.last_changed_time = *state->tmp.out.last_changed_time;
1636         }
1637
1638         /* Copy result */
1639         state->orig.out.result = state->tmp.out.result;
1640
1641         /* Reset temporary structure */
1642         ZERO_STRUCT(state->tmp);
1643
1644         if (DEBUGLEVEL >= 10) {
1645                 NDR_PRINT_OUT_DEBUG(winreg_EnumKey, &state->orig);
1646         }
1647
1648         tevent_req_done(req);
1649 }
1650
1651 NTSTATUS rpccli_winreg_EnumKey_recv(struct tevent_req *req,
1652                                     TALLOC_CTX *mem_ctx,
1653                                     WERROR *result)
1654 {
1655         struct rpccli_winreg_EnumKey_state *state = tevent_req_data(
1656                 req, struct rpccli_winreg_EnumKey_state);
1657         NTSTATUS status;
1658
1659         if (tevent_req_is_nterror(req, &status)) {
1660                 tevent_req_received(req);
1661                 return status;
1662         }
1663
1664         /* Steal possbile out parameters to the callers context */
1665         talloc_steal(mem_ctx, state->out_mem_ctx);
1666
1667         /* Return result */
1668         *result = state->orig.out.result;
1669
1670         tevent_req_received(req);
1671         return NT_STATUS_OK;
1672 }
1673
1674 NTSTATUS rpccli_winreg_EnumKey(struct rpc_pipe_client *cli,
1675                                TALLOC_CTX *mem_ctx,
1676                                struct policy_handle *handle /* [in] [ref] */,
1677                                uint32_t enum_index /* [in]  */,
1678                                struct winreg_StringBuf *name /* [in,out] [ref] */,
1679                                struct winreg_StringBuf *keyclass /* [in,out] [unique] */,
1680                                NTTIME *last_changed_time /* [in,out] [unique] */,
1681                                WERROR *werror)
1682 {
1683         struct winreg_EnumKey r;
1684         NTSTATUS status;
1685
1686         /* In parameters */
1687         r.in.handle = handle;
1688         r.in.enum_index = enum_index;
1689         r.in.name = name;
1690         r.in.keyclass = keyclass;
1691         r.in.last_changed_time = last_changed_time;
1692
1693         if (DEBUGLEVEL >= 10) {
1694                 NDR_PRINT_IN_DEBUG(winreg_EnumKey, &r);
1695         }
1696
1697         status = cli->dispatch(cli,
1698                                 mem_ctx,
1699                                 &ndr_table_winreg,
1700                                 NDR_WINREG_ENUMKEY,
1701                                 &r);
1702
1703         if (!NT_STATUS_IS_OK(status)) {
1704                 return status;
1705         }
1706
1707         if (DEBUGLEVEL >= 10) {
1708                 NDR_PRINT_OUT_DEBUG(winreg_EnumKey, &r);
1709         }
1710
1711         if (NT_STATUS_IS_ERR(status)) {
1712                 return status;
1713         }
1714
1715         /* Return variables */
1716         *name = *r.out.name;
1717         if (keyclass && r.out.keyclass) {
1718                 *keyclass = *r.out.keyclass;
1719         }
1720         if (last_changed_time && r.out.last_changed_time) {
1721                 *last_changed_time = *r.out.last_changed_time;
1722         }
1723
1724         /* Return result */
1725         if (werror) {
1726                 *werror = r.out.result;
1727         }
1728
1729         return werror_to_ntstatus(r.out.result);
1730 }
1731
1732 struct rpccli_winreg_EnumValue_state {
1733         struct winreg_EnumValue orig;
1734         struct winreg_EnumValue tmp;
1735         TALLOC_CTX *out_mem_ctx;
1736         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1737 };
1738
1739 static void rpccli_winreg_EnumValue_done(struct tevent_req *subreq);
1740
1741 struct tevent_req *rpccli_winreg_EnumValue_send(TALLOC_CTX *mem_ctx,
1742                                                 struct tevent_context *ev,
1743                                                 struct rpc_pipe_client *cli,
1744                                                 struct policy_handle *_handle /* [in] [ref] */,
1745                                                 uint32_t _enum_index /* [in]  */,
1746                                                 struct winreg_ValNameBuf *_name /* [in,out] [ref] */,
1747                                                 enum winreg_Type *_type /* [in,out] [unique] */,
1748                                                 uint8_t *_value /* [in,out] [unique,length_is(*length),size_is(*size)] */,
1749                                                 uint32_t *_size /* [in,out] [unique] */,
1750                                                 uint32_t *_length /* [in,out] [unique] */)
1751 {
1752         struct tevent_req *req;
1753         struct rpccli_winreg_EnumValue_state *state;
1754         struct tevent_req *subreq;
1755
1756         req = tevent_req_create(mem_ctx, &state,
1757                                 struct rpccli_winreg_EnumValue_state);
1758         if (req == NULL) {
1759                 return NULL;
1760         }
1761         state->out_mem_ctx = NULL;
1762         state->dispatch_recv = cli->dispatch_recv;
1763
1764         /* In parameters */
1765         state->orig.in.handle = _handle;
1766         state->orig.in.enum_index = _enum_index;
1767         state->orig.in.name = _name;
1768         state->orig.in.type = _type;
1769         state->orig.in.value = _value;
1770         state->orig.in.size = _size;
1771         state->orig.in.length = _length;
1772
1773         /* Out parameters */
1774         state->orig.out.name = _name;
1775         state->orig.out.type = _type;
1776         state->orig.out.value = _value;
1777         state->orig.out.size = _size;
1778         state->orig.out.length = _length;
1779
1780         /* Result */
1781         ZERO_STRUCT(state->orig.out.result);
1782
1783         if (DEBUGLEVEL >= 10) {
1784                 NDR_PRINT_IN_DEBUG(winreg_EnumValue, &state->orig);
1785         }
1786
1787         state->out_mem_ctx = talloc_named_const(state, 0,
1788                              "rpccli_winreg_EnumValue_out_memory");
1789         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1790                 return tevent_req_post(req, ev);
1791         }
1792
1793         /* make a temporary copy, that we pass to the dispatch function */
1794         state->tmp = state->orig;
1795
1796         subreq = cli->dispatch_send(state, ev, cli,
1797                                     &ndr_table_winreg,
1798                                     NDR_WINREG_ENUMVALUE,
1799                                     &state->tmp);
1800         if (tevent_req_nomem(subreq, req)) {
1801                 return tevent_req_post(req, ev);
1802         }
1803         tevent_req_set_callback(subreq, rpccli_winreg_EnumValue_done, req);
1804         return req;
1805 }
1806
1807 static void rpccli_winreg_EnumValue_done(struct tevent_req *subreq)
1808 {
1809         struct tevent_req *req = tevent_req_callback_data(
1810                 subreq, struct tevent_req);
1811         struct rpccli_winreg_EnumValue_state *state = tevent_req_data(
1812                 req, struct rpccli_winreg_EnumValue_state);
1813         NTSTATUS status;
1814         TALLOC_CTX *mem_ctx;
1815
1816         if (state->out_mem_ctx) {
1817                 mem_ctx = state->out_mem_ctx;
1818         } else {
1819                 mem_ctx = state;
1820         }
1821
1822         status = state->dispatch_recv(subreq, mem_ctx);
1823         TALLOC_FREE(subreq);
1824         if (!NT_STATUS_IS_OK(status)) {
1825                 tevent_req_nterror(req, status);
1826                 return;
1827         }
1828
1829         /* Copy out parameters */
1830         *state->orig.out.name = *state->tmp.out.name;
1831         if (state->orig.out.type && state->tmp.out.type) {
1832                 *state->orig.out.type = *state->tmp.out.type;
1833         }
1834         if (state->orig.out.value && state->tmp.out.value) {
1835                 memcpy(state->orig.out.value, state->tmp.out.value, *state->tmp.in.size * sizeof(*state->orig.out.value));
1836         }
1837         if (state->orig.out.size && state->tmp.out.size) {
1838                 *state->orig.out.size = *state->tmp.out.size;
1839         }
1840         if (state->orig.out.length && state->tmp.out.length) {
1841                 *state->orig.out.length = *state->tmp.out.length;
1842         }
1843
1844         /* Copy result */
1845         state->orig.out.result = state->tmp.out.result;
1846
1847         /* Reset temporary structure */
1848         ZERO_STRUCT(state->tmp);
1849
1850         if (DEBUGLEVEL >= 10) {
1851                 NDR_PRINT_OUT_DEBUG(winreg_EnumValue, &state->orig);
1852         }
1853
1854         tevent_req_done(req);
1855 }
1856
1857 NTSTATUS rpccli_winreg_EnumValue_recv(struct tevent_req *req,
1858                                       TALLOC_CTX *mem_ctx,
1859                                       WERROR *result)
1860 {
1861         struct rpccli_winreg_EnumValue_state *state = tevent_req_data(
1862                 req, struct rpccli_winreg_EnumValue_state);
1863         NTSTATUS status;
1864
1865         if (tevent_req_is_nterror(req, &status)) {
1866                 tevent_req_received(req);
1867                 return status;
1868         }
1869
1870         /* Steal possbile out parameters to the callers context */
1871         talloc_steal(mem_ctx, state->out_mem_ctx);
1872
1873         /* Return result */
1874         *result = state->orig.out.result;
1875
1876         tevent_req_received(req);
1877         return NT_STATUS_OK;
1878 }
1879
1880 NTSTATUS rpccli_winreg_EnumValue(struct rpc_pipe_client *cli,
1881                                  TALLOC_CTX *mem_ctx,
1882                                  struct policy_handle *handle /* [in] [ref] */,
1883                                  uint32_t enum_index /* [in]  */,
1884                                  struct winreg_ValNameBuf *name /* [in,out] [ref] */,
1885                                  enum winreg_Type *type /* [in,out] [unique] */,
1886                                  uint8_t *value /* [in,out] [unique,length_is(*length),size_is(*size)] */,
1887                                  uint32_t *size /* [in,out] [unique] */,
1888                                  uint32_t *length /* [in,out] [unique] */,
1889                                  WERROR *werror)
1890 {
1891         struct winreg_EnumValue r;
1892         NTSTATUS status;
1893
1894         /* In parameters */
1895         r.in.handle = handle;
1896         r.in.enum_index = enum_index;
1897         r.in.name = name;
1898         r.in.type = type;
1899         r.in.value = value;
1900         r.in.size = size;
1901         r.in.length = length;
1902
1903         if (DEBUGLEVEL >= 10) {
1904                 NDR_PRINT_IN_DEBUG(winreg_EnumValue, &r);
1905         }
1906
1907         status = cli->dispatch(cli,
1908                                 mem_ctx,
1909                                 &ndr_table_winreg,
1910                                 NDR_WINREG_ENUMVALUE,
1911                                 &r);
1912
1913         if (!NT_STATUS_IS_OK(status)) {
1914                 return status;
1915         }
1916
1917         if (DEBUGLEVEL >= 10) {
1918                 NDR_PRINT_OUT_DEBUG(winreg_EnumValue, &r);
1919         }
1920
1921         if (NT_STATUS_IS_ERR(status)) {
1922                 return status;
1923         }
1924
1925         /* Return variables */
1926         *name = *r.out.name;
1927         if (type && r.out.type) {
1928                 *type = *r.out.type;
1929         }
1930         if (value && r.out.value) {
1931                 memcpy(value, r.out.value, *r.in.size * sizeof(*value));
1932         }
1933         if (size && r.out.size) {
1934                 *size = *r.out.size;
1935         }
1936         if (length && r.out.length) {
1937                 *length = *r.out.length;
1938         }
1939
1940         /* Return result */
1941         if (werror) {
1942                 *werror = r.out.result;
1943         }
1944
1945         return werror_to_ntstatus(r.out.result);
1946 }
1947
1948 struct rpccli_winreg_FlushKey_state {
1949         struct winreg_FlushKey orig;
1950         struct winreg_FlushKey tmp;
1951         TALLOC_CTX *out_mem_ctx;
1952         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1953 };
1954
1955 static void rpccli_winreg_FlushKey_done(struct tevent_req *subreq);
1956
1957 struct tevent_req *rpccli_winreg_FlushKey_send(TALLOC_CTX *mem_ctx,
1958                                                struct tevent_context *ev,
1959                                                struct rpc_pipe_client *cli,
1960                                                struct policy_handle *_handle /* [in] [ref] */)
1961 {
1962         struct tevent_req *req;
1963         struct rpccli_winreg_FlushKey_state *state;
1964         struct tevent_req *subreq;
1965
1966         req = tevent_req_create(mem_ctx, &state,
1967                                 struct rpccli_winreg_FlushKey_state);
1968         if (req == NULL) {
1969                 return NULL;
1970         }
1971         state->out_mem_ctx = NULL;
1972         state->dispatch_recv = cli->dispatch_recv;
1973
1974         /* In parameters */
1975         state->orig.in.handle = _handle;
1976
1977         /* Out parameters */
1978
1979         /* Result */
1980         ZERO_STRUCT(state->orig.out.result);
1981
1982         if (DEBUGLEVEL >= 10) {
1983                 NDR_PRINT_IN_DEBUG(winreg_FlushKey, &state->orig);
1984         }
1985
1986         /* make a temporary copy, that we pass to the dispatch function */
1987         state->tmp = state->orig;
1988
1989         subreq = cli->dispatch_send(state, ev, cli,
1990                                     &ndr_table_winreg,
1991                                     NDR_WINREG_FLUSHKEY,
1992                                     &state->tmp);
1993         if (tevent_req_nomem(subreq, req)) {
1994                 return tevent_req_post(req, ev);
1995         }
1996         tevent_req_set_callback(subreq, rpccli_winreg_FlushKey_done, req);
1997         return req;
1998 }
1999
2000 static void rpccli_winreg_FlushKey_done(struct tevent_req *subreq)
2001 {
2002         struct tevent_req *req = tevent_req_callback_data(
2003                 subreq, struct tevent_req);
2004         struct rpccli_winreg_FlushKey_state *state = tevent_req_data(
2005                 req, struct rpccli_winreg_FlushKey_state);
2006         NTSTATUS status;
2007         TALLOC_CTX *mem_ctx;
2008
2009         if (state->out_mem_ctx) {
2010                 mem_ctx = state->out_mem_ctx;
2011         } else {
2012                 mem_ctx = state;
2013         }
2014
2015         status = state->dispatch_recv(subreq, mem_ctx);
2016         TALLOC_FREE(subreq);
2017         if (!NT_STATUS_IS_OK(status)) {
2018                 tevent_req_nterror(req, status);
2019                 return;
2020         }
2021
2022         /* Copy out parameters */
2023
2024         /* Copy result */
2025         state->orig.out.result = state->tmp.out.result;
2026
2027         /* Reset temporary structure */
2028         ZERO_STRUCT(state->tmp);
2029
2030         if (DEBUGLEVEL >= 10) {
2031                 NDR_PRINT_OUT_DEBUG(winreg_FlushKey, &state->orig);
2032         }
2033
2034         tevent_req_done(req);
2035 }
2036
2037 NTSTATUS rpccli_winreg_FlushKey_recv(struct tevent_req *req,
2038                                      TALLOC_CTX *mem_ctx,
2039                                      WERROR *result)
2040 {
2041         struct rpccli_winreg_FlushKey_state *state = tevent_req_data(
2042                 req, struct rpccli_winreg_FlushKey_state);
2043         NTSTATUS status;
2044
2045         if (tevent_req_is_nterror(req, &status)) {
2046                 tevent_req_received(req);
2047                 return status;
2048         }
2049
2050         /* Steal possbile out parameters to the callers context */
2051         talloc_steal(mem_ctx, state->out_mem_ctx);
2052
2053         /* Return result */
2054         *result = state->orig.out.result;
2055
2056         tevent_req_received(req);
2057         return NT_STATUS_OK;
2058 }
2059
2060 NTSTATUS rpccli_winreg_FlushKey(struct rpc_pipe_client *cli,
2061                                 TALLOC_CTX *mem_ctx,
2062                                 struct policy_handle *handle /* [in] [ref] */,
2063                                 WERROR *werror)
2064 {
2065         struct winreg_FlushKey r;
2066         NTSTATUS status;
2067
2068         /* In parameters */
2069         r.in.handle = handle;
2070
2071         if (DEBUGLEVEL >= 10) {
2072                 NDR_PRINT_IN_DEBUG(winreg_FlushKey, &r);
2073         }
2074
2075         status = cli->dispatch(cli,
2076                                 mem_ctx,
2077                                 &ndr_table_winreg,
2078                                 NDR_WINREG_FLUSHKEY,
2079                                 &r);
2080
2081         if (!NT_STATUS_IS_OK(status)) {
2082                 return status;
2083         }
2084
2085         if (DEBUGLEVEL >= 10) {
2086                 NDR_PRINT_OUT_DEBUG(winreg_FlushKey, &r);
2087         }
2088
2089         if (NT_STATUS_IS_ERR(status)) {
2090                 return status;
2091         }
2092
2093         /* Return variables */
2094
2095         /* Return result */
2096         if (werror) {
2097                 *werror = r.out.result;
2098         }
2099
2100         return werror_to_ntstatus(r.out.result);
2101 }
2102
2103 struct rpccli_winreg_GetKeySecurity_state {
2104         struct winreg_GetKeySecurity orig;
2105         struct winreg_GetKeySecurity tmp;
2106         TALLOC_CTX *out_mem_ctx;
2107         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2108 };
2109
2110 static void rpccli_winreg_GetKeySecurity_done(struct tevent_req *subreq);
2111
2112 struct tevent_req *rpccli_winreg_GetKeySecurity_send(TALLOC_CTX *mem_ctx,
2113                                                      struct tevent_context *ev,
2114                                                      struct rpc_pipe_client *cli,
2115                                                      struct policy_handle *_handle /* [in] [ref] */,
2116                                                      uint32_t _sec_info /* [in]  */,
2117                                                      struct KeySecurityData *_sd /* [in,out] [ref] */)
2118 {
2119         struct tevent_req *req;
2120         struct rpccli_winreg_GetKeySecurity_state *state;
2121         struct tevent_req *subreq;
2122
2123         req = tevent_req_create(mem_ctx, &state,
2124                                 struct rpccli_winreg_GetKeySecurity_state);
2125         if (req == NULL) {
2126                 return NULL;
2127         }
2128         state->out_mem_ctx = NULL;
2129         state->dispatch_recv = cli->dispatch_recv;
2130
2131         /* In parameters */
2132         state->orig.in.handle = _handle;
2133         state->orig.in.sec_info = _sec_info;
2134         state->orig.in.sd = _sd;
2135
2136         /* Out parameters */
2137         state->orig.out.sd = _sd;
2138
2139         /* Result */
2140         ZERO_STRUCT(state->orig.out.result);
2141
2142         if (DEBUGLEVEL >= 10) {
2143                 NDR_PRINT_IN_DEBUG(winreg_GetKeySecurity, &state->orig);
2144         }
2145
2146         state->out_mem_ctx = talloc_named_const(state, 0,
2147                              "rpccli_winreg_GetKeySecurity_out_memory");
2148         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2149                 return tevent_req_post(req, ev);
2150         }
2151
2152         /* make a temporary copy, that we pass to the dispatch function */
2153         state->tmp = state->orig;
2154
2155         subreq = cli->dispatch_send(state, ev, cli,
2156                                     &ndr_table_winreg,
2157                                     NDR_WINREG_GETKEYSECURITY,
2158                                     &state->tmp);
2159         if (tevent_req_nomem(subreq, req)) {
2160                 return tevent_req_post(req, ev);
2161         }
2162         tevent_req_set_callback(subreq, rpccli_winreg_GetKeySecurity_done, req);
2163         return req;
2164 }
2165
2166 static void rpccli_winreg_GetKeySecurity_done(struct tevent_req *subreq)
2167 {
2168         struct tevent_req *req = tevent_req_callback_data(
2169                 subreq, struct tevent_req);
2170         struct rpccli_winreg_GetKeySecurity_state *state = tevent_req_data(
2171                 req, struct rpccli_winreg_GetKeySecurity_state);
2172         NTSTATUS status;
2173         TALLOC_CTX *mem_ctx;
2174
2175         if (state->out_mem_ctx) {
2176                 mem_ctx = state->out_mem_ctx;
2177         } else {
2178                 mem_ctx = state;
2179         }
2180
2181         status = state->dispatch_recv(subreq, mem_ctx);
2182         TALLOC_FREE(subreq);
2183         if (!NT_STATUS_IS_OK(status)) {
2184                 tevent_req_nterror(req, status);
2185                 return;
2186         }
2187
2188         /* Copy out parameters */
2189         *state->orig.out.sd = *state->tmp.out.sd;
2190
2191         /* Copy result */
2192         state->orig.out.result = state->tmp.out.result;
2193
2194         /* Reset temporary structure */
2195         ZERO_STRUCT(state->tmp);
2196
2197         if (DEBUGLEVEL >= 10) {
2198                 NDR_PRINT_OUT_DEBUG(winreg_GetKeySecurity, &state->orig);
2199         }
2200
2201         tevent_req_done(req);
2202 }
2203
2204 NTSTATUS rpccli_winreg_GetKeySecurity_recv(struct tevent_req *req,
2205                                            TALLOC_CTX *mem_ctx,
2206                                            WERROR *result)
2207 {
2208         struct rpccli_winreg_GetKeySecurity_state *state = tevent_req_data(
2209                 req, struct rpccli_winreg_GetKeySecurity_state);
2210         NTSTATUS status;
2211
2212         if (tevent_req_is_nterror(req, &status)) {
2213                 tevent_req_received(req);
2214                 return status;
2215         }
2216
2217         /* Steal possbile out parameters to the callers context */
2218         talloc_steal(mem_ctx, state->out_mem_ctx);
2219
2220         /* Return result */
2221         *result = state->orig.out.result;
2222
2223         tevent_req_received(req);
2224         return NT_STATUS_OK;
2225 }
2226
2227 NTSTATUS rpccli_winreg_GetKeySecurity(struct rpc_pipe_client *cli,
2228                                       TALLOC_CTX *mem_ctx,
2229                                       struct policy_handle *handle /* [in] [ref] */,
2230                                       uint32_t sec_info /* [in]  */,
2231                                       struct KeySecurityData *sd /* [in,out] [ref] */,
2232                                       WERROR *werror)
2233 {
2234         struct winreg_GetKeySecurity r;
2235         NTSTATUS status;
2236
2237         /* In parameters */
2238         r.in.handle = handle;
2239         r.in.sec_info = sec_info;
2240         r.in.sd = sd;
2241
2242         if (DEBUGLEVEL >= 10) {
2243                 NDR_PRINT_IN_DEBUG(winreg_GetKeySecurity, &r);
2244         }
2245
2246         status = cli->dispatch(cli,
2247                                 mem_ctx,
2248                                 &ndr_table_winreg,
2249                                 NDR_WINREG_GETKEYSECURITY,
2250                                 &r);
2251
2252         if (!NT_STATUS_IS_OK(status)) {
2253                 return status;
2254         }
2255
2256         if (DEBUGLEVEL >= 10) {
2257                 NDR_PRINT_OUT_DEBUG(winreg_GetKeySecurity, &r);
2258         }
2259
2260         if (NT_STATUS_IS_ERR(status)) {
2261                 return status;
2262         }
2263
2264         /* Return variables */
2265         *sd = *r.out.sd;
2266
2267         /* Return result */
2268         if (werror) {
2269                 *werror = r.out.result;
2270         }
2271
2272         return werror_to_ntstatus(r.out.result);
2273 }
2274
2275 struct rpccli_winreg_LoadKey_state {
2276         struct winreg_LoadKey orig;
2277         struct winreg_LoadKey tmp;
2278         TALLOC_CTX *out_mem_ctx;
2279         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2280 };
2281
2282 static void rpccli_winreg_LoadKey_done(struct tevent_req *subreq);
2283
2284 struct tevent_req *rpccli_winreg_LoadKey_send(TALLOC_CTX *mem_ctx,
2285                                               struct tevent_context *ev,
2286                                               struct rpc_pipe_client *cli,
2287                                               struct policy_handle *_handle /* [in] [ref] */,
2288                                               struct winreg_String *_keyname /* [in] [unique] */,
2289                                               struct winreg_String *_filename /* [in] [unique] */)
2290 {
2291         struct tevent_req *req;
2292         struct rpccli_winreg_LoadKey_state *state;
2293         struct tevent_req *subreq;
2294
2295         req = tevent_req_create(mem_ctx, &state,
2296                                 struct rpccli_winreg_LoadKey_state);
2297         if (req == NULL) {
2298                 return NULL;
2299         }
2300         state->out_mem_ctx = NULL;
2301         state->dispatch_recv = cli->dispatch_recv;
2302
2303         /* In parameters */
2304         state->orig.in.handle = _handle;
2305         state->orig.in.keyname = _keyname;
2306         state->orig.in.filename = _filename;
2307
2308         /* Out parameters */
2309
2310         /* Result */
2311         ZERO_STRUCT(state->orig.out.result);
2312
2313         if (DEBUGLEVEL >= 10) {
2314                 NDR_PRINT_IN_DEBUG(winreg_LoadKey, &state->orig);
2315         }
2316
2317         /* make a temporary copy, that we pass to the dispatch function */
2318         state->tmp = state->orig;
2319
2320         subreq = cli->dispatch_send(state, ev, cli,
2321                                     &ndr_table_winreg,
2322                                     NDR_WINREG_LOADKEY,
2323                                     &state->tmp);
2324         if (tevent_req_nomem(subreq, req)) {
2325                 return tevent_req_post(req, ev);
2326         }
2327         tevent_req_set_callback(subreq, rpccli_winreg_LoadKey_done, req);
2328         return req;
2329 }
2330
2331 static void rpccli_winreg_LoadKey_done(struct tevent_req *subreq)
2332 {
2333         struct tevent_req *req = tevent_req_callback_data(
2334                 subreq, struct tevent_req);
2335         struct rpccli_winreg_LoadKey_state *state = tevent_req_data(
2336                 req, struct rpccli_winreg_LoadKey_state);
2337         NTSTATUS status;
2338         TALLOC_CTX *mem_ctx;
2339
2340         if (state->out_mem_ctx) {
2341                 mem_ctx = state->out_mem_ctx;
2342         } else {
2343                 mem_ctx = state;
2344         }
2345
2346         status = state->dispatch_recv(subreq, mem_ctx);
2347         TALLOC_FREE(subreq);
2348         if (!NT_STATUS_IS_OK(status)) {
2349                 tevent_req_nterror(req, status);
2350                 return;
2351         }
2352
2353         /* Copy out parameters */
2354
2355         /* Copy result */
2356         state->orig.out.result = state->tmp.out.result;
2357
2358         /* Reset temporary structure */
2359         ZERO_STRUCT(state->tmp);
2360
2361         if (DEBUGLEVEL >= 10) {
2362                 NDR_PRINT_OUT_DEBUG(winreg_LoadKey, &state->orig);
2363         }
2364
2365         tevent_req_done(req);
2366 }
2367
2368 NTSTATUS rpccli_winreg_LoadKey_recv(struct tevent_req *req,
2369                                     TALLOC_CTX *mem_ctx,
2370                                     WERROR *result)
2371 {
2372         struct rpccli_winreg_LoadKey_state *state = tevent_req_data(
2373                 req, struct rpccli_winreg_LoadKey_state);
2374         NTSTATUS status;
2375
2376         if (tevent_req_is_nterror(req, &status)) {
2377                 tevent_req_received(req);
2378                 return status;
2379         }
2380
2381         /* Steal possbile out parameters to the callers context */
2382         talloc_steal(mem_ctx, state->out_mem_ctx);
2383
2384         /* Return result */
2385         *result = state->orig.out.result;
2386
2387         tevent_req_received(req);
2388         return NT_STATUS_OK;
2389 }
2390
2391 NTSTATUS rpccli_winreg_LoadKey(struct rpc_pipe_client *cli,
2392                                TALLOC_CTX *mem_ctx,
2393                                struct policy_handle *handle /* [in] [ref] */,
2394                                struct winreg_String *keyname /* [in] [unique] */,
2395                                struct winreg_String *filename /* [in] [unique] */,
2396                                WERROR *werror)
2397 {
2398         struct winreg_LoadKey r;
2399         NTSTATUS status;
2400
2401         /* In parameters */
2402         r.in.handle = handle;
2403         r.in.keyname = keyname;
2404         r.in.filename = filename;
2405
2406         if (DEBUGLEVEL >= 10) {
2407                 NDR_PRINT_IN_DEBUG(winreg_LoadKey, &r);
2408         }
2409
2410         status = cli->dispatch(cli,
2411                                 mem_ctx,
2412                                 &ndr_table_winreg,
2413                                 NDR_WINREG_LOADKEY,
2414                                 &r);
2415
2416         if (!NT_STATUS_IS_OK(status)) {
2417                 return status;
2418         }
2419
2420         if (DEBUGLEVEL >= 10) {
2421                 NDR_PRINT_OUT_DEBUG(winreg_LoadKey, &r);
2422         }
2423
2424         if (NT_STATUS_IS_ERR(status)) {
2425                 return status;
2426         }
2427
2428         /* Return variables */
2429
2430         /* Return result */
2431         if (werror) {
2432                 *werror = r.out.result;
2433         }
2434
2435         return werror_to_ntstatus(r.out.result);
2436 }
2437
2438 struct rpccli_winreg_NotifyChangeKeyValue_state {
2439         struct winreg_NotifyChangeKeyValue orig;
2440         struct winreg_NotifyChangeKeyValue tmp;
2441         TALLOC_CTX *out_mem_ctx;
2442         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2443 };
2444
2445 static void rpccli_winreg_NotifyChangeKeyValue_done(struct tevent_req *subreq);
2446
2447 struct tevent_req *rpccli_winreg_NotifyChangeKeyValue_send(TALLOC_CTX *mem_ctx,
2448                                                            struct tevent_context *ev,
2449                                                            struct rpc_pipe_client *cli,
2450                                                            struct policy_handle *_handle /* [in] [ref] */,
2451                                                            uint8_t _watch_subtree /* [in]  */,
2452                                                            uint32_t _notify_filter /* [in]  */,
2453                                                            uint32_t _unknown /* [in]  */,
2454                                                            struct winreg_String _string1 /* [in]  */,
2455                                                            struct winreg_String _string2 /* [in]  */,
2456                                                            uint32_t _unknown2 /* [in]  */)
2457 {
2458         struct tevent_req *req;
2459         struct rpccli_winreg_NotifyChangeKeyValue_state *state;
2460         struct tevent_req *subreq;
2461
2462         req = tevent_req_create(mem_ctx, &state,
2463                                 struct rpccli_winreg_NotifyChangeKeyValue_state);
2464         if (req == NULL) {
2465                 return NULL;
2466         }
2467         state->out_mem_ctx = NULL;
2468         state->dispatch_recv = cli->dispatch_recv;
2469
2470         /* In parameters */
2471         state->orig.in.handle = _handle;
2472         state->orig.in.watch_subtree = _watch_subtree;
2473         state->orig.in.notify_filter = _notify_filter;
2474         state->orig.in.unknown = _unknown;
2475         state->orig.in.string1 = _string1;
2476         state->orig.in.string2 = _string2;
2477         state->orig.in.unknown2 = _unknown2;
2478
2479         /* Out parameters */
2480
2481         /* Result */
2482         ZERO_STRUCT(state->orig.out.result);
2483
2484         if (DEBUGLEVEL >= 10) {
2485                 NDR_PRINT_IN_DEBUG(winreg_NotifyChangeKeyValue, &state->orig);
2486         }
2487
2488         /* make a temporary copy, that we pass to the dispatch function */
2489         state->tmp = state->orig;
2490
2491         subreq = cli->dispatch_send(state, ev, cli,
2492                                     &ndr_table_winreg,
2493                                     NDR_WINREG_NOTIFYCHANGEKEYVALUE,
2494                                     &state->tmp);
2495         if (tevent_req_nomem(subreq, req)) {
2496                 return tevent_req_post(req, ev);
2497         }
2498         tevent_req_set_callback(subreq, rpccli_winreg_NotifyChangeKeyValue_done, req);
2499         return req;
2500 }
2501
2502 static void rpccli_winreg_NotifyChangeKeyValue_done(struct tevent_req *subreq)
2503 {
2504         struct tevent_req *req = tevent_req_callback_data(
2505                 subreq, struct tevent_req);
2506         struct rpccli_winreg_NotifyChangeKeyValue_state *state = tevent_req_data(
2507                 req, struct rpccli_winreg_NotifyChangeKeyValue_state);
2508         NTSTATUS status;
2509         TALLOC_CTX *mem_ctx;
2510
2511         if (state->out_mem_ctx) {
2512                 mem_ctx = state->out_mem_ctx;
2513         } else {
2514                 mem_ctx = state;
2515         }
2516
2517         status = state->dispatch_recv(subreq, mem_ctx);
2518         TALLOC_FREE(subreq);
2519         if (!NT_STATUS_IS_OK(status)) {
2520                 tevent_req_nterror(req, status);
2521                 return;
2522         }
2523
2524         /* Copy out parameters */
2525
2526         /* Copy result */
2527         state->orig.out.result = state->tmp.out.result;
2528
2529         /* Reset temporary structure */
2530         ZERO_STRUCT(state->tmp);
2531
2532         if (DEBUGLEVEL >= 10) {
2533                 NDR_PRINT_OUT_DEBUG(winreg_NotifyChangeKeyValue, &state->orig);
2534         }
2535
2536         tevent_req_done(req);
2537 }
2538
2539 NTSTATUS rpccli_winreg_NotifyChangeKeyValue_recv(struct tevent_req *req,
2540                                                  TALLOC_CTX *mem_ctx,
2541                                                  WERROR *result)
2542 {
2543         struct rpccli_winreg_NotifyChangeKeyValue_state *state = tevent_req_data(
2544                 req, struct rpccli_winreg_NotifyChangeKeyValue_state);
2545         NTSTATUS status;
2546
2547         if (tevent_req_is_nterror(req, &status)) {
2548                 tevent_req_received(req);
2549                 return status;
2550         }
2551
2552         /* Steal possbile out parameters to the callers context */
2553         talloc_steal(mem_ctx, state->out_mem_ctx);
2554
2555         /* Return result */
2556         *result = state->orig.out.result;
2557
2558         tevent_req_received(req);
2559         return NT_STATUS_OK;
2560 }
2561
2562 NTSTATUS rpccli_winreg_NotifyChangeKeyValue(struct rpc_pipe_client *cli,
2563                                             TALLOC_CTX *mem_ctx,
2564                                             struct policy_handle *handle /* [in] [ref] */,
2565                                             uint8_t watch_subtree /* [in]  */,
2566                                             uint32_t notify_filter /* [in]  */,
2567                                             uint32_t unknown /* [in]  */,
2568                                             struct winreg_String string1 /* [in]  */,
2569                                             struct winreg_String string2 /* [in]  */,
2570                                             uint32_t unknown2 /* [in]  */,
2571                                             WERROR *werror)
2572 {
2573         struct winreg_NotifyChangeKeyValue r;
2574         NTSTATUS status;
2575
2576         /* In parameters */
2577         r.in.handle = handle;
2578         r.in.watch_subtree = watch_subtree;
2579         r.in.notify_filter = notify_filter;
2580         r.in.unknown = unknown;
2581         r.in.string1 = string1;
2582         r.in.string2 = string2;
2583         r.in.unknown2 = unknown2;
2584
2585         if (DEBUGLEVEL >= 10) {
2586                 NDR_PRINT_IN_DEBUG(winreg_NotifyChangeKeyValue, &r);
2587         }
2588
2589         status = cli->dispatch(cli,
2590                                 mem_ctx,
2591                                 &ndr_table_winreg,
2592                                 NDR_WINREG_NOTIFYCHANGEKEYVALUE,
2593                                 &r);
2594
2595         if (!NT_STATUS_IS_OK(status)) {
2596                 return status;
2597         }
2598
2599         if (DEBUGLEVEL >= 10) {
2600                 NDR_PRINT_OUT_DEBUG(winreg_NotifyChangeKeyValue, &r);
2601         }
2602
2603         if (NT_STATUS_IS_ERR(status)) {
2604                 return status;
2605         }
2606
2607         /* Return variables */
2608
2609         /* Return result */
2610         if (werror) {
2611                 *werror = r.out.result;
2612         }
2613
2614         return werror_to_ntstatus(r.out.result);
2615 }
2616
2617 struct rpccli_winreg_OpenKey_state {
2618         struct winreg_OpenKey orig;
2619         struct winreg_OpenKey tmp;
2620         TALLOC_CTX *out_mem_ctx;
2621         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2622 };
2623
2624 static void rpccli_winreg_OpenKey_done(struct tevent_req *subreq);
2625
2626 struct tevent_req *rpccli_winreg_OpenKey_send(TALLOC_CTX *mem_ctx,
2627                                               struct tevent_context *ev,
2628                                               struct rpc_pipe_client *cli,
2629                                               struct policy_handle *_parent_handle /* [in] [ref] */,
2630                                               struct winreg_String _keyname /* [in]  */,
2631                                               uint32_t _unknown /* [in]  */,
2632                                               uint32_t _access_mask /* [in]  */,
2633                                               struct policy_handle *_handle /* [out] [ref] */)
2634 {
2635         struct tevent_req *req;
2636         struct rpccli_winreg_OpenKey_state *state;
2637         struct tevent_req *subreq;
2638
2639         req = tevent_req_create(mem_ctx, &state,
2640                                 struct rpccli_winreg_OpenKey_state);
2641         if (req == NULL) {
2642                 return NULL;
2643         }
2644         state->out_mem_ctx = NULL;
2645         state->dispatch_recv = cli->dispatch_recv;
2646
2647         /* In parameters */
2648         state->orig.in.parent_handle = _parent_handle;
2649         state->orig.in.keyname = _keyname;
2650         state->orig.in.unknown = _unknown;
2651         state->orig.in.access_mask = _access_mask;
2652
2653         /* Out parameters */
2654         state->orig.out.handle = _handle;
2655
2656         /* Result */
2657         ZERO_STRUCT(state->orig.out.result);
2658
2659         if (DEBUGLEVEL >= 10) {
2660                 NDR_PRINT_IN_DEBUG(winreg_OpenKey, &state->orig);
2661         }
2662
2663         state->out_mem_ctx = talloc_named_const(state, 0,
2664                              "rpccli_winreg_OpenKey_out_memory");
2665         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2666                 return tevent_req_post(req, ev);
2667         }
2668
2669         /* make a temporary copy, that we pass to the dispatch function */
2670         state->tmp = state->orig;
2671
2672         subreq = cli->dispatch_send(state, ev, cli,
2673                                     &ndr_table_winreg,
2674                                     NDR_WINREG_OPENKEY,
2675                                     &state->tmp);
2676         if (tevent_req_nomem(subreq, req)) {
2677                 return tevent_req_post(req, ev);
2678         }
2679         tevent_req_set_callback(subreq, rpccli_winreg_OpenKey_done, req);
2680         return req;
2681 }
2682
2683 static void rpccli_winreg_OpenKey_done(struct tevent_req *subreq)
2684 {
2685         struct tevent_req *req = tevent_req_callback_data(
2686                 subreq, struct tevent_req);
2687         struct rpccli_winreg_OpenKey_state *state = tevent_req_data(
2688                 req, struct rpccli_winreg_OpenKey_state);
2689         NTSTATUS status;
2690         TALLOC_CTX *mem_ctx;
2691
2692         if (state->out_mem_ctx) {
2693                 mem_ctx = state->out_mem_ctx;
2694         } else {
2695                 mem_ctx = state;
2696         }
2697
2698         status = state->dispatch_recv(subreq, mem_ctx);
2699         TALLOC_FREE(subreq);
2700         if (!NT_STATUS_IS_OK(status)) {
2701                 tevent_req_nterror(req, status);
2702                 return;
2703         }
2704
2705         /* Copy out parameters */
2706         *state->orig.out.handle = *state->tmp.out.handle;
2707
2708         /* Copy result */
2709         state->orig.out.result = state->tmp.out.result;
2710
2711         /* Reset temporary structure */
2712         ZERO_STRUCT(state->tmp);
2713
2714         if (DEBUGLEVEL >= 10) {
2715                 NDR_PRINT_OUT_DEBUG(winreg_OpenKey, &state->orig);
2716         }
2717
2718         tevent_req_done(req);
2719 }
2720
2721 NTSTATUS rpccli_winreg_OpenKey_recv(struct tevent_req *req,
2722                                     TALLOC_CTX *mem_ctx,
2723                                     WERROR *result)
2724 {
2725         struct rpccli_winreg_OpenKey_state *state = tevent_req_data(
2726                 req, struct rpccli_winreg_OpenKey_state);
2727         NTSTATUS status;
2728
2729         if (tevent_req_is_nterror(req, &status)) {
2730                 tevent_req_received(req);
2731                 return status;
2732         }
2733
2734         /* Steal possbile out parameters to the callers context */
2735         talloc_steal(mem_ctx, state->out_mem_ctx);
2736
2737         /* Return result */
2738         *result = state->orig.out.result;
2739
2740         tevent_req_received(req);
2741         return NT_STATUS_OK;
2742 }
2743
2744 NTSTATUS rpccli_winreg_OpenKey(struct rpc_pipe_client *cli,
2745                                TALLOC_CTX *mem_ctx,
2746                                struct policy_handle *parent_handle /* [in] [ref] */,
2747                                struct winreg_String keyname /* [in]  */,
2748                                uint32_t unknown /* [in]  */,
2749                                uint32_t access_mask /* [in]  */,
2750                                struct policy_handle *handle /* [out] [ref] */,
2751                                WERROR *werror)
2752 {
2753         struct winreg_OpenKey r;
2754         NTSTATUS status;
2755
2756         /* In parameters */
2757         r.in.parent_handle = parent_handle;
2758         r.in.keyname = keyname;
2759         r.in.unknown = unknown;
2760         r.in.access_mask = access_mask;
2761
2762         if (DEBUGLEVEL >= 10) {
2763                 NDR_PRINT_IN_DEBUG(winreg_OpenKey, &r);
2764         }
2765
2766         status = cli->dispatch(cli,
2767                                 mem_ctx,
2768                                 &ndr_table_winreg,
2769                                 NDR_WINREG_OPENKEY,
2770                                 &r);
2771
2772         if (!NT_STATUS_IS_OK(status)) {
2773                 return status;
2774         }
2775
2776         if (DEBUGLEVEL >= 10) {
2777                 NDR_PRINT_OUT_DEBUG(winreg_OpenKey, &r);
2778         }
2779
2780         if (NT_STATUS_IS_ERR(status)) {
2781                 return status;
2782         }
2783
2784         /* Return variables */
2785         *handle = *r.out.handle;
2786
2787         /* Return result */
2788         if (werror) {
2789                 *werror = r.out.result;
2790         }
2791
2792         return werror_to_ntstatus(r.out.result);
2793 }
2794
2795 struct rpccli_winreg_QueryInfoKey_state {
2796         struct winreg_QueryInfoKey orig;
2797         struct winreg_QueryInfoKey tmp;
2798         TALLOC_CTX *out_mem_ctx;
2799         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2800 };
2801
2802 static void rpccli_winreg_QueryInfoKey_done(struct tevent_req *subreq);
2803
2804 struct tevent_req *rpccli_winreg_QueryInfoKey_send(TALLOC_CTX *mem_ctx,
2805                                                    struct tevent_context *ev,
2806                                                    struct rpc_pipe_client *cli,
2807                                                    struct policy_handle *_handle /* [in] [ref] */,
2808                                                    struct winreg_String *_classname /* [in,out] [ref] */,
2809                                                    uint32_t *_num_subkeys /* [out] [ref] */,
2810                                                    uint32_t *_max_subkeylen /* [out] [ref] */,
2811                                                    uint32_t *_max_classlen /* [out] [ref] */,
2812                                                    uint32_t *_num_values /* [out] [ref] */,
2813                                                    uint32_t *_max_valnamelen /* [out] [ref] */,
2814                                                    uint32_t *_max_valbufsize /* [out] [ref] */,
2815                                                    uint32_t *_secdescsize /* [out] [ref] */,
2816                                                    NTTIME *_last_changed_time /* [out] [ref] */)
2817 {
2818         struct tevent_req *req;
2819         struct rpccli_winreg_QueryInfoKey_state *state;
2820         struct tevent_req *subreq;
2821
2822         req = tevent_req_create(mem_ctx, &state,
2823                                 struct rpccli_winreg_QueryInfoKey_state);
2824         if (req == NULL) {
2825                 return NULL;
2826         }
2827         state->out_mem_ctx = NULL;
2828         state->dispatch_recv = cli->dispatch_recv;
2829
2830         /* In parameters */
2831         state->orig.in.handle = _handle;
2832         state->orig.in.classname = _classname;
2833
2834         /* Out parameters */
2835         state->orig.out.classname = _classname;
2836         state->orig.out.num_subkeys = _num_subkeys;
2837         state->orig.out.max_subkeylen = _max_subkeylen;
2838         state->orig.out.max_classlen = _max_classlen;
2839         state->orig.out.num_values = _num_values;
2840         state->orig.out.max_valnamelen = _max_valnamelen;
2841         state->orig.out.max_valbufsize = _max_valbufsize;
2842         state->orig.out.secdescsize = _secdescsize;
2843         state->orig.out.last_changed_time = _last_changed_time;
2844
2845         /* Result */
2846         ZERO_STRUCT(state->orig.out.result);
2847
2848         if (DEBUGLEVEL >= 10) {
2849                 NDR_PRINT_IN_DEBUG(winreg_QueryInfoKey, &state->orig);
2850         }
2851
2852         state->out_mem_ctx = talloc_named_const(state, 0,
2853                              "rpccli_winreg_QueryInfoKey_out_memory");
2854         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2855                 return tevent_req_post(req, ev);
2856         }
2857
2858         /* make a temporary copy, that we pass to the dispatch function */
2859         state->tmp = state->orig;
2860
2861         subreq = cli->dispatch_send(state, ev, cli,
2862                                     &ndr_table_winreg,
2863                                     NDR_WINREG_QUERYINFOKEY,
2864                                     &state->tmp);
2865         if (tevent_req_nomem(subreq, req)) {
2866                 return tevent_req_post(req, ev);
2867         }
2868         tevent_req_set_callback(subreq, rpccli_winreg_QueryInfoKey_done, req);
2869         return req;
2870 }
2871
2872 static void rpccli_winreg_QueryInfoKey_done(struct tevent_req *subreq)
2873 {
2874         struct tevent_req *req = tevent_req_callback_data(
2875                 subreq, struct tevent_req);
2876         struct rpccli_winreg_QueryInfoKey_state *state = tevent_req_data(
2877                 req, struct rpccli_winreg_QueryInfoKey_state);
2878         NTSTATUS status;
2879         TALLOC_CTX *mem_ctx;
2880
2881         if (state->out_mem_ctx) {
2882                 mem_ctx = state->out_mem_ctx;
2883         } else {
2884                 mem_ctx = state;
2885         }
2886
2887         status = state->dispatch_recv(subreq, mem_ctx);
2888         TALLOC_FREE(subreq);
2889         if (!NT_STATUS_IS_OK(status)) {
2890                 tevent_req_nterror(req, status);
2891                 return;
2892         }
2893
2894         /* Copy out parameters */
2895         *state->orig.out.classname = *state->tmp.out.classname;
2896         *state->orig.out.num_subkeys = *state->tmp.out.num_subkeys;
2897         *state->orig.out.max_subkeylen = *state->tmp.out.max_subkeylen;
2898         *state->orig.out.max_classlen = *state->tmp.out.max_classlen;
2899         *state->orig.out.num_values = *state->tmp.out.num_values;
2900         *state->orig.out.max_valnamelen = *state->tmp.out.max_valnamelen;
2901         *state->orig.out.max_valbufsize = *state->tmp.out.max_valbufsize;
2902         *state->orig.out.secdescsize = *state->tmp.out.secdescsize;
2903         *state->orig.out.last_changed_time = *state->tmp.out.last_changed_time;
2904
2905         /* Copy result */
2906         state->orig.out.result = state->tmp.out.result;
2907
2908         /* Reset temporary structure */
2909         ZERO_STRUCT(state->tmp);
2910
2911         if (DEBUGLEVEL >= 10) {
2912                 NDR_PRINT_OUT_DEBUG(winreg_QueryInfoKey, &state->orig);
2913         }
2914
2915         tevent_req_done(req);
2916 }
2917
2918 NTSTATUS rpccli_winreg_QueryInfoKey_recv(struct tevent_req *req,
2919                                          TALLOC_CTX *mem_ctx,
2920                                          WERROR *result)
2921 {
2922         struct rpccli_winreg_QueryInfoKey_state *state = tevent_req_data(
2923                 req, struct rpccli_winreg_QueryInfoKey_state);
2924         NTSTATUS status;
2925
2926         if (tevent_req_is_nterror(req, &status)) {
2927                 tevent_req_received(req);
2928                 return status;
2929         }
2930
2931         /* Steal possbile out parameters to the callers context */
2932         talloc_steal(mem_ctx, state->out_mem_ctx);
2933
2934         /* Return result */
2935         *result = state->orig.out.result;
2936
2937         tevent_req_received(req);
2938         return NT_STATUS_OK;
2939 }
2940
2941 NTSTATUS rpccli_winreg_QueryInfoKey(struct rpc_pipe_client *cli,
2942                                     TALLOC_CTX *mem_ctx,
2943                                     struct policy_handle *handle /* [in] [ref] */,
2944                                     struct winreg_String *classname /* [in,out] [ref] */,
2945                                     uint32_t *num_subkeys /* [out] [ref] */,
2946                                     uint32_t *max_subkeylen /* [out] [ref] */,
2947                                     uint32_t *max_classlen /* [out] [ref] */,
2948                                     uint32_t *num_values /* [out] [ref] */,
2949                                     uint32_t *max_valnamelen /* [out] [ref] */,
2950                                     uint32_t *max_valbufsize /* [out] [ref] */,
2951                                     uint32_t *secdescsize /* [out] [ref] */,
2952                                     NTTIME *last_changed_time /* [out] [ref] */,
2953                                     WERROR *werror)
2954 {
2955         struct winreg_QueryInfoKey r;
2956         NTSTATUS status;
2957
2958         /* In parameters */
2959         r.in.handle = handle;
2960         r.in.classname = classname;
2961
2962         if (DEBUGLEVEL >= 10) {
2963                 NDR_PRINT_IN_DEBUG(winreg_QueryInfoKey, &r);
2964         }
2965
2966         status = cli->dispatch(cli,
2967                                 mem_ctx,
2968                                 &ndr_table_winreg,
2969                                 NDR_WINREG_QUERYINFOKEY,
2970                                 &r);
2971
2972         if (!NT_STATUS_IS_OK(status)) {
2973                 return status;
2974         }
2975
2976         if (DEBUGLEVEL >= 10) {
2977                 NDR_PRINT_OUT_DEBUG(winreg_QueryInfoKey, &r);
2978         }
2979
2980         if (NT_STATUS_IS_ERR(status)) {
2981                 return status;
2982         }
2983
2984         /* Return variables */
2985         *classname = *r.out.classname;
2986         *num_subkeys = *r.out.num_subkeys;
2987         *max_subkeylen = *r.out.max_subkeylen;
2988         *max_classlen = *r.out.max_classlen;
2989         *num_values = *r.out.num_values;
2990         *max_valnamelen = *r.out.max_valnamelen;
2991         *max_valbufsize = *r.out.max_valbufsize;
2992         *secdescsize = *r.out.secdescsize;
2993         *last_changed_time = *r.out.last_changed_time;
2994
2995         /* Return result */
2996         if (werror) {
2997                 *werror = r.out.result;
2998         }
2999
3000         return werror_to_ntstatus(r.out.result);
3001 }
3002
3003 struct rpccli_winreg_QueryValue_state {
3004         struct winreg_QueryValue orig;
3005         struct winreg_QueryValue tmp;
3006         TALLOC_CTX *out_mem_ctx;
3007         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3008 };
3009
3010 static void rpccli_winreg_QueryValue_done(struct tevent_req *subreq);
3011
3012 struct tevent_req *rpccli_winreg_QueryValue_send(TALLOC_CTX *mem_ctx,
3013                                                  struct tevent_context *ev,
3014                                                  struct rpc_pipe_client *cli,
3015                                                  struct policy_handle *_handle /* [in] [ref] */,
3016                                                  struct winreg_String *_value_name /* [in] [ref] */,
3017                                                  enum winreg_Type *_type /* [in,out] [unique] */,
3018                                                  uint8_t *_data /* [in,out] [unique,length_is(*data_length),size_is(*data_size)] */,
3019                                                  uint32_t *_data_size /* [in,out] [unique] */,
3020                                                  uint32_t *_data_length /* [in,out] [unique] */)
3021 {
3022         struct tevent_req *req;
3023         struct rpccli_winreg_QueryValue_state *state;
3024         struct tevent_req *subreq;
3025
3026         req = tevent_req_create(mem_ctx, &state,
3027                                 struct rpccli_winreg_QueryValue_state);
3028         if (req == NULL) {
3029                 return NULL;
3030         }
3031         state->out_mem_ctx = NULL;
3032         state->dispatch_recv = cli->dispatch_recv;
3033
3034         /* In parameters */
3035         state->orig.in.handle = _handle;
3036         state->orig.in.value_name = _value_name;
3037         state->orig.in.type = _type;
3038         state->orig.in.data = _data;
3039         state->orig.in.data_size = _data_size;
3040         state->orig.in.data_length = _data_length;
3041
3042         /* Out parameters */
3043         state->orig.out.type = _type;
3044         state->orig.out.data = _data;
3045         state->orig.out.data_size = _data_size;
3046         state->orig.out.data_length = _data_length;
3047
3048         /* Result */
3049         ZERO_STRUCT(state->orig.out.result);
3050
3051         if (DEBUGLEVEL >= 10) {
3052                 NDR_PRINT_IN_DEBUG(winreg_QueryValue, &state->orig);
3053         }
3054
3055         state->out_mem_ctx = talloc_named_const(state, 0,
3056                              "rpccli_winreg_QueryValue_out_memory");
3057         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3058                 return tevent_req_post(req, ev);
3059         }
3060
3061         /* make a temporary copy, that we pass to the dispatch function */
3062         state->tmp = state->orig;
3063
3064         subreq = cli->dispatch_send(state, ev, cli,
3065                                     &ndr_table_winreg,
3066                                     NDR_WINREG_QUERYVALUE,
3067                                     &state->tmp);
3068         if (tevent_req_nomem(subreq, req)) {
3069                 return tevent_req_post(req, ev);
3070         }
3071         tevent_req_set_callback(subreq, rpccli_winreg_QueryValue_done, req);
3072         return req;
3073 }
3074
3075 static void rpccli_winreg_QueryValue_done(struct tevent_req *subreq)
3076 {
3077         struct tevent_req *req = tevent_req_callback_data(
3078                 subreq, struct tevent_req);
3079         struct rpccli_winreg_QueryValue_state *state = tevent_req_data(
3080                 req, struct rpccli_winreg_QueryValue_state);
3081         NTSTATUS status;
3082         TALLOC_CTX *mem_ctx;
3083
3084         if (state->out_mem_ctx) {
3085                 mem_ctx = state->out_mem_ctx;
3086         } else {
3087                 mem_ctx = state;
3088         }
3089
3090         status = state->dispatch_recv(subreq, mem_ctx);
3091         TALLOC_FREE(subreq);
3092         if (!NT_STATUS_IS_OK(status)) {
3093                 tevent_req_nterror(req, status);
3094                 return;
3095         }
3096
3097         /* Copy out parameters */
3098         if (state->orig.out.type && state->tmp.out.type) {
3099                 *state->orig.out.type = *state->tmp.out.type;
3100         }
3101         if (state->orig.out.data && state->tmp.out.data) {
3102                 memcpy(state->orig.out.data, state->tmp.out.data, *state->tmp.in.data_size * sizeof(*state->orig.out.data));
3103         }
3104         if (state->orig.out.data_size && state->tmp.out.data_size) {
3105                 *state->orig.out.data_size = *state->tmp.out.data_size;
3106         }
3107         if (state->orig.out.data_length && state->tmp.out.data_length) {
3108                 *state->orig.out.data_length = *state->tmp.out.data_length;
3109         }
3110
3111         /* Copy result */
3112         state->orig.out.result = state->tmp.out.result;
3113
3114         /* Reset temporary structure */
3115         ZERO_STRUCT(state->tmp);
3116
3117         if (DEBUGLEVEL >= 10) {
3118                 NDR_PRINT_OUT_DEBUG(winreg_QueryValue, &state->orig);
3119         }
3120
3121         tevent_req_done(req);
3122 }
3123
3124 NTSTATUS rpccli_winreg_QueryValue_recv(struct tevent_req *req,
3125                                        TALLOC_CTX *mem_ctx,
3126                                        WERROR *result)
3127 {
3128         struct rpccli_winreg_QueryValue_state *state = tevent_req_data(
3129                 req, struct rpccli_winreg_QueryValue_state);
3130         NTSTATUS status;
3131
3132         if (tevent_req_is_nterror(req, &status)) {
3133                 tevent_req_received(req);
3134                 return status;
3135         }
3136
3137         /* Steal possbile out parameters to the callers context */
3138         talloc_steal(mem_ctx, state->out_mem_ctx);
3139
3140         /* Return result */
3141         *result = state->orig.out.result;
3142
3143         tevent_req_received(req);
3144         return NT_STATUS_OK;
3145 }
3146
3147 NTSTATUS rpccli_winreg_QueryValue(struct rpc_pipe_client *cli,
3148                                   TALLOC_CTX *mem_ctx,
3149                                   struct policy_handle *handle /* [in] [ref] */,
3150                                   struct winreg_String *value_name /* [in] [ref] */,
3151                                   enum winreg_Type *type /* [in,out] [unique] */,
3152                                   uint8_t *data /* [in,out] [unique,length_is(*data_length),size_is(*data_size)] */,
3153                                   uint32_t *data_size /* [in,out] [unique] */,
3154                                   uint32_t *data_length /* [in,out] [unique] */,
3155                                   WERROR *werror)
3156 {
3157         struct winreg_QueryValue r;
3158         NTSTATUS status;
3159
3160         /* In parameters */
3161         r.in.handle = handle;
3162         r.in.value_name = value_name;
3163         r.in.type = type;
3164         r.in.data = data;
3165         r.in.data_size = data_size;
3166         r.in.data_length = data_length;
3167
3168         if (DEBUGLEVEL >= 10) {
3169                 NDR_PRINT_IN_DEBUG(winreg_QueryValue, &r);
3170         }
3171
3172         status = cli->dispatch(cli,
3173                                 mem_ctx,
3174                                 &ndr_table_winreg,
3175                                 NDR_WINREG_QUERYVALUE,
3176                                 &r);
3177
3178         if (!NT_STATUS_IS_OK(status)) {
3179                 return status;
3180         }
3181
3182         if (DEBUGLEVEL >= 10) {
3183                 NDR_PRINT_OUT_DEBUG(winreg_QueryValue, &r);
3184         }
3185
3186         if (NT_STATUS_IS_ERR(status)) {
3187                 return status;
3188         }
3189
3190         /* Return variables */
3191         if (type && r.out.type) {
3192                 *type = *r.out.type;
3193         }
3194         if (data && r.out.data) {
3195                 memcpy(data, r.out.data, *r.in.data_size * sizeof(*data));
3196         }
3197         if (data_size && r.out.data_size) {
3198                 *data_size = *r.out.data_size;
3199         }
3200         if (data_length && r.out.data_length) {
3201                 *data_length = *r.out.data_length;
3202         }
3203
3204         /* Return result */
3205         if (werror) {
3206                 *werror = r.out.result;
3207         }
3208
3209         return werror_to_ntstatus(r.out.result);
3210 }
3211
3212 struct rpccli_winreg_ReplaceKey_state {
3213         struct winreg_ReplaceKey orig;
3214         struct winreg_ReplaceKey tmp;
3215         TALLOC_CTX *out_mem_ctx;
3216         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3217 };
3218
3219 static void rpccli_winreg_ReplaceKey_done(struct tevent_req *subreq);
3220
3221 struct tevent_req *rpccli_winreg_ReplaceKey_send(TALLOC_CTX *mem_ctx,
3222                                                  struct tevent_context *ev,
3223                                                  struct rpc_pipe_client *cli)
3224 {
3225         struct tevent_req *req;
3226         struct rpccli_winreg_ReplaceKey_state *state;
3227         struct tevent_req *subreq;
3228
3229         req = tevent_req_create(mem_ctx, &state,
3230                                 struct rpccli_winreg_ReplaceKey_state);
3231         if (req == NULL) {
3232                 return NULL;
3233         }
3234         state->out_mem_ctx = NULL;
3235         state->dispatch_recv = cli->dispatch_recv;
3236
3237         /* In parameters */
3238
3239         /* Out parameters */
3240
3241         /* Result */
3242         ZERO_STRUCT(state->orig.out.result);
3243
3244         if (DEBUGLEVEL >= 10) {
3245                 NDR_PRINT_IN_DEBUG(winreg_ReplaceKey, &state->orig);
3246         }
3247
3248         /* make a temporary copy, that we pass to the dispatch function */
3249         state->tmp = state->orig;
3250
3251         subreq = cli->dispatch_send(state, ev, cli,
3252                                     &ndr_table_winreg,
3253                                     NDR_WINREG_REPLACEKEY,
3254                                     &state->tmp);
3255         if (tevent_req_nomem(subreq, req)) {
3256                 return tevent_req_post(req, ev);
3257         }
3258         tevent_req_set_callback(subreq, rpccli_winreg_ReplaceKey_done, req);
3259         return req;
3260 }
3261
3262 static void rpccli_winreg_ReplaceKey_done(struct tevent_req *subreq)
3263 {
3264         struct tevent_req *req = tevent_req_callback_data(
3265                 subreq, struct tevent_req);
3266         struct rpccli_winreg_ReplaceKey_state *state = tevent_req_data(
3267                 req, struct rpccli_winreg_ReplaceKey_state);
3268         NTSTATUS status;
3269         TALLOC_CTX *mem_ctx;
3270
3271         if (state->out_mem_ctx) {
3272                 mem_ctx = state->out_mem_ctx;
3273         } else {
3274                 mem_ctx = state;
3275         }
3276
3277         status = state->dispatch_recv(subreq, mem_ctx);
3278         TALLOC_FREE(subreq);
3279         if (!NT_STATUS_IS_OK(status)) {
3280                 tevent_req_nterror(req, status);
3281                 return;
3282         }
3283
3284         /* Copy out parameters */
3285
3286         /* Copy result */
3287         state->orig.out.result = state->tmp.out.result;
3288
3289         /* Reset temporary structure */
3290         ZERO_STRUCT(state->tmp);
3291
3292         if (DEBUGLEVEL >= 10) {
3293                 NDR_PRINT_OUT_DEBUG(winreg_ReplaceKey, &state->orig);
3294         }
3295
3296         tevent_req_done(req);
3297 }
3298
3299 NTSTATUS rpccli_winreg_ReplaceKey_recv(struct tevent_req *req,
3300                                        TALLOC_CTX *mem_ctx,
3301                                        WERROR *result)
3302 {
3303         struct rpccli_winreg_ReplaceKey_state *state = tevent_req_data(
3304                 req, struct rpccli_winreg_ReplaceKey_state);
3305         NTSTATUS status;
3306
3307         if (tevent_req_is_nterror(req, &status)) {
3308                 tevent_req_received(req);
3309                 return status;
3310         }
3311
3312         /* Steal possbile out parameters to the callers context */
3313         talloc_steal(mem_ctx, state->out_mem_ctx);
3314
3315         /* Return result */
3316         *result = state->orig.out.result;
3317
3318         tevent_req_received(req);
3319         return NT_STATUS_OK;
3320 }
3321
3322 NTSTATUS rpccli_winreg_ReplaceKey(struct rpc_pipe_client *cli,
3323                                   TALLOC_CTX *mem_ctx,
3324                                   WERROR *werror)
3325 {
3326         struct winreg_ReplaceKey r;
3327         NTSTATUS status;
3328
3329         /* In parameters */
3330
3331         if (DEBUGLEVEL >= 10) {
3332                 NDR_PRINT_IN_DEBUG(winreg_ReplaceKey, &r);
3333         }
3334
3335         status = cli->dispatch(cli,
3336                                 mem_ctx,
3337                                 &ndr_table_winreg,
3338                                 NDR_WINREG_REPLACEKEY,
3339                                 &r);
3340
3341         if (!NT_STATUS_IS_OK(status)) {
3342                 return status;
3343         }
3344
3345         if (DEBUGLEVEL >= 10) {
3346                 NDR_PRINT_OUT_DEBUG(winreg_ReplaceKey, &r);
3347         }
3348
3349         if (NT_STATUS_IS_ERR(status)) {
3350                 return status;
3351         }
3352
3353         /* Return variables */
3354
3355         /* Return result */
3356         if (werror) {
3357                 *werror = r.out.result;
3358         }
3359
3360         return werror_to_ntstatus(r.out.result);
3361 }
3362
3363 struct rpccli_winreg_RestoreKey_state {
3364         struct winreg_RestoreKey orig;
3365         struct winreg_RestoreKey tmp;
3366         TALLOC_CTX *out_mem_ctx;
3367         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3368 };
3369
3370 static void rpccli_winreg_RestoreKey_done(struct tevent_req *subreq);
3371
3372 struct tevent_req *rpccli_winreg_RestoreKey_send(TALLOC_CTX *mem_ctx,
3373                                                  struct tevent_context *ev,
3374                                                  struct rpc_pipe_client *cli,
3375                                                  struct policy_handle *_handle /* [in] [ref] */,
3376                                                  struct winreg_String *_filename /* [in] [ref] */,
3377                                                  uint32_t _flags /* [in]  */)
3378 {
3379         struct tevent_req *req;
3380         struct rpccli_winreg_RestoreKey_state *state;
3381         struct tevent_req *subreq;
3382
3383         req = tevent_req_create(mem_ctx, &state,
3384                                 struct rpccli_winreg_RestoreKey_state);
3385         if (req == NULL) {
3386                 return NULL;
3387         }
3388         state->out_mem_ctx = NULL;
3389         state->dispatch_recv = cli->dispatch_recv;
3390
3391         /* In parameters */
3392         state->orig.in.handle = _handle;
3393         state->orig.in.filename = _filename;
3394         state->orig.in.flags = _flags;
3395
3396         /* Out parameters */
3397
3398         /* Result */
3399         ZERO_STRUCT(state->orig.out.result);
3400
3401         if (DEBUGLEVEL >= 10) {
3402                 NDR_PRINT_IN_DEBUG(winreg_RestoreKey, &state->orig);
3403         }
3404
3405         /* make a temporary copy, that we pass to the dispatch function */
3406         state->tmp = state->orig;
3407
3408         subreq = cli->dispatch_send(state, ev, cli,
3409                                     &ndr_table_winreg,
3410                                     NDR_WINREG_RESTOREKEY,
3411                                     &state->tmp);
3412         if (tevent_req_nomem(subreq, req)) {
3413                 return tevent_req_post(req, ev);
3414         }
3415         tevent_req_set_callback(subreq, rpccli_winreg_RestoreKey_done, req);
3416         return req;
3417 }
3418
3419 static void rpccli_winreg_RestoreKey_done(struct tevent_req *subreq)
3420 {
3421         struct tevent_req *req = tevent_req_callback_data(
3422                 subreq, struct tevent_req);
3423         struct rpccli_winreg_RestoreKey_state *state = tevent_req_data(
3424                 req, struct rpccli_winreg_RestoreKey_state);
3425         NTSTATUS status;
3426         TALLOC_CTX *mem_ctx;
3427
3428         if (state->out_mem_ctx) {
3429                 mem_ctx = state->out_mem_ctx;
3430         } else {
3431                 mem_ctx = state;
3432         }
3433
3434         status = state->dispatch_recv(subreq, mem_ctx);
3435         TALLOC_FREE(subreq);
3436         if (!NT_STATUS_IS_OK(status)) {
3437                 tevent_req_nterror(req, status);
3438                 return;
3439         }
3440
3441         /* Copy out parameters */
3442
3443         /* Copy result */
3444         state->orig.out.result = state->tmp.out.result;
3445
3446         /* Reset temporary structure */
3447         ZERO_STRUCT(state->tmp);
3448
3449         if (DEBUGLEVEL >= 10) {
3450                 NDR_PRINT_OUT_DEBUG(winreg_RestoreKey, &state->orig);
3451         }
3452
3453         tevent_req_done(req);
3454 }
3455
3456 NTSTATUS rpccli_winreg_RestoreKey_recv(struct tevent_req *req,
3457                                        TALLOC_CTX *mem_ctx,
3458                                        WERROR *result)
3459 {
3460         struct rpccli_winreg_RestoreKey_state *state = tevent_req_data(
3461                 req, struct rpccli_winreg_RestoreKey_state);
3462         NTSTATUS status;
3463
3464         if (tevent_req_is_nterror(req, &status)) {
3465                 tevent_req_received(req);
3466                 return status;
3467         }
3468
3469         /* Steal possbile out parameters to the callers context */
3470         talloc_steal(mem_ctx, state->out_mem_ctx);
3471
3472         /* Return result */
3473         *result = state->orig.out.result;
3474
3475         tevent_req_received(req);
3476         return NT_STATUS_OK;
3477 }
3478
3479 NTSTATUS rpccli_winreg_RestoreKey(struct rpc_pipe_client *cli,
3480                                   TALLOC_CTX *mem_ctx,
3481                                   struct policy_handle *handle /* [in] [ref] */,
3482                                   struct winreg_String *filename /* [in] [ref] */,
3483                                   uint32_t flags /* [in]  */,
3484                                   WERROR *werror)
3485 {
3486         struct winreg_RestoreKey r;
3487         NTSTATUS status;
3488
3489         /* In parameters */
3490         r.in.handle = handle;
3491         r.in.filename = filename;
3492         r.in.flags = flags;
3493
3494         if (DEBUGLEVEL >= 10) {
3495                 NDR_PRINT_IN_DEBUG(winreg_RestoreKey, &r);
3496         }
3497
3498         status = cli->dispatch(cli,
3499                                 mem_ctx,
3500                                 &ndr_table_winreg,
3501                                 NDR_WINREG_RESTOREKEY,
3502                                 &r);
3503
3504         if (!NT_STATUS_IS_OK(status)) {
3505                 return status;
3506         }
3507
3508         if (DEBUGLEVEL >= 10) {
3509                 NDR_PRINT_OUT_DEBUG(winreg_RestoreKey, &r);
3510         }
3511
3512         if (NT_STATUS_IS_ERR(status)) {
3513                 return status;
3514         }
3515
3516         /* Return variables */
3517
3518         /* Return result */
3519         if (werror) {
3520                 *werror = r.out.result;
3521         }
3522
3523         return werror_to_ntstatus(r.out.result);
3524 }
3525
3526 struct rpccli_winreg_SaveKey_state {
3527         struct winreg_SaveKey orig;
3528         struct winreg_SaveKey tmp;
3529         TALLOC_CTX *out_mem_ctx;
3530         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3531 };
3532
3533 static void rpccli_winreg_SaveKey_done(struct tevent_req *subreq);
3534
3535 struct tevent_req *rpccli_winreg_SaveKey_send(TALLOC_CTX *mem_ctx,
3536                                               struct tevent_context *ev,
3537                                               struct rpc_pipe_client *cli,
3538                                               struct policy_handle *_handle /* [in] [ref] */,
3539                                               struct winreg_String *_filename /* [in] [ref] */,
3540                                               struct KeySecurityAttribute *_sec_attrib /* [in] [unique] */)
3541 {
3542         struct tevent_req *req;
3543         struct rpccli_winreg_SaveKey_state *state;
3544         struct tevent_req *subreq;
3545
3546         req = tevent_req_create(mem_ctx, &state,
3547                                 struct rpccli_winreg_SaveKey_state);
3548         if (req == NULL) {
3549                 return NULL;
3550         }
3551         state->out_mem_ctx = NULL;
3552         state->dispatch_recv = cli->dispatch_recv;
3553
3554         /* In parameters */
3555         state->orig.in.handle = _handle;
3556         state->orig.in.filename = _filename;
3557         state->orig.in.sec_attrib = _sec_attrib;
3558
3559         /* Out parameters */
3560
3561         /* Result */
3562         ZERO_STRUCT(state->orig.out.result);
3563
3564         if (DEBUGLEVEL >= 10) {
3565                 NDR_PRINT_IN_DEBUG(winreg_SaveKey, &state->orig);
3566         }
3567
3568         /* make a temporary copy, that we pass to the dispatch function */
3569         state->tmp = state->orig;
3570
3571         subreq = cli->dispatch_send(state, ev, cli,
3572                                     &ndr_table_winreg,
3573                                     NDR_WINREG_SAVEKEY,
3574                                     &state->tmp);
3575         if (tevent_req_nomem(subreq, req)) {
3576                 return tevent_req_post(req, ev);
3577         }
3578         tevent_req_set_callback(subreq, rpccli_winreg_SaveKey_done, req);
3579         return req;
3580 }
3581
3582 static void rpccli_winreg_SaveKey_done(struct tevent_req *subreq)
3583 {
3584         struct tevent_req *req = tevent_req_callback_data(
3585                 subreq, struct tevent_req);
3586         struct rpccli_winreg_SaveKey_state *state = tevent_req_data(
3587                 req, struct rpccli_winreg_SaveKey_state);
3588         NTSTATUS status;
3589         TALLOC_CTX *mem_ctx;
3590
3591         if (state->out_mem_ctx) {
3592                 mem_ctx = state->out_mem_ctx;
3593         } else {
3594                 mem_ctx = state;
3595         }
3596
3597         status = state->dispatch_recv(subreq, mem_ctx);
3598         TALLOC_FREE(subreq);
3599         if (!NT_STATUS_IS_OK(status)) {
3600                 tevent_req_nterror(req, status);
3601                 return;
3602         }
3603
3604         /* Copy out parameters */
3605
3606         /* Copy result */
3607         state->orig.out.result = state->tmp.out.result;
3608
3609         /* Reset temporary structure */
3610         ZERO_STRUCT(state->tmp);
3611
3612         if (DEBUGLEVEL >= 10) {
3613                 NDR_PRINT_OUT_DEBUG(winreg_SaveKey, &state->orig);
3614         }
3615
3616         tevent_req_done(req);
3617 }
3618
3619 NTSTATUS rpccli_winreg_SaveKey_recv(struct tevent_req *req,
3620                                     TALLOC_CTX *mem_ctx,
3621                                     WERROR *result)
3622 {
3623         struct rpccli_winreg_SaveKey_state *state = tevent_req_data(
3624                 req, struct rpccli_winreg_SaveKey_state);
3625         NTSTATUS status;
3626
3627         if (tevent_req_is_nterror(req, &status)) {
3628                 tevent_req_received(req);
3629                 return status;
3630         }
3631
3632         /* Steal possbile out parameters to the callers context */
3633         talloc_steal(mem_ctx, state->out_mem_ctx);
3634
3635         /* Return result */
3636         *result = state->orig.out.result;
3637
3638         tevent_req_received(req);
3639         return NT_STATUS_OK;
3640 }
3641
3642 NTSTATUS rpccli_winreg_SaveKey(struct rpc_pipe_client *cli,
3643                                TALLOC_CTX *mem_ctx,
3644                                struct policy_handle *handle /* [in] [ref] */,
3645                                struct winreg_String *filename /* [in] [ref] */,
3646                                struct KeySecurityAttribute *sec_attrib /* [in] [unique] */,
3647                                WERROR *werror)
3648 {
3649         struct winreg_SaveKey r;
3650         NTSTATUS status;
3651
3652         /* In parameters */
3653         r.in.handle = handle;
3654         r.in.filename = filename;
3655         r.in.sec_attrib = sec_attrib;
3656
3657         if (DEBUGLEVEL >= 10) {
3658                 NDR_PRINT_IN_DEBUG(winreg_SaveKey, &r);
3659         }
3660
3661         status = cli->dispatch(cli,
3662                                 mem_ctx,
3663                                 &ndr_table_winreg,
3664                                 NDR_WINREG_SAVEKEY,
3665                                 &r);
3666
3667         if (!NT_STATUS_IS_OK(status)) {
3668                 return status;
3669         }
3670
3671         if (DEBUGLEVEL >= 10) {
3672                 NDR_PRINT_OUT_DEBUG(winreg_SaveKey, &r);
3673         }
3674
3675         if (NT_STATUS_IS_ERR(status)) {
3676                 return status;
3677         }
3678
3679         /* Return variables */
3680
3681         /* Return result */
3682         if (werror) {
3683                 *werror = r.out.result;
3684         }
3685
3686         return werror_to_ntstatus(r.out.result);
3687 }
3688
3689 struct rpccli_winreg_SetKeySecurity_state {
3690         struct winreg_SetKeySecurity orig;
3691         struct winreg_SetKeySecurity tmp;
3692         TALLOC_CTX *out_mem_ctx;
3693         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3694 };
3695
3696 static void rpccli_winreg_SetKeySecurity_done(struct tevent_req *subreq);
3697
3698 struct tevent_req *rpccli_winreg_SetKeySecurity_send(TALLOC_CTX *mem_ctx,
3699                                                      struct tevent_context *ev,
3700                                                      struct rpc_pipe_client *cli,
3701                                                      struct policy_handle *_handle /* [in] [ref] */,
3702                                                      uint32_t _sec_info /* [in]  */,
3703                                                      struct KeySecurityData *_sd /* [in] [ref] */)
3704 {
3705         struct tevent_req *req;
3706         struct rpccli_winreg_SetKeySecurity_state *state;
3707         struct tevent_req *subreq;
3708
3709         req = tevent_req_create(mem_ctx, &state,
3710                                 struct rpccli_winreg_SetKeySecurity_state);
3711         if (req == NULL) {
3712                 return NULL;
3713         }
3714         state->out_mem_ctx = NULL;
3715         state->dispatch_recv = cli->dispatch_recv;
3716
3717         /* In parameters */
3718         state->orig.in.handle = _handle;
3719         state->orig.in.sec_info = _sec_info;
3720         state->orig.in.sd = _sd;
3721
3722         /* Out parameters */
3723
3724         /* Result */
3725         ZERO_STRUCT(state->orig.out.result);
3726
3727         if (DEBUGLEVEL >= 10) {
3728                 NDR_PRINT_IN_DEBUG(winreg_SetKeySecurity, &state->orig);
3729         }
3730
3731         /* make a temporary copy, that we pass to the dispatch function */
3732         state->tmp = state->orig;
3733
3734         subreq = cli->dispatch_send(state, ev, cli,
3735                                     &ndr_table_winreg,
3736                                     NDR_WINREG_SETKEYSECURITY,
3737                                     &state->tmp);
3738         if (tevent_req_nomem(subreq, req)) {
3739                 return tevent_req_post(req, ev);
3740         }
3741         tevent_req_set_callback(subreq, rpccli_winreg_SetKeySecurity_done, req);
3742         return req;
3743 }
3744
3745 static void rpccli_winreg_SetKeySecurity_done(struct tevent_req *subreq)
3746 {
3747         struct tevent_req *req = tevent_req_callback_data(
3748                 subreq, struct tevent_req);
3749         struct rpccli_winreg_SetKeySecurity_state *state = tevent_req_data(
3750                 req, struct rpccli_winreg_SetKeySecurity_state);
3751         NTSTATUS status;
3752         TALLOC_CTX *mem_ctx;
3753
3754         if (state->out_mem_ctx) {
3755                 mem_ctx = state->out_mem_ctx;
3756         } else {
3757                 mem_ctx = state;
3758         }
3759
3760         status = state->dispatch_recv(subreq, mem_ctx);
3761         TALLOC_FREE(subreq);
3762         if (!NT_STATUS_IS_OK(status)) {
3763                 tevent_req_nterror(req, status);
3764                 return;
3765         }
3766
3767         /* Copy out parameters */
3768
3769         /* Copy result */
3770         state->orig.out.result = state->tmp.out.result;
3771
3772         /* Reset temporary structure */
3773         ZERO_STRUCT(state->tmp);
3774
3775         if (DEBUGLEVEL >= 10) {
3776                 NDR_PRINT_OUT_DEBUG(winreg_SetKeySecurity, &state->orig);
3777         }
3778
3779         tevent_req_done(req);
3780 }
3781
3782 NTSTATUS rpccli_winreg_SetKeySecurity_recv(struct tevent_req *req,
3783                                            TALLOC_CTX *mem_ctx,
3784                                            WERROR *result)
3785 {
3786         struct rpccli_winreg_SetKeySecurity_state *state = tevent_req_data(
3787                 req, struct rpccli_winreg_SetKeySecurity_state);
3788         NTSTATUS status;
3789
3790         if (tevent_req_is_nterror(req, &status)) {
3791                 tevent_req_received(req);
3792                 return status;
3793         }
3794
3795         /* Steal possbile out parameters to the callers context */
3796         talloc_steal(mem_ctx, state->out_mem_ctx);
3797
3798         /* Return result */
3799         *result = state->orig.out.result;
3800
3801         tevent_req_received(req);
3802         return NT_STATUS_OK;
3803 }
3804
3805 NTSTATUS rpccli_winreg_SetKeySecurity(struct rpc_pipe_client *cli,
3806                                       TALLOC_CTX *mem_ctx,
3807                                       struct policy_handle *handle /* [in] [ref] */,
3808                                       uint32_t sec_info /* [in]  */,
3809                                       struct KeySecurityData *sd /* [in] [ref] */,
3810                                       WERROR *werror)
3811 {
3812         struct winreg_SetKeySecurity r;
3813         NTSTATUS status;
3814
3815         /* In parameters */
3816         r.in.handle = handle;
3817         r.in.sec_info = sec_info;
3818         r.in.sd = sd;
3819
3820         if (DEBUGLEVEL >= 10) {
3821                 NDR_PRINT_IN_DEBUG(winreg_SetKeySecurity, &r);
3822         }
3823
3824         status = cli->dispatch(cli,
3825                                 mem_ctx,
3826                                 &ndr_table_winreg,
3827                                 NDR_WINREG_SETKEYSECURITY,
3828                                 &r);
3829
3830         if (!NT_STATUS_IS_OK(status)) {
3831                 return status;
3832         }
3833
3834         if (DEBUGLEVEL >= 10) {
3835                 NDR_PRINT_OUT_DEBUG(winreg_SetKeySecurity, &r);
3836         }
3837
3838         if (NT_STATUS_IS_ERR(status)) {
3839                 return status;
3840         }
3841
3842         /* Return variables */
3843
3844         /* Return result */
3845         if (werror) {
3846                 *werror = r.out.result;
3847         }
3848
3849         return werror_to_ntstatus(r.out.result);
3850 }
3851
3852 struct rpccli_winreg_SetValue_state {
3853         struct winreg_SetValue orig;
3854         struct winreg_SetValue tmp;
3855         TALLOC_CTX *out_mem_ctx;
3856         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3857 };
3858
3859 static void rpccli_winreg_SetValue_done(struct tevent_req *subreq);
3860
3861 struct tevent_req *rpccli_winreg_SetValue_send(TALLOC_CTX *mem_ctx,
3862                                                struct tevent_context *ev,
3863                                                struct rpc_pipe_client *cli,
3864                                                struct policy_handle *_handle /* [in] [ref] */,
3865                                                struct winreg_String _name /* [in]  */,
3866                                                enum winreg_Type _type /* [in]  */,
3867                                                uint8_t *_data /* [in] [ref,size_is(size)] */,
3868                                                uint32_t _size /* [in]  */)
3869 {
3870         struct tevent_req *req;
3871         struct rpccli_winreg_SetValue_state *state;
3872         struct tevent_req *subreq;
3873
3874         req = tevent_req_create(mem_ctx, &state,
3875                                 struct rpccli_winreg_SetValue_state);
3876         if (req == NULL) {
3877                 return NULL;
3878         }
3879         state->out_mem_ctx = NULL;
3880         state->dispatch_recv = cli->dispatch_recv;
3881
3882         /* In parameters */
3883         state->orig.in.handle = _handle;
3884         state->orig.in.name = _name;
3885         state->orig.in.type = _type;
3886         state->orig.in.data = _data;
3887         state->orig.in.size = _size;
3888
3889         /* Out parameters */
3890
3891         /* Result */
3892         ZERO_STRUCT(state->orig.out.result);
3893
3894         if (DEBUGLEVEL >= 10) {
3895                 NDR_PRINT_IN_DEBUG(winreg_SetValue, &state->orig);
3896         }
3897
3898         /* make a temporary copy, that we pass to the dispatch function */
3899         state->tmp = state->orig;
3900
3901         subreq = cli->dispatch_send(state, ev, cli,
3902                                     &ndr_table_winreg,
3903                                     NDR_WINREG_SETVALUE,
3904                                     &state->tmp);
3905         if (tevent_req_nomem(subreq, req)) {
3906                 return tevent_req_post(req, ev);
3907         }
3908         tevent_req_set_callback(subreq, rpccli_winreg_SetValue_done, req);
3909         return req;
3910 }
3911
3912 static void rpccli_winreg_SetValue_done(struct tevent_req *subreq)
3913 {
3914         struct tevent_req *req = tevent_req_callback_data(
3915                 subreq, struct tevent_req);
3916         struct rpccli_winreg_SetValue_state *state = tevent_req_data(
3917                 req, struct rpccli_winreg_SetValue_state);
3918         NTSTATUS status;
3919         TALLOC_CTX *mem_ctx;
3920
3921         if (state->out_mem_ctx) {
3922                 mem_ctx = state->out_mem_ctx;
3923         } else {
3924                 mem_ctx = state;
3925         }
3926
3927         status = state->dispatch_recv(subreq, mem_ctx);
3928         TALLOC_FREE(subreq);
3929         if (!NT_STATUS_IS_OK(status)) {
3930                 tevent_req_nterror(req, status);
3931                 return;
3932         }
3933
3934         /* Copy out parameters */
3935
3936         /* Copy result */
3937         state->orig.out.result = state->tmp.out.result;
3938
3939         /* Reset temporary structure */
3940         ZERO_STRUCT(state->tmp);
3941
3942         if (DEBUGLEVEL >= 10) {
3943                 NDR_PRINT_OUT_DEBUG(winreg_SetValue, &state->orig);
3944         }
3945
3946         tevent_req_done(req);
3947 }
3948
3949 NTSTATUS rpccli_winreg_SetValue_recv(struct tevent_req *req,
3950                                      TALLOC_CTX *mem_ctx,
3951                                      WERROR *result)
3952 {
3953         struct rpccli_winreg_SetValue_state *state = tevent_req_data(
3954                 req, struct rpccli_winreg_SetValue_state);
3955         NTSTATUS status;
3956
3957         if (tevent_req_is_nterror(req, &status)) {
3958                 tevent_req_received(req);
3959                 return status;
3960         }
3961
3962         /* Steal possbile out parameters to the callers context */
3963         talloc_steal(mem_ctx, state->out_mem_ctx);
3964
3965         /* Return result */
3966         *result = state->orig.out.result;
3967
3968         tevent_req_received(req);
3969         return NT_STATUS_OK;
3970 }
3971
3972 NTSTATUS rpccli_winreg_SetValue(struct rpc_pipe_client *cli,
3973                                 TALLOC_CTX *mem_ctx,
3974                                 struct policy_handle *handle /* [in] [ref] */,
3975                                 struct winreg_String name /* [in]  */,
3976                                 enum winreg_Type type /* [in]  */,
3977                                 uint8_t *data /* [in] [ref,size_is(size)] */,
3978                                 uint32_t size /* [in]  */,
3979                                 WERROR *werror)
3980 {
3981         struct winreg_SetValue r;
3982         NTSTATUS status;
3983
3984         /* In parameters */
3985         r.in.handle = handle;
3986         r.in.name = name;
3987         r.in.type = type;
3988         r.in.data = data;
3989         r.in.size = size;
3990
3991         if (DEBUGLEVEL >= 10) {
3992                 NDR_PRINT_IN_DEBUG(winreg_SetValue, &r);
3993         }
3994
3995         status = cli->dispatch(cli,
3996                                 mem_ctx,
3997                                 &ndr_table_winreg,
3998                                 NDR_WINREG_SETVALUE,
3999                                 &r);
4000
4001         if (!NT_STATUS_IS_OK(status)) {
4002                 return status;
4003         }
4004
4005         if (DEBUGLEVEL >= 10) {
4006                 NDR_PRINT_OUT_DEBUG(winreg_SetValue, &r);
4007         }
4008
4009         if (NT_STATUS_IS_ERR(status)) {
4010                 return status;
4011         }
4012
4013         /* Return variables */
4014
4015         /* Return result */
4016         if (werror) {
4017                 *werror = r.out.result;
4018         }
4019
4020         return werror_to_ntstatus(r.out.result);
4021 }
4022
4023 struct rpccli_winreg_UnLoadKey_state {
4024         struct winreg_UnLoadKey orig;
4025         struct winreg_UnLoadKey tmp;
4026         TALLOC_CTX *out_mem_ctx;
4027         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4028 };
4029
4030 static void rpccli_winreg_UnLoadKey_done(struct tevent_req *subreq);
4031
4032 struct tevent_req *rpccli_winreg_UnLoadKey_send(TALLOC_CTX *mem_ctx,
4033                                                 struct tevent_context *ev,
4034                                                 struct rpc_pipe_client *cli)
4035 {
4036         struct tevent_req *req;
4037         struct rpccli_winreg_UnLoadKey_state *state;
4038         struct tevent_req *subreq;
4039
4040         req = tevent_req_create(mem_ctx, &state,
4041                                 struct rpccli_winreg_UnLoadKey_state);
4042         if (req == NULL) {
4043                 return NULL;
4044         }
4045         state->out_mem_ctx = NULL;
4046         state->dispatch_recv = cli->dispatch_recv;
4047
4048         /* In parameters */
4049
4050         /* Out parameters */
4051
4052         /* Result */
4053         ZERO_STRUCT(state->orig.out.result);
4054
4055         if (DEBUGLEVEL >= 10) {
4056                 NDR_PRINT_IN_DEBUG(winreg_UnLoadKey, &state->orig);
4057         }
4058
4059         /* make a temporary copy, that we pass to the dispatch function */
4060         state->tmp = state->orig;
4061
4062         subreq = cli->dispatch_send(state, ev, cli,
4063                                     &ndr_table_winreg,
4064                                     NDR_WINREG_UNLOADKEY,
4065                                     &state->tmp);
4066         if (tevent_req_nomem(subreq, req)) {
4067                 return tevent_req_post(req, ev);
4068         }
4069         tevent_req_set_callback(subreq, rpccli_winreg_UnLoadKey_done, req);
4070         return req;
4071 }
4072
4073 static void rpccli_winreg_UnLoadKey_done(struct tevent_req *subreq)
4074 {
4075         struct tevent_req *req = tevent_req_callback_data(
4076                 subreq, struct tevent_req);
4077         struct rpccli_winreg_UnLoadKey_state *state = tevent_req_data(
4078                 req, struct rpccli_winreg_UnLoadKey_state);
4079         NTSTATUS status;
4080         TALLOC_CTX *mem_ctx;
4081
4082         if (state->out_mem_ctx) {
4083                 mem_ctx = state->out_mem_ctx;
4084         } else {
4085                 mem_ctx = state;
4086         }
4087
4088         status = state->dispatch_recv(subreq, mem_ctx);
4089         TALLOC_FREE(subreq);
4090         if (!NT_STATUS_IS_OK(status)) {
4091                 tevent_req_nterror(req, status);
4092                 return;
4093         }
4094
4095         /* Copy out parameters */
4096
4097         /* Copy result */
4098         state->orig.out.result = state->tmp.out.result;
4099
4100         /* Reset temporary structure */
4101         ZERO_STRUCT(state->tmp);
4102
4103         if (DEBUGLEVEL >= 10) {
4104                 NDR_PRINT_OUT_DEBUG(winreg_UnLoadKey, &state->orig);
4105         }
4106
4107         tevent_req_done(req);
4108 }
4109
4110 NTSTATUS rpccli_winreg_UnLoadKey_recv(struct tevent_req *req,
4111                                       TALLOC_CTX *mem_ctx,
4112                                       WERROR *result)
4113 {
4114         struct rpccli_winreg_UnLoadKey_state *state = tevent_req_data(
4115                 req, struct rpccli_winreg_UnLoadKey_state);
4116         NTSTATUS status;
4117
4118         if (tevent_req_is_nterror(req, &status)) {
4119                 tevent_req_received(req);
4120                 return status;
4121         }
4122
4123         /* Steal possbile out parameters to the callers context */
4124         talloc_steal(mem_ctx, state->out_mem_ctx);
4125
4126         /* Return result */
4127         *result = state->orig.out.result;
4128
4129         tevent_req_received(req);
4130         return NT_STATUS_OK;
4131 }
4132
4133 NTSTATUS rpccli_winreg_UnLoadKey(struct rpc_pipe_client *cli,
4134                                  TALLOC_CTX *mem_ctx,
4135                                  WERROR *werror)
4136 {
4137         struct winreg_UnLoadKey r;
4138         NTSTATUS status;
4139
4140         /* In parameters */
4141
4142         if (DEBUGLEVEL >= 10) {
4143                 NDR_PRINT_IN_DEBUG(winreg_UnLoadKey, &r);
4144         }
4145
4146         status = cli->dispatch(cli,
4147                                 mem_ctx,
4148                                 &ndr_table_winreg,
4149                                 NDR_WINREG_UNLOADKEY,
4150                                 &r);
4151
4152         if (!NT_STATUS_IS_OK(status)) {
4153                 return status;
4154         }
4155
4156         if (DEBUGLEVEL >= 10) {
4157                 NDR_PRINT_OUT_DEBUG(winreg_UnLoadKey, &r);
4158         }
4159
4160         if (NT_STATUS_IS_ERR(status)) {
4161                 return status;
4162         }
4163
4164         /* Return variables */
4165
4166         /* Return result */
4167         if (werror) {
4168                 *werror = r.out.result;
4169         }
4170
4171         return werror_to_ntstatus(r.out.result);
4172 }
4173
4174 struct rpccli_winreg_InitiateSystemShutdown_state {
4175         struct winreg_InitiateSystemShutdown orig;
4176         struct winreg_InitiateSystemShutdown tmp;
4177         TALLOC_CTX *out_mem_ctx;
4178         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4179 };
4180
4181 static void rpccli_winreg_InitiateSystemShutdown_done(struct tevent_req *subreq);
4182
4183 struct tevent_req *rpccli_winreg_InitiateSystemShutdown_send(TALLOC_CTX *mem_ctx,
4184                                                              struct tevent_context *ev,
4185                                                              struct rpc_pipe_client *cli,
4186                                                              uint16_t *_hostname /* [in] [unique] */,
4187                                                              struct lsa_StringLarge *_message /* [in] [unique] */,
4188                                                              uint32_t _timeout /* [in]  */,
4189                                                              uint8_t _force_apps /* [in]  */,
4190                                                              uint8_t _do_reboot /* [in]  */)
4191 {
4192         struct tevent_req *req;
4193         struct rpccli_winreg_InitiateSystemShutdown_state *state;
4194         struct tevent_req *subreq;
4195
4196         req = tevent_req_create(mem_ctx, &state,
4197                                 struct rpccli_winreg_InitiateSystemShutdown_state);
4198         if (req == NULL) {
4199                 return NULL;
4200         }
4201         state->out_mem_ctx = NULL;
4202         state->dispatch_recv = cli->dispatch_recv;
4203
4204         /* In parameters */
4205         state->orig.in.hostname = _hostname;
4206         state->orig.in.message = _message;
4207         state->orig.in.timeout = _timeout;
4208         state->orig.in.force_apps = _force_apps;
4209         state->orig.in.do_reboot = _do_reboot;
4210
4211         /* Out parameters */
4212
4213         /* Result */
4214         ZERO_STRUCT(state->orig.out.result);
4215
4216         if (DEBUGLEVEL >= 10) {
4217                 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdown, &state->orig);
4218         }
4219
4220         /* make a temporary copy, that we pass to the dispatch function */
4221         state->tmp = state->orig;
4222
4223         subreq = cli->dispatch_send(state, ev, cli,
4224                                     &ndr_table_winreg,
4225                                     NDR_WINREG_INITIATESYSTEMSHUTDOWN,
4226                                     &state->tmp);
4227         if (tevent_req_nomem(subreq, req)) {
4228                 return tevent_req_post(req, ev);
4229         }
4230         tevent_req_set_callback(subreq, rpccli_winreg_InitiateSystemShutdown_done, req);
4231         return req;
4232 }
4233
4234 static void rpccli_winreg_InitiateSystemShutdown_done(struct tevent_req *subreq)
4235 {
4236         struct tevent_req *req = tevent_req_callback_data(
4237                 subreq, struct tevent_req);
4238         struct rpccli_winreg_InitiateSystemShutdown_state *state = tevent_req_data(
4239                 req, struct rpccli_winreg_InitiateSystemShutdown_state);
4240         NTSTATUS status;
4241         TALLOC_CTX *mem_ctx;
4242
4243         if (state->out_mem_ctx) {
4244                 mem_ctx = state->out_mem_ctx;
4245         } else {
4246                 mem_ctx = state;
4247         }
4248
4249         status = state->dispatch_recv(subreq, mem_ctx);
4250         TALLOC_FREE(subreq);
4251         if (!NT_STATUS_IS_OK(status)) {
4252                 tevent_req_nterror(req, status);
4253                 return;
4254         }
4255
4256         /* Copy out parameters */
4257
4258         /* Copy result */
4259         state->orig.out.result = state->tmp.out.result;
4260
4261         /* Reset temporary structure */
4262         ZERO_STRUCT(state->tmp);
4263
4264         if (DEBUGLEVEL >= 10) {
4265                 NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdown, &state->orig);
4266         }
4267
4268         tevent_req_done(req);
4269 }
4270
4271 NTSTATUS rpccli_winreg_InitiateSystemShutdown_recv(struct tevent_req *req,
4272                                                    TALLOC_CTX *mem_ctx,
4273                                                    WERROR *result)
4274 {
4275         struct rpccli_winreg_InitiateSystemShutdown_state *state = tevent_req_data(
4276                 req, struct rpccli_winreg_InitiateSystemShutdown_state);
4277         NTSTATUS status;
4278
4279         if (tevent_req_is_nterror(req, &status)) {
4280                 tevent_req_received(req);
4281                 return status;
4282         }
4283
4284         /* Steal possbile out parameters to the callers context */
4285         talloc_steal(mem_ctx, state->out_mem_ctx);
4286
4287         /* Return result */
4288         *result = state->orig.out.result;
4289
4290         tevent_req_received(req);
4291         return NT_STATUS_OK;
4292 }
4293
4294 NTSTATUS rpccli_winreg_InitiateSystemShutdown(struct rpc_pipe_client *cli,
4295                                               TALLOC_CTX *mem_ctx,
4296                                               uint16_t *hostname /* [in] [unique] */,
4297                                               struct lsa_StringLarge *message /* [in] [unique] */,
4298                                               uint32_t timeout /* [in]  */,
4299                                               uint8_t force_apps /* [in]  */,
4300                                               uint8_t do_reboot /* [in]  */,
4301                                               WERROR *werror)
4302 {
4303         struct winreg_InitiateSystemShutdown r;
4304         NTSTATUS status;
4305
4306         /* In parameters */
4307         r.in.hostname = hostname;
4308         r.in.message = message;
4309         r.in.timeout = timeout;
4310         r.in.force_apps = force_apps;
4311         r.in.do_reboot = do_reboot;
4312
4313         if (DEBUGLEVEL >= 10) {
4314                 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdown, &r);
4315         }
4316
4317         status = cli->dispatch(cli,
4318                                 mem_ctx,
4319                                 &ndr_table_winreg,
4320                                 NDR_WINREG_INITIATESYSTEMSHUTDOWN,
4321                                 &r);
4322
4323         if (!NT_STATUS_IS_OK(status)) {
4324                 return status;
4325         }
4326
4327         if (DEBUGLEVEL >= 10) {
4328                 NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdown, &r);
4329         }
4330
4331         if (NT_STATUS_IS_ERR(status)) {
4332                 return status;
4333         }
4334
4335         /* Return variables */
4336
4337         /* Return result */
4338         if (werror) {
4339                 *werror = r.out.result;
4340         }
4341
4342         return werror_to_ntstatus(r.out.result);
4343 }
4344
4345 struct rpccli_winreg_AbortSystemShutdown_state {
4346         struct winreg_AbortSystemShutdown orig;
4347         struct winreg_AbortSystemShutdown tmp;
4348         TALLOC_CTX *out_mem_ctx;
4349         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4350 };
4351
4352 static void rpccli_winreg_AbortSystemShutdown_done(struct tevent_req *subreq);
4353
4354 struct tevent_req *rpccli_winreg_AbortSystemShutdown_send(TALLOC_CTX *mem_ctx,
4355                                                           struct tevent_context *ev,
4356                                                           struct rpc_pipe_client *cli,
4357                                                           uint16_t *_server /* [in] [unique] */)
4358 {
4359         struct tevent_req *req;
4360         struct rpccli_winreg_AbortSystemShutdown_state *state;
4361         struct tevent_req *subreq;
4362
4363         req = tevent_req_create(mem_ctx, &state,
4364                                 struct rpccli_winreg_AbortSystemShutdown_state);
4365         if (req == NULL) {
4366                 return NULL;
4367         }
4368         state->out_mem_ctx = NULL;
4369         state->dispatch_recv = cli->dispatch_recv;
4370
4371         /* In parameters */
4372         state->orig.in.server = _server;
4373
4374         /* Out parameters */
4375
4376         /* Result */
4377         ZERO_STRUCT(state->orig.out.result);
4378
4379         if (DEBUGLEVEL >= 10) {
4380                 NDR_PRINT_IN_DEBUG(winreg_AbortSystemShutdown, &state->orig);
4381         }
4382
4383         /* make a temporary copy, that we pass to the dispatch function */
4384         state->tmp = state->orig;
4385
4386         subreq = cli->dispatch_send(state, ev, cli,
4387                                     &ndr_table_winreg,
4388                                     NDR_WINREG_ABORTSYSTEMSHUTDOWN,
4389                                     &state->tmp);
4390         if (tevent_req_nomem(subreq, req)) {
4391                 return tevent_req_post(req, ev);
4392         }
4393         tevent_req_set_callback(subreq, rpccli_winreg_AbortSystemShutdown_done, req);
4394         return req;
4395 }
4396
4397 static void rpccli_winreg_AbortSystemShutdown_done(struct tevent_req *subreq)
4398 {
4399         struct tevent_req *req = tevent_req_callback_data(
4400                 subreq, struct tevent_req);
4401         struct rpccli_winreg_AbortSystemShutdown_state *state = tevent_req_data(
4402                 req, struct rpccli_winreg_AbortSystemShutdown_state);
4403         NTSTATUS status;
4404         TALLOC_CTX *mem_ctx;
4405
4406         if (state->out_mem_ctx) {
4407                 mem_ctx = state->out_mem_ctx;
4408         } else {
4409                 mem_ctx = state;
4410         }
4411
4412         status = state->dispatch_recv(subreq, mem_ctx);
4413         TALLOC_FREE(subreq);
4414         if (!NT_STATUS_IS_OK(status)) {
4415                 tevent_req_nterror(req, status);
4416                 return;
4417         }
4418
4419         /* Copy out parameters */
4420
4421         /* Copy result */
4422         state->orig.out.result = state->tmp.out.result;
4423
4424         /* Reset temporary structure */
4425         ZERO_STRUCT(state->tmp);
4426
4427         if (DEBUGLEVEL >= 10) {
4428                 NDR_PRINT_OUT_DEBUG(winreg_AbortSystemShutdown, &state->orig);
4429         }
4430
4431         tevent_req_done(req);
4432 }
4433
4434 NTSTATUS rpccli_winreg_AbortSystemShutdown_recv(struct tevent_req *req,
4435                                                 TALLOC_CTX *mem_ctx,
4436                                                 WERROR *result)
4437 {
4438         struct rpccli_winreg_AbortSystemShutdown_state *state = tevent_req_data(
4439                 req, struct rpccli_winreg_AbortSystemShutdown_state);
4440         NTSTATUS status;
4441
4442         if (tevent_req_is_nterror(req, &status)) {
4443                 tevent_req_received(req);
4444                 return status;
4445         }
4446
4447         /* Steal possbile out parameters to the callers context */
4448         talloc_steal(mem_ctx, state->out_mem_ctx);
4449
4450         /* Return result */
4451         *result = state->orig.out.result;
4452
4453         tevent_req_received(req);
4454         return NT_STATUS_OK;
4455 }
4456
4457 NTSTATUS rpccli_winreg_AbortSystemShutdown(struct rpc_pipe_client *cli,
4458                                            TALLOC_CTX *mem_ctx,
4459                                            uint16_t *server /* [in] [unique] */,
4460                                            WERROR *werror)
4461 {
4462         struct winreg_AbortSystemShutdown r;
4463         NTSTATUS status;
4464
4465         /* In parameters */
4466         r.in.server = server;
4467
4468         if (DEBUGLEVEL >= 10) {
4469                 NDR_PRINT_IN_DEBUG(winreg_AbortSystemShutdown, &r);
4470         }
4471
4472         status = cli->dispatch(cli,
4473                                 mem_ctx,
4474                                 &ndr_table_winreg,
4475                                 NDR_WINREG_ABORTSYSTEMSHUTDOWN,
4476                                 &r);
4477
4478         if (!NT_STATUS_IS_OK(status)) {
4479                 return status;
4480         }
4481
4482         if (DEBUGLEVEL >= 10) {
4483                 NDR_PRINT_OUT_DEBUG(winreg_AbortSystemShutdown, &r);
4484         }
4485
4486         if (NT_STATUS_IS_ERR(status)) {
4487                 return status;
4488         }
4489
4490         /* Return variables */
4491
4492         /* Return result */
4493         if (werror) {
4494                 *werror = r.out.result;
4495         }
4496
4497         return werror_to_ntstatus(r.out.result);
4498 }
4499
4500 struct rpccli_winreg_GetVersion_state {
4501         struct winreg_GetVersion orig;
4502         struct winreg_GetVersion tmp;
4503         TALLOC_CTX *out_mem_ctx;
4504         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4505 };
4506
4507 static void rpccli_winreg_GetVersion_done(struct tevent_req *subreq);
4508
4509 struct tevent_req *rpccli_winreg_GetVersion_send(TALLOC_CTX *mem_ctx,
4510                                                  struct tevent_context *ev,
4511                                                  struct rpc_pipe_client *cli,
4512                                                  struct policy_handle *_handle /* [in] [ref] */,
4513                                                  uint32_t *_version /* [out] [ref] */)
4514 {
4515         struct tevent_req *req;
4516         struct rpccli_winreg_GetVersion_state *state;
4517         struct tevent_req *subreq;
4518
4519         req = tevent_req_create(mem_ctx, &state,
4520                                 struct rpccli_winreg_GetVersion_state);
4521         if (req == NULL) {
4522                 return NULL;
4523         }
4524         state->out_mem_ctx = NULL;
4525         state->dispatch_recv = cli->dispatch_recv;
4526
4527         /* In parameters */
4528         state->orig.in.handle = _handle;
4529
4530         /* Out parameters */
4531         state->orig.out.version = _version;
4532
4533         /* Result */
4534         ZERO_STRUCT(state->orig.out.result);
4535
4536         if (DEBUGLEVEL >= 10) {
4537                 NDR_PRINT_IN_DEBUG(winreg_GetVersion, &state->orig);
4538         }
4539
4540         state->out_mem_ctx = talloc_named_const(state, 0,
4541                              "rpccli_winreg_GetVersion_out_memory");
4542         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4543                 return tevent_req_post(req, ev);
4544         }
4545
4546         /* make a temporary copy, that we pass to the dispatch function */
4547         state->tmp = state->orig;
4548
4549         subreq = cli->dispatch_send(state, ev, cli,
4550                                     &ndr_table_winreg,
4551                                     NDR_WINREG_GETVERSION,
4552                                     &state->tmp);
4553         if (tevent_req_nomem(subreq, req)) {
4554                 return tevent_req_post(req, ev);
4555         }
4556         tevent_req_set_callback(subreq, rpccli_winreg_GetVersion_done, req);
4557         return req;
4558 }
4559
4560 static void rpccli_winreg_GetVersion_done(struct tevent_req *subreq)
4561 {
4562         struct tevent_req *req = tevent_req_callback_data(
4563                 subreq, struct tevent_req);
4564         struct rpccli_winreg_GetVersion_state *state = tevent_req_data(
4565                 req, struct rpccli_winreg_GetVersion_state);
4566         NTSTATUS status;
4567         TALLOC_CTX *mem_ctx;
4568
4569         if (state->out_mem_ctx) {
4570                 mem_ctx = state->out_mem_ctx;
4571         } else {
4572                 mem_ctx = state;
4573         }
4574
4575         status = state->dispatch_recv(subreq, mem_ctx);
4576         TALLOC_FREE(subreq);
4577         if (!NT_STATUS_IS_OK(status)) {
4578                 tevent_req_nterror(req, status);
4579                 return;
4580         }
4581
4582         /* Copy out parameters */
4583         *state->orig.out.version = *state->tmp.out.version;
4584
4585         /* Copy result */
4586         state->orig.out.result = state->tmp.out.result;
4587
4588         /* Reset temporary structure */
4589         ZERO_STRUCT(state->tmp);
4590
4591         if (DEBUGLEVEL >= 10) {
4592                 NDR_PRINT_OUT_DEBUG(winreg_GetVersion, &state->orig);
4593         }
4594
4595         tevent_req_done(req);
4596 }
4597
4598 NTSTATUS rpccli_winreg_GetVersion_recv(struct tevent_req *req,
4599                                        TALLOC_CTX *mem_ctx,
4600                                        WERROR *result)
4601 {
4602         struct rpccli_winreg_GetVersion_state *state = tevent_req_data(
4603                 req, struct rpccli_winreg_GetVersion_state);
4604         NTSTATUS status;
4605
4606         if (tevent_req_is_nterror(req, &status)) {
4607                 tevent_req_received(req);
4608                 return status;
4609         }
4610
4611         /* Steal possbile out parameters to the callers context */
4612         talloc_steal(mem_ctx, state->out_mem_ctx);
4613
4614         /* Return result */
4615         *result = state->orig.out.result;
4616
4617         tevent_req_received(req);
4618         return NT_STATUS_OK;
4619 }
4620
4621 NTSTATUS rpccli_winreg_GetVersion(struct rpc_pipe_client *cli,
4622                                   TALLOC_CTX *mem_ctx,
4623                                   struct policy_handle *handle /* [in] [ref] */,
4624                                   uint32_t *version /* [out] [ref] */,
4625                                   WERROR *werror)
4626 {
4627         struct winreg_GetVersion r;
4628         NTSTATUS status;
4629
4630         /* In parameters */
4631         r.in.handle = handle;
4632
4633         if (DEBUGLEVEL >= 10) {
4634                 NDR_PRINT_IN_DEBUG(winreg_GetVersion, &r);
4635         }
4636
4637         status = cli->dispatch(cli,
4638                                 mem_ctx,
4639                                 &ndr_table_winreg,
4640                                 NDR_WINREG_GETVERSION,
4641                                 &r);
4642
4643         if (!NT_STATUS_IS_OK(status)) {
4644                 return status;
4645         }
4646
4647         if (DEBUGLEVEL >= 10) {
4648                 NDR_PRINT_OUT_DEBUG(winreg_GetVersion, &r);
4649         }
4650
4651         if (NT_STATUS_IS_ERR(status)) {
4652                 return status;
4653         }
4654
4655         /* Return variables */
4656         *version = *r.out.version;
4657
4658         /* Return result */
4659         if (werror) {
4660                 *werror = r.out.result;
4661         }
4662
4663         return werror_to_ntstatus(r.out.result);
4664 }
4665
4666 struct rpccli_winreg_OpenHKCC_state {
4667         struct winreg_OpenHKCC orig;
4668         struct winreg_OpenHKCC tmp;
4669         TALLOC_CTX *out_mem_ctx;
4670         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4671 };
4672
4673 static void rpccli_winreg_OpenHKCC_done(struct tevent_req *subreq);
4674
4675 struct tevent_req *rpccli_winreg_OpenHKCC_send(TALLOC_CTX *mem_ctx,
4676                                                struct tevent_context *ev,
4677                                                struct rpc_pipe_client *cli,
4678                                                uint16_t *_system_name /* [in] [unique] */,
4679                                                uint32_t _access_mask /* [in]  */,
4680                                                struct policy_handle *_handle /* [out] [ref] */)
4681 {
4682         struct tevent_req *req;
4683         struct rpccli_winreg_OpenHKCC_state *state;
4684         struct tevent_req *subreq;
4685
4686         req = tevent_req_create(mem_ctx, &state,
4687                                 struct rpccli_winreg_OpenHKCC_state);
4688         if (req == NULL) {
4689                 return NULL;
4690         }
4691         state->out_mem_ctx = NULL;
4692         state->dispatch_recv = cli->dispatch_recv;
4693
4694         /* In parameters */
4695         state->orig.in.system_name = _system_name;
4696         state->orig.in.access_mask = _access_mask;
4697
4698         /* Out parameters */
4699         state->orig.out.handle = _handle;
4700
4701         /* Result */
4702         ZERO_STRUCT(state->orig.out.result);
4703
4704         if (DEBUGLEVEL >= 10) {
4705                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCC, &state->orig);
4706         }
4707
4708         state->out_mem_ctx = talloc_named_const(state, 0,
4709                              "rpccli_winreg_OpenHKCC_out_memory");
4710         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4711                 return tevent_req_post(req, ev);
4712         }
4713
4714         /* make a temporary copy, that we pass to the dispatch function */
4715         state->tmp = state->orig;
4716
4717         subreq = cli->dispatch_send(state, ev, cli,
4718                                     &ndr_table_winreg,
4719                                     NDR_WINREG_OPENHKCC,
4720                                     &state->tmp);
4721         if (tevent_req_nomem(subreq, req)) {
4722                 return tevent_req_post(req, ev);
4723         }
4724         tevent_req_set_callback(subreq, rpccli_winreg_OpenHKCC_done, req);
4725         return req;
4726 }
4727
4728 static void rpccli_winreg_OpenHKCC_done(struct tevent_req *subreq)
4729 {
4730         struct tevent_req *req = tevent_req_callback_data(
4731                 subreq, struct tevent_req);
4732         struct rpccli_winreg_OpenHKCC_state *state = tevent_req_data(
4733                 req, struct rpccli_winreg_OpenHKCC_state);
4734         NTSTATUS status;
4735         TALLOC_CTX *mem_ctx;
4736
4737         if (state->out_mem_ctx) {
4738                 mem_ctx = state->out_mem_ctx;
4739         } else {
4740                 mem_ctx = state;
4741         }
4742
4743         status = state->dispatch_recv(subreq, mem_ctx);
4744         TALLOC_FREE(subreq);
4745         if (!NT_STATUS_IS_OK(status)) {
4746                 tevent_req_nterror(req, status);
4747                 return;
4748         }
4749
4750         /* Copy out parameters */
4751         *state->orig.out.handle = *state->tmp.out.handle;
4752
4753         /* Copy result */
4754         state->orig.out.result = state->tmp.out.result;
4755
4756         /* Reset temporary structure */
4757         ZERO_STRUCT(state->tmp);
4758
4759         if (DEBUGLEVEL >= 10) {
4760                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCC, &state->orig);
4761         }
4762
4763         tevent_req_done(req);
4764 }
4765
4766 NTSTATUS rpccli_winreg_OpenHKCC_recv(struct tevent_req *req,
4767                                      TALLOC_CTX *mem_ctx,
4768                                      WERROR *result)
4769 {
4770         struct rpccli_winreg_OpenHKCC_state *state = tevent_req_data(
4771                 req, struct rpccli_winreg_OpenHKCC_state);
4772         NTSTATUS status;
4773
4774         if (tevent_req_is_nterror(req, &status)) {
4775                 tevent_req_received(req);
4776                 return status;
4777         }
4778
4779         /* Steal possbile out parameters to the callers context */
4780         talloc_steal(mem_ctx, state->out_mem_ctx);
4781
4782         /* Return result */
4783         *result = state->orig.out.result;
4784
4785         tevent_req_received(req);
4786         return NT_STATUS_OK;
4787 }
4788
4789 NTSTATUS rpccli_winreg_OpenHKCC(struct rpc_pipe_client *cli,
4790                                 TALLOC_CTX *mem_ctx,
4791                                 uint16_t *system_name /* [in] [unique] */,
4792                                 uint32_t access_mask /* [in]  */,
4793                                 struct policy_handle *handle /* [out] [ref] */,
4794                                 WERROR *werror)
4795 {
4796         struct winreg_OpenHKCC r;
4797         NTSTATUS status;
4798
4799         /* In parameters */
4800         r.in.system_name = system_name;
4801         r.in.access_mask = access_mask;
4802
4803         if (DEBUGLEVEL >= 10) {
4804                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCC, &r);
4805         }
4806
4807         status = cli->dispatch(cli,
4808                                 mem_ctx,
4809                                 &ndr_table_winreg,
4810                                 NDR_WINREG_OPENHKCC,
4811                                 &r);
4812
4813         if (!NT_STATUS_IS_OK(status)) {
4814                 return status;
4815         }
4816
4817         if (DEBUGLEVEL >= 10) {
4818                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCC, &r);
4819         }
4820
4821         if (NT_STATUS_IS_ERR(status)) {
4822                 return status;
4823         }
4824
4825         /* Return variables */
4826         *handle = *r.out.handle;
4827
4828         /* Return result */
4829         if (werror) {
4830                 *werror = r.out.result;
4831         }
4832
4833         return werror_to_ntstatus(r.out.result);
4834 }
4835
4836 struct rpccli_winreg_OpenHKDD_state {
4837         struct winreg_OpenHKDD orig;
4838         struct winreg_OpenHKDD tmp;
4839         TALLOC_CTX *out_mem_ctx;
4840         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4841 };
4842
4843 static void rpccli_winreg_OpenHKDD_done(struct tevent_req *subreq);
4844
4845 struct tevent_req *rpccli_winreg_OpenHKDD_send(TALLOC_CTX *mem_ctx,
4846                                                struct tevent_context *ev,
4847                                                struct rpc_pipe_client *cli,
4848                                                uint16_t *_system_name /* [in] [unique] */,
4849                                                uint32_t _access_mask /* [in]  */,
4850                                                struct policy_handle *_handle /* [out] [ref] */)
4851 {
4852         struct tevent_req *req;
4853         struct rpccli_winreg_OpenHKDD_state *state;
4854         struct tevent_req *subreq;
4855
4856         req = tevent_req_create(mem_ctx, &state,
4857                                 struct rpccli_winreg_OpenHKDD_state);
4858         if (req == NULL) {
4859                 return NULL;
4860         }
4861         state->out_mem_ctx = NULL;
4862         state->dispatch_recv = cli->dispatch_recv;
4863
4864         /* In parameters */
4865         state->orig.in.system_name = _system_name;
4866         state->orig.in.access_mask = _access_mask;
4867
4868         /* Out parameters */
4869         state->orig.out.handle = _handle;
4870
4871         /* Result */
4872         ZERO_STRUCT(state->orig.out.result);
4873
4874         if (DEBUGLEVEL >= 10) {
4875                 NDR_PRINT_IN_DEBUG(winreg_OpenHKDD, &state->orig);
4876         }
4877
4878         state->out_mem_ctx = talloc_named_const(state, 0,
4879                              "rpccli_winreg_OpenHKDD_out_memory");
4880         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4881                 return tevent_req_post(req, ev);
4882         }
4883
4884         /* make a temporary copy, that we pass to the dispatch function */
4885         state->tmp = state->orig;
4886
4887         subreq = cli->dispatch_send(state, ev, cli,
4888                                     &ndr_table_winreg,
4889                                     NDR_WINREG_OPENHKDD,
4890                                     &state->tmp);
4891         if (tevent_req_nomem(subreq, req)) {
4892                 return tevent_req_post(req, ev);
4893         }
4894         tevent_req_set_callback(subreq, rpccli_winreg_OpenHKDD_done, req);
4895         return req;
4896 }
4897
4898 static void rpccli_winreg_OpenHKDD_done(struct tevent_req *subreq)
4899 {
4900         struct tevent_req *req = tevent_req_callback_data(
4901                 subreq, struct tevent_req);
4902         struct rpccli_winreg_OpenHKDD_state *state = tevent_req_data(
4903                 req, struct rpccli_winreg_OpenHKDD_state);
4904         NTSTATUS status;
4905         TALLOC_CTX *mem_ctx;
4906
4907         if (state->out_mem_ctx) {
4908                 mem_ctx = state->out_mem_ctx;
4909         } else {
4910                 mem_ctx = state;
4911         }
4912
4913         status = state->dispatch_recv(subreq, mem_ctx);
4914         TALLOC_FREE(subreq);
4915         if (!NT_STATUS_IS_OK(status)) {
4916                 tevent_req_nterror(req, status);
4917                 return;
4918         }
4919
4920         /* Copy out parameters */
4921         *state->orig.out.handle = *state->tmp.out.handle;
4922
4923         /* Copy result */
4924         state->orig.out.result = state->tmp.out.result;
4925
4926         /* Reset temporary structure */
4927         ZERO_STRUCT(state->tmp);
4928
4929         if (DEBUGLEVEL >= 10) {
4930                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKDD, &state->orig);
4931         }
4932
4933         tevent_req_done(req);
4934 }
4935
4936 NTSTATUS rpccli_winreg_OpenHKDD_recv(struct tevent_req *req,
4937                                      TALLOC_CTX *mem_ctx,
4938                                      WERROR *result)
4939 {
4940         struct rpccli_winreg_OpenHKDD_state *state = tevent_req_data(
4941                 req, struct rpccli_winreg_OpenHKDD_state);
4942         NTSTATUS status;
4943
4944         if (tevent_req_is_nterror(req, &status)) {
4945                 tevent_req_received(req);
4946                 return status;
4947         }
4948
4949         /* Steal possbile out parameters to the callers context */
4950         talloc_steal(mem_ctx, state->out_mem_ctx);
4951
4952         /* Return result */
4953         *result = state->orig.out.result;
4954
4955         tevent_req_received(req);
4956         return NT_STATUS_OK;
4957 }
4958
4959 NTSTATUS rpccli_winreg_OpenHKDD(struct rpc_pipe_client *cli,
4960                                 TALLOC_CTX *mem_ctx,
4961                                 uint16_t *system_name /* [in] [unique] */,
4962                                 uint32_t access_mask /* [in]  */,
4963                                 struct policy_handle *handle /* [out] [ref] */,
4964                                 WERROR *werror)
4965 {
4966         struct winreg_OpenHKDD r;
4967         NTSTATUS status;
4968
4969         /* In parameters */
4970         r.in.system_name = system_name;
4971         r.in.access_mask = access_mask;
4972
4973         if (DEBUGLEVEL >= 10) {
4974                 NDR_PRINT_IN_DEBUG(winreg_OpenHKDD, &r);
4975         }
4976
4977         status = cli->dispatch(cli,
4978                                 mem_ctx,
4979                                 &ndr_table_winreg,
4980                                 NDR_WINREG_OPENHKDD,
4981                                 &r);
4982
4983         if (!NT_STATUS_IS_OK(status)) {
4984                 return status;
4985         }
4986
4987         if (DEBUGLEVEL >= 10) {
4988                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKDD, &r);
4989         }
4990
4991         if (NT_STATUS_IS_ERR(status)) {
4992                 return status;
4993         }
4994
4995         /* Return variables */
4996         *handle = *r.out.handle;
4997
4998         /* Return result */
4999         if (werror) {
5000                 *werror = r.out.result;
5001         }
5002
5003         return werror_to_ntstatus(r.out.result);
5004 }
5005
5006 struct rpccli_winreg_QueryMultipleValues_state {
5007         struct winreg_QueryMultipleValues orig;
5008         struct winreg_QueryMultipleValues tmp;
5009         TALLOC_CTX *out_mem_ctx;
5010         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5011 };
5012
5013 static void rpccli_winreg_QueryMultipleValues_done(struct tevent_req *subreq);
5014
5015 struct tevent_req *rpccli_winreg_QueryMultipleValues_send(TALLOC_CTX *mem_ctx,
5016                                                           struct tevent_context *ev,
5017                                                           struct rpc_pipe_client *cli,
5018                                                           struct policy_handle *_key_handle /* [in] [ref] */,
5019                                                           struct QueryMultipleValue *_values /* [in,out] [ref,length_is(num_values),size_is(num_values)] */,
5020                                                           uint32_t _num_values /* [in]  */,
5021                                                           uint8_t *_buffer /* [in,out] [unique,length_is(*buffer_size),size_is(*buffer_size)] */,
5022                                                           uint32_t *_buffer_size /* [in,out] [ref] */)
5023 {
5024         struct tevent_req *req;
5025         struct rpccli_winreg_QueryMultipleValues_state *state;
5026         struct tevent_req *subreq;
5027
5028         req = tevent_req_create(mem_ctx, &state,
5029                                 struct rpccli_winreg_QueryMultipleValues_state);
5030         if (req == NULL) {
5031                 return NULL;
5032         }
5033         state->out_mem_ctx = NULL;
5034         state->dispatch_recv = cli->dispatch_recv;
5035
5036         /* In parameters */
5037         state->orig.in.key_handle = _key_handle;
5038         state->orig.in.values = _values;
5039         state->orig.in.num_values = _num_values;
5040         state->orig.in.buffer = _buffer;
5041         state->orig.in.buffer_size = _buffer_size;
5042
5043         /* Out parameters */
5044         state->orig.out.values = _values;
5045         state->orig.out.buffer = _buffer;
5046         state->orig.out.buffer_size = _buffer_size;
5047
5048         /* Result */
5049         ZERO_STRUCT(state->orig.out.result);
5050
5051         if (DEBUGLEVEL >= 10) {
5052                 NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues, &state->orig);
5053         }
5054
5055         state->out_mem_ctx = talloc_named_const(state, 0,
5056                              "rpccli_winreg_QueryMultipleValues_out_memory");
5057         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5058                 return tevent_req_post(req, ev);
5059         }
5060
5061         /* make a temporary copy, that we pass to the dispatch function */
5062         state->tmp = state->orig;
5063
5064         subreq = cli->dispatch_send(state, ev, cli,
5065                                     &ndr_table_winreg,
5066                                     NDR_WINREG_QUERYMULTIPLEVALUES,
5067                                     &state->tmp);
5068         if (tevent_req_nomem(subreq, req)) {
5069                 return tevent_req_post(req, ev);
5070         }
5071         tevent_req_set_callback(subreq, rpccli_winreg_QueryMultipleValues_done, req);
5072         return req;
5073 }
5074
5075 static void rpccli_winreg_QueryMultipleValues_done(struct tevent_req *subreq)
5076 {
5077         struct tevent_req *req = tevent_req_callback_data(
5078                 subreq, struct tevent_req);
5079         struct rpccli_winreg_QueryMultipleValues_state *state = tevent_req_data(
5080                 req, struct rpccli_winreg_QueryMultipleValues_state);
5081         NTSTATUS status;
5082         TALLOC_CTX *mem_ctx;
5083
5084         if (state->out_mem_ctx) {
5085                 mem_ctx = state->out_mem_ctx;
5086         } else {
5087                 mem_ctx = state;
5088         }
5089
5090         status = state->dispatch_recv(subreq, mem_ctx);
5091         TALLOC_FREE(subreq);
5092         if (!NT_STATUS_IS_OK(status)) {
5093                 tevent_req_nterror(req, status);
5094                 return;
5095         }
5096
5097         /* Copy out parameters */
5098         memcpy(state->orig.out.values, state->tmp.out.values, state->tmp.in.num_values * sizeof(*state->orig.out.values));
5099         if (state->orig.out.buffer && state->tmp.out.buffer) {
5100                 memcpy(state->orig.out.buffer, state->tmp.out.buffer, *state->tmp.in.buffer_size * sizeof(*state->orig.out.buffer));
5101         }
5102         *state->orig.out.buffer_size = *state->tmp.out.buffer_size;
5103
5104         /* Copy result */
5105         state->orig.out.result = state->tmp.out.result;
5106
5107         /* Reset temporary structure */
5108         ZERO_STRUCT(state->tmp);
5109
5110         if (DEBUGLEVEL >= 10) {
5111                 NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues, &state->orig);
5112         }
5113
5114         tevent_req_done(req);
5115 }
5116
5117 NTSTATUS rpccli_winreg_QueryMultipleValues_recv(struct tevent_req *req,
5118                                                 TALLOC_CTX *mem_ctx,
5119                                                 WERROR *result)
5120 {
5121         struct rpccli_winreg_QueryMultipleValues_state *state = tevent_req_data(
5122                 req, struct rpccli_winreg_QueryMultipleValues_state);
5123         NTSTATUS status;
5124
5125         if (tevent_req_is_nterror(req, &status)) {
5126                 tevent_req_received(req);
5127                 return status;
5128         }
5129
5130         /* Steal possbile out parameters to the callers context */
5131         talloc_steal(mem_ctx, state->out_mem_ctx);
5132
5133         /* Return result */
5134         *result = state->orig.out.result;
5135
5136         tevent_req_received(req);
5137         return NT_STATUS_OK;
5138 }
5139
5140 NTSTATUS rpccli_winreg_QueryMultipleValues(struct rpc_pipe_client *cli,
5141                                            TALLOC_CTX *mem_ctx,
5142                                            struct policy_handle *key_handle /* [in] [ref] */,
5143                                            struct QueryMultipleValue *values /* [in,out] [ref,length_is(num_values),size_is(num_values)] */,
5144                                            uint32_t num_values /* [in]  */,
5145                                            uint8_t *buffer /* [in,out] [unique,length_is(*buffer_size),size_is(*buffer_size)] */,
5146                                            uint32_t *buffer_size /* [in,out] [ref] */,
5147                                            WERROR *werror)
5148 {
5149         struct winreg_QueryMultipleValues r;
5150         NTSTATUS status;
5151
5152         /* In parameters */
5153         r.in.key_handle = key_handle;
5154         r.in.values = values;
5155         r.in.num_values = num_values;
5156         r.in.buffer = buffer;
5157         r.in.buffer_size = buffer_size;
5158
5159         if (DEBUGLEVEL >= 10) {
5160                 NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues, &r);
5161         }
5162
5163         status = cli->dispatch(cli,
5164                                 mem_ctx,
5165                                 &ndr_table_winreg,
5166                                 NDR_WINREG_QUERYMULTIPLEVALUES,
5167                                 &r);
5168
5169         if (!NT_STATUS_IS_OK(status)) {
5170                 return status;
5171         }
5172
5173         if (DEBUGLEVEL >= 10) {
5174                 NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues, &r);
5175         }
5176
5177         if (NT_STATUS_IS_ERR(status)) {
5178                 return status;
5179         }
5180
5181         /* Return variables */
5182         memcpy(values, r.out.values, r.in.num_values * sizeof(*values));
5183         if (buffer && r.out.buffer) {
5184                 memcpy(buffer, r.out.buffer, *r.in.buffer_size * sizeof(*buffer));
5185         }
5186         *buffer_size = *r.out.buffer_size;
5187
5188         /* Return result */
5189         if (werror) {
5190                 *werror = r.out.result;
5191         }
5192
5193         return werror_to_ntstatus(r.out.result);
5194 }
5195
5196 struct rpccli_winreg_InitiateSystemShutdownEx_state {
5197         struct winreg_InitiateSystemShutdownEx orig;
5198         struct winreg_InitiateSystemShutdownEx tmp;
5199         TALLOC_CTX *out_mem_ctx;
5200         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5201 };
5202
5203 static void rpccli_winreg_InitiateSystemShutdownEx_done(struct tevent_req *subreq);
5204
5205 struct tevent_req *rpccli_winreg_InitiateSystemShutdownEx_send(TALLOC_CTX *mem_ctx,
5206                                                                struct tevent_context *ev,
5207                                                                struct rpc_pipe_client *cli,
5208                                                                uint16_t *_hostname /* [in] [unique] */,
5209                                                                struct lsa_StringLarge *_message /* [in] [unique] */,
5210                                                                uint32_t _timeout /* [in]  */,
5211                                                                uint8_t _force_apps /* [in]  */,
5212                                                                uint8_t _do_reboot /* [in]  */,
5213                                                                uint32_t _reason /* [in]  */)
5214 {
5215         struct tevent_req *req;
5216         struct rpccli_winreg_InitiateSystemShutdownEx_state *state;
5217         struct tevent_req *subreq;
5218
5219         req = tevent_req_create(mem_ctx, &state,
5220                                 struct rpccli_winreg_InitiateSystemShutdownEx_state);
5221         if (req == NULL) {
5222                 return NULL;
5223         }
5224         state->out_mem_ctx = NULL;
5225         state->dispatch_recv = cli->dispatch_recv;
5226
5227         /* In parameters */
5228         state->orig.in.hostname = _hostname;
5229         state->orig.in.message = _message;
5230         state->orig.in.timeout = _timeout;
5231         state->orig.in.force_apps = _force_apps;
5232         state->orig.in.do_reboot = _do_reboot;
5233         state->orig.in.reason = _reason;
5234
5235         /* Out parameters */
5236
5237         /* Result */
5238         ZERO_STRUCT(state->orig.out.result);
5239
5240         if (DEBUGLEVEL >= 10) {
5241                 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdownEx, &state->orig);
5242         }
5243
5244         /* make a temporary copy, that we pass to the dispatch function */
5245         state->tmp = state->orig;
5246
5247         subreq = cli->dispatch_send(state, ev, cli,
5248                                     &ndr_table_winreg,
5249                                     NDR_WINREG_INITIATESYSTEMSHUTDOWNEX,
5250                                     &state->tmp);
5251         if (tevent_req_nomem(subreq, req)) {
5252                 return tevent_req_post(req, ev);
5253         }
5254         tevent_req_set_callback(subreq, rpccli_winreg_InitiateSystemShutdownEx_done, req);
5255         return req;
5256 }
5257
5258 static void rpccli_winreg_InitiateSystemShutdownEx_done(struct tevent_req *subreq)
5259 {
5260         struct tevent_req *req = tevent_req_callback_data(
5261                 subreq, struct tevent_req);
5262         struct rpccli_winreg_InitiateSystemShutdownEx_state *state = tevent_req_data(
5263                 req, struct rpccli_winreg_InitiateSystemShutdownEx_state);
5264         NTSTATUS status;
5265         TALLOC_CTX *mem_ctx;
5266
5267         if (state->out_mem_ctx) {
5268                 mem_ctx = state->out_mem_ctx;
5269         } else {
5270                 mem_ctx = state;
5271         }
5272
5273         status = state->dispatch_recv(subreq, mem_ctx);
5274         TALLOC_FREE(subreq);
5275         if (!NT_STATUS_IS_OK(status)) {
5276                 tevent_req_nterror(req, status);
5277                 return;
5278         }
5279
5280         /* Copy out parameters */
5281
5282         /* Copy result */
5283         state->orig.out.result = state->tmp.out.result;
5284
5285         /* Reset temporary structure */
5286         ZERO_STRUCT(state->tmp);
5287
5288         if (DEBUGLEVEL >= 10) {
5289                 NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdownEx, &state->orig);
5290         }
5291
5292         tevent_req_done(req);
5293 }
5294
5295 NTSTATUS rpccli_winreg_InitiateSystemShutdownEx_recv(struct tevent_req *req,
5296                                                      TALLOC_CTX *mem_ctx,
5297                                                      WERROR *result)
5298 {
5299         struct rpccli_winreg_InitiateSystemShutdownEx_state *state = tevent_req_data(
5300                 req, struct rpccli_winreg_InitiateSystemShutdownEx_state);
5301         NTSTATUS status;
5302
5303         if (tevent_req_is_nterror(req, &status)) {
5304                 tevent_req_received(req);
5305                 return status;
5306         }
5307
5308         /* Steal possbile out parameters to the callers context */
5309         talloc_steal(mem_ctx, state->out_mem_ctx);
5310
5311         /* Return result */
5312         *result = state->orig.out.result;
5313
5314         tevent_req_received(req);
5315         return NT_STATUS_OK;
5316 }
5317
5318 NTSTATUS rpccli_winreg_InitiateSystemShutdownEx(struct rpc_pipe_client *cli,
5319                                                 TALLOC_CTX *mem_ctx,
5320                                                 uint16_t *hostname /* [in] [unique] */,
5321                                                 struct lsa_StringLarge *message /* [in] [unique] */,
5322                                                 uint32_t timeout /* [in]  */,
5323                                                 uint8_t force_apps /* [in]  */,
5324                                                 uint8_t do_reboot /* [in]  */,
5325                                                 uint32_t reason /* [in]  */,
5326                                                 WERROR *werror)
5327 {
5328         struct winreg_InitiateSystemShutdownEx r;
5329         NTSTATUS status;
5330
5331         /* In parameters */
5332         r.in.hostname = hostname;
5333         r.in.message = message;
5334         r.in.timeout = timeout;
5335         r.in.force_apps = force_apps;
5336         r.in.do_reboot = do_reboot;
5337         r.in.reason = reason;
5338
5339         if (DEBUGLEVEL >= 10) {
5340                 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdownEx, &r);
5341         }
5342
5343         status = cli->dispatch(cli,
5344                                 mem_ctx,
5345                                 &ndr_table_winreg,
5346                                 NDR_WINREG_INITIATESYSTEMSHUTDOWNEX,
5347                                 &r);
5348
5349         if (!NT_STATUS_IS_OK(status)) {
5350                 return status;
5351         }
5352
5353         if (DEBUGLEVEL >= 10) {
5354                 NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdownEx, &r);
5355         }
5356
5357         if (NT_STATUS_IS_ERR(status)) {
5358                 return status;
5359         }
5360
5361         /* Return variables */
5362
5363         /* Return result */
5364         if (werror) {
5365                 *werror = r.out.result;
5366         }
5367
5368         return werror_to_ntstatus(r.out.result);
5369 }
5370
5371 struct rpccli_winreg_SaveKeyEx_state {
5372         struct winreg_SaveKeyEx orig;
5373         struct winreg_SaveKeyEx tmp;
5374         TALLOC_CTX *out_mem_ctx;
5375         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5376 };
5377
5378 static void rpccli_winreg_SaveKeyEx_done(struct tevent_req *subreq);
5379
5380 struct tevent_req *rpccli_winreg_SaveKeyEx_send(TALLOC_CTX *mem_ctx,
5381                                                 struct tevent_context *ev,
5382                                                 struct rpc_pipe_client *cli)
5383 {
5384         struct tevent_req *req;
5385         struct rpccli_winreg_SaveKeyEx_state *state;
5386         struct tevent_req *subreq;
5387
5388         req = tevent_req_create(mem_ctx, &state,
5389                                 struct rpccli_winreg_SaveKeyEx_state);
5390         if (req == NULL) {
5391                 return NULL;
5392         }
5393         state->out_mem_ctx = NULL;
5394         state->dispatch_recv = cli->dispatch_recv;
5395
5396         /* In parameters */
5397
5398         /* Out parameters */
5399
5400         /* Result */
5401         ZERO_STRUCT(state->orig.out.result);
5402
5403         if (DEBUGLEVEL >= 10) {
5404                 NDR_PRINT_IN_DEBUG(winreg_SaveKeyEx, &state->orig);
5405         }
5406
5407         /* make a temporary copy, that we pass to the dispatch function */
5408         state->tmp = state->orig;
5409
5410         subreq = cli->dispatch_send(state, ev, cli,
5411                                     &ndr_table_winreg,
5412                                     NDR_WINREG_SAVEKEYEX,
5413                                     &state->tmp);
5414         if (tevent_req_nomem(subreq, req)) {
5415                 return tevent_req_post(req, ev);
5416         }
5417         tevent_req_set_callback(subreq, rpccli_winreg_SaveKeyEx_done, req);
5418         return req;
5419 }
5420
5421 static void rpccli_winreg_SaveKeyEx_done(struct tevent_req *subreq)
5422 {
5423         struct tevent_req *req = tevent_req_callback_data(
5424                 subreq, struct tevent_req);
5425         struct rpccli_winreg_SaveKeyEx_state *state = tevent_req_data(
5426                 req, struct rpccli_winreg_SaveKeyEx_state);
5427         NTSTATUS status;
5428         TALLOC_CTX *mem_ctx;
5429
5430         if (state->out_mem_ctx) {
5431                 mem_ctx = state->out_mem_ctx;
5432         } else {
5433                 mem_ctx = state;
5434         }
5435
5436         status = state->dispatch_recv(subreq, mem_ctx);
5437         TALLOC_FREE(subreq);
5438         if (!NT_STATUS_IS_OK(status)) {
5439                 tevent_req_nterror(req, status);
5440                 return;
5441         }
5442
5443         /* Copy out parameters */
5444
5445         /* Copy result */
5446         state->orig.out.result = state->tmp.out.result;
5447
5448         /* Reset temporary structure */
5449         ZERO_STRUCT(state->tmp);
5450
5451         if (DEBUGLEVEL >= 10) {
5452                 NDR_PRINT_OUT_DEBUG(winreg_SaveKeyEx, &state->orig);
5453         }
5454
5455         tevent_req_done(req);
5456 }
5457
5458 NTSTATUS rpccli_winreg_SaveKeyEx_recv(struct tevent_req *req,
5459                                       TALLOC_CTX *mem_ctx,
5460                                       WERROR *result)
5461 {
5462         struct rpccli_winreg_SaveKeyEx_state *state = tevent_req_data(
5463                 req, struct rpccli_winreg_SaveKeyEx_state);
5464         NTSTATUS status;
5465
5466         if (tevent_req_is_nterror(req, &status)) {
5467                 tevent_req_received(req);
5468                 return status;
5469         }
5470
5471         /* Steal possbile out parameters to the callers context */
5472         talloc_steal(mem_ctx, state->out_mem_ctx);
5473
5474         /* Return result */
5475         *result = state->orig.out.result;
5476
5477         tevent_req_received(req);
5478         return NT_STATUS_OK;
5479 }
5480
5481 NTSTATUS rpccli_winreg_SaveKeyEx(struct rpc_pipe_client *cli,
5482                                  TALLOC_CTX *mem_ctx,
5483                                  WERROR *werror)
5484 {
5485         struct winreg_SaveKeyEx r;
5486         NTSTATUS status;
5487
5488         /* In parameters */
5489
5490         if (DEBUGLEVEL >= 10) {
5491                 NDR_PRINT_IN_DEBUG(winreg_SaveKeyEx, &r);
5492         }
5493
5494         status = cli->dispatch(cli,
5495                                 mem_ctx,
5496                                 &ndr_table_winreg,
5497                                 NDR_WINREG_SAVEKEYEX,
5498                                 &r);
5499
5500         if (!NT_STATUS_IS_OK(status)) {
5501                 return status;
5502         }
5503
5504         if (DEBUGLEVEL >= 10) {
5505                 NDR_PRINT_OUT_DEBUG(winreg_SaveKeyEx, &r);
5506         }
5507
5508         if (NT_STATUS_IS_ERR(status)) {
5509                 return status;
5510         }
5511
5512         /* Return variables */
5513
5514         /* Return result */
5515         if (werror) {
5516                 *werror = r.out.result;
5517         }
5518
5519         return werror_to_ntstatus(r.out.result);
5520 }
5521
5522 struct rpccli_winreg_OpenHKPT_state {
5523         struct winreg_OpenHKPT orig;
5524         struct winreg_OpenHKPT tmp;
5525         TALLOC_CTX *out_mem_ctx;
5526         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5527 };
5528
5529 static void rpccli_winreg_OpenHKPT_done(struct tevent_req *subreq);
5530
5531 struct tevent_req *rpccli_winreg_OpenHKPT_send(TALLOC_CTX *mem_ctx,
5532                                                struct tevent_context *ev,
5533                                                struct rpc_pipe_client *cli,
5534                                                uint16_t *_system_name /* [in] [unique] */,
5535                                                uint32_t _access_mask /* [in]  */,
5536                                                struct policy_handle *_handle /* [out] [ref] */)
5537 {
5538         struct tevent_req *req;
5539         struct rpccli_winreg_OpenHKPT_state *state;
5540         struct tevent_req *subreq;
5541
5542         req = tevent_req_create(mem_ctx, &state,
5543                                 struct rpccli_winreg_OpenHKPT_state);
5544         if (req == NULL) {
5545                 return NULL;
5546         }
5547         state->out_mem_ctx = NULL;
5548         state->dispatch_recv = cli->dispatch_recv;
5549
5550         /* In parameters */
5551         state->orig.in.system_name = _system_name;
5552         state->orig.in.access_mask = _access_mask;
5553
5554         /* Out parameters */
5555         state->orig.out.handle = _handle;
5556
5557         /* Result */
5558         ZERO_STRUCT(state->orig.out.result);
5559
5560         if (DEBUGLEVEL >= 10) {
5561                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPT, &state->orig);
5562         }
5563
5564         state->out_mem_ctx = talloc_named_const(state, 0,
5565                              "rpccli_winreg_OpenHKPT_out_memory");
5566         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5567                 return tevent_req_post(req, ev);
5568         }
5569
5570         /* make a temporary copy, that we pass to the dispatch function */
5571         state->tmp = state->orig;
5572
5573         subreq = cli->dispatch_send(state, ev, cli,
5574                                     &ndr_table_winreg,
5575                                     NDR_WINREG_OPENHKPT,
5576                                     &state->tmp);
5577         if (tevent_req_nomem(subreq, req)) {
5578                 return tevent_req_post(req, ev);
5579         }
5580         tevent_req_set_callback(subreq, rpccli_winreg_OpenHKPT_done, req);
5581         return req;
5582 }
5583
5584 static void rpccli_winreg_OpenHKPT_done(struct tevent_req *subreq)
5585 {
5586         struct tevent_req *req = tevent_req_callback_data(
5587                 subreq, struct tevent_req);
5588         struct rpccli_winreg_OpenHKPT_state *state = tevent_req_data(
5589                 req, struct rpccli_winreg_OpenHKPT_state);
5590         NTSTATUS status;
5591         TALLOC_CTX *mem_ctx;
5592
5593         if (state->out_mem_ctx) {
5594                 mem_ctx = state->out_mem_ctx;
5595         } else {
5596                 mem_ctx = state;
5597         }
5598
5599         status = state->dispatch_recv(subreq, mem_ctx);
5600         TALLOC_FREE(subreq);
5601         if (!NT_STATUS_IS_OK(status)) {
5602                 tevent_req_nterror(req, status);
5603                 return;
5604         }
5605
5606         /* Copy out parameters */
5607         *state->orig.out.handle = *state->tmp.out.handle;
5608
5609         /* Copy result */
5610         state->orig.out.result = state->tmp.out.result;
5611
5612         /* Reset temporary structure */
5613         ZERO_STRUCT(state->tmp);
5614
5615         if (DEBUGLEVEL >= 10) {
5616                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPT, &state->orig);
5617         }
5618
5619         tevent_req_done(req);
5620 }
5621
5622 NTSTATUS rpccli_winreg_OpenHKPT_recv(struct tevent_req *req,
5623                                      TALLOC_CTX *mem_ctx,
5624                                      WERROR *result)
5625 {
5626         struct rpccli_winreg_OpenHKPT_state *state = tevent_req_data(
5627                 req, struct rpccli_winreg_OpenHKPT_state);
5628         NTSTATUS status;
5629
5630         if (tevent_req_is_nterror(req, &status)) {
5631                 tevent_req_received(req);
5632                 return status;
5633         }
5634
5635         /* Steal possbile out parameters to the callers context */
5636         talloc_steal(mem_ctx, state->out_mem_ctx);
5637
5638         /* Return result */
5639         *result = state->orig.out.result;
5640
5641         tevent_req_received(req);
5642         return NT_STATUS_OK;
5643 }
5644
5645 NTSTATUS rpccli_winreg_OpenHKPT(struct rpc_pipe_client *cli,
5646                                 TALLOC_CTX *mem_ctx,
5647                                 uint16_t *system_name /* [in] [unique] */,
5648                                 uint32_t access_mask /* [in]  */,
5649                                 struct policy_handle *handle /* [out] [ref] */,
5650                                 WERROR *werror)
5651 {
5652         struct winreg_OpenHKPT r;
5653         NTSTATUS status;
5654
5655         /* In parameters */
5656         r.in.system_name = system_name;
5657         r.in.access_mask = access_mask;
5658
5659         if (DEBUGLEVEL >= 10) {
5660                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPT, &r);
5661         }
5662
5663         status = cli->dispatch(cli,
5664                                 mem_ctx,
5665                                 &ndr_table_winreg,
5666                                 NDR_WINREG_OPENHKPT,
5667                                 &r);
5668
5669         if (!NT_STATUS_IS_OK(status)) {
5670                 return status;
5671         }
5672
5673         if (DEBUGLEVEL >= 10) {
5674                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPT, &r);
5675         }
5676
5677         if (NT_STATUS_IS_ERR(status)) {
5678                 return status;
5679         }
5680
5681         /* Return variables */
5682         *handle = *r.out.handle;
5683
5684         /* Return result */
5685         if (werror) {
5686                 *werror = r.out.result;
5687         }
5688
5689         return werror_to_ntstatus(r.out.result);
5690 }
5691
5692 struct rpccli_winreg_OpenHKPN_state {
5693         struct winreg_OpenHKPN orig;
5694         struct winreg_OpenHKPN tmp;
5695         TALLOC_CTX *out_mem_ctx;
5696         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5697 };
5698
5699 static void rpccli_winreg_OpenHKPN_done(struct tevent_req *subreq);
5700
5701 struct tevent_req *rpccli_winreg_OpenHKPN_send(TALLOC_CTX *mem_ctx,
5702                                                struct tevent_context *ev,
5703                                                struct rpc_pipe_client *cli,
5704                                                uint16_t *_system_name /* [in] [unique] */,
5705                                                uint32_t _access_mask /* [in]  */,
5706                                                struct policy_handle *_handle /* [out] [ref] */)
5707 {
5708         struct tevent_req *req;
5709         struct rpccli_winreg_OpenHKPN_state *state;
5710         struct tevent_req *subreq;
5711
5712         req = tevent_req_create(mem_ctx, &state,
5713                                 struct rpccli_winreg_OpenHKPN_state);
5714         if (req == NULL) {
5715                 return NULL;
5716         }
5717         state->out_mem_ctx = NULL;
5718         state->dispatch_recv = cli->dispatch_recv;
5719
5720         /* In parameters */
5721         state->orig.in.system_name = _system_name;
5722         state->orig.in.access_mask = _access_mask;
5723
5724         /* Out parameters */
5725         state->orig.out.handle = _handle;
5726
5727         /* Result */
5728         ZERO_STRUCT(state->orig.out.result);
5729
5730         if (DEBUGLEVEL >= 10) {
5731                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPN, &state->orig);
5732         }
5733
5734         state->out_mem_ctx = talloc_named_const(state, 0,
5735                              "rpccli_winreg_OpenHKPN_out_memory");
5736         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5737                 return tevent_req_post(req, ev);
5738         }
5739
5740         /* make a temporary copy, that we pass to the dispatch function */
5741         state->tmp = state->orig;
5742
5743         subreq = cli->dispatch_send(state, ev, cli,
5744                                     &ndr_table_winreg,
5745                                     NDR_WINREG_OPENHKPN,
5746                                     &state->tmp);
5747         if (tevent_req_nomem(subreq, req)) {
5748                 return tevent_req_post(req, ev);
5749         }
5750         tevent_req_set_callback(subreq, rpccli_winreg_OpenHKPN_done, req);
5751         return req;
5752 }
5753
5754 static void rpccli_winreg_OpenHKPN_done(struct tevent_req *subreq)
5755 {
5756         struct tevent_req *req = tevent_req_callback_data(
5757                 subreq, struct tevent_req);
5758         struct rpccli_winreg_OpenHKPN_state *state = tevent_req_data(
5759                 req, struct rpccli_winreg_OpenHKPN_state);
5760         NTSTATUS status;
5761         TALLOC_CTX *mem_ctx;
5762
5763         if (state->out_mem_ctx) {
5764                 mem_ctx = state->out_mem_ctx;
5765         } else {
5766                 mem_ctx = state;
5767         }
5768
5769         status = state->dispatch_recv(subreq, mem_ctx);
5770         TALLOC_FREE(subreq);
5771         if (!NT_STATUS_IS_OK(status)) {
5772                 tevent_req_nterror(req, status);
5773                 return;
5774         }
5775
5776         /* Copy out parameters */
5777         *state->orig.out.handle = *state->tmp.out.handle;
5778
5779         /* Copy result */
5780         state->orig.out.result = state->tmp.out.result;
5781
5782         /* Reset temporary structure */
5783         ZERO_STRUCT(state->tmp);
5784
5785         if (DEBUGLEVEL >= 10) {
5786                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPN, &state->orig);
5787         }
5788
5789         tevent_req_done(req);
5790 }
5791
5792 NTSTATUS rpccli_winreg_OpenHKPN_recv(struct tevent_req *req,
5793                                      TALLOC_CTX *mem_ctx,
5794                                      WERROR *result)
5795 {
5796         struct rpccli_winreg_OpenHKPN_state *state = tevent_req_data(
5797                 req, struct rpccli_winreg_OpenHKPN_state);
5798         NTSTATUS status;
5799
5800         if (tevent_req_is_nterror(req, &status)) {
5801                 tevent_req_received(req);
5802                 return status;
5803         }
5804
5805         /* Steal possbile out parameters to the callers context */
5806         talloc_steal(mem_ctx, state->out_mem_ctx);
5807
5808         /* Return result */
5809         *result = state->orig.out.result;
5810
5811         tevent_req_received(req);
5812         return NT_STATUS_OK;
5813 }
5814
5815 NTSTATUS rpccli_winreg_OpenHKPN(struct rpc_pipe_client *cli,
5816                                 TALLOC_CTX *mem_ctx,
5817                                 uint16_t *system_name /* [in] [unique] */,
5818                                 uint32_t access_mask /* [in]  */,
5819                                 struct policy_handle *handle /* [out] [ref] */,
5820                                 WERROR *werror)
5821 {
5822         struct winreg_OpenHKPN r;
5823         NTSTATUS status;
5824
5825         /* In parameters */
5826         r.in.system_name = system_name;
5827         r.in.access_mask = access_mask;
5828
5829         if (DEBUGLEVEL >= 10) {
5830                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPN, &r);
5831         }
5832
5833         status = cli->dispatch(cli,
5834                                 mem_ctx,
5835                                 &ndr_table_winreg,
5836                                 NDR_WINREG_OPENHKPN,
5837                                 &r);
5838
5839         if (!NT_STATUS_IS_OK(status)) {
5840                 return status;
5841         }
5842
5843         if (DEBUGLEVEL >= 10) {
5844                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPN, &r);
5845         }
5846
5847         if (NT_STATUS_IS_ERR(status)) {
5848                 return status;
5849         }
5850
5851         /* Return variables */
5852         *handle = *r.out.handle;
5853
5854         /* Return result */
5855         if (werror) {
5856                 *werror = r.out.result;
5857         }
5858
5859         return werror_to_ntstatus(r.out.result);
5860 }
5861
5862 struct rpccli_winreg_QueryMultipleValues2_state {
5863         struct winreg_QueryMultipleValues2 orig;
5864         struct winreg_QueryMultipleValues2 tmp;
5865         TALLOC_CTX *out_mem_ctx;
5866         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5867 };
5868
5869 static void rpccli_winreg_QueryMultipleValues2_done(struct tevent_req *subreq);
5870
5871 struct tevent_req *rpccli_winreg_QueryMultipleValues2_send(TALLOC_CTX *mem_ctx,
5872                                                            struct tevent_context *ev,
5873                                                            struct rpc_pipe_client *cli)
5874 {
5875         struct tevent_req *req;
5876         struct rpccli_winreg_QueryMultipleValues2_state *state;
5877         struct tevent_req *subreq;
5878
5879         req = tevent_req_create(mem_ctx, &state,
5880                                 struct rpccli_winreg_QueryMultipleValues2_state);
5881         if (req == NULL) {
5882                 return NULL;
5883         }
5884         state->out_mem_ctx = NULL;
5885         state->dispatch_recv = cli->dispatch_recv;
5886
5887         /* In parameters */
5888
5889         /* Out parameters */
5890
5891         /* Result */
5892         ZERO_STRUCT(state->orig.out.result);
5893
5894         if (DEBUGLEVEL >= 10) {
5895                 NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues2, &state->orig);
5896         }
5897
5898         /* make a temporary copy, that we pass to the dispatch function */
5899         state->tmp = state->orig;
5900
5901         subreq = cli->dispatch_send(state, ev, cli,
5902                                     &ndr_table_winreg,
5903                                     NDR_WINREG_QUERYMULTIPLEVALUES2,
5904                                     &state->tmp);
5905         if (tevent_req_nomem(subreq, req)) {
5906                 return tevent_req_post(req, ev);
5907         }
5908         tevent_req_set_callback(subreq, rpccli_winreg_QueryMultipleValues2_done, req);
5909         return req;
5910 }
5911
5912 static void rpccli_winreg_QueryMultipleValues2_done(struct tevent_req *subreq)
5913 {
5914         struct tevent_req *req = tevent_req_callback_data(
5915                 subreq, struct tevent_req);
5916         struct rpccli_winreg_QueryMultipleValues2_state *state = tevent_req_data(
5917                 req, struct rpccli_winreg_QueryMultipleValues2_state);
5918         NTSTATUS status;
5919         TALLOC_CTX *mem_ctx;
5920
5921         if (state->out_mem_ctx) {
5922                 mem_ctx = state->out_mem_ctx;
5923         } else {
5924                 mem_ctx = state;
5925         }
5926
5927         status = state->dispatch_recv(subreq, mem_ctx);
5928         TALLOC_FREE(subreq);
5929         if (!NT_STATUS_IS_OK(status)) {
5930                 tevent_req_nterror(req, status);
5931                 return;
5932         }
5933
5934         /* Copy out parameters */
5935
5936         /* Copy result */
5937         state->orig.out.result = state->tmp.out.result;
5938
5939         /* Reset temporary structure */
5940         ZERO_STRUCT(state->tmp);
5941
5942         if (DEBUGLEVEL >= 10) {
5943                 NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues2, &state->orig);
5944         }
5945
5946         tevent_req_done(req);
5947 }
5948
5949 NTSTATUS rpccli_winreg_QueryMultipleValues2_recv(struct tevent_req *req,
5950                                                  TALLOC_CTX *mem_ctx,
5951                                                  WERROR *result)
5952 {
5953         struct rpccli_winreg_QueryMultipleValues2_state *state = tevent_req_data(
5954                 req, struct rpccli_winreg_QueryMultipleValues2_state);
5955         NTSTATUS status;
5956
5957         if (tevent_req_is_nterror(req, &status)) {
5958                 tevent_req_received(req);
5959                 return status;
5960         }
5961
5962         /* Steal possbile out parameters to the callers context */
5963         talloc_steal(mem_ctx, state->out_mem_ctx);
5964
5965         /* Return result */
5966         *result = state->orig.out.result;
5967
5968         tevent_req_received(req);
5969         return NT_STATUS_OK;
5970 }
5971
5972 NTSTATUS rpccli_winreg_QueryMultipleValues2(struct rpc_pipe_client *cli,
5973                                             TALLOC_CTX *mem_ctx,
5974                                             WERROR *werror)
5975 {
5976         struct winreg_QueryMultipleValues2 r;
5977         NTSTATUS status;
5978
5979         /* In parameters */
5980
5981         if (DEBUGLEVEL >= 10) {
5982                 NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues2, &r);
5983         }
5984
5985         status = cli->dispatch(cli,
5986                                 mem_ctx,
5987                                 &ndr_table_winreg,
5988                                 NDR_WINREG_QUERYMULTIPLEVALUES2,
5989                                 &r);
5990
5991         if (!NT_STATUS_IS_OK(status)) {
5992                 return status;
5993         }
5994
5995         if (DEBUGLEVEL >= 10) {
5996                 NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues2, &r);
5997         }
5998
5999         if (NT_STATUS_IS_ERR(status)) {
6000                 return status;
6001         }
6002
6003         /* Return variables */
6004
6005         /* Return result */
6006         if (werror) {
6007                 *werror = r.out.result;
6008         }
6009
6010         return werror_to_ntstatus(r.out.result);
6011 }
6012