source/librpc/gen_ndr/srv_ntsvcs.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_ntsvcs.h"
   8
   9 static bool api_PNP_Disconnect(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 PNP_Disconnect *r;
  17
  18         call = &ndr_table_ntsvcs.calls[NDR_PNP_DISCONNECT];
  19
  20         r = talloc(talloc_tos(), struct PNP_Disconnect);
  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);
  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(PNP_Disconnect, r);
  45         }
  46
  47         r->out.result = _PNP_Disconnect(p, r);
  48
  49         if (p->rng_fault_state) {
  50                 talloc_free(r);
  51                 /* Return true here, srv_pipe_hnd.c will take care */
  52                 return true;
  53         }
  54
  55         if (DEBUGLEVEL >= 10) {
  56                 NDR_PRINT_OUT_DEBUG(PNP_Disconnect, r);
  57         }
  58
  59         push = ndr_push_init_ctx(r);
  60         if (push == NULL) {
  61                 talloc_free(r);
  62                 return false;
  63         }
  64
  65         ndr_err = call->ndr_push(push, NDR_OUT, r);
  66         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  67                 talloc_free(r);
  68                 return false;
  69         }
  70
  71         blob = ndr_push_blob(push);
  72         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
  73                 talloc_free(r);
  74                 return false;
  75         }
  76
  77         talloc_free(r);
  78
  79         return true;
  80 }
  81
  82 static bool api_PNP_Connect(pipes_struct *p)
  83 {
  84         const struct ndr_interface_call *call;
  85         struct ndr_pull *pull;
  86         struct ndr_push *push;
  87         enum ndr_err_code ndr_err;
  88         DATA_BLOB blob;
  89         struct PNP_Connect *r;
  90
  91         call = &ndr_table_ntsvcs.calls[NDR_PNP_CONNECT];
  92
  93         r = talloc(talloc_tos(), struct PNP_Connect);
  94         if (r == NULL) {
  95                 return false;
  96         }
  97
  98         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
  99                 talloc_free(r);
 100                 return false;
 101         }
 102
 103         pull = ndr_pull_init_blob(&blob, r);
 104         if (pull == NULL) {
 105                 talloc_free(r);
 106                 return false;
 107         }
 108
 109         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 110         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 111         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 112                 talloc_free(r);
 113                 return false;
 114         }
 115
 116         if (DEBUGLEVEL >= 10) {
 117                 NDR_PRINT_IN_DEBUG(PNP_Connect, r);
 118         }
 119
 120         r->out.result = _PNP_Connect(p, r);
 121
 122         if (p->rng_fault_state) {
 123                 talloc_free(r);
 124                 /* Return true here, srv_pipe_hnd.c will take care */
 125                 return true;
 126         }
 127
 128         if (DEBUGLEVEL >= 10) {
 129                 NDR_PRINT_OUT_DEBUG(PNP_Connect, r);
 130         }
 131
 132         push = ndr_push_init_ctx(r);
 133         if (push == NULL) {
 134                 talloc_free(r);
 135                 return false;
 136         }
 137
 138         ndr_err = call->ndr_push(push, NDR_OUT, r);
 139         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 140                 talloc_free(r);
 141                 return false;
 142         }
 143
 144         blob = ndr_push_blob(push);
 145         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 146                 talloc_free(r);
 147                 return false;
 148         }
 149
 150         talloc_free(r);
 151
 152         return true;
 153 }
 154
 155 static bool api_PNP_GetVersion(pipes_struct *p)
 156 {
 157         const struct ndr_interface_call *call;
 158         struct ndr_pull *pull;
 159         struct ndr_push *push;
 160         enum ndr_err_code ndr_err;
 161         DATA_BLOB blob;
 162         struct PNP_GetVersion *r;
 163
 164         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETVERSION];
 165
 166         r = talloc(talloc_tos(), struct PNP_GetVersion);
 167         if (r == NULL) {
 168                 return false;
 169         }
 170
 171         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 172                 talloc_free(r);
 173                 return false;
 174         }
 175
 176         pull = ndr_pull_init_blob(&blob, r);
 177         if (pull == NULL) {
 178                 talloc_free(r);
 179                 return false;
 180         }
 181
 182         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 183         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 184         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 185                 talloc_free(r);
 186                 return false;
 187         }
 188
 189         if (DEBUGLEVEL >= 10) {
 190                 NDR_PRINT_IN_DEBUG(PNP_GetVersion, r);
 191         }
 192
 193         ZERO_STRUCT(r->out);
 194         r->out.version = talloc_zero(r, uint16_t);
 195         if (r->out.version == NULL) {
 196                 talloc_free(r);
 197                 return false;
 198         }
 199
 200         r->out.result = _PNP_GetVersion(p, r);
 201
 202         if (p->rng_fault_state) {
 203                 talloc_free(r);
 204                 /* Return true here, srv_pipe_hnd.c will take care */
 205                 return true;
 206         }
 207
 208         if (DEBUGLEVEL >= 10) {
 209                 NDR_PRINT_OUT_DEBUG(PNP_GetVersion, r);
 210         }
 211
 212         push = ndr_push_init_ctx(r);
 213         if (push == NULL) {
 214                 talloc_free(r);
 215                 return false;
 216         }
 217
 218         ndr_err = call->ndr_push(push, NDR_OUT, r);
 219         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 220                 talloc_free(r);
 221                 return false;
 222         }
 223
 224         blob = ndr_push_blob(push);
 225         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 226                 talloc_free(r);
 227                 return false;
 228         }
 229
 230         talloc_free(r);
 231
 232         return true;
 233 }
 234
 235 static bool api_PNP_GetGlobalState(pipes_struct *p)
 236 {
 237         const struct ndr_interface_call *call;
 238         struct ndr_pull *pull;
 239         struct ndr_push *push;
 240         enum ndr_err_code ndr_err;
 241         DATA_BLOB blob;
 242         struct PNP_GetGlobalState *r;
 243
 244         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETGLOBALSTATE];
 245
 246         r = talloc(talloc_tos(), struct PNP_GetGlobalState);
 247         if (r == NULL) {
 248                 return false;
 249         }
 250
 251         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 252                 talloc_free(r);
 253                 return false;
 254         }
 255
 256         pull = ndr_pull_init_blob(&blob, r);
 257         if (pull == NULL) {
 258                 talloc_free(r);
 259                 return false;
 260         }
 261
 262         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 263         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 264         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 265                 talloc_free(r);
 266                 return false;
 267         }
 268
 269         if (DEBUGLEVEL >= 10) {
 270                 NDR_PRINT_IN_DEBUG(PNP_GetGlobalState, r);
 271         }
 272
 273         r->out.result = _PNP_GetGlobalState(p, r);
 274
 275         if (p->rng_fault_state) {
 276                 talloc_free(r);
 277                 /* Return true here, srv_pipe_hnd.c will take care */
 278                 return true;
 279         }
 280
 281         if (DEBUGLEVEL >= 10) {
 282                 NDR_PRINT_OUT_DEBUG(PNP_GetGlobalState, r);
 283         }
 284
 285         push = ndr_push_init_ctx(r);
 286         if (push == NULL) {
 287                 talloc_free(r);
 288                 return false;
 289         }
 290
 291         ndr_err = call->ndr_push(push, NDR_OUT, r);
 292         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 293                 talloc_free(r);
 294                 return false;
 295         }
 296
 297         blob = ndr_push_blob(push);
 298         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 299                 talloc_free(r);
 300                 return false;
 301         }
 302
 303         talloc_free(r);
 304
 305         return true;
 306 }
 307
 308 static bool api_PNP_InitDetection(pipes_struct *p)
 309 {
 310         const struct ndr_interface_call *call;
 311         struct ndr_pull *pull;
 312         struct ndr_push *push;
 313         enum ndr_err_code ndr_err;
 314         DATA_BLOB blob;
 315         struct PNP_InitDetection *r;
 316
 317         call = &ndr_table_ntsvcs.calls[NDR_PNP_INITDETECTION];
 318
 319         r = talloc(talloc_tos(), struct PNP_InitDetection);
 320         if (r == NULL) {
 321                 return false;
 322         }
 323
 324         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 325                 talloc_free(r);
 326                 return false;
 327         }
 328
 329         pull = ndr_pull_init_blob(&blob, r);
 330         if (pull == NULL) {
 331                 talloc_free(r);
 332                 return false;
 333         }
 334
 335         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 336         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 337         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 338                 talloc_free(r);
 339                 return false;
 340         }
 341
 342         if (DEBUGLEVEL >= 10) {
 343                 NDR_PRINT_IN_DEBUG(PNP_InitDetection, r);
 344         }
 345
 346         r->out.result = _PNP_InitDetection(p, r);
 347
 348         if (p->rng_fault_state) {
 349                 talloc_free(r);
 350                 /* Return true here, srv_pipe_hnd.c will take care */
 351                 return true;
 352         }
 353
 354         if (DEBUGLEVEL >= 10) {
 355                 NDR_PRINT_OUT_DEBUG(PNP_InitDetection, r);
 356         }
 357
 358         push = ndr_push_init_ctx(r);
 359         if (push == NULL) {
 360                 talloc_free(r);
 361                 return false;
 362         }
 363
 364         ndr_err = call->ndr_push(push, NDR_OUT, r);
 365         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 366                 talloc_free(r);
 367                 return false;
 368         }
 369
 370         blob = ndr_push_blob(push);
 371         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 372                 talloc_free(r);
 373                 return false;
 374         }
 375
 376         talloc_free(r);
 377
 378         return true;
 379 }
 380
 381 static bool api_PNP_ReportLogOn(pipes_struct *p)
 382 {
 383         const struct ndr_interface_call *call;
 384         struct ndr_pull *pull;
 385         struct ndr_push *push;
 386         enum ndr_err_code ndr_err;
 387         DATA_BLOB blob;
 388         struct PNP_ReportLogOn *r;
 389
 390         call = &ndr_table_ntsvcs.calls[NDR_PNP_REPORTLOGON];
 391
 392         r = talloc(talloc_tos(), struct PNP_ReportLogOn);
 393         if (r == NULL) {
 394                 return false;
 395         }
 396
 397         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 398                 talloc_free(r);
 399                 return false;
 400         }
 401
 402         pull = ndr_pull_init_blob(&blob, r);
 403         if (pull == NULL) {
 404                 talloc_free(r);
 405                 return false;
 406         }
 407
 408         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 409         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 410         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 411                 talloc_free(r);
 412                 return false;
 413         }
 414
 415         if (DEBUGLEVEL >= 10) {
 416                 NDR_PRINT_IN_DEBUG(PNP_ReportLogOn, r);
 417         }
 418
 419         r->out.result = _PNP_ReportLogOn(p, r);
 420
 421         if (p->rng_fault_state) {
 422                 talloc_free(r);
 423                 /* Return true here, srv_pipe_hnd.c will take care */
 424                 return true;
 425         }
 426
 427         if (DEBUGLEVEL >= 10) {
 428                 NDR_PRINT_OUT_DEBUG(PNP_ReportLogOn, r);
 429         }
 430
 431         push = ndr_push_init_ctx(r);
 432         if (push == NULL) {
 433                 talloc_free(r);
 434                 return false;
 435         }
 436
 437         ndr_err = call->ndr_push(push, NDR_OUT, r);
 438         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 439                 talloc_free(r);
 440                 return false;
 441         }
 442
 443         blob = ndr_push_blob(push);
 444         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 445                 talloc_free(r);
 446                 return false;
 447         }
 448
 449         talloc_free(r);
 450
 451         return true;
 452 }
 453
 454 static bool api_PNP_ValidateDeviceInstance(pipes_struct *p)
 455 {
 456         const struct ndr_interface_call *call;
 457         struct ndr_pull *pull;
 458         struct ndr_push *push;
 459         enum ndr_err_code ndr_err;
 460         DATA_BLOB blob;
 461         struct PNP_ValidateDeviceInstance *r;
 462
 463         call = &ndr_table_ntsvcs.calls[NDR_PNP_VALIDATEDEVICEINSTANCE];
 464
 465         r = talloc(talloc_tos(), struct PNP_ValidateDeviceInstance);
 466         if (r == NULL) {
 467                 return false;
 468         }
 469
 470         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 471                 talloc_free(r);
 472                 return false;
 473         }
 474
 475         pull = ndr_pull_init_blob(&blob, r);
 476         if (pull == NULL) {
 477                 talloc_free(r);
 478                 return false;
 479         }
 480
 481         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 482         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 483         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 484                 talloc_free(r);
 485                 return false;
 486         }
 487
 488         if (DEBUGLEVEL >= 10) {
 489                 NDR_PRINT_IN_DEBUG(PNP_ValidateDeviceInstance, r);
 490         }
 491
 492         r->out.result = _PNP_ValidateDeviceInstance(p, r);
 493
 494         if (p->rng_fault_state) {
 495                 talloc_free(r);
 496                 /* Return true here, srv_pipe_hnd.c will take care */
 497                 return true;
 498         }
 499
 500         if (DEBUGLEVEL >= 10) {
 501                 NDR_PRINT_OUT_DEBUG(PNP_ValidateDeviceInstance, r);
 502         }
 503
 504         push = ndr_push_init_ctx(r);
 505         if (push == NULL) {
 506                 talloc_free(r);
 507                 return false;
 508         }
 509
 510         ndr_err = call->ndr_push(push, NDR_OUT, r);
 511         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 512                 talloc_free(r);
 513                 return false;
 514         }
 515
 516         blob = ndr_push_blob(push);
 517         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 518                 talloc_free(r);
 519                 return false;
 520         }
 521
 522         talloc_free(r);
 523
 524         return true;
 525 }
 526
 527 static bool api_PNP_GetRootDeviceInstance(pipes_struct *p)
 528 {
 529         const struct ndr_interface_call *call;
 530         struct ndr_pull *pull;
 531         struct ndr_push *push;
 532         enum ndr_err_code ndr_err;
 533         DATA_BLOB blob;
 534         struct PNP_GetRootDeviceInstance *r;
 535
 536         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETROOTDEVICEINSTANCE];
 537
 538         r = talloc(talloc_tos(), struct PNP_GetRootDeviceInstance);
 539         if (r == NULL) {
 540                 return false;
 541         }
 542
 543         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 544                 talloc_free(r);
 545                 return false;
 546         }
 547
 548         pull = ndr_pull_init_blob(&blob, r);
 549         if (pull == NULL) {
 550                 talloc_free(r);
 551                 return false;
 552         }
 553
 554         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 555         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 556         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 557                 talloc_free(r);
 558                 return false;
 559         }
 560
 561         if (DEBUGLEVEL >= 10) {
 562                 NDR_PRINT_IN_DEBUG(PNP_GetRootDeviceInstance, r);
 563         }
 564
 565         r->out.result = _PNP_GetRootDeviceInstance(p, r);
 566
 567         if (p->rng_fault_state) {
 568                 talloc_free(r);
 569                 /* Return true here, srv_pipe_hnd.c will take care */
 570                 return true;
 571         }
 572
 573         if (DEBUGLEVEL >= 10) {
 574                 NDR_PRINT_OUT_DEBUG(PNP_GetRootDeviceInstance, r);
 575         }
 576
 577         push = ndr_push_init_ctx(r);
 578         if (push == NULL) {
 579                 talloc_free(r);
 580                 return false;
 581         }
 582
 583         ndr_err = call->ndr_push(push, NDR_OUT, r);
 584         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 585                 talloc_free(r);
 586                 return false;
 587         }
 588
 589         blob = ndr_push_blob(push);
 590         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 591                 talloc_free(r);
 592                 return false;
 593         }
 594
 595         talloc_free(r);
 596
 597         return true;
 598 }
 599
 600 static bool api_PNP_GetRelatedDeviceInstance(pipes_struct *p)
 601 {
 602         const struct ndr_interface_call *call;
 603         struct ndr_pull *pull;
 604         struct ndr_push *push;
 605         enum ndr_err_code ndr_err;
 606         DATA_BLOB blob;
 607         struct PNP_GetRelatedDeviceInstance *r;
 608
 609         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETRELATEDDEVICEINSTANCE];
 610
 611         r = talloc(talloc_tos(), struct PNP_GetRelatedDeviceInstance);
 612         if (r == NULL) {
 613                 return false;
 614         }
 615
 616         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 617                 talloc_free(r);
 618                 return false;
 619         }
 620
 621         pull = ndr_pull_init_blob(&blob, r);
 622         if (pull == NULL) {
 623                 talloc_free(r);
 624                 return false;
 625         }
 626
 627         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 628         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 629         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 630                 talloc_free(r);
 631                 return false;
 632         }
 633
 634         if (DEBUGLEVEL >= 10) {
 635                 NDR_PRINT_IN_DEBUG(PNP_GetRelatedDeviceInstance, r);
 636         }
 637
 638         r->out.result = _PNP_GetRelatedDeviceInstance(p, r);
 639
 640         if (p->rng_fault_state) {
 641                 talloc_free(r);
 642                 /* Return true here, srv_pipe_hnd.c will take care */
 643                 return true;
 644         }
 645
 646         if (DEBUGLEVEL >= 10) {
 647                 NDR_PRINT_OUT_DEBUG(PNP_GetRelatedDeviceInstance, r);
 648         }
 649
 650         push = ndr_push_init_ctx(r);
 651         if (push == NULL) {
 652                 talloc_free(r);
 653                 return false;
 654         }
 655
 656         ndr_err = call->ndr_push(push, NDR_OUT, r);
 657         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 658                 talloc_free(r);
 659                 return false;
 660         }
 661
 662         blob = ndr_push_blob(push);
 663         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 664                 talloc_free(r);
 665                 return false;
 666         }
 667
 668         talloc_free(r);
 669
 670         return true;
 671 }
 672
 673 static bool api_PNP_EnumerateSubKeys(pipes_struct *p)
 674 {
 675         const struct ndr_interface_call *call;
 676         struct ndr_pull *pull;
 677         struct ndr_push *push;
 678         enum ndr_err_code ndr_err;
 679         DATA_BLOB blob;
 680         struct PNP_EnumerateSubKeys *r;
 681
 682         call = &ndr_table_ntsvcs.calls[NDR_PNP_ENUMERATESUBKEYS];
 683
 684         r = talloc(talloc_tos(), struct PNP_EnumerateSubKeys);
 685         if (r == NULL) {
 686                 return false;
 687         }
 688
 689         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 690                 talloc_free(r);
 691                 return false;
 692         }
 693
 694         pull = ndr_pull_init_blob(&blob, r);
 695         if (pull == NULL) {
 696                 talloc_free(r);
 697                 return false;
 698         }
 699
 700         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 701         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 702         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 703                 talloc_free(r);
 704                 return false;
 705         }
 706
 707         if (DEBUGLEVEL >= 10) {
 708                 NDR_PRINT_IN_DEBUG(PNP_EnumerateSubKeys, r);
 709         }
 710
 711         r->out.result = _PNP_EnumerateSubKeys(p, r);
 712
 713         if (p->rng_fault_state) {
 714                 talloc_free(r);
 715                 /* Return true here, srv_pipe_hnd.c will take care */
 716                 return true;
 717         }
 718
 719         if (DEBUGLEVEL >= 10) {
 720                 NDR_PRINT_OUT_DEBUG(PNP_EnumerateSubKeys, r);
 721         }
 722
 723         push = ndr_push_init_ctx(r);
 724         if (push == NULL) {
 725                 talloc_free(r);
 726                 return false;
 727         }
 728
 729         ndr_err = call->ndr_push(push, NDR_OUT, r);
 730         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 731                 talloc_free(r);
 732                 return false;
 733         }
 734
 735         blob = ndr_push_blob(push);
 736         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 737                 talloc_free(r);
 738                 return false;
 739         }
 740
 741         talloc_free(r);
 742
 743         return true;
 744 }
 745
 746 static bool api_PNP_GetDeviceList(pipes_struct *p)
 747 {
 748         const struct ndr_interface_call *call;
 749         struct ndr_pull *pull;
 750         struct ndr_push *push;
 751         enum ndr_err_code ndr_err;
 752         DATA_BLOB blob;
 753         struct PNP_GetDeviceList *r;
 754
 755         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICELIST];
 756
 757         r = talloc(talloc_tos(), struct PNP_GetDeviceList);
 758         if (r == NULL) {
 759                 return false;
 760         }
 761
 762         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 763                 talloc_free(r);
 764                 return false;
 765         }
 766
 767         pull = ndr_pull_init_blob(&blob, r);
 768         if (pull == NULL) {
 769                 talloc_free(r);
 770                 return false;
 771         }
 772
 773         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 774         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 775         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 776                 talloc_free(r);
 777                 return false;
 778         }
 779
 780         if (DEBUGLEVEL >= 10) {
 781                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceList, r);
 782         }
 783
 784         r->out.result = _PNP_GetDeviceList(p, r);
 785
 786         if (p->rng_fault_state) {
 787                 talloc_free(r);
 788                 /* Return true here, srv_pipe_hnd.c will take care */
 789                 return true;
 790         }
 791
 792         if (DEBUGLEVEL >= 10) {
 793                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceList, r);
 794         }
 795
 796         push = ndr_push_init_ctx(r);
 797         if (push == NULL) {
 798                 talloc_free(r);
 799                 return false;
 800         }
 801
 802         ndr_err = call->ndr_push(push, NDR_OUT, r);
 803         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 804                 talloc_free(r);
 805                 return false;
 806         }
 807
 808         blob = ndr_push_blob(push);
 809         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 810                 talloc_free(r);
 811                 return false;
 812         }
 813
 814         talloc_free(r);
 815
 816         return true;
 817 }
 818
 819 static bool api_PNP_GetDeviceListSize(pipes_struct *p)
 820 {
 821         const struct ndr_interface_call *call;
 822         struct ndr_pull *pull;
 823         struct ndr_push *push;
 824         enum ndr_err_code ndr_err;
 825         DATA_BLOB blob;
 826         struct PNP_GetDeviceListSize *r;
 827
 828         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICELISTSIZE];
 829
 830         r = talloc(talloc_tos(), struct PNP_GetDeviceListSize);
 831         if (r == NULL) {
 832                 return false;
 833         }
 834
 835         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 836                 talloc_free(r);
 837                 return false;
 838         }
 839
 840         pull = ndr_pull_init_blob(&blob, r);
 841         if (pull == NULL) {
 842                 talloc_free(r);
 843                 return false;
 844         }
 845
 846         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 847         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 848         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 849                 talloc_free(r);
 850                 return false;
 851         }
 852
 853         if (DEBUGLEVEL >= 10) {
 854                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceListSize, r);
 855         }
 856
 857         ZERO_STRUCT(r->out);
 858         r->out.size = talloc_zero(r, uint32_t);
 859         if (r->out.size == NULL) {
 860                 talloc_free(r);
 861                 return false;
 862         }
 863
 864         r->out.result = _PNP_GetDeviceListSize(p, r);
 865
 866         if (p->rng_fault_state) {
 867                 talloc_free(r);
 868                 /* Return true here, srv_pipe_hnd.c will take care */
 869                 return true;
 870         }
 871
 872         if (DEBUGLEVEL >= 10) {
 873                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceListSize, r);
 874         }
 875
 876         push = ndr_push_init_ctx(r);
 877         if (push == NULL) {
 878                 talloc_free(r);
 879                 return false;
 880         }
 881
 882         ndr_err = call->ndr_push(push, NDR_OUT, r);
 883         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 884                 talloc_free(r);
 885                 return false;
 886         }
 887
 888         blob = ndr_push_blob(push);
 889         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 890                 talloc_free(r);
 891                 return false;
 892         }
 893
 894         talloc_free(r);
 895
 896         return true;
 897 }
 898
 899 static bool api_PNP_GetDepth(pipes_struct *p)
 900 {
 901         const struct ndr_interface_call *call;
 902         struct ndr_pull *pull;
 903         struct ndr_push *push;
 904         enum ndr_err_code ndr_err;
 905         DATA_BLOB blob;
 906         struct PNP_GetDepth *r;
 907
 908         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEPTH];
 909
 910         r = talloc(talloc_tos(), struct PNP_GetDepth);
 911         if (r == NULL) {
 912                 return false;
 913         }
 914
 915         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 916                 talloc_free(r);
 917                 return false;
 918         }
 919
 920         pull = ndr_pull_init_blob(&blob, r);
 921         if (pull == NULL) {
 922                 talloc_free(r);
 923                 return false;
 924         }
 925
 926         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 927         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 928         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 929                 talloc_free(r);
 930                 return false;
 931         }
 932
 933         if (DEBUGLEVEL >= 10) {
 934                 NDR_PRINT_IN_DEBUG(PNP_GetDepth, r);
 935         }
 936
 937         r->out.result = _PNP_GetDepth(p, r);
 938
 939         if (p->rng_fault_state) {
 940                 talloc_free(r);
 941                 /* Return true here, srv_pipe_hnd.c will take care */
 942                 return true;
 943         }
 944
 945         if (DEBUGLEVEL >= 10) {
 946                 NDR_PRINT_OUT_DEBUG(PNP_GetDepth, r);
 947         }
 948
 949         push = ndr_push_init_ctx(r);
 950         if (push == NULL) {
 951                 talloc_free(r);
 952                 return false;
 953         }
 954
 955         ndr_err = call->ndr_push(push, NDR_OUT, r);
 956         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 957                 talloc_free(r);
 958                 return false;
 959         }
 960
 961         blob = ndr_push_blob(push);
 962         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 963                 talloc_free(r);
 964                 return false;
 965         }
 966
 967         talloc_free(r);
 968
 969         return true;
 970 }
 971
 972 static bool api_PNP_GetDeviceRegProp(pipes_struct *p)
 973 {
 974         const struct ndr_interface_call *call;
 975         struct ndr_pull *pull;
 976         struct ndr_push *push;
 977         enum ndr_err_code ndr_err;
 978         DATA_BLOB blob;
 979         struct PNP_GetDeviceRegProp *r;
 980
 981         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICEREGPROP];
 982
 983         r = talloc(talloc_tos(), struct PNP_GetDeviceRegProp);
 984         if (r == NULL) {
 985                 return false;
 986         }
 987
 988         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 989                 talloc_free(r);
 990                 return false;
 991         }
 992
 993         pull = ndr_pull_init_blob(&blob, r);
 994         if (pull == NULL) {
 995                 talloc_free(r);
 996                 return false;
 997         }
 998
 999         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1000         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1001         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1002                 talloc_free(r);
1003                 return false;
1004         }
1005
1006         if (DEBUGLEVEL >= 10) {
1007                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceRegProp, r);
1008         }
1009
1010         r->out.result = _PNP_GetDeviceRegProp(p, r);
1011
1012         if (p->rng_fault_state) {
1013                 talloc_free(r);
1014                 /* Return true here, srv_pipe_hnd.c will take care */
1015                 return true;
1016         }
1017
1018         if (DEBUGLEVEL >= 10) {
1019                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceRegProp, r);
1020         }
1021
1022         push = ndr_push_init_ctx(r);
1023         if (push == NULL) {
1024                 talloc_free(r);
1025                 return false;
1026         }
1027
1028         ndr_err = call->ndr_push(push, NDR_OUT, r);
1029         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1030                 talloc_free(r);
1031                 return false;
1032         }
1033
1034         blob = ndr_push_blob(push);
1035         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1036                 talloc_free(r);
1037                 return false;
1038         }
1039
1040         talloc_free(r);
1041
1042         return true;
1043 }
1044
1045 static bool api_PNP_SetDeviceRegProp(pipes_struct *p)
1046 {
1047         const struct ndr_interface_call *call;
1048         struct ndr_pull *pull;
1049         struct ndr_push *push;
1050         enum ndr_err_code ndr_err;
1051         DATA_BLOB blob;
1052         struct PNP_SetDeviceRegProp *r;
1053
1054         call = &ndr_table_ntsvcs.calls[NDR_PNP_SETDEVICEREGPROP];
1055
1056         r = talloc(talloc_tos(), struct PNP_SetDeviceRegProp);
1057         if (r == NULL) {
1058                 return false;
1059         }
1060
1061         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1062                 talloc_free(r);
1063                 return false;
1064         }
1065
1066         pull = ndr_pull_init_blob(&blob, r);
1067         if (pull == NULL) {
1068                 talloc_free(r);
1069                 return false;
1070         }
1071
1072         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1073         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1074         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1075                 talloc_free(r);
1076                 return false;
1077         }
1078
1079         if (DEBUGLEVEL >= 10) {
1080                 NDR_PRINT_IN_DEBUG(PNP_SetDeviceRegProp, r);
1081         }
1082
1083         r->out.result = _PNP_SetDeviceRegProp(p, r);
1084
1085         if (p->rng_fault_state) {
1086                 talloc_free(r);
1087                 /* Return true here, srv_pipe_hnd.c will take care */
1088                 return true;
1089         }
1090
1091         if (DEBUGLEVEL >= 10) {
1092                 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceRegProp, r);
1093         }
1094
1095         push = ndr_push_init_ctx(r);
1096         if (push == NULL) {
1097                 talloc_free(r);
1098                 return false;
1099         }
1100
1101         ndr_err = call->ndr_push(push, NDR_OUT, r);
1102         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1103                 talloc_free(r);
1104                 return false;
1105         }
1106
1107         blob = ndr_push_blob(push);
1108         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1109                 talloc_free(r);
1110                 return false;
1111         }
1112
1113         talloc_free(r);
1114
1115         return true;
1116 }
1117
1118 static bool api_PNP_GetClassInstance(pipes_struct *p)
1119 {
1120         const struct ndr_interface_call *call;
1121         struct ndr_pull *pull;
1122         struct ndr_push *push;
1123         enum ndr_err_code ndr_err;
1124         DATA_BLOB blob;
1125         struct PNP_GetClassInstance *r;
1126
1127         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSINSTANCE];
1128
1129         r = talloc(talloc_tos(), struct PNP_GetClassInstance);
1130         if (r == NULL) {
1131                 return false;
1132         }
1133
1134         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1135                 talloc_free(r);
1136                 return false;
1137         }
1138
1139         pull = ndr_pull_init_blob(&blob, r);
1140         if (pull == NULL) {
1141                 talloc_free(r);
1142                 return false;
1143         }
1144
1145         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1146         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1147         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1148                 talloc_free(r);
1149                 return false;
1150         }
1151
1152         if (DEBUGLEVEL >= 10) {
1153                 NDR_PRINT_IN_DEBUG(PNP_GetClassInstance, r);
1154         }
1155
1156         r->out.result = _PNP_GetClassInstance(p, r);
1157
1158         if (p->rng_fault_state) {
1159                 talloc_free(r);
1160                 /* Return true here, srv_pipe_hnd.c will take care */
1161                 return true;
1162         }
1163
1164         if (DEBUGLEVEL >= 10) {
1165                 NDR_PRINT_OUT_DEBUG(PNP_GetClassInstance, r);
1166         }
1167
1168         push = ndr_push_init_ctx(r);
1169         if (push == NULL) {
1170                 talloc_free(r);
1171                 return false;
1172         }
1173
1174         ndr_err = call->ndr_push(push, NDR_OUT, r);
1175         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1176                 talloc_free(r);
1177                 return false;
1178         }
1179
1180         blob = ndr_push_blob(push);
1181         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1182                 talloc_free(r);
1183                 return false;
1184         }
1185
1186         talloc_free(r);
1187
1188         return true;
1189 }
1190
1191 static bool api_PNP_CreateKey(pipes_struct *p)
1192 {
1193         const struct ndr_interface_call *call;
1194         struct ndr_pull *pull;
1195         struct ndr_push *push;
1196         enum ndr_err_code ndr_err;
1197         DATA_BLOB blob;
1198         struct PNP_CreateKey *r;
1199
1200         call = &ndr_table_ntsvcs.calls[NDR_PNP_CREATEKEY];
1201
1202         r = talloc(talloc_tos(), struct PNP_CreateKey);
1203         if (r == NULL) {
1204                 return false;
1205         }
1206
1207         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1208                 talloc_free(r);
1209                 return false;
1210         }
1211
1212         pull = ndr_pull_init_blob(&blob, r);
1213         if (pull == NULL) {
1214                 talloc_free(r);
1215                 return false;
1216         }
1217
1218         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1219         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1220         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1221                 talloc_free(r);
1222                 return false;
1223         }
1224
1225         if (DEBUGLEVEL >= 10) {
1226                 NDR_PRINT_IN_DEBUG(PNP_CreateKey, r);
1227         }
1228
1229         r->out.result = _PNP_CreateKey(p, r);
1230
1231         if (p->rng_fault_state) {
1232                 talloc_free(r);
1233                 /* Return true here, srv_pipe_hnd.c will take care */
1234                 return true;
1235         }
1236
1237         if (DEBUGLEVEL >= 10) {
1238                 NDR_PRINT_OUT_DEBUG(PNP_CreateKey, r);
1239         }
1240
1241         push = ndr_push_init_ctx(r);
1242         if (push == NULL) {
1243                 talloc_free(r);
1244                 return false;
1245         }
1246
1247         ndr_err = call->ndr_push(push, NDR_OUT, r);
1248         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1249                 talloc_free(r);
1250                 return false;
1251         }
1252
1253         blob = ndr_push_blob(push);
1254         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1255                 talloc_free(r);
1256                 return false;
1257         }
1258
1259         talloc_free(r);
1260
1261         return true;
1262 }
1263
1264 static bool api_PNP_DeleteRegistryKey(pipes_struct *p)
1265 {
1266         const struct ndr_interface_call *call;
1267         struct ndr_pull *pull;
1268         struct ndr_push *push;
1269         enum ndr_err_code ndr_err;
1270         DATA_BLOB blob;
1271         struct PNP_DeleteRegistryKey *r;
1272
1273         call = &ndr_table_ntsvcs.calls[NDR_PNP_DELETEREGISTRYKEY];
1274
1275         r = talloc(talloc_tos(), struct PNP_DeleteRegistryKey);
1276         if (r == NULL) {
1277                 return false;
1278         }
1279
1280         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1281                 talloc_free(r);
1282                 return false;
1283         }
1284
1285         pull = ndr_pull_init_blob(&blob, r);
1286         if (pull == NULL) {
1287                 talloc_free(r);
1288                 return false;
1289         }
1290
1291         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1292         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1293         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1294                 talloc_free(r);
1295                 return false;
1296         }
1297
1298         if (DEBUGLEVEL >= 10) {
1299                 NDR_PRINT_IN_DEBUG(PNP_DeleteRegistryKey, r);
1300         }
1301
1302         r->out.result = _PNP_DeleteRegistryKey(p, r);
1303
1304         if (p->rng_fault_state) {
1305                 talloc_free(r);
1306                 /* Return true here, srv_pipe_hnd.c will take care */
1307                 return true;
1308         }
1309
1310         if (DEBUGLEVEL >= 10) {
1311                 NDR_PRINT_OUT_DEBUG(PNP_DeleteRegistryKey, r);
1312         }
1313
1314         push = ndr_push_init_ctx(r);
1315         if (push == NULL) {
1316                 talloc_free(r);
1317                 return false;
1318         }
1319
1320         ndr_err = call->ndr_push(push, NDR_OUT, r);
1321         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1322                 talloc_free(r);
1323                 return false;
1324         }
1325
1326         blob = ndr_push_blob(push);
1327         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1328                 talloc_free(r);
1329                 return false;
1330         }
1331
1332         talloc_free(r);
1333
1334         return true;
1335 }
1336
1337 static bool api_PNP_GetClassCount(pipes_struct *p)
1338 {
1339         const struct ndr_interface_call *call;
1340         struct ndr_pull *pull;
1341         struct ndr_push *push;
1342         enum ndr_err_code ndr_err;
1343         DATA_BLOB blob;
1344         struct PNP_GetClassCount *r;
1345
1346         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSCOUNT];
1347
1348         r = talloc(talloc_tos(), struct PNP_GetClassCount);
1349         if (r == NULL) {
1350                 return false;
1351         }
1352
1353         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1354                 talloc_free(r);
1355                 return false;
1356         }
1357
1358         pull = ndr_pull_init_blob(&blob, r);
1359         if (pull == NULL) {
1360                 talloc_free(r);
1361                 return false;
1362         }
1363
1364         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1365         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1366         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1367                 talloc_free(r);
1368                 return false;
1369         }
1370
1371         if (DEBUGLEVEL >= 10) {
1372                 NDR_PRINT_IN_DEBUG(PNP_GetClassCount, r);
1373         }
1374
1375         r->out.result = _PNP_GetClassCount(p, r);
1376
1377         if (p->rng_fault_state) {
1378                 talloc_free(r);
1379                 /* Return true here, srv_pipe_hnd.c will take care */
1380                 return true;
1381         }
1382
1383         if (DEBUGLEVEL >= 10) {
1384                 NDR_PRINT_OUT_DEBUG(PNP_GetClassCount, r);
1385         }
1386
1387         push = ndr_push_init_ctx(r);
1388         if (push == NULL) {
1389                 talloc_free(r);
1390                 return false;
1391         }
1392
1393         ndr_err = call->ndr_push(push, NDR_OUT, r);
1394         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1395                 talloc_free(r);
1396                 return false;
1397         }
1398
1399         blob = ndr_push_blob(push);
1400         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1401                 talloc_free(r);
1402                 return false;
1403         }
1404
1405         talloc_free(r);
1406
1407         return true;
1408 }
1409
1410 static bool api_PNP_GetClassName(pipes_struct *p)
1411 {
1412         const struct ndr_interface_call *call;
1413         struct ndr_pull *pull;
1414         struct ndr_push *push;
1415         enum ndr_err_code ndr_err;
1416         DATA_BLOB blob;
1417         struct PNP_GetClassName *r;
1418
1419         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSNAME];
1420
1421         r = talloc(talloc_tos(), struct PNP_GetClassName);
1422         if (r == NULL) {
1423                 return false;
1424         }
1425
1426         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1427                 talloc_free(r);
1428                 return false;
1429         }
1430
1431         pull = ndr_pull_init_blob(&blob, r);
1432         if (pull == NULL) {
1433                 talloc_free(r);
1434                 return false;
1435         }
1436
1437         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1438         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1439         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1440                 talloc_free(r);
1441                 return false;
1442         }
1443
1444         if (DEBUGLEVEL >= 10) {
1445                 NDR_PRINT_IN_DEBUG(PNP_GetClassName, r);
1446         }
1447
1448         r->out.result = _PNP_GetClassName(p, r);
1449
1450         if (p->rng_fault_state) {
1451                 talloc_free(r);
1452                 /* Return true here, srv_pipe_hnd.c will take care */
1453                 return true;
1454         }
1455
1456         if (DEBUGLEVEL >= 10) {
1457                 NDR_PRINT_OUT_DEBUG(PNP_GetClassName, r);
1458         }
1459
1460         push = ndr_push_init_ctx(r);
1461         if (push == NULL) {
1462                 talloc_free(r);
1463                 return false;
1464         }
1465
1466         ndr_err = call->ndr_push(push, NDR_OUT, r);
1467         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1468                 talloc_free(r);
1469                 return false;
1470         }
1471
1472         blob = ndr_push_blob(push);
1473         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1474                 talloc_free(r);
1475                 return false;
1476         }
1477
1478         talloc_free(r);
1479
1480         return true;
1481 }
1482
1483 static bool api_PNP_DeleteClassKey(pipes_struct *p)
1484 {
1485         const struct ndr_interface_call *call;
1486         struct ndr_pull *pull;
1487         struct ndr_push *push;
1488         enum ndr_err_code ndr_err;
1489         DATA_BLOB blob;
1490         struct PNP_DeleteClassKey *r;
1491
1492         call = &ndr_table_ntsvcs.calls[NDR_PNP_DELETECLASSKEY];
1493
1494         r = talloc(talloc_tos(), struct PNP_DeleteClassKey);
1495         if (r == NULL) {
1496                 return false;
1497         }
1498
1499         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1500                 talloc_free(r);
1501                 return false;
1502         }
1503
1504         pull = ndr_pull_init_blob(&blob, r);
1505         if (pull == NULL) {
1506                 talloc_free(r);
1507                 return false;
1508         }
1509
1510         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1511         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1512         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1513                 talloc_free(r);
1514                 return false;
1515         }
1516
1517         if (DEBUGLEVEL >= 10) {
1518                 NDR_PRINT_IN_DEBUG(PNP_DeleteClassKey, r);
1519         }
1520
1521         r->out.result = _PNP_DeleteClassKey(p, r);
1522
1523         if (p->rng_fault_state) {
1524                 talloc_free(r);
1525                 /* Return true here, srv_pipe_hnd.c will take care */
1526                 return true;
1527         }
1528
1529         if (DEBUGLEVEL >= 10) {
1530                 NDR_PRINT_OUT_DEBUG(PNP_DeleteClassKey, r);
1531         }
1532
1533         push = ndr_push_init_ctx(r);
1534         if (push == NULL) {
1535                 talloc_free(r);
1536                 return false;
1537         }
1538
1539         ndr_err = call->ndr_push(push, NDR_OUT, r);
1540         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1541                 talloc_free(r);
1542                 return false;
1543         }
1544
1545         blob = ndr_push_blob(push);
1546         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1547                 talloc_free(r);
1548                 return false;
1549         }
1550
1551         talloc_free(r);
1552
1553         return true;
1554 }
1555
1556 static bool api_PNP_GetInterfaceDeviceAlias(pipes_struct *p)
1557 {
1558         const struct ndr_interface_call *call;
1559         struct ndr_pull *pull;
1560         struct ndr_push *push;
1561         enum ndr_err_code ndr_err;
1562         DATA_BLOB blob;
1563         struct PNP_GetInterfaceDeviceAlias *r;
1564
1565         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETINTERFACEDEVICEALIAS];
1566
1567         r = talloc(talloc_tos(), struct PNP_GetInterfaceDeviceAlias);
1568         if (r == NULL) {
1569                 return false;
1570         }
1571
1572         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1573                 talloc_free(r);
1574                 return false;
1575         }
1576
1577         pull = ndr_pull_init_blob(&blob, r);
1578         if (pull == NULL) {
1579                 talloc_free(r);
1580                 return false;
1581         }
1582
1583         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1584         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1585         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1586                 talloc_free(r);
1587                 return false;
1588         }
1589
1590         if (DEBUGLEVEL >= 10) {
1591                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceAlias, r);
1592         }
1593
1594         r->out.result = _PNP_GetInterfaceDeviceAlias(p, r);
1595
1596         if (p->rng_fault_state) {
1597                 talloc_free(r);
1598                 /* Return true here, srv_pipe_hnd.c will take care */
1599                 return true;
1600         }
1601
1602         if (DEBUGLEVEL >= 10) {
1603                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceAlias, r);
1604         }
1605
1606         push = ndr_push_init_ctx(r);
1607         if (push == NULL) {
1608                 talloc_free(r);
1609                 return false;
1610         }
1611
1612         ndr_err = call->ndr_push(push, NDR_OUT, r);
1613         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1614                 talloc_free(r);
1615                 return false;
1616         }
1617
1618         blob = ndr_push_blob(push);
1619         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1620                 talloc_free(r);
1621                 return false;
1622         }
1623
1624         talloc_free(r);
1625
1626         return true;
1627 }
1628
1629 static bool api_PNP_GetInterfaceDeviceList(pipes_struct *p)
1630 {
1631         const struct ndr_interface_call *call;
1632         struct ndr_pull *pull;
1633         struct ndr_push *push;
1634         enum ndr_err_code ndr_err;
1635         DATA_BLOB blob;
1636         struct PNP_GetInterfaceDeviceList *r;
1637
1638         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETINTERFACEDEVICELIST];
1639
1640         r = talloc(talloc_tos(), struct PNP_GetInterfaceDeviceList);
1641         if (r == NULL) {
1642                 return false;
1643         }
1644
1645         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1646                 talloc_free(r);
1647                 return false;
1648         }
1649
1650         pull = ndr_pull_init_blob(&blob, r);
1651         if (pull == NULL) {
1652                 talloc_free(r);
1653                 return false;
1654         }
1655
1656         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1657         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1658         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1659                 talloc_free(r);
1660                 return false;
1661         }
1662
1663         if (DEBUGLEVEL >= 10) {
1664                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceList, r);
1665         }
1666
1667         r->out.result = _PNP_GetInterfaceDeviceList(p, r);
1668
1669         if (p->rng_fault_state) {
1670                 talloc_free(r);
1671                 /* Return true here, srv_pipe_hnd.c will take care */
1672                 return true;
1673         }
1674
1675         if (DEBUGLEVEL >= 10) {
1676                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceList, r);
1677         }
1678
1679         push = ndr_push_init_ctx(r);
1680         if (push == NULL) {
1681                 talloc_free(r);
1682                 return false;
1683         }
1684
1685         ndr_err = call->ndr_push(push, NDR_OUT, r);
1686         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1687                 talloc_free(r);
1688                 return false;
1689         }
1690
1691         blob = ndr_push_blob(push);
1692         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1693                 talloc_free(r);
1694                 return false;
1695         }
1696
1697         talloc_free(r);
1698
1699         return true;
1700 }
1701
1702 static bool api_PNP_GetInterfaceDeviceListSize(pipes_struct *p)
1703 {
1704         const struct ndr_interface_call *call;
1705         struct ndr_pull *pull;
1706         struct ndr_push *push;
1707         enum ndr_err_code ndr_err;
1708         DATA_BLOB blob;
1709         struct PNP_GetInterfaceDeviceListSize *r;
1710
1711         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETINTERFACEDEVICELISTSIZE];
1712
1713         r = talloc(talloc_tos(), struct PNP_GetInterfaceDeviceListSize);
1714         if (r == NULL) {
1715                 return false;
1716         }
1717
1718         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1719                 talloc_free(r);
1720                 return false;
1721         }
1722
1723         pull = ndr_pull_init_blob(&blob, r);
1724         if (pull == NULL) {
1725                 talloc_free(r);
1726                 return false;
1727         }
1728
1729         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1730         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1731         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1732                 talloc_free(r);
1733                 return false;
1734         }
1735
1736         if (DEBUGLEVEL >= 10) {
1737                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceListSize, r);
1738         }
1739
1740         r->out.result = _PNP_GetInterfaceDeviceListSize(p, r);
1741
1742         if (p->rng_fault_state) {
1743                 talloc_free(r);
1744                 /* Return true here, srv_pipe_hnd.c will take care */
1745                 return true;
1746         }
1747
1748         if (DEBUGLEVEL >= 10) {
1749                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceListSize, r);
1750         }
1751
1752         push = ndr_push_init_ctx(r);
1753         if (push == NULL) {
1754                 talloc_free(r);
1755                 return false;
1756         }
1757
1758         ndr_err = call->ndr_push(push, NDR_OUT, r);
1759         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1760                 talloc_free(r);
1761                 return false;
1762         }
1763
1764         blob = ndr_push_blob(push);
1765         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1766                 talloc_free(r);
1767                 return false;
1768         }
1769
1770         talloc_free(r);
1771
1772         return true;
1773 }
1774
1775 static bool api_PNP_RegisterDeviceClassAssociation(pipes_struct *p)
1776 {
1777         const struct ndr_interface_call *call;
1778         struct ndr_pull *pull;
1779         struct ndr_push *push;
1780         enum ndr_err_code ndr_err;
1781         DATA_BLOB blob;
1782         struct PNP_RegisterDeviceClassAssociation *r;
1783
1784         call = &ndr_table_ntsvcs.calls[NDR_PNP_REGISTERDEVICECLASSASSOCIATION];
1785
1786         r = talloc(talloc_tos(), struct PNP_RegisterDeviceClassAssociation);
1787         if (r == NULL) {
1788                 return false;
1789         }
1790
1791         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1792                 talloc_free(r);
1793                 return false;
1794         }
1795
1796         pull = ndr_pull_init_blob(&blob, r);
1797         if (pull == NULL) {
1798                 talloc_free(r);
1799                 return false;
1800         }
1801
1802         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1803         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1804         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1805                 talloc_free(r);
1806                 return false;
1807         }
1808
1809         if (DEBUGLEVEL >= 10) {
1810                 NDR_PRINT_IN_DEBUG(PNP_RegisterDeviceClassAssociation, r);
1811         }
1812
1813         r->out.result = _PNP_RegisterDeviceClassAssociation(p, r);
1814
1815         if (p->rng_fault_state) {
1816                 talloc_free(r);
1817                 /* Return true here, srv_pipe_hnd.c will take care */
1818                 return true;
1819         }
1820
1821         if (DEBUGLEVEL >= 10) {
1822                 NDR_PRINT_OUT_DEBUG(PNP_RegisterDeviceClassAssociation, r);
1823         }
1824
1825         push = ndr_push_init_ctx(r);
1826         if (push == NULL) {
1827                 talloc_free(r);
1828                 return false;
1829         }
1830
1831         ndr_err = call->ndr_push(push, NDR_OUT, r);
1832         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1833                 talloc_free(r);
1834                 return false;
1835         }
1836
1837         blob = ndr_push_blob(push);
1838         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1839                 talloc_free(r);
1840                 return false;
1841         }
1842
1843         talloc_free(r);
1844
1845         return true;
1846 }
1847
1848 static bool api_PNP_UnregisterDeviceClassAssociation(pipes_struct *p)
1849 {
1850         const struct ndr_interface_call *call;
1851         struct ndr_pull *pull;
1852         struct ndr_push *push;
1853         enum ndr_err_code ndr_err;
1854         DATA_BLOB blob;
1855         struct PNP_UnregisterDeviceClassAssociation *r;
1856
1857         call = &ndr_table_ntsvcs.calls[NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION];
1858
1859         r = talloc(talloc_tos(), struct PNP_UnregisterDeviceClassAssociation);
1860         if (r == NULL) {
1861                 return false;
1862         }
1863
1864         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1865                 talloc_free(r);
1866                 return false;
1867         }
1868
1869         pull = ndr_pull_init_blob(&blob, r);
1870         if (pull == NULL) {
1871                 talloc_free(r);
1872                 return false;
1873         }
1874
1875         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1876         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1877         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1878                 talloc_free(r);
1879                 return false;
1880         }
1881
1882         if (DEBUGLEVEL >= 10) {
1883                 NDR_PRINT_IN_DEBUG(PNP_UnregisterDeviceClassAssociation, r);
1884         }
1885
1886         r->out.result = _PNP_UnregisterDeviceClassAssociation(p, r);
1887
1888         if (p->rng_fault_state) {
1889                 talloc_free(r);
1890                 /* Return true here, srv_pipe_hnd.c will take care */
1891                 return true;
1892         }
1893
1894         if (DEBUGLEVEL >= 10) {
1895                 NDR_PRINT_OUT_DEBUG(PNP_UnregisterDeviceClassAssociation, r);
1896         }
1897
1898         push = ndr_push_init_ctx(r);
1899         if (push == NULL) {
1900                 talloc_free(r);
1901                 return false;
1902         }
1903
1904         ndr_err = call->ndr_push(push, NDR_OUT, r);
1905         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1906                 talloc_free(r);
1907                 return false;
1908         }
1909
1910         blob = ndr_push_blob(push);
1911         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1912                 talloc_free(r);
1913                 return false;
1914         }
1915
1916         talloc_free(r);
1917
1918         return true;
1919 }
1920
1921 static bool api_PNP_GetClassRegProp(pipes_struct *p)
1922 {
1923         const struct ndr_interface_call *call;
1924         struct ndr_pull *pull;
1925         struct ndr_push *push;
1926         enum ndr_err_code ndr_err;
1927         DATA_BLOB blob;
1928         struct PNP_GetClassRegProp *r;
1929
1930         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSREGPROP];
1931
1932         r = talloc(talloc_tos(), struct PNP_GetClassRegProp);
1933         if (r == NULL) {
1934                 return false;
1935         }
1936
1937         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1938                 talloc_free(r);
1939                 return false;
1940         }
1941
1942         pull = ndr_pull_init_blob(&blob, r);
1943         if (pull == NULL) {
1944                 talloc_free(r);
1945                 return false;
1946         }
1947
1948         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1949         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1950         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1951                 talloc_free(r);
1952                 return false;
1953         }
1954
1955         if (DEBUGLEVEL >= 10) {
1956                 NDR_PRINT_IN_DEBUG(PNP_GetClassRegProp, r);
1957         }
1958
1959         r->out.result = _PNP_GetClassRegProp(p, r);
1960
1961         if (p->rng_fault_state) {
1962                 talloc_free(r);
1963                 /* Return true here, srv_pipe_hnd.c will take care */
1964                 return true;
1965         }
1966
1967         if (DEBUGLEVEL >= 10) {
1968                 NDR_PRINT_OUT_DEBUG(PNP_GetClassRegProp, r);
1969         }
1970
1971         push = ndr_push_init_ctx(r);
1972         if (push == NULL) {
1973                 talloc_free(r);
1974                 return false;
1975         }
1976
1977         ndr_err = call->ndr_push(push, NDR_OUT, r);
1978         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1979                 talloc_free(r);
1980                 return false;
1981         }
1982
1983         blob = ndr_push_blob(push);
1984         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1985                 talloc_free(r);
1986                 return false;
1987         }
1988
1989         talloc_free(r);
1990
1991         return true;
1992 }
1993
1994 static bool api_PNP_SetClassRegProp(pipes_struct *p)
1995 {
1996         const struct ndr_interface_call *call;
1997         struct ndr_pull *pull;
1998         struct ndr_push *push;
1999         enum ndr_err_code ndr_err;
2000         DATA_BLOB blob;
2001         struct PNP_SetClassRegProp *r;
2002
2003         call = &ndr_table_ntsvcs.calls[NDR_PNP_SETCLASSREGPROP];
2004
2005         r = talloc(talloc_tos(), struct PNP_SetClassRegProp);
2006         if (r == NULL) {
2007                 return false;
2008         }
2009
2010         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2011                 talloc_free(r);
2012                 return false;
2013         }
2014
2015         pull = ndr_pull_init_blob(&blob, r);
2016         if (pull == NULL) {
2017                 talloc_free(r);
2018                 return false;
2019         }
2020
2021         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2022         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2023         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2024                 talloc_free(r);
2025                 return false;
2026         }
2027
2028         if (DEBUGLEVEL >= 10) {
2029                 NDR_PRINT_IN_DEBUG(PNP_SetClassRegProp, r);
2030         }
2031
2032         r->out.result = _PNP_SetClassRegProp(p, r);
2033
2034         if (p->rng_fault_state) {
2035                 talloc_free(r);
2036                 /* Return true here, srv_pipe_hnd.c will take care */
2037                 return true;
2038         }
2039
2040         if (DEBUGLEVEL >= 10) {
2041                 NDR_PRINT_OUT_DEBUG(PNP_SetClassRegProp, r);
2042         }
2043
2044         push = ndr_push_init_ctx(r);
2045         if (push == NULL) {
2046                 talloc_free(r);
2047                 return false;
2048         }
2049
2050         ndr_err = call->ndr_push(push, NDR_OUT, r);
2051         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2052                 talloc_free(r);
2053                 return false;
2054         }
2055
2056         blob = ndr_push_blob(push);
2057         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2058                 talloc_free(r);
2059                 return false;
2060         }
2061
2062         talloc_free(r);
2063
2064         return true;
2065 }
2066
2067 static bool api_PNP_CreateDevInst(pipes_struct *p)
2068 {
2069         const struct ndr_interface_call *call;
2070         struct ndr_pull *pull;
2071         struct ndr_push *push;
2072         enum ndr_err_code ndr_err;
2073         DATA_BLOB blob;
2074         struct PNP_CreateDevInst *r;
2075
2076         call = &ndr_table_ntsvcs.calls[NDR_PNP_CREATEDEVINST];
2077
2078         r = talloc(talloc_tos(), struct PNP_CreateDevInst);
2079         if (r == NULL) {
2080                 return false;
2081         }
2082
2083         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2084                 talloc_free(r);
2085                 return false;
2086         }
2087
2088         pull = ndr_pull_init_blob(&blob, r);
2089         if (pull == NULL) {
2090                 talloc_free(r);
2091                 return false;
2092         }
2093
2094         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2095         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2096         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2097                 talloc_free(r);
2098                 return false;
2099         }
2100
2101         if (DEBUGLEVEL >= 10) {
2102                 NDR_PRINT_IN_DEBUG(PNP_CreateDevInst, r);
2103         }
2104
2105         r->out.result = _PNP_CreateDevInst(p, r);
2106
2107         if (p->rng_fault_state) {
2108                 talloc_free(r);
2109                 /* Return true here, srv_pipe_hnd.c will take care */
2110                 return true;
2111         }
2112
2113         if (DEBUGLEVEL >= 10) {
2114                 NDR_PRINT_OUT_DEBUG(PNP_CreateDevInst, r);
2115         }
2116
2117         push = ndr_push_init_ctx(r);
2118         if (push == NULL) {
2119                 talloc_free(r);
2120                 return false;
2121         }
2122
2123         ndr_err = call->ndr_push(push, NDR_OUT, r);
2124         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2125                 talloc_free(r);
2126                 return false;
2127         }
2128
2129         blob = ndr_push_blob(push);
2130         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2131                 talloc_free(r);
2132                 return false;
2133         }
2134
2135         talloc_free(r);
2136
2137         return true;
2138 }
2139
2140 static bool api_PNP_DeviceInstanceAction(pipes_struct *p)
2141 {
2142         const struct ndr_interface_call *call;
2143         struct ndr_pull *pull;
2144         struct ndr_push *push;
2145         enum ndr_err_code ndr_err;
2146         DATA_BLOB blob;
2147         struct PNP_DeviceInstanceAction *r;
2148
2149         call = &ndr_table_ntsvcs.calls[NDR_PNP_DEVICEINSTANCEACTION];
2150
2151         r = talloc(talloc_tos(), struct PNP_DeviceInstanceAction);
2152         if (r == NULL) {
2153                 return false;
2154         }
2155
2156         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2157                 talloc_free(r);
2158                 return false;
2159         }
2160
2161         pull = ndr_pull_init_blob(&blob, r);
2162         if (pull == NULL) {
2163                 talloc_free(r);
2164                 return false;
2165         }
2166
2167         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2168         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2169         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2170                 talloc_free(r);
2171                 return false;
2172         }
2173
2174         if (DEBUGLEVEL >= 10) {
2175                 NDR_PRINT_IN_DEBUG(PNP_DeviceInstanceAction, r);
2176         }
2177
2178         r->out.result = _PNP_DeviceInstanceAction(p, r);
2179
2180         if (p->rng_fault_state) {
2181                 talloc_free(r);
2182                 /* Return true here, srv_pipe_hnd.c will take care */
2183                 return true;
2184         }
2185
2186         if (DEBUGLEVEL >= 10) {
2187                 NDR_PRINT_OUT_DEBUG(PNP_DeviceInstanceAction, r);
2188         }
2189
2190         push = ndr_push_init_ctx(r);
2191         if (push == NULL) {
2192                 talloc_free(r);
2193                 return false;
2194         }
2195
2196         ndr_err = call->ndr_push(push, NDR_OUT, r);
2197         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2198                 talloc_free(r);
2199                 return false;
2200         }
2201
2202         blob = ndr_push_blob(push);
2203         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2204                 talloc_free(r);
2205                 return false;
2206         }
2207
2208         talloc_free(r);
2209
2210         return true;
2211 }
2212
2213 static bool api_PNP_GetDeviceStatus(pipes_struct *p)
2214 {
2215         const struct ndr_interface_call *call;
2216         struct ndr_pull *pull;
2217         struct ndr_push *push;
2218         enum ndr_err_code ndr_err;
2219         DATA_BLOB blob;
2220         struct PNP_GetDeviceStatus *r;
2221
2222         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICESTATUS];
2223
2224         r = talloc(talloc_tos(), struct PNP_GetDeviceStatus);
2225         if (r == NULL) {
2226                 return false;
2227         }
2228
2229         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2230                 talloc_free(r);
2231                 return false;
2232         }
2233
2234         pull = ndr_pull_init_blob(&blob, r);
2235         if (pull == NULL) {
2236                 talloc_free(r);
2237                 return false;
2238         }
2239
2240         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2241         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2242         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2243                 talloc_free(r);
2244                 return false;
2245         }
2246
2247         if (DEBUGLEVEL >= 10) {
2248                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceStatus, r);
2249         }
2250
2251         r->out.result = _PNP_GetDeviceStatus(p, r);
2252
2253         if (p->rng_fault_state) {
2254                 talloc_free(r);
2255                 /* Return true here, srv_pipe_hnd.c will take care */
2256                 return true;
2257         }
2258
2259         if (DEBUGLEVEL >= 10) {
2260                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceStatus, r);
2261         }
2262
2263         push = ndr_push_init_ctx(r);
2264         if (push == NULL) {
2265                 talloc_free(r);
2266                 return false;
2267         }
2268
2269         ndr_err = call->ndr_push(push, NDR_OUT, r);
2270         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2271                 talloc_free(r);
2272                 return false;
2273         }
2274
2275         blob = ndr_push_blob(push);
2276         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2277                 talloc_free(r);
2278                 return false;
2279         }
2280
2281         talloc_free(r);
2282
2283         return true;
2284 }
2285
2286 static bool api_PNP_SetDeviceProblem(pipes_struct *p)
2287 {
2288         const struct ndr_interface_call *call;
2289         struct ndr_pull *pull;
2290         struct ndr_push *push;
2291         enum ndr_err_code ndr_err;
2292         DATA_BLOB blob;
2293         struct PNP_SetDeviceProblem *r;
2294
2295         call = &ndr_table_ntsvcs.calls[NDR_PNP_SETDEVICEPROBLEM];
2296
2297         r = talloc(talloc_tos(), struct PNP_SetDeviceProblem);
2298         if (r == NULL) {
2299                 return false;
2300         }
2301
2302         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2303                 talloc_free(r);
2304                 return false;
2305         }
2306
2307         pull = ndr_pull_init_blob(&blob, r);
2308         if (pull == NULL) {
2309                 talloc_free(r);
2310                 return false;
2311         }
2312
2313         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2314         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2315         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2316                 talloc_free(r);
2317                 return false;
2318         }
2319
2320         if (DEBUGLEVEL >= 10) {
2321                 NDR_PRINT_IN_DEBUG(PNP_SetDeviceProblem, r);
2322         }
2323
2324         r->out.result = _PNP_SetDeviceProblem(p, r);
2325
2326         if (p->rng_fault_state) {
2327                 talloc_free(r);
2328                 /* Return true here, srv_pipe_hnd.c will take care */
2329                 return true;
2330         }
2331
2332         if (DEBUGLEVEL >= 10) {
2333                 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceProblem, r);
2334         }
2335
2336         push = ndr_push_init_ctx(r);
2337         if (push == NULL) {
2338                 talloc_free(r);
2339                 return false;
2340         }
2341
2342         ndr_err = call->ndr_push(push, NDR_OUT, r);
2343         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2344                 talloc_free(r);
2345                 return false;
2346         }
2347
2348         blob = ndr_push_blob(push);
2349         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2350                 talloc_free(r);
2351                 return false;
2352         }
2353
2354         talloc_free(r);
2355
2356         return true;
2357 }
2358
2359 static bool api_PNP_DisableDevInst(pipes_struct *p)
2360 {
2361         const struct ndr_interface_call *call;
2362         struct ndr_pull *pull;
2363         struct ndr_push *push;
2364         enum ndr_err_code ndr_err;
2365         DATA_BLOB blob;
2366         struct PNP_DisableDevInst *r;
2367
2368         call = &ndr_table_ntsvcs.calls[NDR_PNP_DISABLEDEVINST];
2369
2370         r = talloc(talloc_tos(), struct PNP_DisableDevInst);
2371         if (r == NULL) {
2372                 return false;
2373         }
2374
2375         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2376                 talloc_free(r);
2377                 return false;
2378         }
2379
2380         pull = ndr_pull_init_blob(&blob, r);
2381         if (pull == NULL) {
2382                 talloc_free(r);
2383                 return false;
2384         }
2385
2386         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2387         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2388         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2389                 talloc_free(r);
2390                 return false;
2391         }
2392
2393         if (DEBUGLEVEL >= 10) {
2394                 NDR_PRINT_IN_DEBUG(PNP_DisableDevInst, r);
2395         }
2396
2397         r->out.result = _PNP_DisableDevInst(p, r);
2398
2399         if (p->rng_fault_state) {
2400                 talloc_free(r);
2401                 /* Return true here, srv_pipe_hnd.c will take care */
2402                 return true;
2403         }
2404
2405         if (DEBUGLEVEL >= 10) {
2406                 NDR_PRINT_OUT_DEBUG(PNP_DisableDevInst, r);
2407         }
2408
2409         push = ndr_push_init_ctx(r);
2410         if (push == NULL) {
2411                 talloc_free(r);
2412                 return false;
2413         }
2414
2415         ndr_err = call->ndr_push(push, NDR_OUT, r);
2416         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2417                 talloc_free(r);
2418                 return false;
2419         }
2420
2421         blob = ndr_push_blob(push);
2422         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2423                 talloc_free(r);
2424                 return false;
2425         }
2426
2427         talloc_free(r);
2428
2429         return true;
2430 }
2431
2432 static bool api_PNP_UninstallDevInst(pipes_struct *p)
2433 {
2434         const struct ndr_interface_call *call;
2435         struct ndr_pull *pull;
2436         struct ndr_push *push;
2437         enum ndr_err_code ndr_err;
2438         DATA_BLOB blob;
2439         struct PNP_UninstallDevInst *r;
2440
2441         call = &ndr_table_ntsvcs.calls[NDR_PNP_UNINSTALLDEVINST];
2442
2443         r = talloc(talloc_tos(), struct PNP_UninstallDevInst);
2444         if (r == NULL) {
2445                 return false;
2446         }
2447
2448         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2449                 talloc_free(r);
2450                 return false;
2451         }
2452
2453         pull = ndr_pull_init_blob(&blob, r);
2454         if (pull == NULL) {
2455                 talloc_free(r);
2456                 return false;
2457         }
2458
2459         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2460         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2461         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2462                 talloc_free(r);
2463                 return false;
2464         }
2465
2466         if (DEBUGLEVEL >= 10) {
2467                 NDR_PRINT_IN_DEBUG(PNP_UninstallDevInst, r);
2468         }
2469
2470         r->out.result = _PNP_UninstallDevInst(p, r);
2471
2472         if (p->rng_fault_state) {
2473                 talloc_free(r);
2474                 /* Return true here, srv_pipe_hnd.c will take care */
2475                 return true;
2476         }
2477
2478         if (DEBUGLEVEL >= 10) {
2479                 NDR_PRINT_OUT_DEBUG(PNP_UninstallDevInst, r);
2480         }
2481
2482         push = ndr_push_init_ctx(r);
2483         if (push == NULL) {
2484                 talloc_free(r);
2485                 return false;
2486         }
2487
2488         ndr_err = call->ndr_push(push, NDR_OUT, r);
2489         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2490                 talloc_free(r);
2491                 return false;
2492         }
2493
2494         blob = ndr_push_blob(push);
2495         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2496                 talloc_free(r);
2497                 return false;
2498         }
2499
2500         talloc_free(r);
2501
2502         return true;
2503 }
2504
2505 static bool api_PNP_AddID(pipes_struct *p)
2506 {
2507         const struct ndr_interface_call *call;
2508         struct ndr_pull *pull;
2509         struct ndr_push *push;
2510         enum ndr_err_code ndr_err;
2511         DATA_BLOB blob;
2512         struct PNP_AddID *r;
2513
2514         call = &ndr_table_ntsvcs.calls[NDR_PNP_ADDID];
2515
2516         r = talloc(talloc_tos(), struct PNP_AddID);
2517         if (r == NULL) {
2518                 return false;
2519         }
2520
2521         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2522                 talloc_free(r);
2523                 return false;
2524         }
2525
2526         pull = ndr_pull_init_blob(&blob, r);
2527         if (pull == NULL) {
2528                 talloc_free(r);
2529                 return false;
2530         }
2531
2532         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2533         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2534         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2535                 talloc_free(r);
2536                 return false;
2537         }
2538
2539         if (DEBUGLEVEL >= 10) {
2540                 NDR_PRINT_IN_DEBUG(PNP_AddID, r);
2541         }
2542
2543         r->out.result = _PNP_AddID(p, r);
2544
2545         if (p->rng_fault_state) {
2546                 talloc_free(r);
2547                 /* Return true here, srv_pipe_hnd.c will take care */
2548                 return true;
2549         }
2550
2551         if (DEBUGLEVEL >= 10) {
2552                 NDR_PRINT_OUT_DEBUG(PNP_AddID, r);
2553         }
2554
2555         push = ndr_push_init_ctx(r);
2556         if (push == NULL) {
2557                 talloc_free(r);
2558                 return false;
2559         }
2560
2561         ndr_err = call->ndr_push(push, NDR_OUT, r);
2562         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2563                 talloc_free(r);
2564                 return false;
2565         }
2566
2567         blob = ndr_push_blob(push);
2568         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2569                 talloc_free(r);
2570                 return false;
2571         }
2572
2573         talloc_free(r);
2574
2575         return true;
2576 }
2577
2578 static bool api_PNP_RegisterDriver(pipes_struct *p)
2579 {
2580         const struct ndr_interface_call *call;
2581         struct ndr_pull *pull;
2582         struct ndr_push *push;
2583         enum ndr_err_code ndr_err;
2584         DATA_BLOB blob;
2585         struct PNP_RegisterDriver *r;
2586
2587         call = &ndr_table_ntsvcs.calls[NDR_PNP_REGISTERDRIVER];
2588
2589         r = talloc(talloc_tos(), struct PNP_RegisterDriver);
2590         if (r == NULL) {
2591                 return false;
2592         }
2593
2594         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2595                 talloc_free(r);
2596                 return false;
2597         }
2598
2599         pull = ndr_pull_init_blob(&blob, r);
2600         if (pull == NULL) {
2601                 talloc_free(r);
2602                 return false;
2603         }
2604
2605         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2606         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2607         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2608                 talloc_free(r);
2609                 return false;
2610         }
2611
2612         if (DEBUGLEVEL >= 10) {
2613                 NDR_PRINT_IN_DEBUG(PNP_RegisterDriver, r);
2614         }
2615
2616         r->out.result = _PNP_RegisterDriver(p, r);
2617
2618         if (p->rng_fault_state) {
2619                 talloc_free(r);
2620                 /* Return true here, srv_pipe_hnd.c will take care */
2621                 return true;
2622         }
2623
2624         if (DEBUGLEVEL >= 10) {
2625                 NDR_PRINT_OUT_DEBUG(PNP_RegisterDriver, r);
2626         }
2627
2628         push = ndr_push_init_ctx(r);
2629         if (push == NULL) {
2630                 talloc_free(r);
2631                 return false;
2632         }
2633
2634         ndr_err = call->ndr_push(push, NDR_OUT, r);
2635         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2636                 talloc_free(r);
2637                 return false;
2638         }
2639
2640         blob = ndr_push_blob(push);
2641         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2642                 talloc_free(r);
2643                 return false;
2644         }
2645
2646         talloc_free(r);
2647
2648         return true;
2649 }
2650
2651 static bool api_PNP_QueryRemove(pipes_struct *p)
2652 {
2653         const struct ndr_interface_call *call;
2654         struct ndr_pull *pull;
2655         struct ndr_push *push;
2656         enum ndr_err_code ndr_err;
2657         DATA_BLOB blob;
2658         struct PNP_QueryRemove *r;
2659
2660         call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYREMOVE];
2661
2662         r = talloc(talloc_tos(), struct PNP_QueryRemove);
2663         if (r == NULL) {
2664                 return false;
2665         }
2666
2667         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2668                 talloc_free(r);
2669                 return false;
2670         }
2671
2672         pull = ndr_pull_init_blob(&blob, r);
2673         if (pull == NULL) {
2674                 talloc_free(r);
2675                 return false;
2676         }
2677
2678         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2679         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2680         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2681                 talloc_free(r);
2682                 return false;
2683         }
2684
2685         if (DEBUGLEVEL >= 10) {
2686                 NDR_PRINT_IN_DEBUG(PNP_QueryRemove, r);
2687         }
2688
2689         r->out.result = _PNP_QueryRemove(p, r);
2690
2691         if (p->rng_fault_state) {
2692                 talloc_free(r);
2693                 /* Return true here, srv_pipe_hnd.c will take care */
2694                 return true;
2695         }
2696
2697         if (DEBUGLEVEL >= 10) {
2698                 NDR_PRINT_OUT_DEBUG(PNP_QueryRemove, r);
2699         }
2700
2701         push = ndr_push_init_ctx(r);
2702         if (push == NULL) {
2703                 talloc_free(r);
2704                 return false;
2705         }
2706
2707         ndr_err = call->ndr_push(push, NDR_OUT, r);
2708         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2709                 talloc_free(r);
2710                 return false;
2711         }
2712
2713         blob = ndr_push_blob(push);
2714         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2715                 talloc_free(r);
2716                 return false;
2717         }
2718
2719         talloc_free(r);
2720
2721         return true;
2722 }
2723
2724 static bool api_PNP_RequestDeviceEject(pipes_struct *p)
2725 {
2726         const struct ndr_interface_call *call;
2727         struct ndr_pull *pull;
2728         struct ndr_push *push;
2729         enum ndr_err_code ndr_err;
2730         DATA_BLOB blob;
2731         struct PNP_RequestDeviceEject *r;
2732
2733         call = &ndr_table_ntsvcs.calls[NDR_PNP_REQUESTDEVICEEJECT];
2734
2735         r = talloc(talloc_tos(), struct PNP_RequestDeviceEject);
2736         if (r == NULL) {
2737                 return false;
2738         }
2739
2740         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2741                 talloc_free(r);
2742                 return false;
2743         }
2744
2745         pull = ndr_pull_init_blob(&blob, r);
2746         if (pull == NULL) {
2747                 talloc_free(r);
2748                 return false;
2749         }
2750
2751         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2752         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2753         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2754                 talloc_free(r);
2755                 return false;
2756         }
2757
2758         if (DEBUGLEVEL >= 10) {
2759                 NDR_PRINT_IN_DEBUG(PNP_RequestDeviceEject, r);
2760         }
2761
2762         r->out.result = _PNP_RequestDeviceEject(p, r);
2763
2764         if (p->rng_fault_state) {
2765                 talloc_free(r);
2766                 /* Return true here, srv_pipe_hnd.c will take care */
2767                 return true;
2768         }
2769
2770         if (DEBUGLEVEL >= 10) {
2771                 NDR_PRINT_OUT_DEBUG(PNP_RequestDeviceEject, r);
2772         }
2773
2774         push = ndr_push_init_ctx(r);
2775         if (push == NULL) {
2776                 talloc_free(r);
2777                 return false;
2778         }
2779
2780         ndr_err = call->ndr_push(push, NDR_OUT, r);
2781         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2782                 talloc_free(r);
2783                 return false;
2784         }
2785
2786         blob = ndr_push_blob(push);
2787         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2788                 talloc_free(r);
2789                 return false;
2790         }
2791
2792         talloc_free(r);
2793
2794         return true;
2795 }
2796
2797 static bool api_PNP_IsDockStationPresent(pipes_struct *p)
2798 {
2799         const struct ndr_interface_call *call;
2800         struct ndr_pull *pull;
2801         struct ndr_push *push;
2802         enum ndr_err_code ndr_err;
2803         DATA_BLOB blob;
2804         struct PNP_IsDockStationPresent *r;
2805
2806         call = &ndr_table_ntsvcs.calls[NDR_PNP_ISDOCKSTATIONPRESENT];
2807
2808         r = talloc(talloc_tos(), struct PNP_IsDockStationPresent);
2809         if (r == NULL) {
2810                 return false;
2811         }
2812
2813         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2814                 talloc_free(r);
2815                 return false;
2816         }
2817
2818         pull = ndr_pull_init_blob(&blob, r);
2819         if (pull == NULL) {
2820                 talloc_free(r);
2821                 return false;
2822         }
2823
2824         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2825         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2826         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2827                 talloc_free(r);
2828                 return false;
2829         }
2830
2831         if (DEBUGLEVEL >= 10) {
2832                 NDR_PRINT_IN_DEBUG(PNP_IsDockStationPresent, r);
2833         }
2834
2835         r->out.result = _PNP_IsDockStationPresent(p, r);
2836
2837         if (p->rng_fault_state) {
2838                 talloc_free(r);
2839                 /* Return true here, srv_pipe_hnd.c will take care */
2840                 return true;
2841         }
2842
2843         if (DEBUGLEVEL >= 10) {
2844                 NDR_PRINT_OUT_DEBUG(PNP_IsDockStationPresent, r);
2845         }
2846
2847         push = ndr_push_init_ctx(r);
2848         if (push == NULL) {
2849                 talloc_free(r);
2850                 return false;
2851         }
2852
2853         ndr_err = call->ndr_push(push, NDR_OUT, r);
2854         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2855                 talloc_free(r);
2856                 return false;
2857         }
2858
2859         blob = ndr_push_blob(push);
2860         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2861                 talloc_free(r);
2862                 return false;
2863         }
2864
2865         talloc_free(r);
2866
2867         return true;
2868 }
2869
2870 static bool api_PNP_RequestEjectPC(pipes_struct *p)
2871 {
2872         const struct ndr_interface_call *call;
2873         struct ndr_pull *pull;
2874         struct ndr_push *push;
2875         enum ndr_err_code ndr_err;
2876         DATA_BLOB blob;
2877         struct PNP_RequestEjectPC *r;
2878
2879         call = &ndr_table_ntsvcs.calls[NDR_PNP_REQUESTEJECTPC];
2880
2881         r = talloc(talloc_tos(), struct PNP_RequestEjectPC);
2882         if (r == NULL) {
2883                 return false;
2884         }
2885
2886         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2887                 talloc_free(r);
2888                 return false;
2889         }
2890
2891         pull = ndr_pull_init_blob(&blob, r);
2892         if (pull == NULL) {
2893                 talloc_free(r);
2894                 return false;
2895         }
2896
2897         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2898         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2899         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2900                 talloc_free(r);
2901                 return false;
2902         }
2903
2904         if (DEBUGLEVEL >= 10) {
2905                 NDR_PRINT_IN_DEBUG(PNP_RequestEjectPC, r);
2906         }
2907
2908         r->out.result = _PNP_RequestEjectPC(p, r);
2909
2910         if (p->rng_fault_state) {
2911                 talloc_free(r);
2912                 /* Return true here, srv_pipe_hnd.c will take care */
2913                 return true;
2914         }
2915
2916         if (DEBUGLEVEL >= 10) {
2917                 NDR_PRINT_OUT_DEBUG(PNP_RequestEjectPC, r);
2918         }
2919
2920         push = ndr_push_init_ctx(r);
2921         if (push == NULL) {
2922                 talloc_free(r);
2923                 return false;
2924         }
2925
2926         ndr_err = call->ndr_push(push, NDR_OUT, r);
2927         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2928                 talloc_free(r);
2929                 return false;
2930         }
2931
2932         blob = ndr_push_blob(push);
2933         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2934                 talloc_free(r);
2935                 return false;
2936         }
2937
2938         talloc_free(r);
2939
2940         return true;
2941 }
2942
2943 static bool api_PNP_HwProfFlags(pipes_struct *p)
2944 {
2945         const struct ndr_interface_call *call;
2946         struct ndr_pull *pull;
2947         struct ndr_push *push;
2948         enum ndr_err_code ndr_err;
2949         DATA_BLOB blob;
2950         struct PNP_HwProfFlags *r;
2951
2952         call = &ndr_table_ntsvcs.calls[NDR_PNP_HWPROFFLAGS];
2953
2954         r = talloc(talloc_tos(), struct PNP_HwProfFlags);
2955         if (r == NULL) {
2956                 return false;
2957         }
2958
2959         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2960                 talloc_free(r);
2961                 return false;
2962         }
2963
2964         pull = ndr_pull_init_blob(&blob, r);
2965         if (pull == NULL) {
2966                 talloc_free(r);
2967                 return false;
2968         }
2969
2970         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2971         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2972         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2973                 talloc_free(r);
2974                 return false;
2975         }
2976
2977         if (DEBUGLEVEL >= 10) {
2978                 NDR_PRINT_IN_DEBUG(PNP_HwProfFlags, r);
2979         }
2980
2981         ZERO_STRUCT(r->out);
2982         r->out.unknown3 = r->in.unknown3;
2983         r->out.unknown4 = r->in.unknown4;
2984         r->out.unknown5a = talloc_zero(r, const char *);
2985         if (r->out.unknown5a == NULL) {
2986                 talloc_free(r);
2987                 return false;
2988         }
2989
2990         r->out.result = _PNP_HwProfFlags(p, r);
2991
2992         if (p->rng_fault_state) {
2993                 talloc_free(r);
2994                 /* Return true here, srv_pipe_hnd.c will take care */
2995                 return true;
2996         }
2997
2998         if (DEBUGLEVEL >= 10) {
2999                 NDR_PRINT_OUT_DEBUG(PNP_HwProfFlags, r);
3000         }
3001
3002         push = ndr_push_init_ctx(r);
3003         if (push == NULL) {
3004                 talloc_free(r);
3005                 return false;
3006         }
3007
3008         ndr_err = call->ndr_push(push, NDR_OUT, r);
3009         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3010                 talloc_free(r);
3011                 return false;
3012         }
3013
3014         blob = ndr_push_blob(push);
3015         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3016                 talloc_free(r);
3017                 return false;
3018         }
3019
3020         talloc_free(r);
3021
3022         return true;
3023 }
3024
3025 static bool api_PNP_GetHwProfInfo(pipes_struct *p)
3026 {
3027         const struct ndr_interface_call *call;
3028         struct ndr_pull *pull;
3029         struct ndr_push *push;
3030         enum ndr_err_code ndr_err;
3031         DATA_BLOB blob;
3032         struct PNP_GetHwProfInfo *r;
3033
3034         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETHWPROFINFO];
3035
3036         r = talloc(talloc_tos(), struct PNP_GetHwProfInfo);
3037         if (r == NULL) {
3038                 return false;
3039         }
3040
3041         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3042                 talloc_free(r);
3043                 return false;
3044         }
3045
3046         pull = ndr_pull_init_blob(&blob, r);
3047         if (pull == NULL) {
3048                 talloc_free(r);
3049                 return false;
3050         }
3051
3052         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3053         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3054         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3055                 talloc_free(r);
3056                 return false;
3057         }
3058
3059         if (DEBUGLEVEL >= 10) {
3060                 NDR_PRINT_IN_DEBUG(PNP_GetHwProfInfo, r);
3061         }
3062
3063         ZERO_STRUCT(r->out);
3064         r->out.info = r->in.info;
3065         r->out.result = _PNP_GetHwProfInfo(p, r);
3066
3067         if (p->rng_fault_state) {
3068                 talloc_free(r);
3069                 /* Return true here, srv_pipe_hnd.c will take care */
3070                 return true;
3071         }
3072
3073         if (DEBUGLEVEL >= 10) {
3074                 NDR_PRINT_OUT_DEBUG(PNP_GetHwProfInfo, r);
3075         }
3076
3077         push = ndr_push_init_ctx(r);
3078         if (push == NULL) {
3079                 talloc_free(r);
3080                 return false;
3081         }
3082
3083         ndr_err = call->ndr_push(push, NDR_OUT, r);
3084         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3085                 talloc_free(r);
3086                 return false;
3087         }
3088
3089         blob = ndr_push_blob(push);
3090         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3091                 talloc_free(r);
3092                 return false;
3093         }
3094
3095         talloc_free(r);
3096
3097         return true;
3098 }
3099
3100 static bool api_PNP_AddEmptyLogConf(pipes_struct *p)
3101 {
3102         const struct ndr_interface_call *call;
3103         struct ndr_pull *pull;
3104         struct ndr_push *push;
3105         enum ndr_err_code ndr_err;
3106         DATA_BLOB blob;
3107         struct PNP_AddEmptyLogConf *r;
3108
3109         call = &ndr_table_ntsvcs.calls[NDR_PNP_ADDEMPTYLOGCONF];
3110
3111         r = talloc(talloc_tos(), struct PNP_AddEmptyLogConf);
3112         if (r == NULL) {
3113                 return false;
3114         }
3115
3116         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3117                 talloc_free(r);
3118                 return false;
3119         }
3120
3121         pull = ndr_pull_init_blob(&blob, r);
3122         if (pull == NULL) {
3123                 talloc_free(r);
3124                 return false;
3125         }
3126
3127         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3128         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3129         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3130                 talloc_free(r);
3131                 return false;
3132         }
3133
3134         if (DEBUGLEVEL >= 10) {
3135                 NDR_PRINT_IN_DEBUG(PNP_AddEmptyLogConf, r);
3136         }
3137
3138         r->out.result = _PNP_AddEmptyLogConf(p, r);
3139
3140         if (p->rng_fault_state) {
3141                 talloc_free(r);
3142                 /* Return true here, srv_pipe_hnd.c will take care */
3143                 return true;
3144         }
3145
3146         if (DEBUGLEVEL >= 10) {
3147                 NDR_PRINT_OUT_DEBUG(PNP_AddEmptyLogConf, r);
3148         }
3149
3150         push = ndr_push_init_ctx(r);
3151         if (push == NULL) {
3152                 talloc_free(r);
3153                 return false;
3154         }
3155
3156         ndr_err = call->ndr_push(push, NDR_OUT, r);
3157         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3158                 talloc_free(r);
3159                 return false;
3160         }
3161
3162         blob = ndr_push_blob(push);
3163         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3164                 talloc_free(r);
3165                 return false;
3166         }
3167
3168         talloc_free(r);
3169
3170         return true;
3171 }
3172
3173 static bool api_PNP_FreeLogConf(pipes_struct *p)
3174 {
3175         const struct ndr_interface_call *call;
3176         struct ndr_pull *pull;
3177         struct ndr_push *push;
3178         enum ndr_err_code ndr_err;
3179         DATA_BLOB blob;
3180         struct PNP_FreeLogConf *r;
3181
3182         call = &ndr_table_ntsvcs.calls[NDR_PNP_FREELOGCONF];
3183
3184         r = talloc(talloc_tos(), struct PNP_FreeLogConf);
3185         if (r == NULL) {
3186                 return false;
3187         }
3188
3189         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3190                 talloc_free(r);
3191                 return false;
3192         }
3193
3194         pull = ndr_pull_init_blob(&blob, r);
3195         if (pull == NULL) {
3196                 talloc_free(r);
3197                 return false;
3198         }
3199
3200         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3201         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3202         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3203                 talloc_free(r);
3204                 return false;
3205         }
3206
3207         if (DEBUGLEVEL >= 10) {
3208                 NDR_PRINT_IN_DEBUG(PNP_FreeLogConf, r);
3209         }
3210
3211         r->out.result = _PNP_FreeLogConf(p, r);
3212
3213         if (p->rng_fault_state) {
3214                 talloc_free(r);
3215                 /* Return true here, srv_pipe_hnd.c will take care */
3216                 return true;
3217         }
3218
3219         if (DEBUGLEVEL >= 10) {
3220                 NDR_PRINT_OUT_DEBUG(PNP_FreeLogConf, r);
3221         }
3222
3223         push = ndr_push_init_ctx(r);
3224         if (push == NULL) {
3225                 talloc_free(r);
3226                 return false;
3227         }
3228
3229         ndr_err = call->ndr_push(push, NDR_OUT, r);
3230         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3231                 talloc_free(r);
3232                 return false;
3233         }
3234
3235         blob = ndr_push_blob(push);
3236         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3237                 talloc_free(r);
3238                 return false;
3239         }
3240
3241         talloc_free(r);
3242
3243         return true;
3244 }
3245
3246 static bool api_PNP_GetFirstLogConf(pipes_struct *p)
3247 {
3248         const struct ndr_interface_call *call;
3249         struct ndr_pull *pull;
3250         struct ndr_push *push;
3251         enum ndr_err_code ndr_err;
3252         DATA_BLOB blob;
3253         struct PNP_GetFirstLogConf *r;
3254
3255         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETFIRSTLOGCONF];
3256
3257         r = talloc(talloc_tos(), struct PNP_GetFirstLogConf);
3258         if (r == NULL) {
3259                 return false;
3260         }
3261
3262         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3263                 talloc_free(r);
3264                 return false;
3265         }
3266
3267         pull = ndr_pull_init_blob(&blob, r);
3268         if (pull == NULL) {
3269                 talloc_free(r);
3270                 return false;
3271         }
3272
3273         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3274         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3275         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3276                 talloc_free(r);
3277                 return false;
3278         }
3279
3280         if (DEBUGLEVEL >= 10) {
3281                 NDR_PRINT_IN_DEBUG(PNP_GetFirstLogConf, r);
3282         }
3283
3284         r->out.result = _PNP_GetFirstLogConf(p, r);
3285
3286         if (p->rng_fault_state) {
3287                 talloc_free(r);
3288                 /* Return true here, srv_pipe_hnd.c will take care */
3289                 return true;
3290         }
3291
3292         if (DEBUGLEVEL >= 10) {
3293                 NDR_PRINT_OUT_DEBUG(PNP_GetFirstLogConf, r);
3294         }
3295
3296         push = ndr_push_init_ctx(r);
3297         if (push == NULL) {
3298                 talloc_free(r);
3299                 return false;
3300         }
3301
3302         ndr_err = call->ndr_push(push, NDR_OUT, r);
3303         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3304                 talloc_free(r);
3305                 return false;
3306         }
3307
3308         blob = ndr_push_blob(push);
3309         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3310                 talloc_free(r);
3311                 return false;
3312         }
3313
3314         talloc_free(r);
3315
3316         return true;
3317 }
3318
3319 static bool api_PNP_GetNextLogConf(pipes_struct *p)
3320 {
3321         const struct ndr_interface_call *call;
3322         struct ndr_pull *pull;
3323         struct ndr_push *push;
3324         enum ndr_err_code ndr_err;
3325         DATA_BLOB blob;
3326         struct PNP_GetNextLogConf *r;
3327
3328         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETNEXTLOGCONF];
3329
3330         r = talloc(talloc_tos(), struct PNP_GetNextLogConf);
3331         if (r == NULL) {
3332                 return false;
3333         }
3334
3335         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3336                 talloc_free(r);
3337                 return false;
3338         }
3339
3340         pull = ndr_pull_init_blob(&blob, r);
3341         if (pull == NULL) {
3342                 talloc_free(r);
3343                 return false;
3344         }
3345
3346         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3347         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3348         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3349                 talloc_free(r);
3350                 return false;
3351         }
3352
3353         if (DEBUGLEVEL >= 10) {
3354                 NDR_PRINT_IN_DEBUG(PNP_GetNextLogConf, r);
3355         }
3356
3357         r->out.result = _PNP_GetNextLogConf(p, r);
3358
3359         if (p->rng_fault_state) {
3360                 talloc_free(r);
3361                 /* Return true here, srv_pipe_hnd.c will take care */
3362                 return true;
3363         }
3364
3365         if (DEBUGLEVEL >= 10) {
3366                 NDR_PRINT_OUT_DEBUG(PNP_GetNextLogConf, r);
3367         }
3368
3369         push = ndr_push_init_ctx(r);
3370         if (push == NULL) {
3371                 talloc_free(r);
3372                 return false;
3373         }
3374
3375         ndr_err = call->ndr_push(push, NDR_OUT, r);
3376         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3377                 talloc_free(r);
3378                 return false;
3379         }
3380
3381         blob = ndr_push_blob(push);
3382         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3383                 talloc_free(r);
3384                 return false;
3385         }
3386
3387         talloc_free(r);
3388
3389         return true;
3390 }
3391
3392 static bool api_PNP_GetLogConfPriority(pipes_struct *p)
3393 {
3394         const struct ndr_interface_call *call;
3395         struct ndr_pull *pull;
3396         struct ndr_push *push;
3397         enum ndr_err_code ndr_err;
3398         DATA_BLOB blob;
3399         struct PNP_GetLogConfPriority *r;
3400
3401         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETLOGCONFPRIORITY];
3402
3403         r = talloc(talloc_tos(), struct PNP_GetLogConfPriority);
3404         if (r == NULL) {
3405                 return false;
3406         }
3407
3408         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3409                 talloc_free(r);
3410                 return false;
3411         }
3412
3413         pull = ndr_pull_init_blob(&blob, r);
3414         if (pull == NULL) {
3415                 talloc_free(r);
3416                 return false;
3417         }
3418
3419         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3420         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3421         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3422                 talloc_free(r);
3423                 return false;
3424         }
3425
3426         if (DEBUGLEVEL >= 10) {
3427                 NDR_PRINT_IN_DEBUG(PNP_GetLogConfPriority, r);
3428         }
3429
3430         r->out.result = _PNP_GetLogConfPriority(p, r);
3431
3432         if (p->rng_fault_state) {
3433                 talloc_free(r);
3434                 /* Return true here, srv_pipe_hnd.c will take care */
3435                 return true;
3436         }
3437
3438         if (DEBUGLEVEL >= 10) {
3439                 NDR_PRINT_OUT_DEBUG(PNP_GetLogConfPriority, r);
3440         }
3441
3442         push = ndr_push_init_ctx(r);
3443         if (push == NULL) {
3444                 talloc_free(r);
3445                 return false;
3446         }
3447
3448         ndr_err = call->ndr_push(push, NDR_OUT, r);
3449         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3450                 talloc_free(r);
3451                 return false;
3452         }
3453
3454         blob = ndr_push_blob(push);
3455         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3456                 talloc_free(r);
3457                 return false;
3458         }
3459
3460         talloc_free(r);
3461
3462         return true;
3463 }
3464
3465 static bool api_PNP_AddResDes(pipes_struct *p)
3466 {
3467         const struct ndr_interface_call *call;
3468         struct ndr_pull *pull;
3469         struct ndr_push *push;
3470         enum ndr_err_code ndr_err;
3471         DATA_BLOB blob;
3472         struct PNP_AddResDes *r;
3473
3474         call = &ndr_table_ntsvcs.calls[NDR_PNP_ADDRESDES];
3475
3476         r = talloc(talloc_tos(), struct PNP_AddResDes);
3477         if (r == NULL) {
3478                 return false;
3479         }
3480
3481         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3482                 talloc_free(r);
3483                 return false;
3484         }
3485
3486         pull = ndr_pull_init_blob(&blob, r);
3487         if (pull == NULL) {
3488                 talloc_free(r);
3489                 return false;
3490         }
3491
3492         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3493         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3494         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3495                 talloc_free(r);
3496                 return false;
3497         }
3498
3499         if (DEBUGLEVEL >= 10) {
3500                 NDR_PRINT_IN_DEBUG(PNP_AddResDes, r);
3501         }
3502
3503         r->out.result = _PNP_AddResDes(p, r);
3504
3505         if (p->rng_fault_state) {
3506                 talloc_free(r);
3507                 /* Return true here, srv_pipe_hnd.c will take care */
3508                 return true;
3509         }
3510
3511         if (DEBUGLEVEL >= 10) {
3512                 NDR_PRINT_OUT_DEBUG(PNP_AddResDes, r);
3513         }
3514
3515         push = ndr_push_init_ctx(r);
3516         if (push == NULL) {
3517                 talloc_free(r);
3518                 return false;
3519         }
3520
3521         ndr_err = call->ndr_push(push, NDR_OUT, r);
3522         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3523                 talloc_free(r);
3524                 return false;
3525         }
3526
3527         blob = ndr_push_blob(push);
3528         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3529                 talloc_free(r);
3530                 return false;
3531         }
3532
3533         talloc_free(r);
3534
3535         return true;
3536 }
3537
3538 static bool api_PNP_FreeResDes(pipes_struct *p)
3539 {
3540         const struct ndr_interface_call *call;
3541         struct ndr_pull *pull;
3542         struct ndr_push *push;
3543         enum ndr_err_code ndr_err;
3544         DATA_BLOB blob;
3545         struct PNP_FreeResDes *r;
3546
3547         call = &ndr_table_ntsvcs.calls[NDR_PNP_FREERESDES];
3548
3549         r = talloc(talloc_tos(), struct PNP_FreeResDes);
3550         if (r == NULL) {
3551                 return false;
3552         }
3553
3554         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3555                 talloc_free(r);
3556                 return false;
3557         }
3558
3559         pull = ndr_pull_init_blob(&blob, r);
3560         if (pull == NULL) {
3561                 talloc_free(r);
3562                 return false;
3563         }
3564
3565         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3566         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3567         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3568                 talloc_free(r);
3569                 return false;
3570         }
3571
3572         if (DEBUGLEVEL >= 10) {
3573                 NDR_PRINT_IN_DEBUG(PNP_FreeResDes, r);
3574         }
3575
3576         r->out.result = _PNP_FreeResDes(p, r);
3577
3578         if (p->rng_fault_state) {
3579                 talloc_free(r);
3580                 /* Return true here, srv_pipe_hnd.c will take care */
3581                 return true;
3582         }
3583
3584         if (DEBUGLEVEL >= 10) {
3585                 NDR_PRINT_OUT_DEBUG(PNP_FreeResDes, r);
3586         }
3587
3588         push = ndr_push_init_ctx(r);
3589         if (push == NULL) {
3590                 talloc_free(r);
3591                 return false;
3592         }
3593
3594         ndr_err = call->ndr_push(push, NDR_OUT, r);
3595         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3596                 talloc_free(r);
3597                 return false;
3598         }
3599
3600         blob = ndr_push_blob(push);
3601         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3602                 talloc_free(r);
3603                 return false;
3604         }
3605
3606         talloc_free(r);
3607
3608         return true;
3609 }
3610
3611 static bool api_PNP_GetNextResDes(pipes_struct *p)
3612 {
3613         const struct ndr_interface_call *call;
3614         struct ndr_pull *pull;
3615         struct ndr_push *push;
3616         enum ndr_err_code ndr_err;
3617         DATA_BLOB blob;
3618         struct PNP_GetNextResDes *r;
3619
3620         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETNEXTRESDES];
3621
3622         r = talloc(talloc_tos(), struct PNP_GetNextResDes);
3623         if (r == NULL) {
3624                 return false;
3625         }
3626
3627         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3628                 talloc_free(r);
3629                 return false;
3630         }
3631
3632         pull = ndr_pull_init_blob(&blob, r);
3633         if (pull == NULL) {
3634                 talloc_free(r);
3635                 return false;
3636         }
3637
3638         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3639         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3640         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3641                 talloc_free(r);
3642                 return false;
3643         }
3644
3645         if (DEBUGLEVEL >= 10) {
3646                 NDR_PRINT_IN_DEBUG(PNP_GetNextResDes, r);
3647         }
3648
3649         r->out.result = _PNP_GetNextResDes(p, r);
3650
3651         if (p->rng_fault_state) {
3652                 talloc_free(r);
3653                 /* Return true here, srv_pipe_hnd.c will take care */
3654                 return true;
3655         }
3656
3657         if (DEBUGLEVEL >= 10) {
3658                 NDR_PRINT_OUT_DEBUG(PNP_GetNextResDes, r);
3659         }
3660
3661         push = ndr_push_init_ctx(r);
3662         if (push == NULL) {
3663                 talloc_free(r);
3664                 return false;
3665         }
3666
3667         ndr_err = call->ndr_push(push, NDR_OUT, r);
3668         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3669                 talloc_free(r);
3670                 return false;
3671         }
3672
3673         blob = ndr_push_blob(push);
3674         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3675                 talloc_free(r);
3676                 return false;
3677         }
3678
3679         talloc_free(r);
3680
3681         return true;
3682 }
3683
3684 static bool api_PNP_GetResDesData(pipes_struct *p)
3685 {
3686         const struct ndr_interface_call *call;
3687         struct ndr_pull *pull;
3688         struct ndr_push *push;
3689         enum ndr_err_code ndr_err;
3690         DATA_BLOB blob;
3691         struct PNP_GetResDesData *r;
3692
3693         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETRESDESDATA];
3694
3695         r = talloc(talloc_tos(), struct PNP_GetResDesData);
3696         if (r == NULL) {
3697                 return false;
3698         }
3699
3700         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3701                 talloc_free(r);
3702                 return false;
3703         }
3704
3705         pull = ndr_pull_init_blob(&blob, r);
3706         if (pull == NULL) {
3707                 talloc_free(r);
3708                 return false;
3709         }
3710
3711         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3712         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3713         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3714                 talloc_free(r);
3715                 return false;
3716         }
3717
3718         if (DEBUGLEVEL >= 10) {
3719                 NDR_PRINT_IN_DEBUG(PNP_GetResDesData, r);
3720         }
3721
3722         r->out.result = _PNP_GetResDesData(p, r);
3723
3724         if (p->rng_fault_state) {
3725                 talloc_free(r);
3726                 /* Return true here, srv_pipe_hnd.c will take care */
3727                 return true;
3728         }
3729
3730         if (DEBUGLEVEL >= 10) {
3731                 NDR_PRINT_OUT_DEBUG(PNP_GetResDesData, r);
3732         }
3733
3734         push = ndr_push_init_ctx(r);
3735         if (push == NULL) {
3736                 talloc_free(r);
3737                 return false;
3738         }
3739
3740         ndr_err = call->ndr_push(push, NDR_OUT, r);
3741         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3742                 talloc_free(r);
3743                 return false;
3744         }
3745
3746         blob = ndr_push_blob(push);
3747         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3748                 talloc_free(r);
3749                 return false;
3750         }
3751
3752         talloc_free(r);
3753
3754         return true;
3755 }
3756
3757 static bool api_PNP_GetResDesDataSize(pipes_struct *p)
3758 {
3759         const struct ndr_interface_call *call;
3760         struct ndr_pull *pull;
3761         struct ndr_push *push;
3762         enum ndr_err_code ndr_err;
3763         DATA_BLOB blob;
3764         struct PNP_GetResDesDataSize *r;
3765
3766         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETRESDESDATASIZE];
3767
3768         r = talloc(talloc_tos(), struct PNP_GetResDesDataSize);
3769         if (r == NULL) {
3770                 return false;
3771         }
3772
3773         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3774                 talloc_free(r);
3775                 return false;
3776         }
3777
3778         pull = ndr_pull_init_blob(&blob, r);
3779         if (pull == NULL) {
3780                 talloc_free(r);
3781                 return false;
3782         }
3783
3784         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3785         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3786         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3787                 talloc_free(r);
3788                 return false;
3789         }
3790
3791         if (DEBUGLEVEL >= 10) {
3792                 NDR_PRINT_IN_DEBUG(PNP_GetResDesDataSize, r);
3793         }
3794
3795         r->out.result = _PNP_GetResDesDataSize(p, r);
3796
3797         if (p->rng_fault_state) {
3798                 talloc_free(r);
3799                 /* Return true here, srv_pipe_hnd.c will take care */
3800                 return true;
3801         }
3802
3803         if (DEBUGLEVEL >= 10) {
3804                 NDR_PRINT_OUT_DEBUG(PNP_GetResDesDataSize, r);
3805         }
3806
3807         push = ndr_push_init_ctx(r);
3808         if (push == NULL) {
3809                 talloc_free(r);
3810                 return false;
3811         }
3812
3813         ndr_err = call->ndr_push(push, NDR_OUT, r);
3814         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3815                 talloc_free(r);
3816                 return false;
3817         }
3818
3819         blob = ndr_push_blob(push);
3820         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3821                 talloc_free(r);
3822                 return false;
3823         }
3824
3825         talloc_free(r);
3826
3827         return true;
3828 }
3829
3830 static bool api_PNP_ModifyResDes(pipes_struct *p)
3831 {
3832         const struct ndr_interface_call *call;
3833         struct ndr_pull *pull;
3834         struct ndr_push *push;
3835         enum ndr_err_code ndr_err;
3836         DATA_BLOB blob;
3837         struct PNP_ModifyResDes *r;
3838
3839         call = &ndr_table_ntsvcs.calls[NDR_PNP_MODIFYRESDES];
3840
3841         r = talloc(talloc_tos(), struct PNP_ModifyResDes);
3842         if (r == NULL) {
3843                 return false;
3844         }
3845
3846         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3847                 talloc_free(r);
3848                 return false;
3849         }
3850
3851         pull = ndr_pull_init_blob(&blob, r);
3852         if (pull == NULL) {
3853                 talloc_free(r);
3854                 return false;
3855         }
3856
3857         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3858         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3859         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3860                 talloc_free(r);
3861                 return false;
3862         }
3863
3864         if (DEBUGLEVEL >= 10) {
3865                 NDR_PRINT_IN_DEBUG(PNP_ModifyResDes, r);
3866         }
3867
3868         r->out.result = _PNP_ModifyResDes(p, r);
3869
3870         if (p->rng_fault_state) {
3871                 talloc_free(r);
3872                 /* Return true here, srv_pipe_hnd.c will take care */
3873                 return true;
3874         }
3875
3876         if (DEBUGLEVEL >= 10) {
3877                 NDR_PRINT_OUT_DEBUG(PNP_ModifyResDes, r);
3878         }
3879
3880         push = ndr_push_init_ctx(r);
3881         if (push == NULL) {
3882                 talloc_free(r);
3883                 return false;
3884         }
3885
3886         ndr_err = call->ndr_push(push, NDR_OUT, r);
3887         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3888                 talloc_free(r);
3889                 return false;
3890         }
3891
3892         blob = ndr_push_blob(push);
3893         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3894                 talloc_free(r);
3895                 return false;
3896         }
3897
3898         talloc_free(r);
3899
3900         return true;
3901 }
3902
3903 static bool api_PNP_DetectResourceLimit(pipes_struct *p)
3904 {
3905         const struct ndr_interface_call *call;
3906         struct ndr_pull *pull;
3907         struct ndr_push *push;
3908         enum ndr_err_code ndr_err;
3909         DATA_BLOB blob;
3910         struct PNP_DetectResourceLimit *r;
3911
3912         call = &ndr_table_ntsvcs.calls[NDR_PNP_DETECTRESOURCELIMIT];
3913
3914         r = talloc(talloc_tos(), struct PNP_DetectResourceLimit);
3915         if (r == NULL) {
3916                 return false;
3917         }
3918
3919         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3920                 talloc_free(r);
3921                 return false;
3922         }
3923
3924         pull = ndr_pull_init_blob(&blob, r);
3925         if (pull == NULL) {
3926                 talloc_free(r);
3927                 return false;
3928         }
3929
3930         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3931         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3932         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3933                 talloc_free(r);
3934                 return false;
3935         }
3936
3937         if (DEBUGLEVEL >= 10) {
3938                 NDR_PRINT_IN_DEBUG(PNP_DetectResourceLimit, r);
3939         }
3940
3941         r->out.result = _PNP_DetectResourceLimit(p, r);
3942
3943         if (p->rng_fault_state) {
3944                 talloc_free(r);
3945                 /* Return true here, srv_pipe_hnd.c will take care */
3946                 return true;
3947         }
3948
3949         if (DEBUGLEVEL >= 10) {
3950                 NDR_PRINT_OUT_DEBUG(PNP_DetectResourceLimit, r);
3951         }
3952
3953         push = ndr_push_init_ctx(r);
3954         if (push == NULL) {
3955                 talloc_free(r);
3956                 return false;
3957         }
3958
3959         ndr_err = call->ndr_push(push, NDR_OUT, r);
3960         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3961                 talloc_free(r);
3962                 return false;
3963         }
3964
3965         blob = ndr_push_blob(push);
3966         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3967                 talloc_free(r);
3968                 return false;
3969         }
3970
3971         talloc_free(r);
3972
3973         return true;
3974 }
3975
3976 static bool api_PNP_QueryResConfList(pipes_struct *p)
3977 {
3978         const struct ndr_interface_call *call;
3979         struct ndr_pull *pull;
3980         struct ndr_push *push;
3981         enum ndr_err_code ndr_err;
3982         DATA_BLOB blob;
3983         struct PNP_QueryResConfList *r;
3984
3985         call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYRESCONFLIST];
3986
3987         r = talloc(talloc_tos(), struct PNP_QueryResConfList);
3988         if (r == NULL) {
3989                 return false;
3990         }
3991
3992         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3993                 talloc_free(r);
3994                 return false;
3995         }
3996
3997         pull = ndr_pull_init_blob(&blob, r);
3998         if (pull == NULL) {
3999                 talloc_free(r);
4000                 return false;
4001         }
4002
4003         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4004         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4005         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4006                 talloc_free(r);
4007                 return false;
4008         }
4009
4010         if (DEBUGLEVEL >= 10) {
4011                 NDR_PRINT_IN_DEBUG(PNP_QueryResConfList, r);
4012         }
4013
4014         r->out.result = _PNP_QueryResConfList(p, r);
4015
4016         if (p->rng_fault_state) {
4017                 talloc_free(r);
4018                 /* Return true here, srv_pipe_hnd.c will take care */
4019                 return true;
4020         }
4021
4022         if (DEBUGLEVEL >= 10) {
4023                 NDR_PRINT_OUT_DEBUG(PNP_QueryResConfList, r);
4024         }
4025
4026         push = ndr_push_init_ctx(r);
4027         if (push == NULL) {
4028                 talloc_free(r);
4029                 return false;
4030         }
4031
4032         ndr_err = call->ndr_push(push, NDR_OUT, r);
4033         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4034                 talloc_free(r);
4035                 return false;
4036         }
4037
4038         blob = ndr_push_blob(push);
4039         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4040                 talloc_free(r);
4041                 return false;
4042         }
4043
4044         talloc_free(r);
4045
4046         return true;
4047 }
4048
4049 static bool api_PNP_SetHwProf(pipes_struct *p)
4050 {
4051         const struct ndr_interface_call *call;
4052         struct ndr_pull *pull;
4053         struct ndr_push *push;
4054         enum ndr_err_code ndr_err;
4055         DATA_BLOB blob;
4056         struct PNP_SetHwProf *r;
4057
4058         call = &ndr_table_ntsvcs.calls[NDR_PNP_SETHWPROF];
4059
4060         r = talloc(talloc_tos(), struct PNP_SetHwProf);
4061         if (r == NULL) {
4062                 return false;
4063         }
4064
4065         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4066                 talloc_free(r);
4067                 return false;
4068         }
4069
4070         pull = ndr_pull_init_blob(&blob, r);
4071         if (pull == NULL) {
4072                 talloc_free(r);
4073                 return false;
4074         }
4075
4076         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4077         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4078         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4079                 talloc_free(r);
4080                 return false;
4081         }
4082
4083         if (DEBUGLEVEL >= 10) {
4084                 NDR_PRINT_IN_DEBUG(PNP_SetHwProf, r);
4085         }
4086
4087         r->out.result = _PNP_SetHwProf(p, r);
4088
4089         if (p->rng_fault_state) {
4090                 talloc_free(r);
4091                 /* Return true here, srv_pipe_hnd.c will take care */
4092                 return true;
4093         }
4094
4095         if (DEBUGLEVEL >= 10) {
4096                 NDR_PRINT_OUT_DEBUG(PNP_SetHwProf, r);
4097         }
4098
4099         push = ndr_push_init_ctx(r);
4100         if (push == NULL) {
4101                 talloc_free(r);
4102                 return false;
4103         }
4104
4105         ndr_err = call->ndr_push(push, NDR_OUT, r);
4106         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4107                 talloc_free(r);
4108                 return false;
4109         }
4110
4111         blob = ndr_push_blob(push);
4112         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4113                 talloc_free(r);
4114                 return false;
4115         }
4116
4117         talloc_free(r);
4118
4119         return true;
4120 }
4121
4122 static bool api_PNP_QueryArbitratorFreeData(pipes_struct *p)
4123 {
4124         const struct ndr_interface_call *call;
4125         struct ndr_pull *pull;
4126         struct ndr_push *push;
4127         enum ndr_err_code ndr_err;
4128         DATA_BLOB blob;
4129         struct PNP_QueryArbitratorFreeData *r;
4130
4131         call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYARBITRATORFREEDATA];
4132
4133         r = talloc(talloc_tos(), struct PNP_QueryArbitratorFreeData);
4134         if (r == NULL) {
4135                 return false;
4136         }
4137
4138         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4139                 talloc_free(r);
4140                 return false;
4141         }
4142
4143         pull = ndr_pull_init_blob(&blob, r);
4144         if (pull == NULL) {
4145                 talloc_free(r);
4146                 return false;
4147         }
4148
4149         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4150         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4151         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4152                 talloc_free(r);
4153                 return false;
4154         }
4155
4156         if (DEBUGLEVEL >= 10) {
4157                 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeData, r);
4158         }
4159
4160         r->out.result = _PNP_QueryArbitratorFreeData(p, r);
4161
4162         if (p->rng_fault_state) {
4163                 talloc_free(r);
4164                 /* Return true here, srv_pipe_hnd.c will take care */
4165                 return true;
4166         }
4167
4168         if (DEBUGLEVEL >= 10) {
4169                 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeData, r);
4170         }
4171
4172         push = ndr_push_init_ctx(r);
4173         if (push == NULL) {
4174                 talloc_free(r);
4175                 return false;
4176         }
4177
4178         ndr_err = call->ndr_push(push, NDR_OUT, r);
4179         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4180                 talloc_free(r);
4181                 return false;
4182         }
4183
4184         blob = ndr_push_blob(push);
4185         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4186                 talloc_free(r);
4187                 return false;
4188         }
4189
4190         talloc_free(r);
4191
4192         return true;
4193 }
4194
4195 static bool api_PNP_QueryArbitratorFreeSize(pipes_struct *p)
4196 {
4197         const struct ndr_interface_call *call;
4198         struct ndr_pull *pull;
4199         struct ndr_push *push;
4200         enum ndr_err_code ndr_err;
4201         DATA_BLOB blob;
4202         struct PNP_QueryArbitratorFreeSize *r;
4203
4204         call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYARBITRATORFREESIZE];
4205
4206         r = talloc(talloc_tos(), struct PNP_QueryArbitratorFreeSize);
4207         if (r == NULL) {
4208                 return false;
4209         }
4210
4211         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4212                 talloc_free(r);
4213                 return false;
4214         }
4215
4216         pull = ndr_pull_init_blob(&blob, r);
4217         if (pull == NULL) {
4218                 talloc_free(r);
4219                 return false;
4220         }
4221
4222         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4223         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4224         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4225                 talloc_free(r);
4226                 return false;
4227         }
4228
4229         if (DEBUGLEVEL >= 10) {
4230                 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeSize, r);
4231         }
4232
4233         r->out.result = _PNP_QueryArbitratorFreeSize(p, r);
4234
4235         if (p->rng_fault_state) {
4236                 talloc_free(r);
4237                 /* Return true here, srv_pipe_hnd.c will take care */
4238                 return true;
4239         }
4240
4241         if (DEBUGLEVEL >= 10) {
4242                 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeSize, r);
4243         }
4244
4245         push = ndr_push_init_ctx(r);
4246         if (push == NULL) {
4247                 talloc_free(r);
4248                 return false;
4249         }
4250
4251         ndr_err = call->ndr_push(push, NDR_OUT, r);
4252         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4253                 talloc_free(r);
4254                 return false;
4255         }
4256
4257         blob = ndr_push_blob(push);
4258         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4259                 talloc_free(r);
4260                 return false;
4261         }
4262
4263         talloc_free(r);
4264
4265         return true;
4266 }
4267
4268 static bool api_PNP_RunDetection(pipes_struct *p)
4269 {
4270         const struct ndr_interface_call *call;
4271         struct ndr_pull *pull;
4272         struct ndr_push *push;
4273         enum ndr_err_code ndr_err;
4274         DATA_BLOB blob;
4275         struct PNP_RunDetection *r;
4276
4277         call = &ndr_table_ntsvcs.calls[NDR_PNP_RUNDETECTION];
4278
4279         r = talloc(talloc_tos(), struct PNP_RunDetection);
4280         if (r == NULL) {
4281                 return false;
4282         }
4283
4284         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4285                 talloc_free(r);
4286                 return false;
4287         }
4288
4289         pull = ndr_pull_init_blob(&blob, r);
4290         if (pull == NULL) {
4291                 talloc_free(r);
4292                 return false;
4293         }
4294
4295         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4296         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4297         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4298                 talloc_free(r);
4299                 return false;
4300         }
4301
4302         if (DEBUGLEVEL >= 10) {
4303                 NDR_PRINT_IN_DEBUG(PNP_RunDetection, r);
4304         }
4305
4306         r->out.result = _PNP_RunDetection(p, r);
4307
4308         if (p->rng_fault_state) {
4309                 talloc_free(r);
4310                 /* Return true here, srv_pipe_hnd.c will take care */
4311                 return true;
4312         }
4313
4314         if (DEBUGLEVEL >= 10) {
4315                 NDR_PRINT_OUT_DEBUG(PNP_RunDetection, r);
4316         }
4317
4318         push = ndr_push_init_ctx(r);
4319         if (push == NULL) {
4320                 talloc_free(r);
4321                 return false;
4322         }
4323
4324         ndr_err = call->ndr_push(push, NDR_OUT, r);
4325         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4326                 talloc_free(r);
4327                 return false;
4328         }
4329
4330         blob = ndr_push_blob(push);
4331         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4332                 talloc_free(r);
4333                 return false;
4334         }
4335
4336         talloc_free(r);
4337
4338         return true;
4339 }
4340
4341 static bool api_PNP_RegisterNotification(pipes_struct *p)
4342 {
4343         const struct ndr_interface_call *call;
4344         struct ndr_pull *pull;
4345         struct ndr_push *push;
4346         enum ndr_err_code ndr_err;
4347         DATA_BLOB blob;
4348         struct PNP_RegisterNotification *r;
4349
4350         call = &ndr_table_ntsvcs.calls[NDR_PNP_REGISTERNOTIFICATION];
4351
4352         r = talloc(talloc_tos(), struct PNP_RegisterNotification);
4353         if (r == NULL) {
4354                 return false;
4355         }
4356
4357         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4358                 talloc_free(r);
4359                 return false;
4360         }
4361
4362         pull = ndr_pull_init_blob(&blob, r);
4363         if (pull == NULL) {
4364                 talloc_free(r);
4365                 return false;
4366         }
4367
4368         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4369         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4370         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4371                 talloc_free(r);
4372                 return false;
4373         }
4374
4375         if (DEBUGLEVEL >= 10) {
4376                 NDR_PRINT_IN_DEBUG(PNP_RegisterNotification, r);
4377         }
4378
4379         r->out.result = _PNP_RegisterNotification(p, r);
4380
4381         if (p->rng_fault_state) {
4382                 talloc_free(r);
4383                 /* Return true here, srv_pipe_hnd.c will take care */
4384                 return true;
4385         }
4386
4387         if (DEBUGLEVEL >= 10) {
4388                 NDR_PRINT_OUT_DEBUG(PNP_RegisterNotification, r);
4389         }
4390
4391         push = ndr_push_init_ctx(r);
4392         if (push == NULL) {
4393                 talloc_free(r);
4394                 return false;
4395         }
4396
4397         ndr_err = call->ndr_push(push, NDR_OUT, r);
4398         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4399                 talloc_free(r);
4400                 return false;
4401         }
4402
4403         blob = ndr_push_blob(push);
4404         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4405                 talloc_free(r);
4406                 return false;
4407         }
4408
4409         talloc_free(r);
4410
4411         return true;
4412 }
4413
4414 static bool api_PNP_UnregisterNotification(pipes_struct *p)
4415 {
4416         const struct ndr_interface_call *call;
4417         struct ndr_pull *pull;
4418         struct ndr_push *push;
4419         enum ndr_err_code ndr_err;
4420         DATA_BLOB blob;
4421         struct PNP_UnregisterNotification *r;
4422
4423         call = &ndr_table_ntsvcs.calls[NDR_PNP_UNREGISTERNOTIFICATION];
4424
4425         r = talloc(talloc_tos(), struct PNP_UnregisterNotification);
4426         if (r == NULL) {
4427                 return false;
4428         }
4429
4430         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4431                 talloc_free(r);
4432                 return false;
4433         }
4434
4435         pull = ndr_pull_init_blob(&blob, r);
4436         if (pull == NULL) {
4437                 talloc_free(r);
4438                 return false;
4439         }
4440
4441         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4442         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4443         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4444                 talloc_free(r);
4445                 return false;
4446         }
4447
4448         if (DEBUGLEVEL >= 10) {
4449                 NDR_PRINT_IN_DEBUG(PNP_UnregisterNotification, r);
4450         }
4451
4452         r->out.result = _PNP_UnregisterNotification(p, r);
4453
4454         if (p->rng_fault_state) {
4455                 talloc_free(r);
4456                 /* Return true here, srv_pipe_hnd.c will take care */
4457                 return true;
4458         }
4459
4460         if (DEBUGLEVEL >= 10) {
4461                 NDR_PRINT_OUT_DEBUG(PNP_UnregisterNotification, r);
4462         }
4463
4464         push = ndr_push_init_ctx(r);
4465         if (push == NULL) {
4466                 talloc_free(r);
4467                 return false;
4468         }
4469
4470         ndr_err = call->ndr_push(push, NDR_OUT, r);
4471         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4472                 talloc_free(r);
4473                 return false;
4474         }
4475
4476         blob = ndr_push_blob(push);
4477         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4478                 talloc_free(r);
4479                 return false;
4480         }
4481
4482         talloc_free(r);
4483
4484         return true;
4485 }
4486
4487 static bool api_PNP_GetCustomDevProp(pipes_struct *p)
4488 {
4489         const struct ndr_interface_call *call;
4490         struct ndr_pull *pull;
4491         struct ndr_push *push;
4492         enum ndr_err_code ndr_err;
4493         DATA_BLOB blob;
4494         struct PNP_GetCustomDevProp *r;
4495
4496         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCUSTOMDEVPROP];
4497
4498         r = talloc(talloc_tos(), struct PNP_GetCustomDevProp);
4499         if (r == NULL) {
4500                 return false;
4501         }
4502
4503         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4504                 talloc_free(r);
4505                 return false;
4506         }
4507
4508         pull = ndr_pull_init_blob(&blob, r);
4509         if (pull == NULL) {
4510                 talloc_free(r);
4511                 return false;
4512         }
4513
4514         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4515         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4516         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4517                 talloc_free(r);
4518                 return false;
4519         }
4520
4521         if (DEBUGLEVEL >= 10) {
4522                 NDR_PRINT_IN_DEBUG(PNP_GetCustomDevProp, r);
4523         }
4524
4525         r->out.result = _PNP_GetCustomDevProp(p, r);
4526
4527         if (p->rng_fault_state) {
4528                 talloc_free(r);
4529                 /* Return true here, srv_pipe_hnd.c will take care */
4530                 return true;
4531         }
4532
4533         if (DEBUGLEVEL >= 10) {
4534                 NDR_PRINT_OUT_DEBUG(PNP_GetCustomDevProp, r);
4535         }
4536
4537         push = ndr_push_init_ctx(r);
4538         if (push == NULL) {
4539                 talloc_free(r);
4540                 return false;
4541         }
4542
4543         ndr_err = call->ndr_push(push, NDR_OUT, r);
4544         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4545                 talloc_free(r);
4546                 return false;
4547         }
4548
4549         blob = ndr_push_blob(push);
4550         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4551                 talloc_free(r);
4552                 return false;
4553         }
4554
4555         talloc_free(r);
4556
4557         return true;
4558 }
4559
4560 static bool api_PNP_GetVersionInternal(pipes_struct *p)
4561 {
4562         const struct ndr_interface_call *call;
4563         struct ndr_pull *pull;
4564         struct ndr_push *push;
4565         enum ndr_err_code ndr_err;
4566         DATA_BLOB blob;
4567         struct PNP_GetVersionInternal *r;
4568
4569         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETVERSIONINTERNAL];
4570
4571         r = talloc(talloc_tos(), struct PNP_GetVersionInternal);
4572         if (r == NULL) {
4573                 return false;
4574         }
4575
4576         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4577                 talloc_free(r);
4578                 return false;
4579         }
4580
4581         pull = ndr_pull_init_blob(&blob, r);
4582         if (pull == NULL) {
4583                 talloc_free(r);
4584                 return false;
4585         }
4586
4587         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4588         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4589         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4590                 talloc_free(r);
4591                 return false;
4592         }
4593
4594         if (DEBUGLEVEL >= 10) {
4595                 NDR_PRINT_IN_DEBUG(PNP_GetVersionInternal, r);
4596         }
4597
4598         r->out.result = _PNP_GetVersionInternal(p, r);
4599
4600         if (p->rng_fault_state) {
4601                 talloc_free(r);
4602                 /* Return true here, srv_pipe_hnd.c will take care */
4603                 return true;
4604         }
4605
4606         if (DEBUGLEVEL >= 10) {
4607                 NDR_PRINT_OUT_DEBUG(PNP_GetVersionInternal, r);
4608         }
4609
4610         push = ndr_push_init_ctx(r);
4611         if (push == NULL) {
4612                 talloc_free(r);
4613                 return false;
4614         }
4615
4616         ndr_err = call->ndr_push(push, NDR_OUT, r);
4617         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4618                 talloc_free(r);
4619                 return false;
4620         }
4621
4622         blob = ndr_push_blob(push);
4623         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4624                 talloc_free(r);
4625                 return false;
4626         }
4627
4628         talloc_free(r);
4629
4630         return true;
4631 }
4632
4633 static bool api_PNP_GetBlockedDriverInfo(pipes_struct *p)
4634 {
4635         const struct ndr_interface_call *call;
4636         struct ndr_pull *pull;
4637         struct ndr_push *push;
4638         enum ndr_err_code ndr_err;
4639         DATA_BLOB blob;
4640         struct PNP_GetBlockedDriverInfo *r;
4641
4642         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETBLOCKEDDRIVERINFO];
4643
4644         r = talloc(talloc_tos(), struct PNP_GetBlockedDriverInfo);
4645         if (r == NULL) {
4646                 return false;
4647         }
4648
4649         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4650                 talloc_free(r);
4651                 return false;
4652         }
4653
4654         pull = ndr_pull_init_blob(&blob, r);
4655         if (pull == NULL) {
4656                 talloc_free(r);
4657                 return false;
4658         }
4659
4660         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4661         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4662         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4663                 talloc_free(r);
4664                 return false;
4665         }
4666
4667         if (DEBUGLEVEL >= 10) {
4668                 NDR_PRINT_IN_DEBUG(PNP_GetBlockedDriverInfo, r);
4669         }
4670
4671         r->out.result = _PNP_GetBlockedDriverInfo(p, r);
4672
4673         if (p->rng_fault_state) {
4674                 talloc_free(r);
4675                 /* Return true here, srv_pipe_hnd.c will take care */
4676                 return true;
4677         }
4678
4679         if (DEBUGLEVEL >= 10) {
4680                 NDR_PRINT_OUT_DEBUG(PNP_GetBlockedDriverInfo, r);
4681         }
4682
4683         push = ndr_push_init_ctx(r);
4684         if (push == NULL) {
4685                 talloc_free(r);
4686                 return false;
4687         }
4688
4689         ndr_err = call->ndr_push(push, NDR_OUT, r);
4690         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4691                 talloc_free(r);
4692                 return false;
4693         }
4694
4695         blob = ndr_push_blob(push);
4696         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4697                 talloc_free(r);
4698                 return false;
4699         }
4700
4701         talloc_free(r);
4702
4703         return true;
4704 }
4705
4706 static bool api_PNP_GetServerSideDeviceInstallFlags(pipes_struct *p)
4707 {
4708         const struct ndr_interface_call *call;
4709         struct ndr_pull *pull;
4710         struct ndr_push *push;
4711         enum ndr_err_code ndr_err;
4712         DATA_BLOB blob;
4713         struct PNP_GetServerSideDeviceInstallFlags *r;
4714
4715         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS];
4716
4717         r = talloc(talloc_tos(), struct PNP_GetServerSideDeviceInstallFlags);
4718         if (r == NULL) {
4719                 return false;
4720         }
4721
4722         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4723                 talloc_free(r);
4724                 return false;
4725         }
4726
4727         pull = ndr_pull_init_blob(&blob, r);
4728         if (pull == NULL) {
4729                 talloc_free(r);
4730                 return false;
4731         }
4732
4733         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4734         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4735         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4736                 talloc_free(r);
4737                 return false;
4738         }
4739
4740         if (DEBUGLEVEL >= 10) {
4741                 NDR_PRINT_IN_DEBUG(PNP_GetServerSideDeviceInstallFlags, r);
4742         }
4743
4744         r->out.result = _PNP_GetServerSideDeviceInstallFlags(p, r);
4745
4746         if (p->rng_fault_state) {
4747                 talloc_free(r);
4748                 /* Return true here, srv_pipe_hnd.c will take care */
4749                 return true;
4750         }
4751
4752         if (DEBUGLEVEL >= 10) {
4753                 NDR_PRINT_OUT_DEBUG(PNP_GetServerSideDeviceInstallFlags, r);
4754         }
4755
4756         push = ndr_push_init_ctx(r);
4757         if (push == NULL) {
4758                 talloc_free(r);
4759                 return false;
4760         }
4761
4762         ndr_err = call->ndr_push(push, NDR_OUT, r);
4763         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4764                 talloc_free(r);
4765                 return false;
4766         }
4767
4768         blob = ndr_push_blob(push);
4769         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4770                 talloc_free(r);
4771                 return false;
4772         }
4773
4774         talloc_free(r);
4775
4776         return true;
4777 }
4778
4779
4780 /* Tables */
4781 static struct api_struct api_ntsvcs_cmds[] =
4782 {
4783         {"PNP_DISCONNECT", NDR_PNP_DISCONNECT, api_PNP_Disconnect},
4784         {"PNP_CONNECT", NDR_PNP_CONNECT, api_PNP_Connect},
4785         {"PNP_GETVERSION", NDR_PNP_GETVERSION, api_PNP_GetVersion},
4786         {"PNP_GETGLOBALSTATE", NDR_PNP_GETGLOBALSTATE, api_PNP_GetGlobalState},
4787         {"PNP_INITDETECTION", NDR_PNP_INITDETECTION, api_PNP_InitDetection},
4788         {"PNP_REPORTLOGON", NDR_PNP_REPORTLOGON, api_PNP_ReportLogOn},
4789         {"PNP_VALIDATEDEVICEINSTANCE", NDR_PNP_VALIDATEDEVICEINSTANCE, api_PNP_ValidateDeviceInstance},
4790         {"PNP_GETROOTDEVICEINSTANCE", NDR_PNP_GETROOTDEVICEINSTANCE, api_PNP_GetRootDeviceInstance},
4791         {"PNP_GETRELATEDDEVICEINSTANCE", NDR_PNP_GETRELATEDDEVICEINSTANCE, api_PNP_GetRelatedDeviceInstance},
4792         {"PNP_ENUMERATESUBKEYS", NDR_PNP_ENUMERATESUBKEYS, api_PNP_EnumerateSubKeys},
4793         {"PNP_GETDEVICELIST", NDR_PNP_GETDEVICELIST, api_PNP_GetDeviceList},
4794         {"PNP_GETDEVICELISTSIZE", NDR_PNP_GETDEVICELISTSIZE, api_PNP_GetDeviceListSize},
4795         {"PNP_GETDEPTH", NDR_PNP_GETDEPTH, api_PNP_GetDepth},
4796         {"PNP_GETDEVICEREGPROP", NDR_PNP_GETDEVICEREGPROP, api_PNP_GetDeviceRegProp},
4797         {"PNP_SETDEVICEREGPROP", NDR_PNP_SETDEVICEREGPROP, api_PNP_SetDeviceRegProp},
4798         {"PNP_GETCLASSINSTANCE", NDR_PNP_GETCLASSINSTANCE, api_PNP_GetClassInstance},
4799         {"PNP_CREATEKEY", NDR_PNP_CREATEKEY, api_PNP_CreateKey},
4800         {"PNP_DELETEREGISTRYKEY", NDR_PNP_DELETEREGISTRYKEY, api_PNP_DeleteRegistryKey},
4801         {"PNP_GETCLASSCOUNT", NDR_PNP_GETCLASSCOUNT, api_PNP_GetClassCount},
4802         {"PNP_GETCLASSNAME", NDR_PNP_GETCLASSNAME, api_PNP_GetClassName},
4803         {"PNP_DELETECLASSKEY", NDR_PNP_DELETECLASSKEY, api_PNP_DeleteClassKey},
4804         {"PNP_GETINTERFACEDEVICEALIAS", NDR_PNP_GETINTERFACEDEVICEALIAS, api_PNP_GetInterfaceDeviceAlias},
4805         {"PNP_GETINTERFACEDEVICELIST", NDR_PNP_GETINTERFACEDEVICELIST, api_PNP_GetInterfaceDeviceList},
4806         {"PNP_GETINTERFACEDEVICELISTSIZE", NDR_PNP_GETINTERFACEDEVICELISTSIZE, api_PNP_GetInterfaceDeviceListSize},
4807         {"PNP_REGISTERDEVICECLASSASSOCIATION", NDR_PNP_REGISTERDEVICECLASSASSOCIATION, api_PNP_RegisterDeviceClassAssociation},
4808         {"PNP_UNREGISTERDEVICECLASSASSOCIATION", NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION, api_PNP_UnregisterDeviceClassAssociation},
4809         {"PNP_GETCLASSREGPROP", NDR_PNP_GETCLASSREGPROP, api_PNP_GetClassRegProp},
4810         {"PNP_SETCLASSREGPROP", NDR_PNP_SETCLASSREGPROP, api_PNP_SetClassRegProp},
4811         {"PNP_CREATEDEVINST", NDR_PNP_CREATEDEVINST, api_PNP_CreateDevInst},
4812         {"PNP_DEVICEINSTANCEACTION", NDR_PNP_DEVICEINSTANCEACTION, api_PNP_DeviceInstanceAction},
4813         {"PNP_GETDEVICESTATUS", NDR_PNP_GETDEVICESTATUS, api_PNP_GetDeviceStatus},
4814         {"PNP_SETDEVICEPROBLEM", NDR_PNP_SETDEVICEPROBLEM, api_PNP_SetDeviceProblem},
4815         {"PNP_DISABLEDEVINST", NDR_PNP_DISABLEDEVINST, api_PNP_DisableDevInst},
4816         {"PNP_UNINSTALLDEVINST", NDR_PNP_UNINSTALLDEVINST, api_PNP_UninstallDevInst},
4817         {"PNP_ADDID", NDR_PNP_ADDID, api_PNP_AddID},
4818         {"PNP_REGISTERDRIVER", NDR_PNP_REGISTERDRIVER, api_PNP_RegisterDriver},
4819         {"PNP_QUERYREMOVE", NDR_PNP_QUERYREMOVE, api_PNP_QueryRemove},
4820         {"PNP_REQUESTDEVICEEJECT", NDR_PNP_REQUESTDEVICEEJECT, api_PNP_RequestDeviceEject},
4821         {"PNP_ISDOCKSTATIONPRESENT", NDR_PNP_ISDOCKSTATIONPRESENT, api_PNP_IsDockStationPresent},
4822         {"PNP_REQUESTEJECTPC", NDR_PNP_REQUESTEJECTPC, api_PNP_RequestEjectPC},
4823         {"PNP_HWPROFFLAGS", NDR_PNP_HWPROFFLAGS, api_PNP_HwProfFlags},
4824         {"PNP_GETHWPROFINFO", NDR_PNP_GETHWPROFINFO, api_PNP_GetHwProfInfo},
4825         {"PNP_ADDEMPTYLOGCONF", NDR_PNP_ADDEMPTYLOGCONF, api_PNP_AddEmptyLogConf},
4826         {"PNP_FREELOGCONF", NDR_PNP_FREELOGCONF, api_PNP_FreeLogConf},
4827         {"PNP_GETFIRSTLOGCONF", NDR_PNP_GETFIRSTLOGCONF, api_PNP_GetFirstLogConf},
4828         {"PNP_GETNEXTLOGCONF", NDR_PNP_GETNEXTLOGCONF, api_PNP_GetNextLogConf},
4829         {"PNP_GETLOGCONFPRIORITY", NDR_PNP_GETLOGCONFPRIORITY, api_PNP_GetLogConfPriority},
4830         {"PNP_ADDRESDES", NDR_PNP_ADDRESDES, api_PNP_AddResDes},
4831         {"PNP_FREERESDES", NDR_PNP_FREERESDES, api_PNP_FreeResDes},
4832         {"PNP_GETNEXTRESDES", NDR_PNP_GETNEXTRESDES, api_PNP_GetNextResDes},
4833         {"PNP_GETRESDESDATA", NDR_PNP_GETRESDESDATA, api_PNP_GetResDesData},
4834         {"PNP_GETRESDESDATASIZE", NDR_PNP_GETRESDESDATASIZE, api_PNP_GetResDesDataSize},
4835         {"PNP_MODIFYRESDES", NDR_PNP_MODIFYRESDES, api_PNP_ModifyResDes},
4836         {"PNP_DETECTRESOURCELIMIT", NDR_PNP_DETECTRESOURCELIMIT, api_PNP_DetectResourceLimit},
4837         {"PNP_QUERYRESCONFLIST", NDR_PNP_QUERYRESCONFLIST, api_PNP_QueryResConfList},
4838         {"PNP_SETHWPROF", NDR_PNP_SETHWPROF, api_PNP_SetHwProf},
4839         {"PNP_QUERYARBITRATORFREEDATA", NDR_PNP_QUERYARBITRATORFREEDATA, api_PNP_QueryArbitratorFreeData},
4840         {"PNP_QUERYARBITRATORFREESIZE", NDR_PNP_QUERYARBITRATORFREESIZE, api_PNP_QueryArbitratorFreeSize},
4841         {"PNP_RUNDETECTION", NDR_PNP_RUNDETECTION, api_PNP_RunDetection},
4842         {"PNP_REGISTERNOTIFICATION", NDR_PNP_REGISTERNOTIFICATION, api_PNP_RegisterNotification},
4843         {"PNP_UNREGISTERNOTIFICATION", NDR_PNP_UNREGISTERNOTIFICATION, api_PNP_UnregisterNotification},
4844         {"PNP_GETCUSTOMDEVPROP", NDR_PNP_GETCUSTOMDEVPROP, api_PNP_GetCustomDevProp},
4845         {"PNP_GETVERSIONINTERNAL", NDR_PNP_GETVERSIONINTERNAL, api_PNP_GetVersionInternal},
4846         {"PNP_GETBLOCKEDDRIVERINFO", NDR_PNP_GETBLOCKEDDRIVERINFO, api_PNP_GetBlockedDriverInfo},
4847         {"PNP_GETSERVERSIDEDEVICEINSTALLFLAGS", NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS, api_PNP_GetServerSideDeviceInstallFlags},
4848 };
4849
4850 void ntsvcs_get_pipe_fns(struct api_struct **fns, int *n_fns)
4851 {
4852         *fns = api_ntsvcs_cmds;
4853         *n_fns = sizeof(api_ntsvcs_cmds) / sizeof(struct api_struct);
4854 }
4855
4856 NTSTATUS rpc_ntsvcs_init(void)
4857 {
4858         return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "ntsvcs", "ntsvcs", api_ntsvcs_cmds, sizeof(api_ntsvcs_cmds) / sizeof(struct api_struct));
4859 }