root/librpc/gen_ndr/cli_winreg.c

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

DEFINITIONS

This source file includes following definitions.
  1. rpccli_winreg_OpenHKCR
  2. rpccli_winreg_OpenHKCU
  3. rpccli_winreg_OpenHKLM
  4. rpccli_winreg_OpenHKPD
  5. rpccli_winreg_OpenHKU
  6. rpccli_winreg_CloseKey
  7. rpccli_winreg_CreateKey
  8. rpccli_winreg_DeleteKey
  9. rpccli_winreg_DeleteValue
  10. rpccli_winreg_EnumKey
  11. rpccli_winreg_EnumValue
  12. rpccli_winreg_FlushKey
  13. rpccli_winreg_GetKeySecurity
  14. rpccli_winreg_LoadKey
  15. rpccli_winreg_NotifyChangeKeyValue
  16. rpccli_winreg_OpenKey
  17. rpccli_winreg_QueryInfoKey
  18. rpccli_winreg_QueryValue
  19. rpccli_winreg_ReplaceKey
  20. rpccli_winreg_RestoreKey
  21. rpccli_winreg_SaveKey
  22. rpccli_winreg_SetKeySecurity
  23. rpccli_winreg_SetValue
  24. rpccli_winreg_UnLoadKey
  25. rpccli_winreg_InitiateSystemShutdown
  26. rpccli_winreg_AbortSystemShutdown
  27. rpccli_winreg_GetVersion
  28. rpccli_winreg_OpenHKCC
  29. rpccli_winreg_OpenHKDD
  30. rpccli_winreg_QueryMultipleValues
  31. rpccli_winreg_InitiateSystemShutdownEx
  32. rpccli_winreg_SaveKeyEx
  33. rpccli_winreg_OpenHKPT
  34. rpccli_winreg_OpenHKPN
  35. rpccli_winreg_QueryMultipleValues2

   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_winreg.h"
   8 
   9 NTSTATUS rpccli_winreg_OpenHKCR(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
  10                                 TALLOC_CTX *mem_ctx,
  11                                 uint16_t *system_name /* [in] [unique] */,
  12                                 uint32_t access_mask /* [in]  */,
  13                                 struct policy_handle *handle /* [out] [ref] */,
  14                                 WERROR *werror)
  15 {
  16         struct winreg_OpenHKCR r;
  17         NTSTATUS status;
  18 
  19         /* In parameters */
  20         r.in.system_name = system_name;
  21         r.in.access_mask = access_mask;
  22 
  23         if (DEBUGLEVEL >= 10) {
  24                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCR, &r);
  25         }
  26 
  27         status = cli->dispatch(cli,
  28                                 mem_ctx,
  29                                 &ndr_table_winreg,
  30                                 NDR_WINREG_OPENHKCR,
  31                                 &r);
  32 
  33         if (!NT_STATUS_IS_OK(status)) {
  34                 return status;
  35         }
  36 
  37         if (DEBUGLEVEL >= 10) {
  38                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCR, &r);
  39         }
  40 
  41         if (NT_STATUS_IS_ERR(status)) {
  42                 return status;
  43         }
  44 
  45         /* Return variables */
  46         *handle = *r.out.handle;
  47 
  48         /* Return result */
  49         if (werror) {
  50                 *werror = r.out.result;
  51         }
  52 
  53         return werror_to_ntstatus(r.out.result);
  54 }
  55 
  56 NTSTATUS rpccli_winreg_OpenHKCU(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
  57                                 TALLOC_CTX *mem_ctx,
  58                                 uint16_t *system_name /* [in] [unique] */,
  59                                 uint32_t access_mask /* [in]  */,
  60                                 struct policy_handle *handle /* [out] [ref] */,
  61                                 WERROR *werror)
  62 {
  63         struct winreg_OpenHKCU r;
  64         NTSTATUS status;
  65 
  66         /* In parameters */
  67         r.in.system_name = system_name;
  68         r.in.access_mask = access_mask;
  69 
  70         if (DEBUGLEVEL >= 10) {
  71                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCU, &r);
  72         }
  73 
  74         status = cli->dispatch(cli,
  75                                 mem_ctx,
  76                                 &ndr_table_winreg,
  77                                 NDR_WINREG_OPENHKCU,
  78                                 &r);
  79 
  80         if (!NT_STATUS_IS_OK(status)) {
  81                 return status;
  82         }
  83 
  84         if (DEBUGLEVEL >= 10) {
  85                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCU, &r);
  86         }
  87 
  88         if (NT_STATUS_IS_ERR(status)) {
  89                 return status;
  90         }
  91 
  92         /* Return variables */
  93         *handle = *r.out.handle;
  94 
  95         /* Return result */
  96         if (werror) {
  97                 *werror = r.out.result;
  98         }
  99 
 100         return werror_to_ntstatus(r.out.result);
 101 }
 102 
 103 NTSTATUS rpccli_winreg_OpenHKLM(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 104                                 TALLOC_CTX *mem_ctx,
 105                                 uint16_t *system_name /* [in] [unique] */,
 106                                 uint32_t access_mask /* [in]  */,
 107                                 struct policy_handle *handle /* [out] [ref] */,
 108                                 WERROR *werror)
 109 {
 110         struct winreg_OpenHKLM r;
 111         NTSTATUS status;
 112 
 113         /* In parameters */
 114         r.in.system_name = system_name;
 115         r.in.access_mask = access_mask;
 116 
 117         if (DEBUGLEVEL >= 10) {
 118                 NDR_PRINT_IN_DEBUG(winreg_OpenHKLM, &r);
 119         }
 120 
 121         status = cli->dispatch(cli,
 122                                 mem_ctx,
 123                                 &ndr_table_winreg,
 124                                 NDR_WINREG_OPENHKLM,
 125                                 &r);
 126 
 127         if (!NT_STATUS_IS_OK(status)) {
 128                 return status;
 129         }
 130 
 131         if (DEBUGLEVEL >= 10) {
 132                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKLM, &r);
 133         }
 134 
 135         if (NT_STATUS_IS_ERR(status)) {
 136                 return status;
 137         }
 138 
 139         /* Return variables */
 140         *handle = *r.out.handle;
 141 
 142         /* Return result */
 143         if (werror) {
 144                 *werror = r.out.result;
 145         }
 146 
 147         return werror_to_ntstatus(r.out.result);
 148 }
 149 
 150 NTSTATUS rpccli_winreg_OpenHKPD(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 151                                 TALLOC_CTX *mem_ctx,
 152                                 uint16_t *system_name /* [in] [unique] */,
 153                                 uint32_t access_mask /* [in]  */,
 154                                 struct policy_handle *handle /* [out] [ref] */,
 155                                 WERROR *werror)
 156 {
 157         struct winreg_OpenHKPD r;
 158         NTSTATUS status;
 159 
 160         /* In parameters */
 161         r.in.system_name = system_name;
 162         r.in.access_mask = access_mask;
 163 
 164         if (DEBUGLEVEL >= 10) {
 165                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPD, &r);
 166         }
 167 
 168         status = cli->dispatch(cli,
 169                                 mem_ctx,
 170                                 &ndr_table_winreg,
 171                                 NDR_WINREG_OPENHKPD,
 172                                 &r);
 173 
 174         if (!NT_STATUS_IS_OK(status)) {
 175                 return status;
 176         }
 177 
 178         if (DEBUGLEVEL >= 10) {
 179                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPD, &r);
 180         }
 181 
 182         if (NT_STATUS_IS_ERR(status)) {
 183                 return status;
 184         }
 185 
 186         /* Return variables */
 187         *handle = *r.out.handle;
 188 
 189         /* Return result */
 190         if (werror) {
 191                 *werror = r.out.result;
 192         }
 193 
 194         return werror_to_ntstatus(r.out.result);
 195 }
 196 
 197 NTSTATUS rpccli_winreg_OpenHKU(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 198                                TALLOC_CTX *mem_ctx,
 199                                uint16_t *system_name /* [in] [unique] */,
 200                                uint32_t access_mask /* [in]  */,
 201                                struct policy_handle *handle /* [out] [ref] */,
 202                                WERROR *werror)
 203 {
 204         struct winreg_OpenHKU r;
 205         NTSTATUS status;
 206 
 207         /* In parameters */
 208         r.in.system_name = system_name;
 209         r.in.access_mask = access_mask;
 210 
 211         if (DEBUGLEVEL >= 10) {
 212                 NDR_PRINT_IN_DEBUG(winreg_OpenHKU, &r);
 213         }
 214 
 215         status = cli->dispatch(cli,
 216                                 mem_ctx,
 217                                 &ndr_table_winreg,
 218                                 NDR_WINREG_OPENHKU,
 219                                 &r);
 220 
 221         if (!NT_STATUS_IS_OK(status)) {
 222                 return status;
 223         }
 224 
 225         if (DEBUGLEVEL >= 10) {
 226                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKU, &r);
 227         }
 228 
 229         if (NT_STATUS_IS_ERR(status)) {
 230                 return status;
 231         }
 232 
 233         /* Return variables */
 234         *handle = *r.out.handle;
 235 
 236         /* Return result */
 237         if (werror) {
 238                 *werror = r.out.result;
 239         }
 240 
 241         return werror_to_ntstatus(r.out.result);
 242 }
 243 
 244 NTSTATUS rpccli_winreg_CloseKey(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 245                                 TALLOC_CTX *mem_ctx,
 246                                 struct policy_handle *handle /* [in,out] [ref] */,
 247                                 WERROR *werror)
 248 {
 249         struct winreg_CloseKey r;
 250         NTSTATUS status;
 251 
 252         /* In parameters */
 253         r.in.handle = handle;
 254 
 255         if (DEBUGLEVEL >= 10) {
 256                 NDR_PRINT_IN_DEBUG(winreg_CloseKey, &r);
 257         }
 258 
 259         status = cli->dispatch(cli,
 260                                 mem_ctx,
 261                                 &ndr_table_winreg,
 262                                 NDR_WINREG_CLOSEKEY,
 263                                 &r);
 264 
 265         if (!NT_STATUS_IS_OK(status)) {
 266                 return status;
 267         }
 268 
 269         if (DEBUGLEVEL >= 10) {
 270                 NDR_PRINT_OUT_DEBUG(winreg_CloseKey, &r);
 271         }
 272 
 273         if (NT_STATUS_IS_ERR(status)) {
 274                 return status;
 275         }
 276 
 277         /* Return variables */
 278         *handle = *r.out.handle;
 279 
 280         /* Return result */
 281         if (werror) {
 282                 *werror = r.out.result;
 283         }
 284 
 285         return werror_to_ntstatus(r.out.result);
 286 }
 287 
 288 NTSTATUS rpccli_winreg_CreateKey(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 289                                  TALLOC_CTX *mem_ctx,
 290                                  struct policy_handle *handle /* [in] [ref] */,
 291                                  struct winreg_String name /* [in]  */,
 292                                  struct winreg_String keyclass /* [in]  */,
 293                                  uint32_t options /* [in]  */,
 294                                  uint32_t access_mask /* [in]  */,
 295                                  struct winreg_SecBuf *secdesc /* [in] [unique] */,
 296                                  struct policy_handle *new_handle /* [out] [ref] */,
 297                                  enum winreg_CreateAction *action_taken /* [in,out] [unique] */,
 298                                  WERROR *werror)
 299 {
 300         struct winreg_CreateKey r;
 301         NTSTATUS status;
 302 
 303         /* In parameters */
 304         r.in.handle = handle;
 305         r.in.name = name;
 306         r.in.keyclass = keyclass;
 307         r.in.options = options;
 308         r.in.access_mask = access_mask;
 309         r.in.secdesc = secdesc;
 310         r.in.action_taken = action_taken;
 311 
 312         if (DEBUGLEVEL >= 10) {
 313                 NDR_PRINT_IN_DEBUG(winreg_CreateKey, &r);
 314         }
 315 
 316         status = cli->dispatch(cli,
 317                                 mem_ctx,
 318                                 &ndr_table_winreg,
 319                                 NDR_WINREG_CREATEKEY,
 320                                 &r);
 321 
 322         if (!NT_STATUS_IS_OK(status)) {
 323                 return status;
 324         }
 325 
 326         if (DEBUGLEVEL >= 10) {
 327                 NDR_PRINT_OUT_DEBUG(winreg_CreateKey, &r);
 328         }
 329 
 330         if (NT_STATUS_IS_ERR(status)) {
 331                 return status;
 332         }
 333 
 334         /* Return variables */
 335         *new_handle = *r.out.new_handle;
 336         if (action_taken && r.out.action_taken) {
 337                 *action_taken = *r.out.action_taken;
 338         }
 339 
 340         /* Return result */
 341         if (werror) {
 342                 *werror = r.out.result;
 343         }
 344 
 345         return werror_to_ntstatus(r.out.result);
 346 }
 347 
 348 NTSTATUS rpccli_winreg_DeleteKey(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 349                                  TALLOC_CTX *mem_ctx,
 350                                  struct policy_handle *handle /* [in] [ref] */,
 351                                  struct winreg_String key /* [in]  */,
 352                                  WERROR *werror)
 353 {
 354         struct winreg_DeleteKey r;
 355         NTSTATUS status;
 356 
 357         /* In parameters */
 358         r.in.handle = handle;
 359         r.in.key = key;
 360 
 361         if (DEBUGLEVEL >= 10) {
 362                 NDR_PRINT_IN_DEBUG(winreg_DeleteKey, &r);
 363         }
 364 
 365         status = cli->dispatch(cli,
 366                                 mem_ctx,
 367                                 &ndr_table_winreg,
 368                                 NDR_WINREG_DELETEKEY,
 369                                 &r);
 370 
 371         if (!NT_STATUS_IS_OK(status)) {
 372                 return status;
 373         }
 374 
 375         if (DEBUGLEVEL >= 10) {
 376                 NDR_PRINT_OUT_DEBUG(winreg_DeleteKey, &r);
 377         }
 378 
 379         if (NT_STATUS_IS_ERR(status)) {
 380                 return status;
 381         }
 382 
 383         /* Return variables */
 384 
 385         /* Return result */
 386         if (werror) {
 387                 *werror = r.out.result;
 388         }
 389 
 390         return werror_to_ntstatus(r.out.result);
 391 }
 392 
 393 NTSTATUS rpccli_winreg_DeleteValue(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 394                                    TALLOC_CTX *mem_ctx,
 395                                    struct policy_handle *handle /* [in] [ref] */,
 396                                    struct winreg_String value /* [in]  */,
 397                                    WERROR *werror)
 398 {
 399         struct winreg_DeleteValue r;
 400         NTSTATUS status;
 401 
 402         /* In parameters */
 403         r.in.handle = handle;
 404         r.in.value = value;
 405 
 406         if (DEBUGLEVEL >= 10) {
 407                 NDR_PRINT_IN_DEBUG(winreg_DeleteValue, &r);
 408         }
 409 
 410         status = cli->dispatch(cli,
 411                                 mem_ctx,
 412                                 &ndr_table_winreg,
 413                                 NDR_WINREG_DELETEVALUE,
 414                                 &r);
 415 
 416         if (!NT_STATUS_IS_OK(status)) {
 417                 return status;
 418         }
 419 
 420         if (DEBUGLEVEL >= 10) {
 421                 NDR_PRINT_OUT_DEBUG(winreg_DeleteValue, &r);
 422         }
 423 
 424         if (NT_STATUS_IS_ERR(status)) {
 425                 return status;
 426         }
 427 
 428         /* Return variables */
 429 
 430         /* Return result */
 431         if (werror) {
 432                 *werror = r.out.result;
 433         }
 434 
 435         return werror_to_ntstatus(r.out.result);
 436 }
 437 
 438 NTSTATUS rpccli_winreg_EnumKey(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 439                                TALLOC_CTX *mem_ctx,
 440                                struct policy_handle *handle /* [in] [ref] */,
 441                                uint32_t enum_index /* [in]  */,
 442                                struct winreg_StringBuf *name /* [in,out] [ref] */,
 443                                struct winreg_StringBuf *keyclass /* [in,out] [unique] */,
 444                                NTTIME *last_changed_time /* [in,out] [unique] */,
 445                                WERROR *werror)
 446 {
 447         struct winreg_EnumKey r;
 448         NTSTATUS status;
 449 
 450         /* In parameters */
 451         r.in.handle = handle;
 452         r.in.enum_index = enum_index;
 453         r.in.name = name;
 454         r.in.keyclass = keyclass;
 455         r.in.last_changed_time = last_changed_time;
 456 
 457         if (DEBUGLEVEL >= 10) {
 458                 NDR_PRINT_IN_DEBUG(winreg_EnumKey, &r);
 459         }
 460 
 461         status = cli->dispatch(cli,
 462                                 mem_ctx,
 463                                 &ndr_table_winreg,
 464                                 NDR_WINREG_ENUMKEY,
 465                                 &r);
 466 
 467         if (!NT_STATUS_IS_OK(status)) {
 468                 return status;
 469         }
 470 
 471         if (DEBUGLEVEL >= 10) {
 472                 NDR_PRINT_OUT_DEBUG(winreg_EnumKey, &r);
 473         }
 474 
 475         if (NT_STATUS_IS_ERR(status)) {
 476                 return status;
 477         }
 478 
 479         /* Return variables */
 480         *name = *r.out.name;
 481         if (keyclass && r.out.keyclass) {
 482                 *keyclass = *r.out.keyclass;
 483         }
 484         if (last_changed_time && r.out.last_changed_time) {
 485                 *last_changed_time = *r.out.last_changed_time;
 486         }
 487 
 488         /* Return result */
 489         if (werror) {
 490                 *werror = r.out.result;
 491         }
 492 
 493         return werror_to_ntstatus(r.out.result);
 494 }
 495 
 496 NTSTATUS rpccli_winreg_EnumValue(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 497                                  TALLOC_CTX *mem_ctx,
 498                                  struct policy_handle *handle /* [in] [ref] */,
 499                                  uint32_t enum_index /* [in]  */,
 500                                  struct winreg_ValNameBuf *name /* [in,out] [ref] */,
 501                                  enum winreg_Type *type /* [in,out] [unique] */,
 502                                  uint8_t *value /* [in,out] [unique,length_is(*length),size_is(*size)] */,
 503                                  uint32_t *size /* [in,out] [unique] */,
 504                                  uint32_t *length /* [in,out] [unique] */,
 505                                  WERROR *werror)
 506 {
 507         struct winreg_EnumValue r;
 508         NTSTATUS status;
 509 
 510         /* In parameters */
 511         r.in.handle = handle;
 512         r.in.enum_index = enum_index;
 513         r.in.name = name;
 514         r.in.type = type;
 515         r.in.value = value;
 516         r.in.size = size;
 517         r.in.length = length;
 518 
 519         if (DEBUGLEVEL >= 10) {
 520                 NDR_PRINT_IN_DEBUG(winreg_EnumValue, &r);
 521         }
 522 
 523         status = cli->dispatch(cli,
 524                                 mem_ctx,
 525                                 &ndr_table_winreg,
 526                                 NDR_WINREG_ENUMVALUE,
 527                                 &r);
 528 
 529         if (!NT_STATUS_IS_OK(status)) {
 530                 return status;
 531         }
 532 
 533         if (DEBUGLEVEL >= 10) {
 534                 NDR_PRINT_OUT_DEBUG(winreg_EnumValue, &r);
 535         }
 536 
 537         if (NT_STATUS_IS_ERR(status)) {
 538                 return status;
 539         }
 540 
 541         /* Return variables */
 542         *name = *r.out.name;
 543         if (type && r.out.type) {
 544                 *type = *r.out.type;
 545         }
 546         if (value && r.out.value) {
 547                 memcpy(value, r.out.value, *r.in.size * sizeof(*value));
 548         }
 549         if (size && r.out.size) {
 550                 *size = *r.out.size;
 551         }
 552         if (length && r.out.length) {
 553                 *length = *r.out.length;
 554         }
 555 
 556         /* Return result */
 557         if (werror) {
 558                 *werror = r.out.result;
 559         }
 560 
 561         return werror_to_ntstatus(r.out.result);
 562 }
 563 
 564 NTSTATUS rpccli_winreg_FlushKey(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 565                                 TALLOC_CTX *mem_ctx,
 566                                 struct policy_handle *handle /* [in] [ref] */,
 567                                 WERROR *werror)
 568 {
 569         struct winreg_FlushKey r;
 570         NTSTATUS status;
 571 
 572         /* In parameters */
 573         r.in.handle = handle;
 574 
 575         if (DEBUGLEVEL >= 10) {
 576                 NDR_PRINT_IN_DEBUG(winreg_FlushKey, &r);
 577         }
 578 
 579         status = cli->dispatch(cli,
 580                                 mem_ctx,
 581                                 &ndr_table_winreg,
 582                                 NDR_WINREG_FLUSHKEY,
 583                                 &r);
 584 
 585         if (!NT_STATUS_IS_OK(status)) {
 586                 return status;
 587         }
 588 
 589         if (DEBUGLEVEL >= 10) {
 590                 NDR_PRINT_OUT_DEBUG(winreg_FlushKey, &r);
 591         }
 592 
 593         if (NT_STATUS_IS_ERR(status)) {
 594                 return status;
 595         }
 596 
 597         /* Return variables */
 598 
 599         /* Return result */
 600         if (werror) {
 601                 *werror = r.out.result;
 602         }
 603 
 604         return werror_to_ntstatus(r.out.result);
 605 }
 606 
 607 NTSTATUS rpccli_winreg_GetKeySecurity(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 608                                       TALLOC_CTX *mem_ctx,
 609                                       struct policy_handle *handle /* [in] [ref] */,
 610                                       uint32_t sec_info /* [in]  */,
 611                                       struct KeySecurityData *sd /* [in,out] [ref] */,
 612                                       WERROR *werror)
 613 {
 614         struct winreg_GetKeySecurity r;
 615         NTSTATUS status;
 616 
 617         /* In parameters */
 618         r.in.handle = handle;
 619         r.in.sec_info = sec_info;
 620         r.in.sd = sd;
 621 
 622         if (DEBUGLEVEL >= 10) {
 623                 NDR_PRINT_IN_DEBUG(winreg_GetKeySecurity, &r);
 624         }
 625 
 626         status = cli->dispatch(cli,
 627                                 mem_ctx,
 628                                 &ndr_table_winreg,
 629                                 NDR_WINREG_GETKEYSECURITY,
 630                                 &r);
 631 
 632         if (!NT_STATUS_IS_OK(status)) {
 633                 return status;
 634         }
 635 
 636         if (DEBUGLEVEL >= 10) {
 637                 NDR_PRINT_OUT_DEBUG(winreg_GetKeySecurity, &r);
 638         }
 639 
 640         if (NT_STATUS_IS_ERR(status)) {
 641                 return status;
 642         }
 643 
 644         /* Return variables */
 645         *sd = *r.out.sd;
 646 
 647         /* Return result */
 648         if (werror) {
 649                 *werror = r.out.result;
 650         }
 651 
 652         return werror_to_ntstatus(r.out.result);
 653 }
 654 
 655 NTSTATUS rpccli_winreg_LoadKey(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 656                                TALLOC_CTX *mem_ctx,
 657                                struct policy_handle *handle /* [in] [ref] */,
 658                                struct winreg_String *keyname /* [in] [unique] */,
 659                                struct winreg_String *filename /* [in] [unique] */,
 660                                WERROR *werror)
 661 {
 662         struct winreg_LoadKey r;
 663         NTSTATUS status;
 664 
 665         /* In parameters */
 666         r.in.handle = handle;
 667         r.in.keyname = keyname;
 668         r.in.filename = filename;
 669 
 670         if (DEBUGLEVEL >= 10) {
 671                 NDR_PRINT_IN_DEBUG(winreg_LoadKey, &r);
 672         }
 673 
 674         status = cli->dispatch(cli,
 675                                 mem_ctx,
 676                                 &ndr_table_winreg,
 677                                 NDR_WINREG_LOADKEY,
 678                                 &r);
 679 
 680         if (!NT_STATUS_IS_OK(status)) {
 681                 return status;
 682         }
 683 
 684         if (DEBUGLEVEL >= 10) {
 685                 NDR_PRINT_OUT_DEBUG(winreg_LoadKey, &r);
 686         }
 687 
 688         if (NT_STATUS_IS_ERR(status)) {
 689                 return status;
 690         }
 691 
 692         /* Return variables */
 693 
 694         /* Return result */
 695         if (werror) {
 696                 *werror = r.out.result;
 697         }
 698 
 699         return werror_to_ntstatus(r.out.result);
 700 }
 701 
 702 NTSTATUS rpccli_winreg_NotifyChangeKeyValue(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 703                                             TALLOC_CTX *mem_ctx,
 704                                             struct policy_handle *handle /* [in] [ref] */,
 705                                             uint8_t watch_subtree /* [in]  */,
 706                                             uint32_t notify_filter /* [in]  */,
 707                                             uint32_t unknown /* [in]  */,
 708                                             struct winreg_String string1 /* [in]  */,
 709                                             struct winreg_String string2 /* [in]  */,
 710                                             uint32_t unknown2 /* [in]  */,
 711                                             WERROR *werror)
 712 {
 713         struct winreg_NotifyChangeKeyValue r;
 714         NTSTATUS status;
 715 
 716         /* In parameters */
 717         r.in.handle = handle;
 718         r.in.watch_subtree = watch_subtree;
 719         r.in.notify_filter = notify_filter;
 720         r.in.unknown = unknown;
 721         r.in.string1 = string1;
 722         r.in.string2 = string2;
 723         r.in.unknown2 = unknown2;
 724 
 725         if (DEBUGLEVEL >= 10) {
 726                 NDR_PRINT_IN_DEBUG(winreg_NotifyChangeKeyValue, &r);
 727         }
 728 
 729         status = cli->dispatch(cli,
 730                                 mem_ctx,
 731                                 &ndr_table_winreg,
 732                                 NDR_WINREG_NOTIFYCHANGEKEYVALUE,
 733                                 &r);
 734 
 735         if (!NT_STATUS_IS_OK(status)) {
 736                 return status;
 737         }
 738 
 739         if (DEBUGLEVEL >= 10) {
 740                 NDR_PRINT_OUT_DEBUG(winreg_NotifyChangeKeyValue, &r);
 741         }
 742 
 743         if (NT_STATUS_IS_ERR(status)) {
 744                 return status;
 745         }
 746 
 747         /* Return variables */
 748 
 749         /* Return result */
 750         if (werror) {
 751                 *werror = r.out.result;
 752         }
 753 
 754         return werror_to_ntstatus(r.out.result);
 755 }
 756 
 757 NTSTATUS rpccli_winreg_OpenKey(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 758                                TALLOC_CTX *mem_ctx,
 759                                struct policy_handle *parent_handle /* [in] [ref] */,
 760                                struct winreg_String keyname /* [in]  */,
 761                                uint32_t unknown /* [in]  */,
 762                                uint32_t access_mask /* [in]  */,
 763                                struct policy_handle *handle /* [out] [ref] */,
 764                                WERROR *werror)
 765 {
 766         struct winreg_OpenKey r;
 767         NTSTATUS status;
 768 
 769         /* In parameters */
 770         r.in.parent_handle = parent_handle;
 771         r.in.keyname = keyname;
 772         r.in.unknown = unknown;
 773         r.in.access_mask = access_mask;
 774 
 775         if (DEBUGLEVEL >= 10) {
 776                 NDR_PRINT_IN_DEBUG(winreg_OpenKey, &r);
 777         }
 778 
 779         status = cli->dispatch(cli,
 780                                 mem_ctx,
 781                                 &ndr_table_winreg,
 782                                 NDR_WINREG_OPENKEY,
 783                                 &r);
 784 
 785         if (!NT_STATUS_IS_OK(status)) {
 786                 return status;
 787         }
 788 
 789         if (DEBUGLEVEL >= 10) {
 790                 NDR_PRINT_OUT_DEBUG(winreg_OpenKey, &r);
 791         }
 792 
 793         if (NT_STATUS_IS_ERR(status)) {
 794                 return status;
 795         }
 796 
 797         /* Return variables */
 798         *handle = *r.out.handle;
 799 
 800         /* Return result */
 801         if (werror) {
 802                 *werror = r.out.result;
 803         }
 804 
 805         return werror_to_ntstatus(r.out.result);
 806 }
 807 
 808 NTSTATUS rpccli_winreg_QueryInfoKey(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 809                                     TALLOC_CTX *mem_ctx,
 810                                     struct policy_handle *handle /* [in] [ref] */,
 811                                     struct winreg_String *classname /* [in,out] [ref] */,
 812                                     uint32_t *num_subkeys /* [out] [ref] */,
 813                                     uint32_t *max_subkeylen /* [out] [ref] */,
 814                                     uint32_t *max_classlen /* [out] [ref] */,
 815                                     uint32_t *num_values /* [out] [ref] */,
 816                                     uint32_t *max_valnamelen /* [out] [ref] */,
 817                                     uint32_t *max_valbufsize /* [out] [ref] */,
 818                                     uint32_t *secdescsize /* [out] [ref] */,
 819                                     NTTIME *last_changed_time /* [out] [ref] */,
 820                                     WERROR *werror)
 821 {
 822         struct winreg_QueryInfoKey r;
 823         NTSTATUS status;
 824 
 825         /* In parameters */
 826         r.in.handle = handle;
 827         r.in.classname = classname;
 828 
 829         if (DEBUGLEVEL >= 10) {
 830                 NDR_PRINT_IN_DEBUG(winreg_QueryInfoKey, &r);
 831         }
 832 
 833         status = cli->dispatch(cli,
 834                                 mem_ctx,
 835                                 &ndr_table_winreg,
 836                                 NDR_WINREG_QUERYINFOKEY,
 837                                 &r);
 838 
 839         if (!NT_STATUS_IS_OK(status)) {
 840                 return status;
 841         }
 842 
 843         if (DEBUGLEVEL >= 10) {
 844                 NDR_PRINT_OUT_DEBUG(winreg_QueryInfoKey, &r);
 845         }
 846 
 847         if (NT_STATUS_IS_ERR(status)) {
 848                 return status;
 849         }
 850 
 851         /* Return variables */
 852         *classname = *r.out.classname;
 853         *num_subkeys = *r.out.num_subkeys;
 854         *max_subkeylen = *r.out.max_subkeylen;
 855         *max_classlen = *r.out.max_classlen;
 856         *num_values = *r.out.num_values;
 857         *max_valnamelen = *r.out.max_valnamelen;
 858         *max_valbufsize = *r.out.max_valbufsize;
 859         *secdescsize = *r.out.secdescsize;
 860         *last_changed_time = *r.out.last_changed_time;
 861 
 862         /* Return result */
 863         if (werror) {
 864                 *werror = r.out.result;
 865         }
 866 
 867         return werror_to_ntstatus(r.out.result);
 868 }
 869 
 870 NTSTATUS rpccli_winreg_QueryValue(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 871                                   TALLOC_CTX *mem_ctx,
 872                                   struct policy_handle *handle /* [in] [ref] */,
 873                                   struct winreg_String *value_name /* [in] [ref] */,
 874                                   enum winreg_Type *type /* [in,out] [unique] */,
 875                                   uint8_t *data /* [in,out] [unique,length_is(*data_length),size_is(*data_size)] */,
 876                                   uint32_t *data_size /* [in,out] [unique] */,
 877                                   uint32_t *data_length /* [in,out] [unique] */,
 878                                   WERROR *werror)
 879 {
 880         struct winreg_QueryValue r;
 881         NTSTATUS status;
 882 
 883         /* In parameters */
 884         r.in.handle = handle;
 885         r.in.value_name = value_name;
 886         r.in.type = type;
 887         r.in.data = data;
 888         r.in.data_size = data_size;
 889         r.in.data_length = data_length;
 890 
 891         if (DEBUGLEVEL >= 10) {
 892                 NDR_PRINT_IN_DEBUG(winreg_QueryValue, &r);
 893         }
 894 
 895         status = cli->dispatch(cli,
 896                                 mem_ctx,
 897                                 &ndr_table_winreg,
 898                                 NDR_WINREG_QUERYVALUE,
 899                                 &r);
 900 
 901         if (!NT_STATUS_IS_OK(status)) {
 902                 return status;
 903         }
 904 
 905         if (DEBUGLEVEL >= 10) {
 906                 NDR_PRINT_OUT_DEBUG(winreg_QueryValue, &r);
 907         }
 908 
 909         if (NT_STATUS_IS_ERR(status)) {
 910                 return status;
 911         }
 912 
 913         /* Return variables */
 914         if (type && r.out.type) {
 915                 *type = *r.out.type;
 916         }
 917         if (data && r.out.data) {
 918                 memcpy(data, r.out.data, *r.in.data_size * sizeof(*data));
 919         }
 920         if (data_size && r.out.data_size) {
 921                 *data_size = *r.out.data_size;
 922         }
 923         if (data_length && r.out.data_length) {
 924                 *data_length = *r.out.data_length;
 925         }
 926 
 927         /* Return result */
 928         if (werror) {
 929                 *werror = r.out.result;
 930         }
 931 
 932         return werror_to_ntstatus(r.out.result);
 933 }
 934 
 935 NTSTATUS rpccli_winreg_ReplaceKey(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 936                                   TALLOC_CTX *mem_ctx,
 937                                   WERROR *werror)
 938 {
 939         struct winreg_ReplaceKey r;
 940         NTSTATUS status;
 941 
 942         /* In parameters */
 943 
 944         if (DEBUGLEVEL >= 10) {
 945                 NDR_PRINT_IN_DEBUG(winreg_ReplaceKey, &r);
 946         }
 947 
 948         status = cli->dispatch(cli,
 949                                 mem_ctx,
 950                                 &ndr_table_winreg,
 951                                 NDR_WINREG_REPLACEKEY,
 952                                 &r);
 953 
 954         if (!NT_STATUS_IS_OK(status)) {
 955                 return status;
 956         }
 957 
 958         if (DEBUGLEVEL >= 10) {
 959                 NDR_PRINT_OUT_DEBUG(winreg_ReplaceKey, &r);
 960         }
 961 
 962         if (NT_STATUS_IS_ERR(status)) {
 963                 return status;
 964         }
 965 
 966         /* Return variables */
 967 
 968         /* Return result */
 969         if (werror) {
 970                 *werror = r.out.result;
 971         }
 972 
 973         return werror_to_ntstatus(r.out.result);
 974 }
 975 
 976 NTSTATUS rpccli_winreg_RestoreKey(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 977                                   TALLOC_CTX *mem_ctx,
 978                                   struct policy_handle *handle /* [in] [ref] */,
 979                                   struct winreg_String *filename /* [in] [ref] */,
 980                                   uint32_t flags /* [in]  */,
 981                                   WERROR *werror)
 982 {
 983         struct winreg_RestoreKey r;
 984         NTSTATUS status;
 985 
 986         /* In parameters */
 987         r.in.handle = handle;
 988         r.in.filename = filename;
 989         r.in.flags = flags;
 990 
 991         if (DEBUGLEVEL >= 10) {
 992                 NDR_PRINT_IN_DEBUG(winreg_RestoreKey, &r);
 993         }
 994 
 995         status = cli->dispatch(cli,
 996                                 mem_ctx,
 997                                 &ndr_table_winreg,
 998                                 NDR_WINREG_RESTOREKEY,
 999                                 &r);
1000 
1001         if (!NT_STATUS_IS_OK(status)) {
1002                 return status;
1003         }
1004 
1005         if (DEBUGLEVEL >= 10) {
1006                 NDR_PRINT_OUT_DEBUG(winreg_RestoreKey, &r);
1007         }
1008 
1009         if (NT_STATUS_IS_ERR(status)) {
1010                 return status;
1011         }
1012 
1013         /* Return variables */
1014 
1015         /* Return result */
1016         if (werror) {
1017                 *werror = r.out.result;
1018         }
1019 
1020         return werror_to_ntstatus(r.out.result);
1021 }
1022 
1023 NTSTATUS rpccli_winreg_SaveKey(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1024                                TALLOC_CTX *mem_ctx,
1025                                struct policy_handle *handle /* [in] [ref] */,
1026                                struct winreg_String *filename /* [in] [ref] */,
1027                                struct KeySecurityAttribute *sec_attrib /* [in] [unique] */,
1028                                WERROR *werror)
1029 {
1030         struct winreg_SaveKey r;
1031         NTSTATUS status;
1032 
1033         /* In parameters */
1034         r.in.handle = handle;
1035         r.in.filename = filename;
1036         r.in.sec_attrib = sec_attrib;
1037 
1038         if (DEBUGLEVEL >= 10) {
1039                 NDR_PRINT_IN_DEBUG(winreg_SaveKey, &r);
1040         }
1041 
1042         status = cli->dispatch(cli,
1043                                 mem_ctx,
1044                                 &ndr_table_winreg,
1045                                 NDR_WINREG_SAVEKEY,
1046                                 &r);
1047 
1048         if (!NT_STATUS_IS_OK(status)) {
1049                 return status;
1050         }
1051 
1052         if (DEBUGLEVEL >= 10) {
1053                 NDR_PRINT_OUT_DEBUG(winreg_SaveKey, &r);
1054         }
1055 
1056         if (NT_STATUS_IS_ERR(status)) {
1057                 return status;
1058         }
1059 
1060         /* Return variables */
1061 
1062         /* Return result */
1063         if (werror) {
1064                 *werror = r.out.result;
1065         }
1066 
1067         return werror_to_ntstatus(r.out.result);
1068 }
1069 
1070 NTSTATUS rpccli_winreg_SetKeySecurity(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1071                                       TALLOC_CTX *mem_ctx,
1072                                       struct policy_handle *handle /* [in] [ref] */,
1073                                       uint32_t sec_info /* [in]  */,
1074                                       struct KeySecurityData *sd /* [in] [ref] */,
1075                                       WERROR *werror)
1076 {
1077         struct winreg_SetKeySecurity r;
1078         NTSTATUS status;
1079 
1080         /* In parameters */
1081         r.in.handle = handle;
1082         r.in.sec_info = sec_info;
1083         r.in.sd = sd;
1084 
1085         if (DEBUGLEVEL >= 10) {
1086                 NDR_PRINT_IN_DEBUG(winreg_SetKeySecurity, &r);
1087         }
1088 
1089         status = cli->dispatch(cli,
1090                                 mem_ctx,
1091                                 &ndr_table_winreg,
1092                                 NDR_WINREG_SETKEYSECURITY,
1093                                 &r);
1094 
1095         if (!NT_STATUS_IS_OK(status)) {
1096                 return status;
1097         }
1098 
1099         if (DEBUGLEVEL >= 10) {
1100                 NDR_PRINT_OUT_DEBUG(winreg_SetKeySecurity, &r);
1101         }
1102 
1103         if (NT_STATUS_IS_ERR(status)) {
1104                 return status;
1105         }
1106 
1107         /* Return variables */
1108 
1109         /* Return result */
1110         if (werror) {
1111                 *werror = r.out.result;
1112         }
1113 
1114         return werror_to_ntstatus(r.out.result);
1115 }
1116 
1117 NTSTATUS rpccli_winreg_SetValue(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1118                                 TALLOC_CTX *mem_ctx,
1119                                 struct policy_handle *handle /* [in] [ref] */,
1120                                 struct winreg_String name /* [in]  */,
1121                                 enum winreg_Type type /* [in]  */,
1122                                 uint8_t *data /* [in] [ref,size_is(size)] */,
1123                                 uint32_t size /* [in]  */,
1124                                 WERROR *werror)
1125 {
1126         struct winreg_SetValue r;
1127         NTSTATUS status;
1128 
1129         /* In parameters */
1130         r.in.handle = handle;
1131         r.in.name = name;
1132         r.in.type = type;
1133         r.in.data = data;
1134         r.in.size = size;
1135 
1136         if (DEBUGLEVEL >= 10) {
1137                 NDR_PRINT_IN_DEBUG(winreg_SetValue, &r);
1138         }
1139 
1140         status = cli->dispatch(cli,
1141                                 mem_ctx,
1142                                 &ndr_table_winreg,
1143                                 NDR_WINREG_SETVALUE,
1144                                 &r);
1145 
1146         if (!NT_STATUS_IS_OK(status)) {
1147                 return status;
1148         }
1149 
1150         if (DEBUGLEVEL >= 10) {
1151                 NDR_PRINT_OUT_DEBUG(winreg_SetValue, &r);
1152         }
1153 
1154         if (NT_STATUS_IS_ERR(status)) {
1155                 return status;
1156         }
1157 
1158         /* Return variables */
1159 
1160         /* Return result */
1161         if (werror) {
1162                 *werror = r.out.result;
1163         }
1164 
1165         return werror_to_ntstatus(r.out.result);
1166 }
1167 
1168 NTSTATUS rpccli_winreg_UnLoadKey(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1169                                  TALLOC_CTX *mem_ctx,
1170                                  WERROR *werror)
1171 {
1172         struct winreg_UnLoadKey r;
1173         NTSTATUS status;
1174 
1175         /* In parameters */
1176 
1177         if (DEBUGLEVEL >= 10) {
1178                 NDR_PRINT_IN_DEBUG(winreg_UnLoadKey, &r);
1179         }
1180 
1181         status = cli->dispatch(cli,
1182                                 mem_ctx,
1183                                 &ndr_table_winreg,
1184                                 NDR_WINREG_UNLOADKEY,
1185                                 &r);
1186 
1187         if (!NT_STATUS_IS_OK(status)) {
1188                 return status;
1189         }
1190 
1191         if (DEBUGLEVEL >= 10) {
1192                 NDR_PRINT_OUT_DEBUG(winreg_UnLoadKey, &r);
1193         }
1194 
1195         if (NT_STATUS_IS_ERR(status)) {
1196                 return status;
1197         }
1198 
1199         /* Return variables */
1200 
1201         /* Return result */
1202         if (werror) {
1203                 *werror = r.out.result;
1204         }
1205 
1206         return werror_to_ntstatus(r.out.result);
1207 }
1208 
1209 NTSTATUS rpccli_winreg_InitiateSystemShutdown(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1210                                               TALLOC_CTX *mem_ctx,
1211                                               uint16_t *hostname /* [in] [unique] */,
1212                                               struct lsa_StringLarge *message /* [in] [unique] */,
1213                                               uint32_t timeout /* [in]  */,
1214                                               uint8_t force_apps /* [in]  */,
1215                                               uint8_t do_reboot /* [in]  */,
1216                                               WERROR *werror)
1217 {
1218         struct winreg_InitiateSystemShutdown r;
1219         NTSTATUS status;
1220 
1221         /* In parameters */
1222         r.in.hostname = hostname;
1223         r.in.message = message;
1224         r.in.timeout = timeout;
1225         r.in.force_apps = force_apps;
1226         r.in.do_reboot = do_reboot;
1227 
1228         if (DEBUGLEVEL >= 10) {
1229                 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdown, &r);
1230         }
1231 
1232         status = cli->dispatch(cli,
1233                                 mem_ctx,
1234                                 &ndr_table_winreg,
1235                                 NDR_WINREG_INITIATESYSTEMSHUTDOWN,
1236                                 &r);
1237 
1238         if (!NT_STATUS_IS_OK(status)) {
1239                 return status;
1240         }
1241 
1242         if (DEBUGLEVEL >= 10) {
1243                 NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdown, &r);
1244         }
1245 
1246         if (NT_STATUS_IS_ERR(status)) {
1247                 return status;
1248         }
1249 
1250         /* Return variables */
1251 
1252         /* Return result */
1253         if (werror) {
1254                 *werror = r.out.result;
1255         }
1256 
1257         return werror_to_ntstatus(r.out.result);
1258 }
1259 
1260 NTSTATUS rpccli_winreg_AbortSystemShutdown(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1261                                            TALLOC_CTX *mem_ctx,
1262                                            uint16_t *server /* [in] [unique] */,
1263                                            WERROR *werror)
1264 {
1265         struct winreg_AbortSystemShutdown r;
1266         NTSTATUS status;
1267 
1268         /* In parameters */
1269         r.in.server = server;
1270 
1271         if (DEBUGLEVEL >= 10) {
1272                 NDR_PRINT_IN_DEBUG(winreg_AbortSystemShutdown, &r);
1273         }
1274 
1275         status = cli->dispatch(cli,
1276                                 mem_ctx,
1277                                 &ndr_table_winreg,
1278                                 NDR_WINREG_ABORTSYSTEMSHUTDOWN,
1279                                 &r);
1280 
1281         if (!NT_STATUS_IS_OK(status)) {
1282                 return status;
1283         }
1284 
1285         if (DEBUGLEVEL >= 10) {
1286                 NDR_PRINT_OUT_DEBUG(winreg_AbortSystemShutdown, &r);
1287         }
1288 
1289         if (NT_STATUS_IS_ERR(status)) {
1290                 return status;
1291         }
1292 
1293         /* Return variables */
1294 
1295         /* Return result */
1296         if (werror) {
1297                 *werror = r.out.result;
1298         }
1299 
1300         return werror_to_ntstatus(r.out.result);
1301 }
1302 
1303 NTSTATUS rpccli_winreg_GetVersion(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1304                                   TALLOC_CTX *mem_ctx,
1305                                   struct policy_handle *handle /* [in] [ref] */,
1306                                   uint32_t *version /* [out] [ref] */,
1307                                   WERROR *werror)
1308 {
1309         struct winreg_GetVersion r;
1310         NTSTATUS status;
1311 
1312         /* In parameters */
1313         r.in.handle = handle;
1314 
1315         if (DEBUGLEVEL >= 10) {
1316                 NDR_PRINT_IN_DEBUG(winreg_GetVersion, &r);
1317         }
1318 
1319         status = cli->dispatch(cli,
1320                                 mem_ctx,
1321                                 &ndr_table_winreg,
1322                                 NDR_WINREG_GETVERSION,
1323                                 &r);
1324 
1325         if (!NT_STATUS_IS_OK(status)) {
1326                 return status;
1327         }
1328 
1329         if (DEBUGLEVEL >= 10) {
1330                 NDR_PRINT_OUT_DEBUG(winreg_GetVersion, &r);
1331         }
1332 
1333         if (NT_STATUS_IS_ERR(status)) {
1334                 return status;
1335         }
1336 
1337         /* Return variables */
1338         *version = *r.out.version;
1339 
1340         /* Return result */
1341         if (werror) {
1342                 *werror = r.out.result;
1343         }
1344 
1345         return werror_to_ntstatus(r.out.result);
1346 }
1347 
1348 NTSTATUS rpccli_winreg_OpenHKCC(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1349                                 TALLOC_CTX *mem_ctx,
1350                                 uint16_t *system_name /* [in] [unique] */,
1351                                 uint32_t access_mask /* [in]  */,
1352                                 struct policy_handle *handle /* [out] [ref] */,
1353                                 WERROR *werror)
1354 {
1355         struct winreg_OpenHKCC r;
1356         NTSTATUS status;
1357 
1358         /* In parameters */
1359         r.in.system_name = system_name;
1360         r.in.access_mask = access_mask;
1361 
1362         if (DEBUGLEVEL >= 10) {
1363                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCC, &r);
1364         }
1365 
1366         status = cli->dispatch(cli,
1367                                 mem_ctx,
1368                                 &ndr_table_winreg,
1369                                 NDR_WINREG_OPENHKCC,
1370                                 &r);
1371 
1372         if (!NT_STATUS_IS_OK(status)) {
1373                 return status;
1374         }
1375 
1376         if (DEBUGLEVEL >= 10) {
1377                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCC, &r);
1378         }
1379 
1380         if (NT_STATUS_IS_ERR(status)) {
1381                 return status;
1382         }
1383 
1384         /* Return variables */
1385         *handle = *r.out.handle;
1386 
1387         /* Return result */
1388         if (werror) {
1389                 *werror = r.out.result;
1390         }
1391 
1392         return werror_to_ntstatus(r.out.result);
1393 }
1394 
1395 NTSTATUS rpccli_winreg_OpenHKDD(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1396                                 TALLOC_CTX *mem_ctx,
1397                                 uint16_t *system_name /* [in] [unique] */,
1398                                 uint32_t access_mask /* [in]  */,
1399                                 struct policy_handle *handle /* [out] [ref] */,
1400                                 WERROR *werror)
1401 {
1402         struct winreg_OpenHKDD r;
1403         NTSTATUS status;
1404 
1405         /* In parameters */
1406         r.in.system_name = system_name;
1407         r.in.access_mask = access_mask;
1408 
1409         if (DEBUGLEVEL >= 10) {
1410                 NDR_PRINT_IN_DEBUG(winreg_OpenHKDD, &r);
1411         }
1412 
1413         status = cli->dispatch(cli,
1414                                 mem_ctx,
1415                                 &ndr_table_winreg,
1416                                 NDR_WINREG_OPENHKDD,
1417                                 &r);
1418 
1419         if (!NT_STATUS_IS_OK(status)) {
1420                 return status;
1421         }
1422 
1423         if (DEBUGLEVEL >= 10) {
1424                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKDD, &r);
1425         }
1426 
1427         if (NT_STATUS_IS_ERR(status)) {
1428                 return status;
1429         }
1430 
1431         /* Return variables */
1432         *handle = *r.out.handle;
1433 
1434         /* Return result */
1435         if (werror) {
1436                 *werror = r.out.result;
1437         }
1438 
1439         return werror_to_ntstatus(r.out.result);
1440 }
1441 
1442 NTSTATUS rpccli_winreg_QueryMultipleValues(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1443                                            TALLOC_CTX *mem_ctx,
1444                                            struct policy_handle *key_handle /* [in] [ref] */,
1445                                            struct QueryMultipleValue *values /* [in,out] [ref,length_is(num_values),size_is(num_values)] */,
1446                                            uint32_t num_values /* [in]  */,
1447                                            uint8_t *buffer /* [in,out] [unique,length_is(*buffer_size),size_is(*buffer_size)] */,
1448                                            uint32_t *buffer_size /* [in,out] [ref] */,
1449                                            WERROR *werror)
1450 {
1451         struct winreg_QueryMultipleValues r;
1452         NTSTATUS status;
1453 
1454         /* In parameters */
1455         r.in.key_handle = key_handle;
1456         r.in.values = values;
1457         r.in.num_values = num_values;
1458         r.in.buffer = buffer;
1459         r.in.buffer_size = buffer_size;
1460 
1461         if (DEBUGLEVEL >= 10) {
1462                 NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues, &r);
1463         }
1464 
1465         status = cli->dispatch(cli,
1466                                 mem_ctx,
1467                                 &ndr_table_winreg,
1468                                 NDR_WINREG_QUERYMULTIPLEVALUES,
1469                                 &r);
1470 
1471         if (!NT_STATUS_IS_OK(status)) {
1472                 return status;
1473         }
1474 
1475         if (DEBUGLEVEL >= 10) {
1476                 NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues, &r);
1477         }
1478 
1479         if (NT_STATUS_IS_ERR(status)) {
1480                 return status;
1481         }
1482 
1483         /* Return variables */
1484         memcpy(values, r.out.values, r.in.num_values * sizeof(*values));
1485         if (buffer && r.out.buffer) {
1486                 memcpy(buffer, r.out.buffer, *r.in.buffer_size * sizeof(*buffer));
1487         }
1488         *buffer_size = *r.out.buffer_size;
1489 
1490         /* Return result */
1491         if (werror) {
1492                 *werror = r.out.result;
1493         }
1494 
1495         return werror_to_ntstatus(r.out.result);
1496 }
1497 
1498 NTSTATUS rpccli_winreg_InitiateSystemShutdownEx(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1499                                                 TALLOC_CTX *mem_ctx,
1500                                                 uint16_t *hostname /* [in] [unique] */,
1501                                                 struct lsa_StringLarge *message /* [in] [unique] */,
1502                                                 uint32_t timeout /* [in]  */,
1503                                                 uint8_t force_apps /* [in]  */,
1504                                                 uint8_t do_reboot /* [in]  */,
1505                                                 uint32_t reason /* [in]  */,
1506                                                 WERROR *werror)
1507 {
1508         struct winreg_InitiateSystemShutdownEx r;
1509         NTSTATUS status;
1510 
1511         /* In parameters */
1512         r.in.hostname = hostname;
1513         r.in.message = message;
1514         r.in.timeout = timeout;
1515         r.in.force_apps = force_apps;
1516         r.in.do_reboot = do_reboot;
1517         r.in.reason = reason;
1518 
1519         if (DEBUGLEVEL >= 10) {
1520                 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdownEx, &r);
1521         }
1522 
1523         status = cli->dispatch(cli,
1524                                 mem_ctx,
1525                                 &ndr_table_winreg,
1526                                 NDR_WINREG_INITIATESYSTEMSHUTDOWNEX,
1527                                 &r);
1528 
1529         if (!NT_STATUS_IS_OK(status)) {
1530                 return status;
1531         }
1532 
1533         if (DEBUGLEVEL >= 10) {
1534                 NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdownEx, &r);
1535         }
1536 
1537         if (NT_STATUS_IS_ERR(status)) {
1538                 return status;
1539         }
1540 
1541         /* Return variables */
1542 
1543         /* Return result */
1544         if (werror) {
1545                 *werror = r.out.result;
1546         }
1547 
1548         return werror_to_ntstatus(r.out.result);
1549 }
1550 
1551 NTSTATUS rpccli_winreg_SaveKeyEx(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1552                                  TALLOC_CTX *mem_ctx,
1553                                  WERROR *werror)
1554 {
1555         struct winreg_SaveKeyEx r;
1556         NTSTATUS status;
1557 
1558         /* In parameters */
1559 
1560         if (DEBUGLEVEL >= 10) {
1561                 NDR_PRINT_IN_DEBUG(winreg_SaveKeyEx, &r);
1562         }
1563 
1564         status = cli->dispatch(cli,
1565                                 mem_ctx,
1566                                 &ndr_table_winreg,
1567                                 NDR_WINREG_SAVEKEYEX,
1568                                 &r);
1569 
1570         if (!NT_STATUS_IS_OK(status)) {
1571                 return status;
1572         }
1573 
1574         if (DEBUGLEVEL >= 10) {
1575                 NDR_PRINT_OUT_DEBUG(winreg_SaveKeyEx, &r);
1576         }
1577 
1578         if (NT_STATUS_IS_ERR(status)) {
1579                 return status;
1580         }
1581 
1582         /* Return variables */
1583 
1584         /* Return result */
1585         if (werror) {
1586                 *werror = r.out.result;
1587         }
1588 
1589         return werror_to_ntstatus(r.out.result);
1590 }
1591 
1592 NTSTATUS rpccli_winreg_OpenHKPT(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1593                                 TALLOC_CTX *mem_ctx,
1594                                 uint16_t *system_name /* [in] [unique] */,
1595                                 uint32_t access_mask /* [in]  */,
1596                                 struct policy_handle *handle /* [out] [ref] */,
1597                                 WERROR *werror)
1598 {
1599         struct winreg_OpenHKPT r;
1600         NTSTATUS status;
1601 
1602         /* In parameters */
1603         r.in.system_name = system_name;
1604         r.in.access_mask = access_mask;
1605 
1606         if (DEBUGLEVEL >= 10) {
1607                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPT, &r);
1608         }
1609 
1610         status = cli->dispatch(cli,
1611                                 mem_ctx,
1612                                 &ndr_table_winreg,
1613                                 NDR_WINREG_OPENHKPT,
1614                                 &r);
1615 
1616         if (!NT_STATUS_IS_OK(status)) {
1617                 return status;
1618         }
1619 
1620         if (DEBUGLEVEL >= 10) {
1621                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPT, &r);
1622         }
1623 
1624         if (NT_STATUS_IS_ERR(status)) {
1625                 return status;
1626         }
1627 
1628         /* Return variables */
1629         *handle = *r.out.handle;
1630 
1631         /* Return result */
1632         if (werror) {
1633                 *werror = r.out.result;
1634         }
1635 
1636         return werror_to_ntstatus(r.out.result);
1637 }
1638 
1639 NTSTATUS rpccli_winreg_OpenHKPN(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1640                                 TALLOC_CTX *mem_ctx,
1641                                 uint16_t *system_name /* [in] [unique] */,
1642                                 uint32_t access_mask /* [in]  */,
1643                                 struct policy_handle *handle /* [out] [ref] */,
1644                                 WERROR *werror)
1645 {
1646         struct winreg_OpenHKPN r;
1647         NTSTATUS status;
1648 
1649         /* In parameters */
1650         r.in.system_name = system_name;
1651         r.in.access_mask = access_mask;
1652 
1653         if (DEBUGLEVEL >= 10) {
1654                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPN, &r);
1655         }
1656 
1657         status = cli->dispatch(cli,
1658                                 mem_ctx,
1659                                 &ndr_table_winreg,
1660                                 NDR_WINREG_OPENHKPN,
1661                                 &r);
1662 
1663         if (!NT_STATUS_IS_OK(status)) {
1664                 return status;
1665         }
1666 
1667         if (DEBUGLEVEL >= 10) {
1668                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPN, &r);
1669         }
1670 
1671         if (NT_STATUS_IS_ERR(status)) {
1672                 return status;
1673         }
1674 
1675         /* Return variables */
1676         *handle = *r.out.handle;
1677 
1678         /* Return result */
1679         if (werror) {
1680                 *werror = r.out.result;
1681         }
1682 
1683         return werror_to_ntstatus(r.out.result);
1684 }
1685 
1686 NTSTATUS rpccli_winreg_QueryMultipleValues2(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1687                                             TALLOC_CTX *mem_ctx,
1688                                             WERROR *werror)
1689 {
1690         struct winreg_QueryMultipleValues2 r;
1691         NTSTATUS status;
1692 
1693         /* In parameters */
1694 
1695         if (DEBUGLEVEL >= 10) {
1696                 NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues2, &r);
1697         }
1698 
1699         status = cli->dispatch(cli,
1700                                 mem_ctx,
1701                                 &ndr_table_winreg,
1702                                 NDR_WINREG_QUERYMULTIPLEVALUES2,
1703                                 &r);
1704 
1705         if (!NT_STATUS_IS_OK(status)) {
1706                 return status;
1707         }
1708 
1709         if (DEBUGLEVEL >= 10) {
1710                 NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues2, &r);
1711         }
1712 
1713         if (NT_STATUS_IS_ERR(status)) {
1714                 return status;
1715         }
1716 
1717         /* Return variables */
1718 
1719         /* Return result */
1720         if (werror) {
1721                 *werror = r.out.result;
1722         }
1723 
1724         return werror_to_ntstatus(r.out.result);
1725 }
1726 

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