root/librpc/gen_ndr/cli_ntsvcs.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. rpccli_PNP_Disconnect
  2. rpccli_PNP_Connect
  3. rpccli_PNP_GetVersion
  4. rpccli_PNP_GetGlobalState
  5. rpccli_PNP_InitDetection
  6. rpccli_PNP_ReportLogOn
  7. rpccli_PNP_ValidateDeviceInstance
  8. rpccli_PNP_GetRootDeviceInstance
  9. rpccli_PNP_GetRelatedDeviceInstance
  10. rpccli_PNP_EnumerateSubKeys
  11. rpccli_PNP_GetDeviceList
  12. rpccli_PNP_GetDeviceListSize
  13. rpccli_PNP_GetDepth
  14. rpccli_PNP_GetDeviceRegProp
  15. rpccli_PNP_SetDeviceRegProp
  16. rpccli_PNP_GetClassInstance
  17. rpccli_PNP_CreateKey
  18. rpccli_PNP_DeleteRegistryKey
  19. rpccli_PNP_GetClassCount
  20. rpccli_PNP_GetClassName
  21. rpccli_PNP_DeleteClassKey
  22. rpccli_PNP_GetInterfaceDeviceAlias
  23. rpccli_PNP_GetInterfaceDeviceList
  24. rpccli_PNP_GetInterfaceDeviceListSize
  25. rpccli_PNP_RegisterDeviceClassAssociation
  26. rpccli_PNP_UnregisterDeviceClassAssociation
  27. rpccli_PNP_GetClassRegProp
  28. rpccli_PNP_SetClassRegProp
  29. rpccli_PNP_CreateDevInst
  30. rpccli_PNP_DeviceInstanceAction
  31. rpccli_PNP_GetDeviceStatus
  32. rpccli_PNP_SetDeviceProblem
  33. rpccli_PNP_DisableDevInst
  34. rpccli_PNP_UninstallDevInst
  35. rpccli_PNP_AddID
  36. rpccli_PNP_RegisterDriver
  37. rpccli_PNP_QueryRemove
  38. rpccli_PNP_RequestDeviceEject
  39. rpccli_PNP_IsDockStationPresent
  40. rpccli_PNP_RequestEjectPC
  41. rpccli_PNP_HwProfFlags
  42. rpccli_PNP_GetHwProfInfo
  43. rpccli_PNP_AddEmptyLogConf
  44. rpccli_PNP_FreeLogConf
  45. rpccli_PNP_GetFirstLogConf
  46. rpccli_PNP_GetNextLogConf
  47. rpccli_PNP_GetLogConfPriority
  48. rpccli_PNP_AddResDes
  49. rpccli_PNP_FreeResDes
  50. rpccli_PNP_GetNextResDes
  51. rpccli_PNP_GetResDesData
  52. rpccli_PNP_GetResDesDataSize
  53. rpccli_PNP_ModifyResDes
  54. rpccli_PNP_DetectResourceLimit
  55. rpccli_PNP_QueryResConfList
  56. rpccli_PNP_SetHwProf
  57. rpccli_PNP_QueryArbitratorFreeData
  58. rpccli_PNP_QueryArbitratorFreeSize
  59. rpccli_PNP_RunDetection
  60. rpccli_PNP_RegisterNotification
  61. rpccli_PNP_UnregisterNotification
  62. rpccli_PNP_GetCustomDevProp
  63. rpccli_PNP_GetVersionInternal
  64. rpccli_PNP_GetBlockedDriverInfo
  65. rpccli_PNP_GetServerSideDeviceInstallFlags

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

/* [<][>][^][v][top][bottom][index][help] */