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