source3/librpc/gen_ndr/srv_winreg.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * server auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "librpc/gen_ndr/srv_winreg.h"
   8
   9 static bool api_winreg_OpenHKCR(pipes_struct *p)
  10 {
  11         const struct ndr_interface_call *call;
  12         struct ndr_pull *pull;
  13         struct ndr_push *push;
  14         enum ndr_err_code ndr_err;
  15         DATA_BLOB blob;
  16         struct winreg_OpenHKCR *r;
  17
  18         call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKCR];
  19
  20         r = talloc(talloc_tos(), struct winreg_OpenHKCR);
  21         if (r == NULL) {
  22                 return false;
  23         }
  24
  25         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
  26                 talloc_free(r);
  27                 return false;
  28         }
  29
  30         pull = ndr_pull_init_blob(&blob, r, NULL);
  31         if (pull == NULL) {
  32                 talloc_free(r);
  33                 return false;
  34         }
  35
  36         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
  37         ndr_err = call->ndr_pull(pull, NDR_IN, r);
  38         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  39                 talloc_free(r);
  40                 return false;
  41         }
  42
  43         if (DEBUGLEVEL >= 10) {
  44                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCR, r);
  45         }
  46
  47         ZERO_STRUCT(r->out);
  48         r->out.handle = talloc_zero(r, struct policy_handle);
  49         if (r->out.handle == NULL) {
  50                 talloc_free(r);
  51                 return false;
  52         }
  53
  54         r->out.result = _winreg_OpenHKCR(p, r);
  55
  56         if (p->rng_fault_state) {
  57                 talloc_free(r);
  58                 /* Return true here, srv_pipe_hnd.c will take care */
  59                 return true;
  60         }
  61
  62         if (DEBUGLEVEL >= 10) {
  63                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCR, r);
  64         }
  65
  66         push = ndr_push_init_ctx(r, NULL);
  67         if (push == NULL) {
  68                 talloc_free(r);
  69                 return false;
  70         }
  71
  72         ndr_err = call->ndr_push(push, NDR_OUT, r);
  73         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  74                 talloc_free(r);
  75                 return false;
  76         }
  77
  78         blob = ndr_push_blob(push);
  79         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
  80                 talloc_free(r);
  81                 return false;
  82         }
  83
  84         talloc_free(r);
  85
  86         return true;
  87 }
  88
  89 static bool api_winreg_OpenHKCU(pipes_struct *p)
  90 {
  91         const struct ndr_interface_call *call;
  92         struct ndr_pull *pull;
  93         struct ndr_push *push;
  94         enum ndr_err_code ndr_err;
  95         DATA_BLOB blob;
  96         struct winreg_OpenHKCU *r;
  97
  98         call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKCU];
  99
 100         r = talloc(talloc_tos(), struct winreg_OpenHKCU);
 101         if (r == NULL) {
 102                 return false;
 103         }
 104
 105         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 106                 talloc_free(r);
 107                 return false;
 108         }
 109
 110         pull = ndr_pull_init_blob(&blob, r, NULL);
 111         if (pull == NULL) {
 112                 talloc_free(r);
 113                 return false;
 114         }
 115
 116         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 117         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 118         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 119                 talloc_free(r);
 120                 return false;
 121         }
 122
 123         if (DEBUGLEVEL >= 10) {
 124                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCU, r);
 125         }
 126
 127         ZERO_STRUCT(r->out);
 128         r->out.handle = talloc_zero(r, struct policy_handle);
 129         if (r->out.handle == NULL) {
 130                 talloc_free(r);
 131                 return false;
 132         }
 133
 134         r->out.result = _winreg_OpenHKCU(p, r);
 135
 136         if (p->rng_fault_state) {
 137                 talloc_free(r);
 138                 /* Return true here, srv_pipe_hnd.c will take care */
 139                 return true;
 140         }
 141
 142         if (DEBUGLEVEL >= 10) {
 143                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCU, r);
 144         }
 145
 146         push = ndr_push_init_ctx(r, NULL);
 147         if (push == NULL) {
 148                 talloc_free(r);
 149                 return false;
 150         }
 151
 152         ndr_err = call->ndr_push(push, NDR_OUT, r);
 153         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 154                 talloc_free(r);
 155                 return false;
 156         }
 157
 158         blob = ndr_push_blob(push);
 159         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 160                 talloc_free(r);
 161                 return false;
 162         }
 163
 164         talloc_free(r);
 165
 166         return true;
 167 }
 168
 169 static bool api_winreg_OpenHKLM(pipes_struct *p)
 170 {
 171         const struct ndr_interface_call *call;
 172         struct ndr_pull *pull;
 173         struct ndr_push *push;
 174         enum ndr_err_code ndr_err;
 175         DATA_BLOB blob;
 176         struct winreg_OpenHKLM *r;
 177
 178         call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKLM];
 179
 180         r = talloc(talloc_tos(), struct winreg_OpenHKLM);
 181         if (r == NULL) {
 182                 return false;
 183         }
 184
 185         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 186                 talloc_free(r);
 187                 return false;
 188         }
 189
 190         pull = ndr_pull_init_blob(&blob, r, NULL);
 191         if (pull == NULL) {
 192                 talloc_free(r);
 193                 return false;
 194         }
 195
 196         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 197         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 198         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 199                 talloc_free(r);
 200                 return false;
 201         }
 202
 203         if (DEBUGLEVEL >= 10) {
 204                 NDR_PRINT_IN_DEBUG(winreg_OpenHKLM, r);
 205         }
 206
 207         ZERO_STRUCT(r->out);
 208         r->out.handle = talloc_zero(r, struct policy_handle);
 209         if (r->out.handle == NULL) {
 210                 talloc_free(r);
 211                 return false;
 212         }
 213
 214         r->out.result = _winreg_OpenHKLM(p, r);
 215
 216         if (p->rng_fault_state) {
 217                 talloc_free(r);
 218                 /* Return true here, srv_pipe_hnd.c will take care */
 219                 return true;
 220         }
 221
 222         if (DEBUGLEVEL >= 10) {
 223                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKLM, r);
 224         }
 225
 226         push = ndr_push_init_ctx(r, NULL);
 227         if (push == NULL) {
 228                 talloc_free(r);
 229                 return false;
 230         }
 231
 232         ndr_err = call->ndr_push(push, NDR_OUT, r);
 233         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 234                 talloc_free(r);
 235                 return false;
 236         }
 237
 238         blob = ndr_push_blob(push);
 239         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 240                 talloc_free(r);
 241                 return false;
 242         }
 243
 244         talloc_free(r);
 245
 246         return true;
 247 }
 248
 249 static bool api_winreg_OpenHKPD(pipes_struct *p)
 250 {
 251         const struct ndr_interface_call *call;
 252         struct ndr_pull *pull;
 253         struct ndr_push *push;
 254         enum ndr_err_code ndr_err;
 255         DATA_BLOB blob;
 256         struct winreg_OpenHKPD *r;
 257
 258         call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKPD];
 259
 260         r = talloc(talloc_tos(), struct winreg_OpenHKPD);
 261         if (r == NULL) {
 262                 return false;
 263         }
 264
 265         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 266                 talloc_free(r);
 267                 return false;
 268         }
 269
 270         pull = ndr_pull_init_blob(&blob, r, NULL);
 271         if (pull == NULL) {
 272                 talloc_free(r);
 273                 return false;
 274         }
 275
 276         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 277         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 278         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 279                 talloc_free(r);
 280                 return false;
 281         }
 282
 283         if (DEBUGLEVEL >= 10) {
 284                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPD, r);
 285         }
 286
 287         ZERO_STRUCT(r->out);
 288         r->out.handle = talloc_zero(r, struct policy_handle);
 289         if (r->out.handle == NULL) {
 290                 talloc_free(r);
 291                 return false;
 292         }
 293
 294         r->out.result = _winreg_OpenHKPD(p, r);
 295
 296         if (p->rng_fault_state) {
 297                 talloc_free(r);
 298                 /* Return true here, srv_pipe_hnd.c will take care */
 299                 return true;
 300         }
 301
 302         if (DEBUGLEVEL >= 10) {
 303                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPD, r);
 304         }
 305
 306         push = ndr_push_init_ctx(r, NULL);
 307         if (push == NULL) {
 308                 talloc_free(r);
 309                 return false;
 310         }
 311
 312         ndr_err = call->ndr_push(push, NDR_OUT, r);
 313         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 314                 talloc_free(r);
 315                 return false;
 316         }
 317
 318         blob = ndr_push_blob(push);
 319         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 320                 talloc_free(r);
 321                 return false;
 322         }
 323
 324         talloc_free(r);
 325
 326         return true;
 327 }
 328
 329 static bool api_winreg_OpenHKU(pipes_struct *p)
 330 {
 331         const struct ndr_interface_call *call;
 332         struct ndr_pull *pull;
 333         struct ndr_push *push;
 334         enum ndr_err_code ndr_err;
 335         DATA_BLOB blob;
 336         struct winreg_OpenHKU *r;
 337
 338         call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKU];
 339
 340         r = talloc(talloc_tos(), struct winreg_OpenHKU);
 341         if (r == NULL) {
 342                 return false;
 343         }
 344
 345         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 346                 talloc_free(r);
 347                 return false;
 348         }
 349
 350         pull = ndr_pull_init_blob(&blob, r, NULL);
 351         if (pull == NULL) {
 352                 talloc_free(r);
 353                 return false;
 354         }
 355
 356         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 357         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 358         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 359                 talloc_free(r);
 360                 return false;
 361         }
 362
 363         if (DEBUGLEVEL >= 10) {
 364                 NDR_PRINT_IN_DEBUG(winreg_OpenHKU, r);
 365         }
 366
 367         ZERO_STRUCT(r->out);
 368         r->out.handle = talloc_zero(r, struct policy_handle);
 369         if (r->out.handle == NULL) {
 370                 talloc_free(r);
 371                 return false;
 372         }
 373
 374         r->out.result = _winreg_OpenHKU(p, r);
 375
 376         if (p->rng_fault_state) {
 377                 talloc_free(r);
 378                 /* Return true here, srv_pipe_hnd.c will take care */
 379                 return true;
 380         }
 381
 382         if (DEBUGLEVEL >= 10) {
 383                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKU, r);
 384         }
 385
 386         push = ndr_push_init_ctx(r, NULL);
 387         if (push == NULL) {
 388                 talloc_free(r);
 389                 return false;
 390         }
 391
 392         ndr_err = call->ndr_push(push, NDR_OUT, r);
 393         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 394                 talloc_free(r);
 395                 return false;
 396         }
 397
 398         blob = ndr_push_blob(push);
 399         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 400                 talloc_free(r);
 401                 return false;
 402         }
 403
 404         talloc_free(r);
 405
 406         return true;
 407 }
 408
 409 static bool api_winreg_CloseKey(pipes_struct *p)
 410 {
 411         const struct ndr_interface_call *call;
 412         struct ndr_pull *pull;
 413         struct ndr_push *push;
 414         enum ndr_err_code ndr_err;
 415         DATA_BLOB blob;
 416         struct winreg_CloseKey *r;
 417
 418         call = &ndr_table_winreg.calls[NDR_WINREG_CLOSEKEY];
 419
 420         r = talloc(talloc_tos(), struct winreg_CloseKey);
 421         if (r == NULL) {
 422                 return false;
 423         }
 424
 425         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 426                 talloc_free(r);
 427                 return false;
 428         }
 429
 430         pull = ndr_pull_init_blob(&blob, r, NULL);
 431         if (pull == NULL) {
 432                 talloc_free(r);
 433                 return false;
 434         }
 435
 436         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 437         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 438         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 439                 talloc_free(r);
 440                 return false;
 441         }
 442
 443         if (DEBUGLEVEL >= 10) {
 444                 NDR_PRINT_IN_DEBUG(winreg_CloseKey, r);
 445         }
 446
 447         ZERO_STRUCT(r->out);
 448         r->out.handle = r->in.handle;
 449         r->out.result = _winreg_CloseKey(p, r);
 450
 451         if (p->rng_fault_state) {
 452                 talloc_free(r);
 453                 /* Return true here, srv_pipe_hnd.c will take care */
 454                 return true;
 455         }
 456
 457         if (DEBUGLEVEL >= 10) {
 458                 NDR_PRINT_OUT_DEBUG(winreg_CloseKey, r);
 459         }
 460
 461         push = ndr_push_init_ctx(r, NULL);
 462         if (push == NULL) {
 463                 talloc_free(r);
 464                 return false;
 465         }
 466
 467         ndr_err = call->ndr_push(push, NDR_OUT, r);
 468         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 469                 talloc_free(r);
 470                 return false;
 471         }
 472
 473         blob = ndr_push_blob(push);
 474         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 475                 talloc_free(r);
 476                 return false;
 477         }
 478
 479         talloc_free(r);
 480
 481         return true;
 482 }
 483
 484 static bool api_winreg_CreateKey(pipes_struct *p)
 485 {
 486         const struct ndr_interface_call *call;
 487         struct ndr_pull *pull;
 488         struct ndr_push *push;
 489         enum ndr_err_code ndr_err;
 490         DATA_BLOB blob;
 491         struct winreg_CreateKey *r;
 492
 493         call = &ndr_table_winreg.calls[NDR_WINREG_CREATEKEY];
 494
 495         r = talloc(talloc_tos(), struct winreg_CreateKey);
 496         if (r == NULL) {
 497                 return false;
 498         }
 499
 500         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 501                 talloc_free(r);
 502                 return false;
 503         }
 504
 505         pull = ndr_pull_init_blob(&blob, r, NULL);
 506         if (pull == NULL) {
 507                 talloc_free(r);
 508                 return false;
 509         }
 510
 511         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 512         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 513         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 514                 talloc_free(r);
 515                 return false;
 516         }
 517
 518         if (DEBUGLEVEL >= 10) {
 519                 NDR_PRINT_IN_DEBUG(winreg_CreateKey, r);
 520         }
 521
 522         ZERO_STRUCT(r->out);
 523         r->out.action_taken = r->in.action_taken;
 524         r->out.new_handle = talloc_zero(r, struct policy_handle);
 525         if (r->out.new_handle == NULL) {
 526                 talloc_free(r);
 527                 return false;
 528         }
 529
 530         r->out.result = _winreg_CreateKey(p, r);
 531
 532         if (p->rng_fault_state) {
 533                 talloc_free(r);
 534                 /* Return true here, srv_pipe_hnd.c will take care */
 535                 return true;
 536         }
 537
 538         if (DEBUGLEVEL >= 10) {
 539                 NDR_PRINT_OUT_DEBUG(winreg_CreateKey, r);
 540         }
 541
 542         push = ndr_push_init_ctx(r, NULL);
 543         if (push == NULL) {
 544                 talloc_free(r);
 545                 return false;
 546         }
 547
 548         ndr_err = call->ndr_push(push, NDR_OUT, r);
 549         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 550                 talloc_free(r);
 551                 return false;
 552         }
 553
 554         blob = ndr_push_blob(push);
 555         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 556                 talloc_free(r);
 557                 return false;
 558         }
 559
 560         talloc_free(r);
 561
 562         return true;
 563 }
 564
 565 static bool api_winreg_DeleteKey(pipes_struct *p)
 566 {
 567         const struct ndr_interface_call *call;
 568         struct ndr_pull *pull;
 569         struct ndr_push *push;
 570         enum ndr_err_code ndr_err;
 571         DATA_BLOB blob;
 572         struct winreg_DeleteKey *r;
 573
 574         call = &ndr_table_winreg.calls[NDR_WINREG_DELETEKEY];
 575
 576         r = talloc(talloc_tos(), struct winreg_DeleteKey);
 577         if (r == NULL) {
 578                 return false;
 579         }
 580
 581         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 582                 talloc_free(r);
 583                 return false;
 584         }
 585
 586         pull = ndr_pull_init_blob(&blob, r, NULL);
 587         if (pull == NULL) {
 588                 talloc_free(r);
 589                 return false;
 590         }
 591
 592         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 593         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 594         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 595                 talloc_free(r);
 596                 return false;
 597         }
 598
 599         if (DEBUGLEVEL >= 10) {
 600                 NDR_PRINT_IN_DEBUG(winreg_DeleteKey, r);
 601         }
 602
 603         r->out.result = _winreg_DeleteKey(p, r);
 604
 605         if (p->rng_fault_state) {
 606                 talloc_free(r);
 607                 /* Return true here, srv_pipe_hnd.c will take care */
 608                 return true;
 609         }
 610
 611         if (DEBUGLEVEL >= 10) {
 612                 NDR_PRINT_OUT_DEBUG(winreg_DeleteKey, r);
 613         }
 614
 615         push = ndr_push_init_ctx(r, NULL);
 616         if (push == NULL) {
 617                 talloc_free(r);
 618                 return false;
 619         }
 620
 621         ndr_err = call->ndr_push(push, NDR_OUT, r);
 622         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 623                 talloc_free(r);
 624                 return false;
 625         }
 626
 627         blob = ndr_push_blob(push);
 628         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 629                 talloc_free(r);
 630                 return false;
 631         }
 632
 633         talloc_free(r);
 634
 635         return true;
 636 }
 637
 638 static bool api_winreg_DeleteValue(pipes_struct *p)
 639 {
 640         const struct ndr_interface_call *call;
 641         struct ndr_pull *pull;
 642         struct ndr_push *push;
 643         enum ndr_err_code ndr_err;
 644         DATA_BLOB blob;
 645         struct winreg_DeleteValue *r;
 646
 647         call = &ndr_table_winreg.calls[NDR_WINREG_DELETEVALUE];
 648
 649         r = talloc(talloc_tos(), struct winreg_DeleteValue);
 650         if (r == NULL) {
 651                 return false;
 652         }
 653
 654         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 655                 talloc_free(r);
 656                 return false;
 657         }
 658
 659         pull = ndr_pull_init_blob(&blob, r, NULL);
 660         if (pull == NULL) {
 661                 talloc_free(r);
 662                 return false;
 663         }
 664
 665         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 666         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 667         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 668                 talloc_free(r);
 669                 return false;
 670         }
 671
 672         if (DEBUGLEVEL >= 10) {
 673                 NDR_PRINT_IN_DEBUG(winreg_DeleteValue, r);
 674         }
 675
 676         r->out.result = _winreg_DeleteValue(p, r);
 677
 678         if (p->rng_fault_state) {
 679                 talloc_free(r);
 680                 /* Return true here, srv_pipe_hnd.c will take care */
 681                 return true;
 682         }
 683
 684         if (DEBUGLEVEL >= 10) {
 685                 NDR_PRINT_OUT_DEBUG(winreg_DeleteValue, r);
 686         }
 687
 688         push = ndr_push_init_ctx(r, NULL);
 689         if (push == NULL) {
 690                 talloc_free(r);
 691                 return false;
 692         }
 693
 694         ndr_err = call->ndr_push(push, NDR_OUT, r);
 695         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 696                 talloc_free(r);
 697                 return false;
 698         }
 699
 700         blob = ndr_push_blob(push);
 701         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 702                 talloc_free(r);
 703                 return false;
 704         }
 705
 706         talloc_free(r);
 707
 708         return true;
 709 }
 710
 711 static bool api_winreg_EnumKey(pipes_struct *p)
 712 {
 713         const struct ndr_interface_call *call;
 714         struct ndr_pull *pull;
 715         struct ndr_push *push;
 716         enum ndr_err_code ndr_err;
 717         DATA_BLOB blob;
 718         struct winreg_EnumKey *r;
 719
 720         call = &ndr_table_winreg.calls[NDR_WINREG_ENUMKEY];
 721
 722         r = talloc(talloc_tos(), struct winreg_EnumKey);
 723         if (r == NULL) {
 724                 return false;
 725         }
 726
 727         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 728                 talloc_free(r);
 729                 return false;
 730         }
 731
 732         pull = ndr_pull_init_blob(&blob, r, NULL);
 733         if (pull == NULL) {
 734                 talloc_free(r);
 735                 return false;
 736         }
 737
 738         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 739         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 740         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 741                 talloc_free(r);
 742                 return false;
 743         }
 744
 745         if (DEBUGLEVEL >= 10) {
 746                 NDR_PRINT_IN_DEBUG(winreg_EnumKey, r);
 747         }
 748
 749         ZERO_STRUCT(r->out);
 750         r->out.name = r->in.name;
 751         r->out.keyclass = r->in.keyclass;
 752         r->out.last_changed_time = r->in.last_changed_time;
 753         r->out.result = _winreg_EnumKey(p, r);
 754
 755         if (p->rng_fault_state) {
 756                 talloc_free(r);
 757                 /* Return true here, srv_pipe_hnd.c will take care */
 758                 return true;
 759         }
 760
 761         if (DEBUGLEVEL >= 10) {
 762                 NDR_PRINT_OUT_DEBUG(winreg_EnumKey, r);
 763         }
 764
 765         push = ndr_push_init_ctx(r, NULL);
 766         if (push == NULL) {
 767                 talloc_free(r);
 768                 return false;
 769         }
 770
 771         ndr_err = call->ndr_push(push, NDR_OUT, r);
 772         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 773                 talloc_free(r);
 774                 return false;
 775         }
 776
 777         blob = ndr_push_blob(push);
 778         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 779                 talloc_free(r);
 780                 return false;
 781         }
 782
 783         talloc_free(r);
 784
 785         return true;
 786 }
 787
 788 static bool api_winreg_EnumValue(pipes_struct *p)
 789 {
 790         const struct ndr_interface_call *call;
 791         struct ndr_pull *pull;
 792         struct ndr_push *push;
 793         enum ndr_err_code ndr_err;
 794         DATA_BLOB blob;
 795         struct winreg_EnumValue *r;
 796
 797         call = &ndr_table_winreg.calls[NDR_WINREG_ENUMVALUE];
 798
 799         r = talloc(talloc_tos(), struct winreg_EnumValue);
 800         if (r == NULL) {
 801                 return false;
 802         }
 803
 804         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 805                 talloc_free(r);
 806                 return false;
 807         }
 808
 809         pull = ndr_pull_init_blob(&blob, r, NULL);
 810         if (pull == NULL) {
 811                 talloc_free(r);
 812                 return false;
 813         }
 814
 815         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 816         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 817         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 818                 talloc_free(r);
 819                 return false;
 820         }
 821
 822         if (DEBUGLEVEL >= 10) {
 823                 NDR_PRINT_IN_DEBUG(winreg_EnumValue, r);
 824         }
 825
 826         ZERO_STRUCT(r->out);
 827         r->out.name = r->in.name;
 828         r->out.type = r->in.type;
 829         r->out.value = r->in.value;
 830         r->out.size = r->in.size;
 831         r->out.length = r->in.length;
 832         r->out.result = _winreg_EnumValue(p, r);
 833
 834         if (p->rng_fault_state) {
 835                 talloc_free(r);
 836                 /* Return true here, srv_pipe_hnd.c will take care */
 837                 return true;
 838         }
 839
 840         if (DEBUGLEVEL >= 10) {
 841                 NDR_PRINT_OUT_DEBUG(winreg_EnumValue, r);
 842         }
 843
 844         push = ndr_push_init_ctx(r, NULL);
 845         if (push == NULL) {
 846                 talloc_free(r);
 847                 return false;
 848         }
 849
 850         ndr_err = call->ndr_push(push, NDR_OUT, r);
 851         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 852                 talloc_free(r);
 853                 return false;
 854         }
 855
 856         blob = ndr_push_blob(push);
 857         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 858                 talloc_free(r);
 859                 return false;
 860         }
 861
 862         talloc_free(r);
 863
 864         return true;
 865 }
 866
 867 static bool api_winreg_FlushKey(pipes_struct *p)
 868 {
 869         const struct ndr_interface_call *call;
 870         struct ndr_pull *pull;
 871         struct ndr_push *push;
 872         enum ndr_err_code ndr_err;
 873         DATA_BLOB blob;
 874         struct winreg_FlushKey *r;
 875
 876         call = &ndr_table_winreg.calls[NDR_WINREG_FLUSHKEY];
 877
 878         r = talloc(talloc_tos(), struct winreg_FlushKey);
 879         if (r == NULL) {
 880                 return false;
 881         }
 882
 883         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 884                 talloc_free(r);
 885                 return false;
 886         }
 887
 888         pull = ndr_pull_init_blob(&blob, r, NULL);
 889         if (pull == NULL) {
 890                 talloc_free(r);
 891                 return false;
 892         }
 893
 894         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 895         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 896         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 897                 talloc_free(r);
 898                 return false;
 899         }
 900
 901         if (DEBUGLEVEL >= 10) {
 902                 NDR_PRINT_IN_DEBUG(winreg_FlushKey, r);
 903         }
 904
 905         r->out.result = _winreg_FlushKey(p, r);
 906
 907         if (p->rng_fault_state) {
 908                 talloc_free(r);
 909                 /* Return true here, srv_pipe_hnd.c will take care */
 910                 return true;
 911         }
 912
 913         if (DEBUGLEVEL >= 10) {
 914                 NDR_PRINT_OUT_DEBUG(winreg_FlushKey, r);
 915         }
 916
 917         push = ndr_push_init_ctx(r, NULL);
 918         if (push == NULL) {
 919                 talloc_free(r);
 920                 return false;
 921         }
 922
 923         ndr_err = call->ndr_push(push, NDR_OUT, r);
 924         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 925                 talloc_free(r);
 926                 return false;
 927         }
 928
 929         blob = ndr_push_blob(push);
 930         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 931                 talloc_free(r);
 932                 return false;
 933         }
 934
 935         talloc_free(r);
 936
 937         return true;
 938 }
 939
 940 static bool api_winreg_GetKeySecurity(pipes_struct *p)
 941 {
 942         const struct ndr_interface_call *call;
 943         struct ndr_pull *pull;
 944         struct ndr_push *push;
 945         enum ndr_err_code ndr_err;
 946         DATA_BLOB blob;
 947         struct winreg_GetKeySecurity *r;
 948
 949         call = &ndr_table_winreg.calls[NDR_WINREG_GETKEYSECURITY];
 950
 951         r = talloc(talloc_tos(), struct winreg_GetKeySecurity);
 952         if (r == NULL) {
 953                 return false;
 954         }
 955
 956         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 957                 talloc_free(r);
 958                 return false;
 959         }
 960
 961         pull = ndr_pull_init_blob(&blob, r, NULL);
 962         if (pull == NULL) {
 963                 talloc_free(r);
 964                 return false;
 965         }
 966
 967         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 968         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 969         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 970                 talloc_free(r);
 971                 return false;
 972         }
 973
 974         if (DEBUGLEVEL >= 10) {
 975                 NDR_PRINT_IN_DEBUG(winreg_GetKeySecurity, r);
 976         }
 977
 978         ZERO_STRUCT(r->out);
 979         r->out.sd = r->in.sd;
 980         r->out.result = _winreg_GetKeySecurity(p, r);
 981
 982         if (p->rng_fault_state) {
 983                 talloc_free(r);
 984                 /* Return true here, srv_pipe_hnd.c will take care */
 985                 return true;
 986         }
 987
 988         if (DEBUGLEVEL >= 10) {
 989                 NDR_PRINT_OUT_DEBUG(winreg_GetKeySecurity, r);
 990         }
 991
 992         push = ndr_push_init_ctx(r, NULL);
 993         if (push == NULL) {
 994                 talloc_free(r);
 995                 return false;
 996         }
 997
 998         ndr_err = call->ndr_push(push, NDR_OUT, r);
 999         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1000                 talloc_free(r);
1001                 return false;
1002         }
1003
1004         blob = ndr_push_blob(push);
1005         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1006                 talloc_free(r);
1007                 return false;
1008         }
1009
1010         talloc_free(r);
1011
1012         return true;
1013 }
1014
1015 static bool api_winreg_LoadKey(pipes_struct *p)
1016 {
1017         const struct ndr_interface_call *call;
1018         struct ndr_pull *pull;
1019         struct ndr_push *push;
1020         enum ndr_err_code ndr_err;
1021         DATA_BLOB blob;
1022         struct winreg_LoadKey *r;
1023
1024         call = &ndr_table_winreg.calls[NDR_WINREG_LOADKEY];
1025
1026         r = talloc(talloc_tos(), struct winreg_LoadKey);
1027         if (r == NULL) {
1028                 return false;
1029         }
1030
1031         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1032                 talloc_free(r);
1033                 return false;
1034         }
1035
1036         pull = ndr_pull_init_blob(&blob, r, NULL);
1037         if (pull == NULL) {
1038                 talloc_free(r);
1039                 return false;
1040         }
1041
1042         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1043         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1044         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1045                 talloc_free(r);
1046                 return false;
1047         }
1048
1049         if (DEBUGLEVEL >= 10) {
1050                 NDR_PRINT_IN_DEBUG(winreg_LoadKey, r);
1051         }
1052
1053         r->out.result = _winreg_LoadKey(p, r);
1054
1055         if (p->rng_fault_state) {
1056                 talloc_free(r);
1057                 /* Return true here, srv_pipe_hnd.c will take care */
1058                 return true;
1059         }
1060
1061         if (DEBUGLEVEL >= 10) {
1062                 NDR_PRINT_OUT_DEBUG(winreg_LoadKey, r);
1063         }
1064
1065         push = ndr_push_init_ctx(r, NULL);
1066         if (push == NULL) {
1067                 talloc_free(r);
1068                 return false;
1069         }
1070
1071         ndr_err = call->ndr_push(push, NDR_OUT, r);
1072         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1073                 talloc_free(r);
1074                 return false;
1075         }
1076
1077         blob = ndr_push_blob(push);
1078         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1079                 talloc_free(r);
1080                 return false;
1081         }
1082
1083         talloc_free(r);
1084
1085         return true;
1086 }
1087
1088 static bool api_winreg_NotifyChangeKeyValue(pipes_struct *p)
1089 {
1090         const struct ndr_interface_call *call;
1091         struct ndr_pull *pull;
1092         struct ndr_push *push;
1093         enum ndr_err_code ndr_err;
1094         DATA_BLOB blob;
1095         struct winreg_NotifyChangeKeyValue *r;
1096
1097         call = &ndr_table_winreg.calls[NDR_WINREG_NOTIFYCHANGEKEYVALUE];
1098
1099         r = talloc(talloc_tos(), struct winreg_NotifyChangeKeyValue);
1100         if (r == NULL) {
1101                 return false;
1102         }
1103
1104         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1105                 talloc_free(r);
1106                 return false;
1107         }
1108
1109         pull = ndr_pull_init_blob(&blob, r, NULL);
1110         if (pull == NULL) {
1111                 talloc_free(r);
1112                 return false;
1113         }
1114
1115         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1116         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1117         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1118                 talloc_free(r);
1119                 return false;
1120         }
1121
1122         if (DEBUGLEVEL >= 10) {
1123                 NDR_PRINT_IN_DEBUG(winreg_NotifyChangeKeyValue, r);
1124         }
1125
1126         r->out.result = _winreg_NotifyChangeKeyValue(p, r);
1127
1128         if (p->rng_fault_state) {
1129                 talloc_free(r);
1130                 /* Return true here, srv_pipe_hnd.c will take care */
1131                 return true;
1132         }
1133
1134         if (DEBUGLEVEL >= 10) {
1135                 NDR_PRINT_OUT_DEBUG(winreg_NotifyChangeKeyValue, r);
1136         }
1137
1138         push = ndr_push_init_ctx(r, NULL);
1139         if (push == NULL) {
1140                 talloc_free(r);
1141                 return false;
1142         }
1143
1144         ndr_err = call->ndr_push(push, NDR_OUT, r);
1145         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1146                 talloc_free(r);
1147                 return false;
1148         }
1149
1150         blob = ndr_push_blob(push);
1151         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1152                 talloc_free(r);
1153                 return false;
1154         }
1155
1156         talloc_free(r);
1157
1158         return true;
1159 }
1160
1161 static bool api_winreg_OpenKey(pipes_struct *p)
1162 {
1163         const struct ndr_interface_call *call;
1164         struct ndr_pull *pull;
1165         struct ndr_push *push;
1166         enum ndr_err_code ndr_err;
1167         DATA_BLOB blob;
1168         struct winreg_OpenKey *r;
1169
1170         call = &ndr_table_winreg.calls[NDR_WINREG_OPENKEY];
1171
1172         r = talloc(talloc_tos(), struct winreg_OpenKey);
1173         if (r == NULL) {
1174                 return false;
1175         }
1176
1177         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1178                 talloc_free(r);
1179                 return false;
1180         }
1181
1182         pull = ndr_pull_init_blob(&blob, r, NULL);
1183         if (pull == NULL) {
1184                 talloc_free(r);
1185                 return false;
1186         }
1187
1188         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1189         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1190         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1191                 talloc_free(r);
1192                 return false;
1193         }
1194
1195         if (DEBUGLEVEL >= 10) {
1196                 NDR_PRINT_IN_DEBUG(winreg_OpenKey, r);
1197         }
1198
1199         ZERO_STRUCT(r->out);
1200         r->out.handle = talloc_zero(r, struct policy_handle);
1201         if (r->out.handle == NULL) {
1202                 talloc_free(r);
1203                 return false;
1204         }
1205
1206         r->out.result = _winreg_OpenKey(p, r);
1207
1208         if (p->rng_fault_state) {
1209                 talloc_free(r);
1210                 /* Return true here, srv_pipe_hnd.c will take care */
1211                 return true;
1212         }
1213
1214         if (DEBUGLEVEL >= 10) {
1215                 NDR_PRINT_OUT_DEBUG(winreg_OpenKey, r);
1216         }
1217
1218         push = ndr_push_init_ctx(r, NULL);
1219         if (push == NULL) {
1220                 talloc_free(r);
1221                 return false;
1222         }
1223
1224         ndr_err = call->ndr_push(push, NDR_OUT, r);
1225         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1226                 talloc_free(r);
1227                 return false;
1228         }
1229
1230         blob = ndr_push_blob(push);
1231         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1232                 talloc_free(r);
1233                 return false;
1234         }
1235
1236         talloc_free(r);
1237
1238         return true;
1239 }
1240
1241 static bool api_winreg_QueryInfoKey(pipes_struct *p)
1242 {
1243         const struct ndr_interface_call *call;
1244         struct ndr_pull *pull;
1245         struct ndr_push *push;
1246         enum ndr_err_code ndr_err;
1247         DATA_BLOB blob;
1248         struct winreg_QueryInfoKey *r;
1249
1250         call = &ndr_table_winreg.calls[NDR_WINREG_QUERYINFOKEY];
1251
1252         r = talloc(talloc_tos(), struct winreg_QueryInfoKey);
1253         if (r == NULL) {
1254                 return false;
1255         }
1256
1257         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1258                 talloc_free(r);
1259                 return false;
1260         }
1261
1262         pull = ndr_pull_init_blob(&blob, r, NULL);
1263         if (pull == NULL) {
1264                 talloc_free(r);
1265                 return false;
1266         }
1267
1268         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1269         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1270         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1271                 talloc_free(r);
1272                 return false;
1273         }
1274
1275         if (DEBUGLEVEL >= 10) {
1276                 NDR_PRINT_IN_DEBUG(winreg_QueryInfoKey, r);
1277         }
1278
1279         ZERO_STRUCT(r->out);
1280         r->out.classname = r->in.classname;
1281         r->out.num_subkeys = talloc_zero(r, uint32_t);
1282         if (r->out.num_subkeys == NULL) {
1283                 talloc_free(r);
1284                 return false;
1285         }
1286
1287         r->out.max_subkeylen = talloc_zero(r, uint32_t);
1288         if (r->out.max_subkeylen == NULL) {
1289                 talloc_free(r);
1290                 return false;
1291         }
1292
1293         r->out.max_classlen = talloc_zero(r, uint32_t);
1294         if (r->out.max_classlen == NULL) {
1295                 talloc_free(r);
1296                 return false;
1297         }
1298
1299         r->out.num_values = talloc_zero(r, uint32_t);
1300         if (r->out.num_values == NULL) {
1301                 talloc_free(r);
1302                 return false;
1303         }
1304
1305         r->out.max_valnamelen = talloc_zero(r, uint32_t);
1306         if (r->out.max_valnamelen == NULL) {
1307                 talloc_free(r);
1308                 return false;
1309         }
1310
1311         r->out.max_valbufsize = talloc_zero(r, uint32_t);
1312         if (r->out.max_valbufsize == NULL) {
1313                 talloc_free(r);
1314                 return false;
1315         }
1316
1317         r->out.secdescsize = talloc_zero(r, uint32_t);
1318         if (r->out.secdescsize == NULL) {
1319                 talloc_free(r);
1320                 return false;
1321         }
1322
1323         r->out.last_changed_time = talloc_zero(r, NTTIME);
1324         if (r->out.last_changed_time == NULL) {
1325                 talloc_free(r);
1326                 return false;
1327         }
1328
1329         r->out.result = _winreg_QueryInfoKey(p, r);
1330
1331         if (p->rng_fault_state) {
1332                 talloc_free(r);
1333                 /* Return true here, srv_pipe_hnd.c will take care */
1334                 return true;
1335         }
1336
1337         if (DEBUGLEVEL >= 10) {
1338                 NDR_PRINT_OUT_DEBUG(winreg_QueryInfoKey, r);
1339         }
1340
1341         push = ndr_push_init_ctx(r, NULL);
1342         if (push == NULL) {
1343                 talloc_free(r);
1344                 return false;
1345         }
1346
1347         ndr_err = call->ndr_push(push, NDR_OUT, r);
1348         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1349                 talloc_free(r);
1350                 return false;
1351         }
1352
1353         blob = ndr_push_blob(push);
1354         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1355                 talloc_free(r);
1356                 return false;
1357         }
1358
1359         talloc_free(r);
1360
1361         return true;
1362 }
1363
1364 static bool api_winreg_QueryValue(pipes_struct *p)
1365 {
1366         const struct ndr_interface_call *call;
1367         struct ndr_pull *pull;
1368         struct ndr_push *push;
1369         enum ndr_err_code ndr_err;
1370         DATA_BLOB blob;
1371         struct winreg_QueryValue *r;
1372
1373         call = &ndr_table_winreg.calls[NDR_WINREG_QUERYVALUE];
1374
1375         r = talloc(talloc_tos(), struct winreg_QueryValue);
1376         if (r == NULL) {
1377                 return false;
1378         }
1379
1380         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1381                 talloc_free(r);
1382                 return false;
1383         }
1384
1385         pull = ndr_pull_init_blob(&blob, r, NULL);
1386         if (pull == NULL) {
1387                 talloc_free(r);
1388                 return false;
1389         }
1390
1391         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1392         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1393         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1394                 talloc_free(r);
1395                 return false;
1396         }
1397
1398         if (DEBUGLEVEL >= 10) {
1399                 NDR_PRINT_IN_DEBUG(winreg_QueryValue, r);
1400         }
1401
1402         ZERO_STRUCT(r->out);
1403         r->out.type = r->in.type;
1404         r->out.data = r->in.data;
1405         r->out.data_size = r->in.data_size;
1406         r->out.data_length = r->in.data_length;
1407         r->out.result = _winreg_QueryValue(p, r);
1408
1409         if (p->rng_fault_state) {
1410                 talloc_free(r);
1411                 /* Return true here, srv_pipe_hnd.c will take care */
1412                 return true;
1413         }
1414
1415         if (DEBUGLEVEL >= 10) {
1416                 NDR_PRINT_OUT_DEBUG(winreg_QueryValue, r);
1417         }
1418
1419         push = ndr_push_init_ctx(r, NULL);
1420         if (push == NULL) {
1421                 talloc_free(r);
1422                 return false;
1423         }
1424
1425         ndr_err = call->ndr_push(push, NDR_OUT, r);
1426         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1427                 talloc_free(r);
1428                 return false;
1429         }
1430
1431         blob = ndr_push_blob(push);
1432         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1433                 talloc_free(r);
1434                 return false;
1435         }
1436
1437         talloc_free(r);
1438
1439         return true;
1440 }
1441
1442 static bool api_winreg_ReplaceKey(pipes_struct *p)
1443 {
1444         const struct ndr_interface_call *call;
1445         struct ndr_pull *pull;
1446         struct ndr_push *push;
1447         enum ndr_err_code ndr_err;
1448         DATA_BLOB blob;
1449         struct winreg_ReplaceKey *r;
1450
1451         call = &ndr_table_winreg.calls[NDR_WINREG_REPLACEKEY];
1452
1453         r = talloc(talloc_tos(), struct winreg_ReplaceKey);
1454         if (r == NULL) {
1455                 return false;
1456         }
1457
1458         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1459                 talloc_free(r);
1460                 return false;
1461         }
1462
1463         pull = ndr_pull_init_blob(&blob, r, NULL);
1464         if (pull == NULL) {
1465                 talloc_free(r);
1466                 return false;
1467         }
1468
1469         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1470         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1471         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1472                 talloc_free(r);
1473                 return false;
1474         }
1475
1476         if (DEBUGLEVEL >= 10) {
1477                 NDR_PRINT_IN_DEBUG(winreg_ReplaceKey, r);
1478         }
1479
1480         r->out.result = _winreg_ReplaceKey(p, r);
1481
1482         if (p->rng_fault_state) {
1483                 talloc_free(r);
1484                 /* Return true here, srv_pipe_hnd.c will take care */
1485                 return true;
1486         }
1487
1488         if (DEBUGLEVEL >= 10) {
1489                 NDR_PRINT_OUT_DEBUG(winreg_ReplaceKey, r);
1490         }
1491
1492         push = ndr_push_init_ctx(r, NULL);
1493         if (push == NULL) {
1494                 talloc_free(r);
1495                 return false;
1496         }
1497
1498         ndr_err = call->ndr_push(push, NDR_OUT, r);
1499         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1500                 talloc_free(r);
1501                 return false;
1502         }
1503
1504         blob = ndr_push_blob(push);
1505         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1506                 talloc_free(r);
1507                 return false;
1508         }
1509
1510         talloc_free(r);
1511
1512         return true;
1513 }
1514
1515 static bool api_winreg_RestoreKey(pipes_struct *p)
1516 {
1517         const struct ndr_interface_call *call;
1518         struct ndr_pull *pull;
1519         struct ndr_push *push;
1520         enum ndr_err_code ndr_err;
1521         DATA_BLOB blob;
1522         struct winreg_RestoreKey *r;
1523
1524         call = &ndr_table_winreg.calls[NDR_WINREG_RESTOREKEY];
1525
1526         r = talloc(talloc_tos(), struct winreg_RestoreKey);
1527         if (r == NULL) {
1528                 return false;
1529         }
1530
1531         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1532                 talloc_free(r);
1533                 return false;
1534         }
1535
1536         pull = ndr_pull_init_blob(&blob, r, NULL);
1537         if (pull == NULL) {
1538                 talloc_free(r);
1539                 return false;
1540         }
1541
1542         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1543         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1544         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1545                 talloc_free(r);
1546                 return false;
1547         }
1548
1549         if (DEBUGLEVEL >= 10) {
1550                 NDR_PRINT_IN_DEBUG(winreg_RestoreKey, r);
1551         }
1552
1553         r->out.result = _winreg_RestoreKey(p, r);
1554
1555         if (p->rng_fault_state) {
1556                 talloc_free(r);
1557                 /* Return true here, srv_pipe_hnd.c will take care */
1558                 return true;
1559         }
1560
1561         if (DEBUGLEVEL >= 10) {
1562                 NDR_PRINT_OUT_DEBUG(winreg_RestoreKey, r);
1563         }
1564
1565         push = ndr_push_init_ctx(r, NULL);
1566         if (push == NULL) {
1567                 talloc_free(r);
1568                 return false;
1569         }
1570
1571         ndr_err = call->ndr_push(push, NDR_OUT, r);
1572         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1573                 talloc_free(r);
1574                 return false;
1575         }
1576
1577         blob = ndr_push_blob(push);
1578         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1579                 talloc_free(r);
1580                 return false;
1581         }
1582
1583         talloc_free(r);
1584
1585         return true;
1586 }
1587
1588 static bool api_winreg_SaveKey(pipes_struct *p)
1589 {
1590         const struct ndr_interface_call *call;
1591         struct ndr_pull *pull;
1592         struct ndr_push *push;
1593         enum ndr_err_code ndr_err;
1594         DATA_BLOB blob;
1595         struct winreg_SaveKey *r;
1596
1597         call = &ndr_table_winreg.calls[NDR_WINREG_SAVEKEY];
1598
1599         r = talloc(talloc_tos(), struct winreg_SaveKey);
1600         if (r == NULL) {
1601                 return false;
1602         }
1603
1604         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1605                 talloc_free(r);
1606                 return false;
1607         }
1608
1609         pull = ndr_pull_init_blob(&blob, r, NULL);
1610         if (pull == NULL) {
1611                 talloc_free(r);
1612                 return false;
1613         }
1614
1615         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1616         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1617         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1618                 talloc_free(r);
1619                 return false;
1620         }
1621
1622         if (DEBUGLEVEL >= 10) {
1623                 NDR_PRINT_IN_DEBUG(winreg_SaveKey, r);
1624         }
1625
1626         r->out.result = _winreg_SaveKey(p, r);
1627
1628         if (p->rng_fault_state) {
1629                 talloc_free(r);
1630                 /* Return true here, srv_pipe_hnd.c will take care */
1631                 return true;
1632         }
1633
1634         if (DEBUGLEVEL >= 10) {
1635                 NDR_PRINT_OUT_DEBUG(winreg_SaveKey, r);
1636         }
1637
1638         push = ndr_push_init_ctx(r, NULL);
1639         if (push == NULL) {
1640                 talloc_free(r);
1641                 return false;
1642         }
1643
1644         ndr_err = call->ndr_push(push, NDR_OUT, r);
1645         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1646                 talloc_free(r);
1647                 return false;
1648         }
1649
1650         blob = ndr_push_blob(push);
1651         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1652                 talloc_free(r);
1653                 return false;
1654         }
1655
1656         talloc_free(r);
1657
1658         return true;
1659 }
1660
1661 static bool api_winreg_SetKeySecurity(pipes_struct *p)
1662 {
1663         const struct ndr_interface_call *call;
1664         struct ndr_pull *pull;
1665         struct ndr_push *push;
1666         enum ndr_err_code ndr_err;
1667         DATA_BLOB blob;
1668         struct winreg_SetKeySecurity *r;
1669
1670         call = &ndr_table_winreg.calls[NDR_WINREG_SETKEYSECURITY];
1671
1672         r = talloc(talloc_tos(), struct winreg_SetKeySecurity);
1673         if (r == NULL) {
1674                 return false;
1675         }
1676
1677         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1678                 talloc_free(r);
1679                 return false;
1680         }
1681
1682         pull = ndr_pull_init_blob(&blob, r, NULL);
1683         if (pull == NULL) {
1684                 talloc_free(r);
1685                 return false;
1686         }
1687
1688         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1689         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1690         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1691                 talloc_free(r);
1692                 return false;
1693         }
1694
1695         if (DEBUGLEVEL >= 10) {
1696                 NDR_PRINT_IN_DEBUG(winreg_SetKeySecurity, r);
1697         }
1698
1699         r->out.result = _winreg_SetKeySecurity(p, r);
1700
1701         if (p->rng_fault_state) {
1702                 talloc_free(r);
1703                 /* Return true here, srv_pipe_hnd.c will take care */
1704                 return true;
1705         }
1706
1707         if (DEBUGLEVEL >= 10) {
1708                 NDR_PRINT_OUT_DEBUG(winreg_SetKeySecurity, r);
1709         }
1710
1711         push = ndr_push_init_ctx(r, NULL);
1712         if (push == NULL) {
1713                 talloc_free(r);
1714                 return false;
1715         }
1716
1717         ndr_err = call->ndr_push(push, NDR_OUT, r);
1718         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1719                 talloc_free(r);
1720                 return false;
1721         }
1722
1723         blob = ndr_push_blob(push);
1724         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1725                 talloc_free(r);
1726                 return false;
1727         }
1728
1729         talloc_free(r);
1730
1731         return true;
1732 }
1733
1734 static bool api_winreg_SetValue(pipes_struct *p)
1735 {
1736         const struct ndr_interface_call *call;
1737         struct ndr_pull *pull;
1738         struct ndr_push *push;
1739         enum ndr_err_code ndr_err;
1740         DATA_BLOB blob;
1741         struct winreg_SetValue *r;
1742
1743         call = &ndr_table_winreg.calls[NDR_WINREG_SETVALUE];
1744
1745         r = talloc(talloc_tos(), struct winreg_SetValue);
1746         if (r == NULL) {
1747                 return false;
1748         }
1749
1750         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1751                 talloc_free(r);
1752                 return false;
1753         }
1754
1755         pull = ndr_pull_init_blob(&blob, r, NULL);
1756         if (pull == NULL) {
1757                 talloc_free(r);
1758                 return false;
1759         }
1760
1761         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1762         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1763         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1764                 talloc_free(r);
1765                 return false;
1766         }
1767
1768         if (DEBUGLEVEL >= 10) {
1769                 NDR_PRINT_IN_DEBUG(winreg_SetValue, r);
1770         }
1771
1772         r->out.result = _winreg_SetValue(p, r);
1773
1774         if (p->rng_fault_state) {
1775                 talloc_free(r);
1776                 /* Return true here, srv_pipe_hnd.c will take care */
1777                 return true;
1778         }
1779
1780         if (DEBUGLEVEL >= 10) {
1781                 NDR_PRINT_OUT_DEBUG(winreg_SetValue, r);
1782         }
1783
1784         push = ndr_push_init_ctx(r, NULL);
1785         if (push == NULL) {
1786                 talloc_free(r);
1787                 return false;
1788         }
1789
1790         ndr_err = call->ndr_push(push, NDR_OUT, r);
1791         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1792                 talloc_free(r);
1793                 return false;
1794         }
1795
1796         blob = ndr_push_blob(push);
1797         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1798                 talloc_free(r);
1799                 return false;
1800         }
1801
1802         talloc_free(r);
1803
1804         return true;
1805 }
1806
1807 static bool api_winreg_UnLoadKey(pipes_struct *p)
1808 {
1809         const struct ndr_interface_call *call;
1810         struct ndr_pull *pull;
1811         struct ndr_push *push;
1812         enum ndr_err_code ndr_err;
1813         DATA_BLOB blob;
1814         struct winreg_UnLoadKey *r;
1815
1816         call = &ndr_table_winreg.calls[NDR_WINREG_UNLOADKEY];
1817
1818         r = talloc(talloc_tos(), struct winreg_UnLoadKey);
1819         if (r == NULL) {
1820                 return false;
1821         }
1822
1823         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1824                 talloc_free(r);
1825                 return false;
1826         }
1827
1828         pull = ndr_pull_init_blob(&blob, r, NULL);
1829         if (pull == NULL) {
1830                 talloc_free(r);
1831                 return false;
1832         }
1833
1834         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1835         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1836         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1837                 talloc_free(r);
1838                 return false;
1839         }
1840
1841         if (DEBUGLEVEL >= 10) {
1842                 NDR_PRINT_IN_DEBUG(winreg_UnLoadKey, r);
1843         }
1844
1845         r->out.result = _winreg_UnLoadKey(p, r);
1846
1847         if (p->rng_fault_state) {
1848                 talloc_free(r);
1849                 /* Return true here, srv_pipe_hnd.c will take care */
1850                 return true;
1851         }
1852
1853         if (DEBUGLEVEL >= 10) {
1854                 NDR_PRINT_OUT_DEBUG(winreg_UnLoadKey, r);
1855         }
1856
1857         push = ndr_push_init_ctx(r, NULL);
1858         if (push == NULL) {
1859                 talloc_free(r);
1860                 return false;
1861         }
1862
1863         ndr_err = call->ndr_push(push, NDR_OUT, r);
1864         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1865                 talloc_free(r);
1866                 return false;
1867         }
1868
1869         blob = ndr_push_blob(push);
1870         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1871                 talloc_free(r);
1872                 return false;
1873         }
1874
1875         talloc_free(r);
1876
1877         return true;
1878 }
1879
1880 static bool api_winreg_InitiateSystemShutdown(pipes_struct *p)
1881 {
1882         const struct ndr_interface_call *call;
1883         struct ndr_pull *pull;
1884         struct ndr_push *push;
1885         enum ndr_err_code ndr_err;
1886         DATA_BLOB blob;
1887         struct winreg_InitiateSystemShutdown *r;
1888
1889         call = &ndr_table_winreg.calls[NDR_WINREG_INITIATESYSTEMSHUTDOWN];
1890
1891         r = talloc(talloc_tos(), struct winreg_InitiateSystemShutdown);
1892         if (r == NULL) {
1893                 return false;
1894         }
1895
1896         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1897                 talloc_free(r);
1898                 return false;
1899         }
1900
1901         pull = ndr_pull_init_blob(&blob, r, NULL);
1902         if (pull == NULL) {
1903                 talloc_free(r);
1904                 return false;
1905         }
1906
1907         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1908         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1909         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1910                 talloc_free(r);
1911                 return false;
1912         }
1913
1914         if (DEBUGLEVEL >= 10) {
1915                 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdown, r);
1916         }
1917
1918         r->out.result = _winreg_InitiateSystemShutdown(p, r);
1919
1920         if (p->rng_fault_state) {
1921                 talloc_free(r);
1922                 /* Return true here, srv_pipe_hnd.c will take care */
1923                 return true;
1924         }
1925
1926         if (DEBUGLEVEL >= 10) {
1927                 NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdown, r);
1928         }
1929
1930         push = ndr_push_init_ctx(r, NULL);
1931         if (push == NULL) {
1932                 talloc_free(r);
1933                 return false;
1934         }
1935
1936         ndr_err = call->ndr_push(push, NDR_OUT, r);
1937         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1938                 talloc_free(r);
1939                 return false;
1940         }
1941
1942         blob = ndr_push_blob(push);
1943         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1944                 talloc_free(r);
1945                 return false;
1946         }
1947
1948         talloc_free(r);
1949
1950         return true;
1951 }
1952
1953 static bool api_winreg_AbortSystemShutdown(pipes_struct *p)
1954 {
1955         const struct ndr_interface_call *call;
1956         struct ndr_pull *pull;
1957         struct ndr_push *push;
1958         enum ndr_err_code ndr_err;
1959         DATA_BLOB blob;
1960         struct winreg_AbortSystemShutdown *r;
1961
1962         call = &ndr_table_winreg.calls[NDR_WINREG_ABORTSYSTEMSHUTDOWN];
1963
1964         r = talloc(talloc_tos(), struct winreg_AbortSystemShutdown);
1965         if (r == NULL) {
1966                 return false;
1967         }
1968
1969         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1970                 talloc_free(r);
1971                 return false;
1972         }
1973
1974         pull = ndr_pull_init_blob(&blob, r, NULL);
1975         if (pull == NULL) {
1976                 talloc_free(r);
1977                 return false;
1978         }
1979
1980         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1981         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1982         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1983                 talloc_free(r);
1984                 return false;
1985         }
1986
1987         if (DEBUGLEVEL >= 10) {
1988                 NDR_PRINT_IN_DEBUG(winreg_AbortSystemShutdown, r);
1989         }
1990
1991         r->out.result = _winreg_AbortSystemShutdown(p, r);
1992
1993         if (p->rng_fault_state) {
1994                 talloc_free(r);
1995                 /* Return true here, srv_pipe_hnd.c will take care */
1996                 return true;
1997         }
1998
1999         if (DEBUGLEVEL >= 10) {
2000                 NDR_PRINT_OUT_DEBUG(winreg_AbortSystemShutdown, r);
2001         }
2002
2003         push = ndr_push_init_ctx(r, NULL);
2004         if (push == NULL) {
2005                 talloc_free(r);
2006                 return false;
2007         }
2008
2009         ndr_err = call->ndr_push(push, NDR_OUT, r);
2010         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2011                 talloc_free(r);
2012                 return false;
2013         }
2014
2015         blob = ndr_push_blob(push);
2016         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2017                 talloc_free(r);
2018                 return false;
2019         }
2020
2021         talloc_free(r);
2022
2023         return true;
2024 }
2025
2026 static bool api_winreg_GetVersion(pipes_struct *p)
2027 {
2028         const struct ndr_interface_call *call;
2029         struct ndr_pull *pull;
2030         struct ndr_push *push;
2031         enum ndr_err_code ndr_err;
2032         DATA_BLOB blob;
2033         struct winreg_GetVersion *r;
2034
2035         call = &ndr_table_winreg.calls[NDR_WINREG_GETVERSION];
2036
2037         r = talloc(talloc_tos(), struct winreg_GetVersion);
2038         if (r == NULL) {
2039                 return false;
2040         }
2041
2042         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2043                 talloc_free(r);
2044                 return false;
2045         }
2046
2047         pull = ndr_pull_init_blob(&blob, r, NULL);
2048         if (pull == NULL) {
2049                 talloc_free(r);
2050                 return false;
2051         }
2052
2053         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2054         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2055         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2056                 talloc_free(r);
2057                 return false;
2058         }
2059
2060         if (DEBUGLEVEL >= 10) {
2061                 NDR_PRINT_IN_DEBUG(winreg_GetVersion, r);
2062         }
2063
2064         ZERO_STRUCT(r->out);
2065         r->out.version = talloc_zero(r, uint32_t);
2066         if (r->out.version == NULL) {
2067                 talloc_free(r);
2068                 return false;
2069         }
2070
2071         r->out.result = _winreg_GetVersion(p, r);
2072
2073         if (p->rng_fault_state) {
2074                 talloc_free(r);
2075                 /* Return true here, srv_pipe_hnd.c will take care */
2076                 return true;
2077         }
2078
2079         if (DEBUGLEVEL >= 10) {
2080                 NDR_PRINT_OUT_DEBUG(winreg_GetVersion, r);
2081         }
2082
2083         push = ndr_push_init_ctx(r, NULL);
2084         if (push == NULL) {
2085                 talloc_free(r);
2086                 return false;
2087         }
2088
2089         ndr_err = call->ndr_push(push, NDR_OUT, r);
2090         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2091                 talloc_free(r);
2092                 return false;
2093         }
2094
2095         blob = ndr_push_blob(push);
2096         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2097                 talloc_free(r);
2098                 return false;
2099         }
2100
2101         talloc_free(r);
2102
2103         return true;
2104 }
2105
2106 static bool api_winreg_OpenHKCC(pipes_struct *p)
2107 {
2108         const struct ndr_interface_call *call;
2109         struct ndr_pull *pull;
2110         struct ndr_push *push;
2111         enum ndr_err_code ndr_err;
2112         DATA_BLOB blob;
2113         struct winreg_OpenHKCC *r;
2114
2115         call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKCC];
2116
2117         r = talloc(talloc_tos(), struct winreg_OpenHKCC);
2118         if (r == NULL) {
2119                 return false;
2120         }
2121
2122         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2123                 talloc_free(r);
2124                 return false;
2125         }
2126
2127         pull = ndr_pull_init_blob(&blob, r, NULL);
2128         if (pull == NULL) {
2129                 talloc_free(r);
2130                 return false;
2131         }
2132
2133         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2134         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2135         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2136                 talloc_free(r);
2137                 return false;
2138         }
2139
2140         if (DEBUGLEVEL >= 10) {
2141                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCC, r);
2142         }
2143
2144         ZERO_STRUCT(r->out);
2145         r->out.handle = talloc_zero(r, struct policy_handle);
2146         if (r->out.handle == NULL) {
2147                 talloc_free(r);
2148                 return false;
2149         }
2150
2151         r->out.result = _winreg_OpenHKCC(p, r);
2152
2153         if (p->rng_fault_state) {
2154                 talloc_free(r);
2155                 /* Return true here, srv_pipe_hnd.c will take care */
2156                 return true;
2157         }
2158
2159         if (DEBUGLEVEL >= 10) {
2160                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCC, r);
2161         }
2162
2163         push = ndr_push_init_ctx(r, NULL);
2164         if (push == NULL) {
2165                 talloc_free(r);
2166                 return false;
2167         }
2168
2169         ndr_err = call->ndr_push(push, NDR_OUT, r);
2170         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2171                 talloc_free(r);
2172                 return false;
2173         }
2174
2175         blob = ndr_push_blob(push);
2176         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2177                 talloc_free(r);
2178                 return false;
2179         }
2180
2181         talloc_free(r);
2182
2183         return true;
2184 }
2185
2186 static bool api_winreg_OpenHKDD(pipes_struct *p)
2187 {
2188         const struct ndr_interface_call *call;
2189         struct ndr_pull *pull;
2190         struct ndr_push *push;
2191         enum ndr_err_code ndr_err;
2192         DATA_BLOB blob;
2193         struct winreg_OpenHKDD *r;
2194
2195         call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKDD];
2196
2197         r = talloc(talloc_tos(), struct winreg_OpenHKDD);
2198         if (r == NULL) {
2199                 return false;
2200         }
2201
2202         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2203                 talloc_free(r);
2204                 return false;
2205         }
2206
2207         pull = ndr_pull_init_blob(&blob, r, NULL);
2208         if (pull == NULL) {
2209                 talloc_free(r);
2210                 return false;
2211         }
2212
2213         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2214         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2215         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2216                 talloc_free(r);
2217                 return false;
2218         }
2219
2220         if (DEBUGLEVEL >= 10) {
2221                 NDR_PRINT_IN_DEBUG(winreg_OpenHKDD, r);
2222         }
2223
2224         ZERO_STRUCT(r->out);
2225         r->out.handle = talloc_zero(r, struct policy_handle);
2226         if (r->out.handle == NULL) {
2227                 talloc_free(r);
2228                 return false;
2229         }
2230
2231         r->out.result = _winreg_OpenHKDD(p, r);
2232
2233         if (p->rng_fault_state) {
2234                 talloc_free(r);
2235                 /* Return true here, srv_pipe_hnd.c will take care */
2236                 return true;
2237         }
2238
2239         if (DEBUGLEVEL >= 10) {
2240                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKDD, r);
2241         }
2242
2243         push = ndr_push_init_ctx(r, NULL);
2244         if (push == NULL) {
2245                 talloc_free(r);
2246                 return false;
2247         }
2248
2249         ndr_err = call->ndr_push(push, NDR_OUT, r);
2250         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2251                 talloc_free(r);
2252                 return false;
2253         }
2254
2255         blob = ndr_push_blob(push);
2256         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2257                 talloc_free(r);
2258                 return false;
2259         }
2260
2261         talloc_free(r);
2262
2263         return true;
2264 }
2265
2266 static bool api_winreg_QueryMultipleValues(pipes_struct *p)
2267 {
2268         const struct ndr_interface_call *call;
2269         struct ndr_pull *pull;
2270         struct ndr_push *push;
2271         enum ndr_err_code ndr_err;
2272         DATA_BLOB blob;
2273         struct winreg_QueryMultipleValues *r;
2274
2275         call = &ndr_table_winreg.calls[NDR_WINREG_QUERYMULTIPLEVALUES];
2276
2277         r = talloc(talloc_tos(), struct winreg_QueryMultipleValues);
2278         if (r == NULL) {
2279                 return false;
2280         }
2281
2282         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2283                 talloc_free(r);
2284                 return false;
2285         }
2286
2287         pull = ndr_pull_init_blob(&blob, r, NULL);
2288         if (pull == NULL) {
2289                 talloc_free(r);
2290                 return false;
2291         }
2292
2293         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2294         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2295         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2296                 talloc_free(r);
2297                 return false;
2298         }
2299
2300         if (DEBUGLEVEL >= 10) {
2301                 NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues, r);
2302         }
2303
2304         ZERO_STRUCT(r->out);
2305         r->out.values = r->in.values;
2306         r->out.buffer = r->in.buffer;
2307         r->out.buffer_size = r->in.buffer_size;
2308         r->out.result = _winreg_QueryMultipleValues(p, r);
2309
2310         if (p->rng_fault_state) {
2311                 talloc_free(r);
2312                 /* Return true here, srv_pipe_hnd.c will take care */
2313                 return true;
2314         }
2315
2316         if (DEBUGLEVEL >= 10) {
2317                 NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues, r);
2318         }
2319
2320         push = ndr_push_init_ctx(r, NULL);
2321         if (push == NULL) {
2322                 talloc_free(r);
2323                 return false;
2324         }
2325
2326         ndr_err = call->ndr_push(push, NDR_OUT, r);
2327         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2328                 talloc_free(r);
2329                 return false;
2330         }
2331
2332         blob = ndr_push_blob(push);
2333         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2334                 talloc_free(r);
2335                 return false;
2336         }
2337
2338         talloc_free(r);
2339
2340         return true;
2341 }
2342
2343 static bool api_winreg_InitiateSystemShutdownEx(pipes_struct *p)
2344 {
2345         const struct ndr_interface_call *call;
2346         struct ndr_pull *pull;
2347         struct ndr_push *push;
2348         enum ndr_err_code ndr_err;
2349         DATA_BLOB blob;
2350         struct winreg_InitiateSystemShutdownEx *r;
2351
2352         call = &ndr_table_winreg.calls[NDR_WINREG_INITIATESYSTEMSHUTDOWNEX];
2353
2354         r = talloc(talloc_tos(), struct winreg_InitiateSystemShutdownEx);
2355         if (r == NULL) {
2356                 return false;
2357         }
2358
2359         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2360                 talloc_free(r);
2361                 return false;
2362         }
2363
2364         pull = ndr_pull_init_blob(&blob, r, NULL);
2365         if (pull == NULL) {
2366                 talloc_free(r);
2367                 return false;
2368         }
2369
2370         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2371         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2372         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2373                 talloc_free(r);
2374                 return false;
2375         }
2376
2377         if (DEBUGLEVEL >= 10) {
2378                 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdownEx, r);
2379         }
2380
2381         r->out.result = _winreg_InitiateSystemShutdownEx(p, r);
2382
2383         if (p->rng_fault_state) {
2384                 talloc_free(r);
2385                 /* Return true here, srv_pipe_hnd.c will take care */
2386                 return true;
2387         }
2388
2389         if (DEBUGLEVEL >= 10) {
2390                 NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdownEx, r);
2391         }
2392
2393         push = ndr_push_init_ctx(r, NULL);
2394         if (push == NULL) {
2395                 talloc_free(r);
2396                 return false;
2397         }
2398
2399         ndr_err = call->ndr_push(push, NDR_OUT, r);
2400         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2401                 talloc_free(r);
2402                 return false;
2403         }
2404
2405         blob = ndr_push_blob(push);
2406         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2407                 talloc_free(r);
2408                 return false;
2409         }
2410
2411         talloc_free(r);
2412
2413         return true;
2414 }
2415
2416 static bool api_winreg_SaveKeyEx(pipes_struct *p)
2417 {
2418         const struct ndr_interface_call *call;
2419         struct ndr_pull *pull;
2420         struct ndr_push *push;
2421         enum ndr_err_code ndr_err;
2422         DATA_BLOB blob;
2423         struct winreg_SaveKeyEx *r;
2424
2425         call = &ndr_table_winreg.calls[NDR_WINREG_SAVEKEYEX];
2426
2427         r = talloc(talloc_tos(), struct winreg_SaveKeyEx);
2428         if (r == NULL) {
2429                 return false;
2430         }
2431
2432         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2433                 talloc_free(r);
2434                 return false;
2435         }
2436
2437         pull = ndr_pull_init_blob(&blob, r, NULL);
2438         if (pull == NULL) {
2439                 talloc_free(r);
2440                 return false;
2441         }
2442
2443         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2444         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2445         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2446                 talloc_free(r);
2447                 return false;
2448         }
2449
2450         if (DEBUGLEVEL >= 10) {
2451                 NDR_PRINT_IN_DEBUG(winreg_SaveKeyEx, r);
2452         }
2453
2454         r->out.result = _winreg_SaveKeyEx(p, r);
2455
2456         if (p->rng_fault_state) {
2457                 talloc_free(r);
2458                 /* Return true here, srv_pipe_hnd.c will take care */
2459                 return true;
2460         }
2461
2462         if (DEBUGLEVEL >= 10) {
2463                 NDR_PRINT_OUT_DEBUG(winreg_SaveKeyEx, r);
2464         }
2465
2466         push = ndr_push_init_ctx(r, NULL);
2467         if (push == NULL) {
2468                 talloc_free(r);
2469                 return false;
2470         }
2471
2472         ndr_err = call->ndr_push(push, NDR_OUT, r);
2473         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2474                 talloc_free(r);
2475                 return false;
2476         }
2477
2478         blob = ndr_push_blob(push);
2479         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2480                 talloc_free(r);
2481                 return false;
2482         }
2483
2484         talloc_free(r);
2485
2486         return true;
2487 }
2488
2489 static bool api_winreg_OpenHKPT(pipes_struct *p)
2490 {
2491         const struct ndr_interface_call *call;
2492         struct ndr_pull *pull;
2493         struct ndr_push *push;
2494         enum ndr_err_code ndr_err;
2495         DATA_BLOB blob;
2496         struct winreg_OpenHKPT *r;
2497
2498         call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKPT];
2499
2500         r = talloc(talloc_tos(), struct winreg_OpenHKPT);
2501         if (r == NULL) {
2502                 return false;
2503         }
2504
2505         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2506                 talloc_free(r);
2507                 return false;
2508         }
2509
2510         pull = ndr_pull_init_blob(&blob, r, NULL);
2511         if (pull == NULL) {
2512                 talloc_free(r);
2513                 return false;
2514         }
2515
2516         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2517         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2518         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2519                 talloc_free(r);
2520                 return false;
2521         }
2522
2523         if (DEBUGLEVEL >= 10) {
2524                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPT, r);
2525         }
2526
2527         ZERO_STRUCT(r->out);
2528         r->out.handle = talloc_zero(r, struct policy_handle);
2529         if (r->out.handle == NULL) {
2530                 talloc_free(r);
2531                 return false;
2532         }
2533
2534         r->out.result = _winreg_OpenHKPT(p, r);
2535
2536         if (p->rng_fault_state) {
2537                 talloc_free(r);
2538                 /* Return true here, srv_pipe_hnd.c will take care */
2539                 return true;
2540         }
2541
2542         if (DEBUGLEVEL >= 10) {
2543                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPT, r);
2544         }
2545
2546         push = ndr_push_init_ctx(r, NULL);
2547         if (push == NULL) {
2548                 talloc_free(r);
2549                 return false;
2550         }
2551
2552         ndr_err = call->ndr_push(push, NDR_OUT, r);
2553         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2554                 talloc_free(r);
2555                 return false;
2556         }
2557
2558         blob = ndr_push_blob(push);
2559         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2560                 talloc_free(r);
2561                 return false;
2562         }
2563
2564         talloc_free(r);
2565
2566         return true;
2567 }
2568
2569 static bool api_winreg_OpenHKPN(pipes_struct *p)
2570 {
2571         const struct ndr_interface_call *call;
2572         struct ndr_pull *pull;
2573         struct ndr_push *push;
2574         enum ndr_err_code ndr_err;
2575         DATA_BLOB blob;
2576         struct winreg_OpenHKPN *r;
2577
2578         call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKPN];
2579
2580         r = talloc(talloc_tos(), struct winreg_OpenHKPN);
2581         if (r == NULL) {
2582                 return false;
2583         }
2584
2585         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2586                 talloc_free(r);
2587                 return false;
2588         }
2589
2590         pull = ndr_pull_init_blob(&blob, r, NULL);
2591         if (pull == NULL) {
2592                 talloc_free(r);
2593                 return false;
2594         }
2595
2596         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2597         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2598         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2599                 talloc_free(r);
2600                 return false;
2601         }
2602
2603         if (DEBUGLEVEL >= 10) {
2604                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPN, r);
2605         }
2606
2607         ZERO_STRUCT(r->out);
2608         r->out.handle = talloc_zero(r, struct policy_handle);
2609         if (r->out.handle == NULL) {
2610                 talloc_free(r);
2611                 return false;
2612         }
2613
2614         r->out.result = _winreg_OpenHKPN(p, r);
2615
2616         if (p->rng_fault_state) {
2617                 talloc_free(r);
2618                 /* Return true here, srv_pipe_hnd.c will take care */
2619                 return true;
2620         }
2621
2622         if (DEBUGLEVEL >= 10) {
2623                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPN, r);
2624         }
2625
2626         push = ndr_push_init_ctx(r, NULL);
2627         if (push == NULL) {
2628                 talloc_free(r);
2629                 return false;
2630         }
2631
2632         ndr_err = call->ndr_push(push, NDR_OUT, r);
2633         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2634                 talloc_free(r);
2635                 return false;
2636         }
2637
2638         blob = ndr_push_blob(push);
2639         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2640                 talloc_free(r);
2641                 return false;
2642         }
2643
2644         talloc_free(r);
2645
2646         return true;
2647 }
2648
2649 static bool api_winreg_QueryMultipleValues2(pipes_struct *p)
2650 {
2651         const struct ndr_interface_call *call;
2652         struct ndr_pull *pull;
2653         struct ndr_push *push;
2654         enum ndr_err_code ndr_err;
2655         DATA_BLOB blob;
2656         struct winreg_QueryMultipleValues2 *r;
2657
2658         call = &ndr_table_winreg.calls[NDR_WINREG_QUERYMULTIPLEVALUES2];
2659
2660         r = talloc(talloc_tos(), struct winreg_QueryMultipleValues2);
2661         if (r == NULL) {
2662                 return false;
2663         }
2664
2665         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2666                 talloc_free(r);
2667                 return false;
2668         }
2669
2670         pull = ndr_pull_init_blob(&blob, r, NULL);
2671         if (pull == NULL) {
2672                 talloc_free(r);
2673                 return false;
2674         }
2675
2676         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2677         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2678         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2679                 talloc_free(r);
2680                 return false;
2681         }
2682
2683         if (DEBUGLEVEL >= 10) {
2684                 NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues2, r);
2685         }
2686
2687         r->out.result = _winreg_QueryMultipleValues2(p, r);
2688
2689         if (p->rng_fault_state) {
2690                 talloc_free(r);
2691                 /* Return true here, srv_pipe_hnd.c will take care */
2692                 return true;
2693         }
2694
2695         if (DEBUGLEVEL >= 10) {
2696                 NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues2, r);
2697         }
2698
2699         push = ndr_push_init_ctx(r, NULL);
2700         if (push == NULL) {
2701                 talloc_free(r);
2702                 return false;
2703         }
2704
2705         ndr_err = call->ndr_push(push, NDR_OUT, r);
2706         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2707                 talloc_free(r);
2708                 return false;
2709         }
2710
2711         blob = ndr_push_blob(push);
2712         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2713                 talloc_free(r);
2714                 return false;
2715         }
2716
2717         talloc_free(r);
2718
2719         return true;
2720 }
2721
2722
2723 /* Tables */
2724 static struct api_struct api_winreg_cmds[] =
2725 {
2726         {"WINREG_OPENHKCR", NDR_WINREG_OPENHKCR, api_winreg_OpenHKCR},
2727         {"WINREG_OPENHKCU", NDR_WINREG_OPENHKCU, api_winreg_OpenHKCU},
2728         {"WINREG_OPENHKLM", NDR_WINREG_OPENHKLM, api_winreg_OpenHKLM},
2729         {"WINREG_OPENHKPD", NDR_WINREG_OPENHKPD, api_winreg_OpenHKPD},
2730         {"WINREG_OPENHKU", NDR_WINREG_OPENHKU, api_winreg_OpenHKU},
2731         {"WINREG_CLOSEKEY", NDR_WINREG_CLOSEKEY, api_winreg_CloseKey},
2732         {"WINREG_CREATEKEY", NDR_WINREG_CREATEKEY, api_winreg_CreateKey},
2733         {"WINREG_DELETEKEY", NDR_WINREG_DELETEKEY, api_winreg_DeleteKey},
2734         {"WINREG_DELETEVALUE", NDR_WINREG_DELETEVALUE, api_winreg_DeleteValue},
2735         {"WINREG_ENUMKEY", NDR_WINREG_ENUMKEY, api_winreg_EnumKey},
2736         {"WINREG_ENUMVALUE", NDR_WINREG_ENUMVALUE, api_winreg_EnumValue},
2737         {"WINREG_FLUSHKEY", NDR_WINREG_FLUSHKEY, api_winreg_FlushKey},
2738         {"WINREG_GETKEYSECURITY", NDR_WINREG_GETKEYSECURITY, api_winreg_GetKeySecurity},
2739         {"WINREG_LOADKEY", NDR_WINREG_LOADKEY, api_winreg_LoadKey},
2740         {"WINREG_NOTIFYCHANGEKEYVALUE", NDR_WINREG_NOTIFYCHANGEKEYVALUE, api_winreg_NotifyChangeKeyValue},
2741         {"WINREG_OPENKEY", NDR_WINREG_OPENKEY, api_winreg_OpenKey},
2742         {"WINREG_QUERYINFOKEY", NDR_WINREG_QUERYINFOKEY, api_winreg_QueryInfoKey},
2743         {"WINREG_QUERYVALUE", NDR_WINREG_QUERYVALUE, api_winreg_QueryValue},
2744         {"WINREG_REPLACEKEY", NDR_WINREG_REPLACEKEY, api_winreg_ReplaceKey},
2745         {"WINREG_RESTOREKEY", NDR_WINREG_RESTOREKEY, api_winreg_RestoreKey},
2746         {"WINREG_SAVEKEY", NDR_WINREG_SAVEKEY, api_winreg_SaveKey},
2747         {"WINREG_SETKEYSECURITY", NDR_WINREG_SETKEYSECURITY, api_winreg_SetKeySecurity},
2748         {"WINREG_SETVALUE", NDR_WINREG_SETVALUE, api_winreg_SetValue},
2749         {"WINREG_UNLOADKEY", NDR_WINREG_UNLOADKEY, api_winreg_UnLoadKey},
2750         {"WINREG_INITIATESYSTEMSHUTDOWN", NDR_WINREG_INITIATESYSTEMSHUTDOWN, api_winreg_InitiateSystemShutdown},
2751         {"WINREG_ABORTSYSTEMSHUTDOWN", NDR_WINREG_ABORTSYSTEMSHUTDOWN, api_winreg_AbortSystemShutdown},
2752         {"WINREG_GETVERSION", NDR_WINREG_GETVERSION, api_winreg_GetVersion},
2753         {"WINREG_OPENHKCC", NDR_WINREG_OPENHKCC, api_winreg_OpenHKCC},
2754         {"WINREG_OPENHKDD", NDR_WINREG_OPENHKDD, api_winreg_OpenHKDD},
2755         {"WINREG_QUERYMULTIPLEVALUES", NDR_WINREG_QUERYMULTIPLEVALUES, api_winreg_QueryMultipleValues},
2756         {"WINREG_INITIATESYSTEMSHUTDOWNEX", NDR_WINREG_INITIATESYSTEMSHUTDOWNEX, api_winreg_InitiateSystemShutdownEx},
2757         {"WINREG_SAVEKEYEX", NDR_WINREG_SAVEKEYEX, api_winreg_SaveKeyEx},
2758         {"WINREG_OPENHKPT", NDR_WINREG_OPENHKPT, api_winreg_OpenHKPT},
2759         {"WINREG_OPENHKPN", NDR_WINREG_OPENHKPN, api_winreg_OpenHKPN},
2760         {"WINREG_QUERYMULTIPLEVALUES2", NDR_WINREG_QUERYMULTIPLEVALUES2, api_winreg_QueryMultipleValues2},
2761 };
2762
2763 void winreg_get_pipe_fns(struct api_struct **fns, int *n_fns)
2764 {
2765         *fns = api_winreg_cmds;
2766         *n_fns = sizeof(api_winreg_cmds) / sizeof(struct api_struct);
2767 }
2768
2769 NTSTATUS rpc_winreg_init(void)
2770 {
2771         return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "winreg", "winreg", &ndr_table_winreg.syntax_id, api_winreg_cmds, sizeof(api_winreg_cmds) / sizeof(struct api_struct));
2772 }