source3/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         r->out.result = _PNP_GetHwProfInfo(p, r);
3064
3065         if (p->rng_fault_state) {
3066                 talloc_free(r);
3067                 /* Return true here, srv_pipe_hnd.c will take care */
3068                 return true;
3069         }
3070
3071         if (DEBUGLEVEL >= 10) {
3072                 NDR_PRINT_OUT_DEBUG(PNP_GetHwProfInfo, r);
3073         }
3074
3075         push = ndr_push_init_ctx(r);
3076         if (push == NULL) {
3077                 talloc_free(r);
3078                 return false;
3079         }
3080
3081         ndr_err = call->ndr_push(push, NDR_OUT, r);
3082         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3083                 talloc_free(r);
3084                 return false;
3085         }
3086
3087         blob = ndr_push_blob(push);
3088         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3089                 talloc_free(r);
3090                 return false;
3091         }
3092
3093         talloc_free(r);
3094
3095         return true;
3096 }
3097
3098 static bool api_PNP_AddEmptyLogConf(pipes_struct *p)
3099 {
3100         const struct ndr_interface_call *call;
3101         struct ndr_pull *pull;
3102         struct ndr_push *push;
3103         enum ndr_err_code ndr_err;
3104         DATA_BLOB blob;
3105         struct PNP_AddEmptyLogConf *r;
3106
3107         call = &ndr_table_ntsvcs.calls[NDR_PNP_ADDEMPTYLOGCONF];
3108
3109         r = talloc(talloc_tos(), struct PNP_AddEmptyLogConf);
3110         if (r == NULL) {
3111                 return false;
3112         }
3113
3114         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3115                 talloc_free(r);
3116                 return false;
3117         }
3118
3119         pull = ndr_pull_init_blob(&blob, r);
3120         if (pull == NULL) {
3121                 talloc_free(r);
3122                 return false;
3123         }
3124
3125         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3126         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3127         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3128                 talloc_free(r);
3129                 return false;
3130         }
3131
3132         if (DEBUGLEVEL >= 10) {
3133                 NDR_PRINT_IN_DEBUG(PNP_AddEmptyLogConf, r);
3134         }
3135
3136         r->out.result = _PNP_AddEmptyLogConf(p, r);
3137
3138         if (p->rng_fault_state) {
3139                 talloc_free(r);
3140                 /* Return true here, srv_pipe_hnd.c will take care */
3141                 return true;
3142         }
3143
3144         if (DEBUGLEVEL >= 10) {
3145                 NDR_PRINT_OUT_DEBUG(PNP_AddEmptyLogConf, r);
3146         }
3147
3148         push = ndr_push_init_ctx(r);
3149         if (push == NULL) {
3150                 talloc_free(r);
3151                 return false;
3152         }
3153
3154         ndr_err = call->ndr_push(push, NDR_OUT, r);
3155         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3156                 talloc_free(r);
3157                 return false;
3158         }
3159
3160         blob = ndr_push_blob(push);
3161         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3162                 talloc_free(r);
3163                 return false;
3164         }
3165
3166         talloc_free(r);
3167
3168         return true;
3169 }
3170
3171 static bool api_PNP_FreeLogConf(pipes_struct *p)
3172 {
3173         const struct ndr_interface_call *call;
3174         struct ndr_pull *pull;
3175         struct ndr_push *push;
3176         enum ndr_err_code ndr_err;
3177         DATA_BLOB blob;
3178         struct PNP_FreeLogConf *r;
3179
3180         call = &ndr_table_ntsvcs.calls[NDR_PNP_FREELOGCONF];
3181
3182         r = talloc(talloc_tos(), struct PNP_FreeLogConf);
3183         if (r == NULL) {
3184                 return false;
3185         }
3186
3187         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3188                 talloc_free(r);
3189                 return false;
3190         }
3191
3192         pull = ndr_pull_init_blob(&blob, r);
3193         if (pull == NULL) {
3194                 talloc_free(r);
3195                 return false;
3196         }
3197
3198         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3199         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3200         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3201                 talloc_free(r);
3202                 return false;
3203         }
3204
3205         if (DEBUGLEVEL >= 10) {
3206                 NDR_PRINT_IN_DEBUG(PNP_FreeLogConf, r);
3207         }
3208
3209         r->out.result = _PNP_FreeLogConf(p, r);
3210
3211         if (p->rng_fault_state) {
3212                 talloc_free(r);
3213                 /* Return true here, srv_pipe_hnd.c will take care */
3214                 return true;
3215         }
3216
3217         if (DEBUGLEVEL >= 10) {
3218                 NDR_PRINT_OUT_DEBUG(PNP_FreeLogConf, r);
3219         }
3220
3221         push = ndr_push_init_ctx(r);
3222         if (push == NULL) {
3223                 talloc_free(r);
3224                 return false;
3225         }
3226
3227         ndr_err = call->ndr_push(push, NDR_OUT, r);
3228         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3229                 talloc_free(r);
3230                 return false;
3231         }
3232
3233         blob = ndr_push_blob(push);
3234         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3235                 talloc_free(r);
3236                 return false;
3237         }
3238
3239         talloc_free(r);
3240
3241         return true;
3242 }
3243
3244 static bool api_PNP_GetFirstLogConf(pipes_struct *p)
3245 {
3246         const struct ndr_interface_call *call;
3247         struct ndr_pull *pull;
3248         struct ndr_push *push;
3249         enum ndr_err_code ndr_err;
3250         DATA_BLOB blob;
3251         struct PNP_GetFirstLogConf *r;
3252
3253         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETFIRSTLOGCONF];
3254
3255         r = talloc(talloc_tos(), struct PNP_GetFirstLogConf);
3256         if (r == NULL) {
3257                 return false;
3258         }
3259
3260         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3261                 talloc_free(r);
3262                 return false;
3263         }
3264
3265         pull = ndr_pull_init_blob(&blob, r);
3266         if (pull == NULL) {
3267                 talloc_free(r);
3268                 return false;
3269         }
3270
3271         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3272         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3273         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3274                 talloc_free(r);
3275                 return false;
3276         }
3277
3278         if (DEBUGLEVEL >= 10) {
3279                 NDR_PRINT_IN_DEBUG(PNP_GetFirstLogConf, r);
3280         }
3281
3282         r->out.result = _PNP_GetFirstLogConf(p, r);
3283
3284         if (p->rng_fault_state) {
3285                 talloc_free(r);
3286                 /* Return true here, srv_pipe_hnd.c will take care */
3287                 return true;
3288         }
3289
3290         if (DEBUGLEVEL >= 10) {
3291                 NDR_PRINT_OUT_DEBUG(PNP_GetFirstLogConf, r);
3292         }
3293
3294         push = ndr_push_init_ctx(r);
3295         if (push == NULL) {
3296                 talloc_free(r);
3297                 return false;
3298         }
3299
3300         ndr_err = call->ndr_push(push, NDR_OUT, r);
3301         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3302                 talloc_free(r);
3303                 return false;
3304         }
3305
3306         blob = ndr_push_blob(push);
3307         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3308                 talloc_free(r);
3309                 return false;
3310         }
3311
3312         talloc_free(r);
3313
3314         return true;
3315 }
3316
3317 static bool api_PNP_GetNextLogConf(pipes_struct *p)
3318 {
3319         const struct ndr_interface_call *call;
3320         struct ndr_pull *pull;
3321         struct ndr_push *push;
3322         enum ndr_err_code ndr_err;
3323         DATA_BLOB blob;
3324         struct PNP_GetNextLogConf *r;
3325
3326         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETNEXTLOGCONF];
3327
3328         r = talloc(talloc_tos(), struct PNP_GetNextLogConf);
3329         if (r == NULL) {
3330                 return false;
3331         }
3332
3333         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3334                 talloc_free(r);
3335                 return false;
3336         }
3337
3338         pull = ndr_pull_init_blob(&blob, r);
3339         if (pull == NULL) {
3340                 talloc_free(r);
3341                 return false;
3342         }
3343
3344         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3345         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3346         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3347                 talloc_free(r);
3348                 return false;
3349         }
3350
3351         if (DEBUGLEVEL >= 10) {
3352                 NDR_PRINT_IN_DEBUG(PNP_GetNextLogConf, r);
3353         }
3354
3355         r->out.result = _PNP_GetNextLogConf(p, r);
3356
3357         if (p->rng_fault_state) {
3358                 talloc_free(r);
3359                 /* Return true here, srv_pipe_hnd.c will take care */
3360                 return true;
3361         }
3362
3363         if (DEBUGLEVEL >= 10) {
3364                 NDR_PRINT_OUT_DEBUG(PNP_GetNextLogConf, r);
3365         }
3366
3367         push = ndr_push_init_ctx(r);
3368         if (push == NULL) {
3369                 talloc_free(r);
3370                 return false;
3371         }
3372
3373         ndr_err = call->ndr_push(push, NDR_OUT, r);
3374         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3375                 talloc_free(r);
3376                 return false;
3377         }
3378
3379         blob = ndr_push_blob(push);
3380         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3381                 talloc_free(r);
3382                 return false;
3383         }
3384
3385         talloc_free(r);
3386
3387         return true;
3388 }
3389
3390 static bool api_PNP_GetLogConfPriority(pipes_struct *p)
3391 {
3392         const struct ndr_interface_call *call;
3393         struct ndr_pull *pull;
3394         struct ndr_push *push;
3395         enum ndr_err_code ndr_err;
3396         DATA_BLOB blob;
3397         struct PNP_GetLogConfPriority *r;
3398
3399         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETLOGCONFPRIORITY];
3400
3401         r = talloc(talloc_tos(), struct PNP_GetLogConfPriority);
3402         if (r == NULL) {
3403                 return false;
3404         }
3405
3406         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3407                 talloc_free(r);
3408                 return false;
3409         }
3410
3411         pull = ndr_pull_init_blob(&blob, r);
3412         if (pull == NULL) {
3413                 talloc_free(r);
3414                 return false;
3415         }
3416
3417         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3418         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3419         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3420                 talloc_free(r);
3421                 return false;
3422         }
3423
3424         if (DEBUGLEVEL >= 10) {
3425                 NDR_PRINT_IN_DEBUG(PNP_GetLogConfPriority, r);
3426         }
3427
3428         r->out.result = _PNP_GetLogConfPriority(p, r);
3429
3430         if (p->rng_fault_state) {
3431                 talloc_free(r);
3432                 /* Return true here, srv_pipe_hnd.c will take care */
3433                 return true;
3434         }
3435
3436         if (DEBUGLEVEL >= 10) {
3437                 NDR_PRINT_OUT_DEBUG(PNP_GetLogConfPriority, r);
3438         }
3439
3440         push = ndr_push_init_ctx(r);
3441         if (push == NULL) {
3442                 talloc_free(r);
3443                 return false;
3444         }
3445
3446         ndr_err = call->ndr_push(push, NDR_OUT, r);
3447         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3448                 talloc_free(r);
3449                 return false;
3450         }
3451
3452         blob = ndr_push_blob(push);
3453         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3454                 talloc_free(r);
3455                 return false;
3456         }
3457
3458         talloc_free(r);
3459
3460         return true;
3461 }
3462
3463 static bool api_PNP_AddResDes(pipes_struct *p)
3464 {
3465         const struct ndr_interface_call *call;
3466         struct ndr_pull *pull;
3467         struct ndr_push *push;
3468         enum ndr_err_code ndr_err;
3469         DATA_BLOB blob;
3470         struct PNP_AddResDes *r;
3471
3472         call = &ndr_table_ntsvcs.calls[NDR_PNP_ADDRESDES];
3473
3474         r = talloc(talloc_tos(), struct PNP_AddResDes);
3475         if (r == NULL) {
3476                 return false;
3477         }
3478
3479         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3480                 talloc_free(r);
3481                 return false;
3482         }
3483
3484         pull = ndr_pull_init_blob(&blob, r);
3485         if (pull == NULL) {
3486                 talloc_free(r);
3487                 return false;
3488         }
3489
3490         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3491         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3492         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3493                 talloc_free(r);
3494                 return false;
3495         }
3496
3497         if (DEBUGLEVEL >= 10) {
3498                 NDR_PRINT_IN_DEBUG(PNP_AddResDes, r);
3499         }
3500
3501         r->out.result = _PNP_AddResDes(p, r);
3502
3503         if (p->rng_fault_state) {
3504                 talloc_free(r);
3505                 /* Return true here, srv_pipe_hnd.c will take care */
3506                 return true;
3507         }
3508
3509         if (DEBUGLEVEL >= 10) {
3510                 NDR_PRINT_OUT_DEBUG(PNP_AddResDes, r);
3511         }
3512
3513         push = ndr_push_init_ctx(r);
3514         if (push == NULL) {
3515                 talloc_free(r);
3516                 return false;
3517         }
3518
3519         ndr_err = call->ndr_push(push, NDR_OUT, r);
3520         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3521                 talloc_free(r);
3522                 return false;
3523         }
3524
3525         blob = ndr_push_blob(push);
3526         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3527                 talloc_free(r);
3528                 return false;
3529         }
3530
3531         talloc_free(r);
3532
3533         return true;
3534 }
3535
3536 static bool api_PNP_FreeResDes(pipes_struct *p)
3537 {
3538         const struct ndr_interface_call *call;
3539         struct ndr_pull *pull;
3540         struct ndr_push *push;
3541         enum ndr_err_code ndr_err;
3542         DATA_BLOB blob;
3543         struct PNP_FreeResDes *r;
3544
3545         call = &ndr_table_ntsvcs.calls[NDR_PNP_FREERESDES];
3546
3547         r = talloc(talloc_tos(), struct PNP_FreeResDes);
3548         if (r == NULL) {
3549                 return false;
3550         }
3551
3552         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3553                 talloc_free(r);
3554                 return false;
3555         }
3556
3557         pull = ndr_pull_init_blob(&blob, r);
3558         if (pull == NULL) {
3559                 talloc_free(r);
3560                 return false;
3561         }
3562
3563         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3564         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3565         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3566                 talloc_free(r);
3567                 return false;
3568         }
3569
3570         if (DEBUGLEVEL >= 10) {
3571                 NDR_PRINT_IN_DEBUG(PNP_FreeResDes, r);
3572         }
3573
3574         r->out.result = _PNP_FreeResDes(p, r);
3575
3576         if (p->rng_fault_state) {
3577                 talloc_free(r);
3578                 /* Return true here, srv_pipe_hnd.c will take care */
3579                 return true;
3580         }
3581
3582         if (DEBUGLEVEL >= 10) {
3583                 NDR_PRINT_OUT_DEBUG(PNP_FreeResDes, r);
3584         }
3585
3586         push = ndr_push_init_ctx(r);
3587         if (push == NULL) {
3588                 talloc_free(r);
3589                 return false;
3590         }
3591
3592         ndr_err = call->ndr_push(push, NDR_OUT, r);
3593         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3594                 talloc_free(r);
3595                 return false;
3596         }
3597
3598         blob = ndr_push_blob(push);
3599         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3600                 talloc_free(r);
3601                 return false;
3602         }
3603
3604         talloc_free(r);
3605
3606         return true;
3607 }
3608
3609 static bool api_PNP_GetNextResDes(pipes_struct *p)
3610 {
3611         const struct ndr_interface_call *call;
3612         struct ndr_pull *pull;
3613         struct ndr_push *push;
3614         enum ndr_err_code ndr_err;
3615         DATA_BLOB blob;
3616         struct PNP_GetNextResDes *r;
3617
3618         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETNEXTRESDES];
3619
3620         r = talloc(talloc_tos(), struct PNP_GetNextResDes);
3621         if (r == NULL) {
3622                 return false;
3623         }
3624
3625         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3626                 talloc_free(r);
3627                 return false;
3628         }
3629
3630         pull = ndr_pull_init_blob(&blob, r);
3631         if (pull == NULL) {
3632                 talloc_free(r);
3633                 return false;
3634         }
3635
3636         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3637         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3638         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3639                 talloc_free(r);
3640                 return false;
3641         }
3642
3643         if (DEBUGLEVEL >= 10) {
3644                 NDR_PRINT_IN_DEBUG(PNP_GetNextResDes, r);
3645         }
3646
3647         r->out.result = _PNP_GetNextResDes(p, r);
3648
3649         if (p->rng_fault_state) {
3650                 talloc_free(r);
3651                 /* Return true here, srv_pipe_hnd.c will take care */
3652                 return true;
3653         }
3654
3655         if (DEBUGLEVEL >= 10) {
3656                 NDR_PRINT_OUT_DEBUG(PNP_GetNextResDes, r);
3657         }
3658
3659         push = ndr_push_init_ctx(r);
3660         if (push == NULL) {
3661                 talloc_free(r);
3662                 return false;
3663         }
3664
3665         ndr_err = call->ndr_push(push, NDR_OUT, r);
3666         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3667                 talloc_free(r);
3668                 return false;
3669         }
3670
3671         blob = ndr_push_blob(push);
3672         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3673                 talloc_free(r);
3674                 return false;
3675         }
3676
3677         talloc_free(r);
3678
3679         return true;
3680 }
3681
3682 static bool api_PNP_GetResDesData(pipes_struct *p)
3683 {
3684         const struct ndr_interface_call *call;
3685         struct ndr_pull *pull;
3686         struct ndr_push *push;
3687         enum ndr_err_code ndr_err;
3688         DATA_BLOB blob;
3689         struct PNP_GetResDesData *r;
3690
3691         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETRESDESDATA];
3692
3693         r = talloc(talloc_tos(), struct PNP_GetResDesData);
3694         if (r == NULL) {
3695                 return false;
3696         }
3697
3698         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3699                 talloc_free(r);
3700                 return false;
3701         }
3702
3703         pull = ndr_pull_init_blob(&blob, r);
3704         if (pull == NULL) {
3705                 talloc_free(r);
3706                 return false;
3707         }
3708
3709         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3710         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3711         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3712                 talloc_free(r);
3713                 return false;
3714         }
3715
3716         if (DEBUGLEVEL >= 10) {
3717                 NDR_PRINT_IN_DEBUG(PNP_GetResDesData, r);
3718         }
3719
3720         r->out.result = _PNP_GetResDesData(p, r);
3721
3722         if (p->rng_fault_state) {
3723                 talloc_free(r);
3724                 /* Return true here, srv_pipe_hnd.c will take care */
3725                 return true;
3726         }
3727
3728         if (DEBUGLEVEL >= 10) {
3729                 NDR_PRINT_OUT_DEBUG(PNP_GetResDesData, r);
3730         }
3731
3732         push = ndr_push_init_ctx(r);
3733         if (push == NULL) {
3734                 talloc_free(r);
3735                 return false;
3736         }
3737
3738         ndr_err = call->ndr_push(push, NDR_OUT, r);
3739         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3740                 talloc_free(r);
3741                 return false;
3742         }
3743
3744         blob = ndr_push_blob(push);
3745         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3746                 talloc_free(r);
3747                 return false;
3748         }
3749
3750         talloc_free(r);
3751
3752         return true;
3753 }
3754
3755 static bool api_PNP_GetResDesDataSize(pipes_struct *p)
3756 {
3757         const struct ndr_interface_call *call;
3758         struct ndr_pull *pull;
3759         struct ndr_push *push;
3760         enum ndr_err_code ndr_err;
3761         DATA_BLOB blob;
3762         struct PNP_GetResDesDataSize *r;
3763
3764         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETRESDESDATASIZE];
3765
3766         r = talloc(talloc_tos(), struct PNP_GetResDesDataSize);
3767         if (r == NULL) {
3768                 return false;
3769         }
3770
3771         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3772                 talloc_free(r);
3773                 return false;
3774         }
3775
3776         pull = ndr_pull_init_blob(&blob, r);
3777         if (pull == NULL) {
3778                 talloc_free(r);
3779                 return false;
3780         }
3781
3782         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3783         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3784         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3785                 talloc_free(r);
3786                 return false;
3787         }
3788
3789         if (DEBUGLEVEL >= 10) {
3790                 NDR_PRINT_IN_DEBUG(PNP_GetResDesDataSize, r);
3791         }
3792
3793         r->out.result = _PNP_GetResDesDataSize(p, r);
3794
3795         if (p->rng_fault_state) {
3796                 talloc_free(r);
3797                 /* Return true here, srv_pipe_hnd.c will take care */
3798                 return true;
3799         }
3800
3801         if (DEBUGLEVEL >= 10) {
3802                 NDR_PRINT_OUT_DEBUG(PNP_GetResDesDataSize, r);
3803         }
3804
3805         push = ndr_push_init_ctx(r);
3806         if (push == NULL) {
3807                 talloc_free(r);
3808                 return false;
3809         }
3810
3811         ndr_err = call->ndr_push(push, NDR_OUT, r);
3812         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3813                 talloc_free(r);
3814                 return false;
3815         }
3816
3817         blob = ndr_push_blob(push);
3818         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3819                 talloc_free(r);
3820                 return false;
3821         }
3822
3823         talloc_free(r);
3824
3825         return true;
3826 }
3827
3828 static bool api_PNP_ModifyResDes(pipes_struct *p)
3829 {
3830         const struct ndr_interface_call *call;
3831         struct ndr_pull *pull;
3832         struct ndr_push *push;
3833         enum ndr_err_code ndr_err;
3834         DATA_BLOB blob;
3835         struct PNP_ModifyResDes *r;
3836
3837         call = &ndr_table_ntsvcs.calls[NDR_PNP_MODIFYRESDES];
3838
3839         r = talloc(talloc_tos(), struct PNP_ModifyResDes);
3840         if (r == NULL) {
3841                 return false;
3842         }
3843
3844         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3845                 talloc_free(r);
3846                 return false;
3847         }
3848
3849         pull = ndr_pull_init_blob(&blob, r);
3850         if (pull == NULL) {
3851                 talloc_free(r);
3852                 return false;
3853         }
3854
3855         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3856         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3857         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3858                 talloc_free(r);
3859                 return false;
3860         }
3861
3862         if (DEBUGLEVEL >= 10) {
3863                 NDR_PRINT_IN_DEBUG(PNP_ModifyResDes, r);
3864         }
3865
3866         r->out.result = _PNP_ModifyResDes(p, r);
3867
3868         if (p->rng_fault_state) {
3869                 talloc_free(r);
3870                 /* Return true here, srv_pipe_hnd.c will take care */
3871                 return true;
3872         }
3873
3874         if (DEBUGLEVEL >= 10) {
3875                 NDR_PRINT_OUT_DEBUG(PNP_ModifyResDes, r);
3876         }
3877
3878         push = ndr_push_init_ctx(r);
3879         if (push == NULL) {
3880                 talloc_free(r);
3881                 return false;
3882         }
3883
3884         ndr_err = call->ndr_push(push, NDR_OUT, r);
3885         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3886                 talloc_free(r);
3887                 return false;
3888         }
3889
3890         blob = ndr_push_blob(push);
3891         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3892                 talloc_free(r);
3893                 return false;
3894         }
3895
3896         talloc_free(r);
3897
3898         return true;
3899 }
3900
3901 static bool api_PNP_DetectResourceLimit(pipes_struct *p)
3902 {
3903         const struct ndr_interface_call *call;
3904         struct ndr_pull *pull;
3905         struct ndr_push *push;
3906         enum ndr_err_code ndr_err;
3907         DATA_BLOB blob;
3908         struct PNP_DetectResourceLimit *r;
3909
3910         call = &ndr_table_ntsvcs.calls[NDR_PNP_DETECTRESOURCELIMIT];
3911
3912         r = talloc(talloc_tos(), struct PNP_DetectResourceLimit);
3913         if (r == NULL) {
3914                 return false;
3915         }
3916
3917         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3918                 talloc_free(r);
3919                 return false;
3920         }
3921
3922         pull = ndr_pull_init_blob(&blob, r);
3923         if (pull == NULL) {
3924                 talloc_free(r);
3925                 return false;
3926         }
3927
3928         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3929         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3930         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3931                 talloc_free(r);
3932                 return false;
3933         }
3934
3935         if (DEBUGLEVEL >= 10) {
3936                 NDR_PRINT_IN_DEBUG(PNP_DetectResourceLimit, r);
3937         }
3938
3939         r->out.result = _PNP_DetectResourceLimit(p, r);
3940
3941         if (p->rng_fault_state) {
3942                 talloc_free(r);
3943                 /* Return true here, srv_pipe_hnd.c will take care */
3944                 return true;
3945         }
3946
3947         if (DEBUGLEVEL >= 10) {
3948                 NDR_PRINT_OUT_DEBUG(PNP_DetectResourceLimit, r);
3949         }
3950
3951         push = ndr_push_init_ctx(r);
3952         if (push == NULL) {
3953                 talloc_free(r);
3954                 return false;
3955         }
3956
3957         ndr_err = call->ndr_push(push, NDR_OUT, r);
3958         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3959                 talloc_free(r);
3960                 return false;
3961         }
3962
3963         blob = ndr_push_blob(push);
3964         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3965                 talloc_free(r);
3966                 return false;
3967         }
3968
3969         talloc_free(r);
3970
3971         return true;
3972 }
3973
3974 static bool api_PNP_QueryResConfList(pipes_struct *p)
3975 {
3976         const struct ndr_interface_call *call;
3977         struct ndr_pull *pull;
3978         struct ndr_push *push;
3979         enum ndr_err_code ndr_err;
3980         DATA_BLOB blob;
3981         struct PNP_QueryResConfList *r;
3982
3983         call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYRESCONFLIST];
3984
3985         r = talloc(talloc_tos(), struct PNP_QueryResConfList);
3986         if (r == NULL) {
3987                 return false;
3988         }
3989
3990         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3991                 talloc_free(r);
3992                 return false;
3993         }
3994
3995         pull = ndr_pull_init_blob(&blob, r);
3996         if (pull == NULL) {
3997                 talloc_free(r);
3998                 return false;
3999         }
4000
4001         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4002         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4003         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4004                 talloc_free(r);
4005                 return false;
4006         }
4007
4008         if (DEBUGLEVEL >= 10) {
4009                 NDR_PRINT_IN_DEBUG(PNP_QueryResConfList, r);
4010         }
4011
4012         r->out.result = _PNP_QueryResConfList(p, r);
4013
4014         if (p->rng_fault_state) {
4015                 talloc_free(r);
4016                 /* Return true here, srv_pipe_hnd.c will take care */
4017                 return true;
4018         }
4019
4020         if (DEBUGLEVEL >= 10) {
4021                 NDR_PRINT_OUT_DEBUG(PNP_QueryResConfList, r);
4022         }
4023
4024         push = ndr_push_init_ctx(r);
4025         if (push == NULL) {
4026                 talloc_free(r);
4027                 return false;
4028         }
4029
4030         ndr_err = call->ndr_push(push, NDR_OUT, r);
4031         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4032                 talloc_free(r);
4033                 return false;
4034         }
4035
4036         blob = ndr_push_blob(push);
4037         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4038                 talloc_free(r);
4039                 return false;
4040         }
4041
4042         talloc_free(r);
4043
4044         return true;
4045 }
4046
4047 static bool api_PNP_SetHwProf(pipes_struct *p)
4048 {
4049         const struct ndr_interface_call *call;
4050         struct ndr_pull *pull;
4051         struct ndr_push *push;
4052         enum ndr_err_code ndr_err;
4053         DATA_BLOB blob;
4054         struct PNP_SetHwProf *r;
4055
4056         call = &ndr_table_ntsvcs.calls[NDR_PNP_SETHWPROF];
4057
4058         r = talloc(talloc_tos(), struct PNP_SetHwProf);
4059         if (r == NULL) {
4060                 return false;
4061         }
4062
4063         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4064                 talloc_free(r);
4065                 return false;
4066         }
4067
4068         pull = ndr_pull_init_blob(&blob, r);
4069         if (pull == NULL) {
4070                 talloc_free(r);
4071                 return false;
4072         }
4073
4074         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4075         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4076         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4077                 talloc_free(r);
4078                 return false;
4079         }
4080
4081         if (DEBUGLEVEL >= 10) {
4082                 NDR_PRINT_IN_DEBUG(PNP_SetHwProf, r);
4083         }
4084
4085         r->out.result = _PNP_SetHwProf(p, r);
4086
4087         if (p->rng_fault_state) {
4088                 talloc_free(r);
4089                 /* Return true here, srv_pipe_hnd.c will take care */
4090                 return true;
4091         }
4092
4093         if (DEBUGLEVEL >= 10) {
4094                 NDR_PRINT_OUT_DEBUG(PNP_SetHwProf, r);
4095         }
4096
4097         push = ndr_push_init_ctx(r);
4098         if (push == NULL) {
4099                 talloc_free(r);
4100                 return false;
4101         }
4102
4103         ndr_err = call->ndr_push(push, NDR_OUT, r);
4104         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4105                 talloc_free(r);
4106                 return false;
4107         }
4108
4109         blob = ndr_push_blob(push);
4110         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4111                 talloc_free(r);
4112                 return false;
4113         }
4114
4115         talloc_free(r);
4116
4117         return true;
4118 }
4119
4120 static bool api_PNP_QueryArbitratorFreeData(pipes_struct *p)
4121 {
4122         const struct ndr_interface_call *call;
4123         struct ndr_pull *pull;
4124         struct ndr_push *push;
4125         enum ndr_err_code ndr_err;
4126         DATA_BLOB blob;
4127         struct PNP_QueryArbitratorFreeData *r;
4128
4129         call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYARBITRATORFREEDATA];
4130
4131         r = talloc(talloc_tos(), struct PNP_QueryArbitratorFreeData);
4132         if (r == NULL) {
4133                 return false;
4134         }
4135
4136         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4137                 talloc_free(r);
4138                 return false;
4139         }
4140
4141         pull = ndr_pull_init_blob(&blob, r);
4142         if (pull == NULL) {
4143                 talloc_free(r);
4144                 return false;
4145         }
4146
4147         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4148         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4149         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4150                 talloc_free(r);
4151                 return false;
4152         }
4153
4154         if (DEBUGLEVEL >= 10) {
4155                 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeData, r);
4156         }
4157
4158         r->out.result = _PNP_QueryArbitratorFreeData(p, r);
4159
4160         if (p->rng_fault_state) {
4161                 talloc_free(r);
4162                 /* Return true here, srv_pipe_hnd.c will take care */
4163                 return true;
4164         }
4165
4166         if (DEBUGLEVEL >= 10) {
4167                 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeData, r);
4168         }
4169
4170         push = ndr_push_init_ctx(r);
4171         if (push == NULL) {
4172                 talloc_free(r);
4173                 return false;
4174         }
4175
4176         ndr_err = call->ndr_push(push, NDR_OUT, r);
4177         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4178                 talloc_free(r);
4179                 return false;
4180         }
4181
4182         blob = ndr_push_blob(push);
4183         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4184                 talloc_free(r);
4185                 return false;
4186         }
4187
4188         talloc_free(r);
4189
4190         return true;
4191 }
4192
4193 static bool api_PNP_QueryArbitratorFreeSize(pipes_struct *p)
4194 {
4195         const struct ndr_interface_call *call;
4196         struct ndr_pull *pull;
4197         struct ndr_push *push;
4198         enum ndr_err_code ndr_err;
4199         DATA_BLOB blob;
4200         struct PNP_QueryArbitratorFreeSize *r;
4201
4202         call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYARBITRATORFREESIZE];
4203
4204         r = talloc(talloc_tos(), struct PNP_QueryArbitratorFreeSize);
4205         if (r == NULL) {
4206                 return false;
4207         }
4208
4209         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4210                 talloc_free(r);
4211                 return false;
4212         }
4213
4214         pull = ndr_pull_init_blob(&blob, r);
4215         if (pull == NULL) {
4216                 talloc_free(r);
4217                 return false;
4218         }
4219
4220         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4221         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4222         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4223                 talloc_free(r);
4224                 return false;
4225         }
4226
4227         if (DEBUGLEVEL >= 10) {
4228                 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeSize, r);
4229         }
4230
4231         r->out.result = _PNP_QueryArbitratorFreeSize(p, r);
4232
4233         if (p->rng_fault_state) {
4234                 talloc_free(r);
4235                 /* Return true here, srv_pipe_hnd.c will take care */
4236                 return true;
4237         }
4238
4239         if (DEBUGLEVEL >= 10) {
4240                 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeSize, r);
4241         }
4242
4243         push = ndr_push_init_ctx(r);
4244         if (push == NULL) {
4245                 talloc_free(r);
4246                 return false;
4247         }
4248
4249         ndr_err = call->ndr_push(push, NDR_OUT, r);
4250         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4251                 talloc_free(r);
4252                 return false;
4253         }
4254
4255         blob = ndr_push_blob(push);
4256         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4257                 talloc_free(r);
4258                 return false;
4259         }
4260
4261         talloc_free(r);
4262
4263         return true;
4264 }
4265
4266 static bool api_PNP_RunDetection(pipes_struct *p)
4267 {
4268         const struct ndr_interface_call *call;
4269         struct ndr_pull *pull;
4270         struct ndr_push *push;
4271         enum ndr_err_code ndr_err;
4272         DATA_BLOB blob;
4273         struct PNP_RunDetection *r;
4274
4275         call = &ndr_table_ntsvcs.calls[NDR_PNP_RUNDETECTION];
4276
4277         r = talloc(talloc_tos(), struct PNP_RunDetection);
4278         if (r == NULL) {
4279                 return false;
4280         }
4281
4282         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4283                 talloc_free(r);
4284                 return false;
4285         }
4286
4287         pull = ndr_pull_init_blob(&blob, r);
4288         if (pull == NULL) {
4289                 talloc_free(r);
4290                 return false;
4291         }
4292
4293         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4294         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4295         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4296                 talloc_free(r);
4297                 return false;
4298         }
4299
4300         if (DEBUGLEVEL >= 10) {
4301                 NDR_PRINT_IN_DEBUG(PNP_RunDetection, r);
4302         }
4303
4304         r->out.result = _PNP_RunDetection(p, r);
4305
4306         if (p->rng_fault_state) {
4307                 talloc_free(r);
4308                 /* Return true here, srv_pipe_hnd.c will take care */
4309                 return true;
4310         }
4311
4312         if (DEBUGLEVEL >= 10) {
4313                 NDR_PRINT_OUT_DEBUG(PNP_RunDetection, r);
4314         }
4315
4316         push = ndr_push_init_ctx(r);
4317         if (push == NULL) {
4318                 talloc_free(r);
4319                 return false;
4320         }
4321
4322         ndr_err = call->ndr_push(push, NDR_OUT, r);
4323         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4324                 talloc_free(r);
4325                 return false;
4326         }
4327
4328         blob = ndr_push_blob(push);
4329         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4330                 talloc_free(r);
4331                 return false;
4332         }
4333
4334         talloc_free(r);
4335
4336         return true;
4337 }
4338
4339 static bool api_PNP_RegisterNotification(pipes_struct *p)
4340 {
4341         const struct ndr_interface_call *call;
4342         struct ndr_pull *pull;
4343         struct ndr_push *push;
4344         enum ndr_err_code ndr_err;
4345         DATA_BLOB blob;
4346         struct PNP_RegisterNotification *r;
4347
4348         call = &ndr_table_ntsvcs.calls[NDR_PNP_REGISTERNOTIFICATION];
4349
4350         r = talloc(talloc_tos(), struct PNP_RegisterNotification);
4351         if (r == NULL) {
4352                 return false;
4353         }
4354
4355         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4356                 talloc_free(r);
4357                 return false;
4358         }
4359
4360         pull = ndr_pull_init_blob(&blob, r);
4361         if (pull == NULL) {
4362                 talloc_free(r);
4363                 return false;
4364         }
4365
4366         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4367         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4368         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4369                 talloc_free(r);
4370                 return false;
4371         }
4372
4373         if (DEBUGLEVEL >= 10) {
4374                 NDR_PRINT_IN_DEBUG(PNP_RegisterNotification, r);
4375         }
4376
4377         r->out.result = _PNP_RegisterNotification(p, r);
4378
4379         if (p->rng_fault_state) {
4380                 talloc_free(r);
4381                 /* Return true here, srv_pipe_hnd.c will take care */
4382                 return true;
4383         }
4384
4385         if (DEBUGLEVEL >= 10) {
4386                 NDR_PRINT_OUT_DEBUG(PNP_RegisterNotification, r);
4387         }
4388
4389         push = ndr_push_init_ctx(r);
4390         if (push == NULL) {
4391                 talloc_free(r);
4392                 return false;
4393         }
4394
4395         ndr_err = call->ndr_push(push, NDR_OUT, r);
4396         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4397                 talloc_free(r);
4398                 return false;
4399         }
4400
4401         blob = ndr_push_blob(push);
4402         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4403                 talloc_free(r);
4404                 return false;
4405         }
4406
4407         talloc_free(r);
4408
4409         return true;
4410 }
4411
4412 static bool api_PNP_UnregisterNotification(pipes_struct *p)
4413 {
4414         const struct ndr_interface_call *call;
4415         struct ndr_pull *pull;
4416         struct ndr_push *push;
4417         enum ndr_err_code ndr_err;
4418         DATA_BLOB blob;
4419         struct PNP_UnregisterNotification *r;
4420
4421         call = &ndr_table_ntsvcs.calls[NDR_PNP_UNREGISTERNOTIFICATION];
4422
4423         r = talloc(talloc_tos(), struct PNP_UnregisterNotification);
4424         if (r == NULL) {
4425                 return false;
4426         }
4427
4428         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4429                 talloc_free(r);
4430                 return false;
4431         }
4432
4433         pull = ndr_pull_init_blob(&blob, r);
4434         if (pull == NULL) {
4435                 talloc_free(r);
4436                 return false;
4437         }
4438
4439         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4440         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4441         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4442                 talloc_free(r);
4443                 return false;
4444         }
4445
4446         if (DEBUGLEVEL >= 10) {
4447                 NDR_PRINT_IN_DEBUG(PNP_UnregisterNotification, r);
4448         }
4449
4450         r->out.result = _PNP_UnregisterNotification(p, r);
4451
4452         if (p->rng_fault_state) {
4453                 talloc_free(r);
4454                 /* Return true here, srv_pipe_hnd.c will take care */
4455                 return true;
4456         }
4457
4458         if (DEBUGLEVEL >= 10) {
4459                 NDR_PRINT_OUT_DEBUG(PNP_UnregisterNotification, r);
4460         }
4461
4462         push = ndr_push_init_ctx(r);
4463         if (push == NULL) {
4464                 talloc_free(r);
4465                 return false;
4466         }
4467
4468         ndr_err = call->ndr_push(push, NDR_OUT, r);
4469         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4470                 talloc_free(r);
4471                 return false;
4472         }
4473
4474         blob = ndr_push_blob(push);
4475         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4476                 talloc_free(r);
4477                 return false;
4478         }
4479
4480         talloc_free(r);
4481
4482         return true;
4483 }
4484
4485 static bool api_PNP_GetCustomDevProp(pipes_struct *p)
4486 {
4487         const struct ndr_interface_call *call;
4488         struct ndr_pull *pull;
4489         struct ndr_push *push;
4490         enum ndr_err_code ndr_err;
4491         DATA_BLOB blob;
4492         struct PNP_GetCustomDevProp *r;
4493
4494         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCUSTOMDEVPROP];
4495
4496         r = talloc(talloc_tos(), struct PNP_GetCustomDevProp);
4497         if (r == NULL) {
4498                 return false;
4499         }
4500
4501         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4502                 talloc_free(r);
4503                 return false;
4504         }
4505
4506         pull = ndr_pull_init_blob(&blob, r);
4507         if (pull == NULL) {
4508                 talloc_free(r);
4509                 return false;
4510         }
4511
4512         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4513         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4514         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4515                 talloc_free(r);
4516                 return false;
4517         }
4518
4519         if (DEBUGLEVEL >= 10) {
4520                 NDR_PRINT_IN_DEBUG(PNP_GetCustomDevProp, r);
4521         }
4522
4523         r->out.result = _PNP_GetCustomDevProp(p, r);
4524
4525         if (p->rng_fault_state) {
4526                 talloc_free(r);
4527                 /* Return true here, srv_pipe_hnd.c will take care */
4528                 return true;
4529         }
4530
4531         if (DEBUGLEVEL >= 10) {
4532                 NDR_PRINT_OUT_DEBUG(PNP_GetCustomDevProp, r);
4533         }
4534
4535         push = ndr_push_init_ctx(r);
4536         if (push == NULL) {
4537                 talloc_free(r);
4538                 return false;
4539         }
4540
4541         ndr_err = call->ndr_push(push, NDR_OUT, r);
4542         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4543                 talloc_free(r);
4544                 return false;
4545         }
4546
4547         blob = ndr_push_blob(push);
4548         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4549                 talloc_free(r);
4550                 return false;
4551         }
4552
4553         talloc_free(r);
4554
4555         return true;
4556 }
4557
4558 static bool api_PNP_GetVersionInternal(pipes_struct *p)
4559 {
4560         const struct ndr_interface_call *call;
4561         struct ndr_pull *pull;
4562         struct ndr_push *push;
4563         enum ndr_err_code ndr_err;
4564         DATA_BLOB blob;
4565         struct PNP_GetVersionInternal *r;
4566
4567         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETVERSIONINTERNAL];
4568
4569         r = talloc(talloc_tos(), struct PNP_GetVersionInternal);
4570         if (r == NULL) {
4571                 return false;
4572         }
4573
4574         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4575                 talloc_free(r);
4576                 return false;
4577         }
4578
4579         pull = ndr_pull_init_blob(&blob, r);
4580         if (pull == NULL) {
4581                 talloc_free(r);
4582                 return false;
4583         }
4584
4585         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4586         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4587         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4588                 talloc_free(r);
4589                 return false;
4590         }
4591
4592         if (DEBUGLEVEL >= 10) {
4593                 NDR_PRINT_IN_DEBUG(PNP_GetVersionInternal, r);
4594         }
4595
4596         r->out.result = _PNP_GetVersionInternal(p, r);
4597
4598         if (p->rng_fault_state) {
4599                 talloc_free(r);
4600                 /* Return true here, srv_pipe_hnd.c will take care */
4601                 return true;
4602         }
4603
4604         if (DEBUGLEVEL >= 10) {
4605                 NDR_PRINT_OUT_DEBUG(PNP_GetVersionInternal, r);
4606         }
4607
4608         push = ndr_push_init_ctx(r);
4609         if (push == NULL) {
4610                 talloc_free(r);
4611                 return false;
4612         }
4613
4614         ndr_err = call->ndr_push(push, NDR_OUT, r);
4615         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4616                 talloc_free(r);
4617                 return false;
4618         }
4619
4620         blob = ndr_push_blob(push);
4621         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4622                 talloc_free(r);
4623                 return false;
4624         }
4625
4626         talloc_free(r);
4627
4628         return true;
4629 }
4630
4631 static bool api_PNP_GetBlockedDriverInfo(pipes_struct *p)
4632 {
4633         const struct ndr_interface_call *call;
4634         struct ndr_pull *pull;
4635         struct ndr_push *push;
4636         enum ndr_err_code ndr_err;
4637         DATA_BLOB blob;
4638         struct PNP_GetBlockedDriverInfo *r;
4639
4640         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETBLOCKEDDRIVERINFO];
4641
4642         r = talloc(talloc_tos(), struct PNP_GetBlockedDriverInfo);
4643         if (r == NULL) {
4644                 return false;
4645         }
4646
4647         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4648                 talloc_free(r);
4649                 return false;
4650         }
4651
4652         pull = ndr_pull_init_blob(&blob, r);
4653         if (pull == NULL) {
4654                 talloc_free(r);
4655                 return false;
4656         }
4657
4658         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4659         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4660         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4661                 talloc_free(r);
4662                 return false;
4663         }
4664
4665         if (DEBUGLEVEL >= 10) {
4666                 NDR_PRINT_IN_DEBUG(PNP_GetBlockedDriverInfo, r);
4667         }
4668
4669         r->out.result = _PNP_GetBlockedDriverInfo(p, r);
4670
4671         if (p->rng_fault_state) {
4672                 talloc_free(r);
4673                 /* Return true here, srv_pipe_hnd.c will take care */
4674                 return true;
4675         }
4676
4677         if (DEBUGLEVEL >= 10) {
4678                 NDR_PRINT_OUT_DEBUG(PNP_GetBlockedDriverInfo, r);
4679         }
4680
4681         push = ndr_push_init_ctx(r);
4682         if (push == NULL) {
4683                 talloc_free(r);
4684                 return false;
4685         }
4686
4687         ndr_err = call->ndr_push(push, NDR_OUT, r);
4688         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4689                 talloc_free(r);
4690                 return false;
4691         }
4692
4693         blob = ndr_push_blob(push);
4694         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4695                 talloc_free(r);
4696                 return false;
4697         }
4698
4699         talloc_free(r);
4700
4701         return true;
4702 }
4703
4704 static bool api_PNP_GetServerSideDeviceInstallFlags(pipes_struct *p)
4705 {
4706         const struct ndr_interface_call *call;
4707         struct ndr_pull *pull;
4708         struct ndr_push *push;
4709         enum ndr_err_code ndr_err;
4710         DATA_BLOB blob;
4711         struct PNP_GetServerSideDeviceInstallFlags *r;
4712
4713         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS];
4714
4715         r = talloc(talloc_tos(), struct PNP_GetServerSideDeviceInstallFlags);
4716         if (r == NULL) {
4717                 return false;
4718         }
4719
4720         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4721                 talloc_free(r);
4722                 return false;
4723         }
4724
4725         pull = ndr_pull_init_blob(&blob, r);
4726         if (pull == NULL) {
4727                 talloc_free(r);
4728                 return false;
4729         }
4730
4731         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4732         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4733         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4734                 talloc_free(r);
4735                 return false;
4736         }
4737
4738         if (DEBUGLEVEL >= 10) {
4739                 NDR_PRINT_IN_DEBUG(PNP_GetServerSideDeviceInstallFlags, r);
4740         }
4741
4742         r->out.result = _PNP_GetServerSideDeviceInstallFlags(p, r);
4743
4744         if (p->rng_fault_state) {
4745                 talloc_free(r);
4746                 /* Return true here, srv_pipe_hnd.c will take care */
4747                 return true;
4748         }
4749
4750         if (DEBUGLEVEL >= 10) {
4751                 NDR_PRINT_OUT_DEBUG(PNP_GetServerSideDeviceInstallFlags, r);
4752         }
4753
4754         push = ndr_push_init_ctx(r);
4755         if (push == NULL) {
4756                 talloc_free(r);
4757                 return false;
4758         }
4759
4760         ndr_err = call->ndr_push(push, NDR_OUT, r);
4761         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4762                 talloc_free(r);
4763                 return false;
4764         }
4765
4766         blob = ndr_push_blob(push);
4767         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4768                 talloc_free(r);
4769                 return false;
4770         }
4771
4772         talloc_free(r);
4773
4774         return true;
4775 }
4776
4777
4778 /* Tables */
4779 static struct api_struct api_ntsvcs_cmds[] =
4780 {
4781         {"PNP_DISCONNECT", NDR_PNP_DISCONNECT, api_PNP_Disconnect},
4782         {"PNP_CONNECT", NDR_PNP_CONNECT, api_PNP_Connect},
4783         {"PNP_GETVERSION", NDR_PNP_GETVERSION, api_PNP_GetVersion},
4784         {"PNP_GETGLOBALSTATE", NDR_PNP_GETGLOBALSTATE, api_PNP_GetGlobalState},
4785         {"PNP_INITDETECTION", NDR_PNP_INITDETECTION, api_PNP_InitDetection},
4786         {"PNP_REPORTLOGON", NDR_PNP_REPORTLOGON, api_PNP_ReportLogOn},
4787         {"PNP_VALIDATEDEVICEINSTANCE", NDR_PNP_VALIDATEDEVICEINSTANCE, api_PNP_ValidateDeviceInstance},
4788         {"PNP_GETROOTDEVICEINSTANCE", NDR_PNP_GETROOTDEVICEINSTANCE, api_PNP_GetRootDeviceInstance},
4789         {"PNP_GETRELATEDDEVICEINSTANCE", NDR_PNP_GETRELATEDDEVICEINSTANCE, api_PNP_GetRelatedDeviceInstance},
4790         {"PNP_ENUMERATESUBKEYS", NDR_PNP_ENUMERATESUBKEYS, api_PNP_EnumerateSubKeys},
4791         {"PNP_GETDEVICELIST", NDR_PNP_GETDEVICELIST, api_PNP_GetDeviceList},
4792         {"PNP_GETDEVICELISTSIZE", NDR_PNP_GETDEVICELISTSIZE, api_PNP_GetDeviceListSize},
4793         {"PNP_GETDEPTH", NDR_PNP_GETDEPTH, api_PNP_GetDepth},
4794         {"PNP_GETDEVICEREGPROP", NDR_PNP_GETDEVICEREGPROP, api_PNP_GetDeviceRegProp},
4795         {"PNP_SETDEVICEREGPROP", NDR_PNP_SETDEVICEREGPROP, api_PNP_SetDeviceRegProp},
4796         {"PNP_GETCLASSINSTANCE", NDR_PNP_GETCLASSINSTANCE, api_PNP_GetClassInstance},
4797         {"PNP_CREATEKEY", NDR_PNP_CREATEKEY, api_PNP_CreateKey},
4798         {"PNP_DELETEREGISTRYKEY", NDR_PNP_DELETEREGISTRYKEY, api_PNP_DeleteRegistryKey},
4799         {"PNP_GETCLASSCOUNT", NDR_PNP_GETCLASSCOUNT, api_PNP_GetClassCount},
4800         {"PNP_GETCLASSNAME", NDR_PNP_GETCLASSNAME, api_PNP_GetClassName},
4801         {"PNP_DELETECLASSKEY", NDR_PNP_DELETECLASSKEY, api_PNP_DeleteClassKey},
4802         {"PNP_GETINTERFACEDEVICEALIAS", NDR_PNP_GETINTERFACEDEVICEALIAS, api_PNP_GetInterfaceDeviceAlias},
4803         {"PNP_GETINTERFACEDEVICELIST", NDR_PNP_GETINTERFACEDEVICELIST, api_PNP_GetInterfaceDeviceList},
4804         {"PNP_GETINTERFACEDEVICELISTSIZE", NDR_PNP_GETINTERFACEDEVICELISTSIZE, api_PNP_GetInterfaceDeviceListSize},
4805         {"PNP_REGISTERDEVICECLASSASSOCIATION", NDR_PNP_REGISTERDEVICECLASSASSOCIATION, api_PNP_RegisterDeviceClassAssociation},
4806         {"PNP_UNREGISTERDEVICECLASSASSOCIATION", NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION, api_PNP_UnregisterDeviceClassAssociation},
4807         {"PNP_GETCLASSREGPROP", NDR_PNP_GETCLASSREGPROP, api_PNP_GetClassRegProp},
4808         {"PNP_SETCLASSREGPROP", NDR_PNP_SETCLASSREGPROP, api_PNP_SetClassRegProp},
4809         {"PNP_CREATEDEVINST", NDR_PNP_CREATEDEVINST, api_PNP_CreateDevInst},
4810         {"PNP_DEVICEINSTANCEACTION", NDR_PNP_DEVICEINSTANCEACTION, api_PNP_DeviceInstanceAction},
4811         {"PNP_GETDEVICESTATUS", NDR_PNP_GETDEVICESTATUS, api_PNP_GetDeviceStatus},
4812         {"PNP_SETDEVICEPROBLEM", NDR_PNP_SETDEVICEPROBLEM, api_PNP_SetDeviceProblem},
4813         {"PNP_DISABLEDEVINST", NDR_PNP_DISABLEDEVINST, api_PNP_DisableDevInst},
4814         {"PNP_UNINSTALLDEVINST", NDR_PNP_UNINSTALLDEVINST, api_PNP_UninstallDevInst},
4815         {"PNP_ADDID", NDR_PNP_ADDID, api_PNP_AddID},
4816         {"PNP_REGISTERDRIVER", NDR_PNP_REGISTERDRIVER, api_PNP_RegisterDriver},
4817         {"PNP_QUERYREMOVE", NDR_PNP_QUERYREMOVE, api_PNP_QueryRemove},
4818         {"PNP_REQUESTDEVICEEJECT", NDR_PNP_REQUESTDEVICEEJECT, api_PNP_RequestDeviceEject},
4819         {"PNP_ISDOCKSTATIONPRESENT", NDR_PNP_ISDOCKSTATIONPRESENT, api_PNP_IsDockStationPresent},
4820         {"PNP_REQUESTEJECTPC", NDR_PNP_REQUESTEJECTPC, api_PNP_RequestEjectPC},
4821         {"PNP_HWPROFFLAGS", NDR_PNP_HWPROFFLAGS, api_PNP_HwProfFlags},
4822         {"PNP_GETHWPROFINFO", NDR_PNP_GETHWPROFINFO, api_PNP_GetHwProfInfo},
4823         {"PNP_ADDEMPTYLOGCONF", NDR_PNP_ADDEMPTYLOGCONF, api_PNP_AddEmptyLogConf},
4824         {"PNP_FREELOGCONF", NDR_PNP_FREELOGCONF, api_PNP_FreeLogConf},
4825         {"PNP_GETFIRSTLOGCONF", NDR_PNP_GETFIRSTLOGCONF, api_PNP_GetFirstLogConf},
4826         {"PNP_GETNEXTLOGCONF", NDR_PNP_GETNEXTLOGCONF, api_PNP_GetNextLogConf},
4827         {"PNP_GETLOGCONFPRIORITY", NDR_PNP_GETLOGCONFPRIORITY, api_PNP_GetLogConfPriority},
4828         {"PNP_ADDRESDES", NDR_PNP_ADDRESDES, api_PNP_AddResDes},
4829         {"PNP_FREERESDES", NDR_PNP_FREERESDES, api_PNP_FreeResDes},
4830         {"PNP_GETNEXTRESDES", NDR_PNP_GETNEXTRESDES, api_PNP_GetNextResDes},
4831         {"PNP_GETRESDESDATA", NDR_PNP_GETRESDESDATA, api_PNP_GetResDesData},
4832         {"PNP_GETRESDESDATASIZE", NDR_PNP_GETRESDESDATASIZE, api_PNP_GetResDesDataSize},
4833         {"PNP_MODIFYRESDES", NDR_PNP_MODIFYRESDES, api_PNP_ModifyResDes},
4834         {"PNP_DETECTRESOURCELIMIT", NDR_PNP_DETECTRESOURCELIMIT, api_PNP_DetectResourceLimit},
4835         {"PNP_QUERYRESCONFLIST", NDR_PNP_QUERYRESCONFLIST, api_PNP_QueryResConfList},
4836         {"PNP_SETHWPROF", NDR_PNP_SETHWPROF, api_PNP_SetHwProf},
4837         {"PNP_QUERYARBITRATORFREEDATA", NDR_PNP_QUERYARBITRATORFREEDATA, api_PNP_QueryArbitratorFreeData},
4838         {"PNP_QUERYARBITRATORFREESIZE", NDR_PNP_QUERYARBITRATORFREESIZE, api_PNP_QueryArbitratorFreeSize},
4839         {"PNP_RUNDETECTION", NDR_PNP_RUNDETECTION, api_PNP_RunDetection},
4840         {"PNP_REGISTERNOTIFICATION", NDR_PNP_REGISTERNOTIFICATION, api_PNP_RegisterNotification},
4841         {"PNP_UNREGISTERNOTIFICATION", NDR_PNP_UNREGISTERNOTIFICATION, api_PNP_UnregisterNotification},
4842         {"PNP_GETCUSTOMDEVPROP", NDR_PNP_GETCUSTOMDEVPROP, api_PNP_GetCustomDevProp},
4843         {"PNP_GETVERSIONINTERNAL", NDR_PNP_GETVERSIONINTERNAL, api_PNP_GetVersionInternal},
4844         {"PNP_GETBLOCKEDDRIVERINFO", NDR_PNP_GETBLOCKEDDRIVERINFO, api_PNP_GetBlockedDriverInfo},
4845         {"PNP_GETSERVERSIDEDEVICEINSTALLFLAGS", NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS, api_PNP_GetServerSideDeviceInstallFlags},
4846 };
4847
4848 void ntsvcs_get_pipe_fns(struct api_struct **fns, int *n_fns)
4849 {
4850         *fns = api_ntsvcs_cmds;
4851         *n_fns = sizeof(api_ntsvcs_cmds) / sizeof(struct api_struct);
4852 }
4853
4854 NTSTATUS rpc_ntsvcs_init(void)
4855 {
4856         return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "ntsvcs", "ntsvcs", api_ntsvcs_cmds, sizeof(api_ntsvcs_cmds) / sizeof(struct api_struct));
4857 }