source3/librpc/gen_ndr/cli_winreg.c

   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, TALLOC_CTX *mem_ctx, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
  10 {
  11         struct winreg_OpenHKCR r;
  12         NTSTATUS status;
  13
  14         /* In parameters */
  15         r.in.system_name = system_name;
  16         r.in.access_mask = access_mask;
  17
  18         if (DEBUGLEVEL >= 10)
  19                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCR, &r);
  20
  21         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKCR, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKCR, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKCR);
  22
  23         if ( !NT_STATUS_IS_OK(status) ) {
  24                 return status;
  25         }
  26
  27         if (DEBUGLEVEL >= 10)
  28                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCR, &r);
  29
  30         if (NT_STATUS_IS_ERR(status)) {
  31                 return status;
  32         }
  33
  34         /* Return variables */
  35         *handle = *r.out.handle;
  36
  37         /* Return result */
  38         return werror_to_ntstatus(r.out.result);
  39 }
  40
  41 NTSTATUS rpccli_winreg_OpenHKCU(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
  42 {
  43         struct winreg_OpenHKCU r;
  44         NTSTATUS status;
  45
  46         /* In parameters */
  47         r.in.system_name = system_name;
  48         r.in.access_mask = access_mask;
  49
  50         if (DEBUGLEVEL >= 10)
  51                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCU, &r);
  52
  53         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKCU, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKCU, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKCU);
  54
  55         if ( !NT_STATUS_IS_OK(status) ) {
  56                 return status;
  57         }
  58
  59         if (DEBUGLEVEL >= 10)
  60                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCU, &r);
  61
  62         if (NT_STATUS_IS_ERR(status)) {
  63                 return status;
  64         }
  65
  66         /* Return variables */
  67         *handle = *r.out.handle;
  68
  69         /* Return result */
  70         return werror_to_ntstatus(r.out.result);
  71 }
  72
  73 NTSTATUS rpccli_winreg_OpenHKLM(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
  74 {
  75         struct winreg_OpenHKLM r;
  76         NTSTATUS status;
  77
  78         /* In parameters */
  79         r.in.system_name = system_name;
  80         r.in.access_mask = access_mask;
  81
  82         if (DEBUGLEVEL >= 10)
  83                 NDR_PRINT_IN_DEBUG(winreg_OpenHKLM, &r);
  84
  85         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKLM, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKLM, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKLM);
  86
  87         if ( !NT_STATUS_IS_OK(status) ) {
  88                 return status;
  89         }
  90
  91         if (DEBUGLEVEL >= 10)
  92                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKLM, &r);
  93
  94         if (NT_STATUS_IS_ERR(status)) {
  95                 return status;
  96         }
  97
  98         /* Return variables */
  99         *handle = *r.out.handle;
 100
 101         /* Return result */
 102         return werror_to_ntstatus(r.out.result);
 103 }
 104
 105 NTSTATUS rpccli_winreg_OpenHKPD(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
 106 {
 107         struct winreg_OpenHKPD r;
 108         NTSTATUS status;
 109
 110         /* In parameters */
 111         r.in.system_name = system_name;
 112         r.in.access_mask = access_mask;
 113
 114         if (DEBUGLEVEL >= 10)
 115                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPD, &r);
 116
 117         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKPD, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKPD, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKPD);
 118
 119         if ( !NT_STATUS_IS_OK(status) ) {
 120                 return status;
 121         }
 122
 123         if (DEBUGLEVEL >= 10)
 124                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPD, &r);
 125
 126         if (NT_STATUS_IS_ERR(status)) {
 127                 return status;
 128         }
 129
 130         /* Return variables */
 131         *handle = *r.out.handle;
 132
 133         /* Return result */
 134         return werror_to_ntstatus(r.out.result);
 135 }
 136
 137 NTSTATUS rpccli_winreg_OpenHKU(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
 138 {
 139         struct winreg_OpenHKU r;
 140         NTSTATUS status;
 141
 142         /* In parameters */
 143         r.in.system_name = system_name;
 144         r.in.access_mask = access_mask;
 145
 146         if (DEBUGLEVEL >= 10)
 147                 NDR_PRINT_IN_DEBUG(winreg_OpenHKU, &r);
 148
 149         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKU, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKU, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKU);
 150
 151         if ( !NT_STATUS_IS_OK(status) ) {
 152                 return status;
 153         }
 154
 155         if (DEBUGLEVEL >= 10)
 156                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKU, &r);
 157
 158         if (NT_STATUS_IS_ERR(status)) {
 159                 return status;
 160         }
 161
 162         /* Return variables */
 163         *handle = *r.out.handle;
 164
 165         /* Return result */
 166         return werror_to_ntstatus(r.out.result);
 167 }
 168
 169 NTSTATUS rpccli_winreg_CloseKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle)
 170 {
 171         struct winreg_CloseKey r;
 172         NTSTATUS status;
 173
 174         /* In parameters */
 175         r.in.handle = handle;
 176
 177         if (DEBUGLEVEL >= 10)
 178                 NDR_PRINT_IN_DEBUG(winreg_CloseKey, &r);
 179
 180         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_CLOSEKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_CloseKey, (ndr_push_flags_fn_t)ndr_push_winreg_CloseKey);
 181
 182         if ( !NT_STATUS_IS_OK(status) ) {
 183                 return status;
 184         }
 185
 186         if (DEBUGLEVEL >= 10)
 187                 NDR_PRINT_OUT_DEBUG(winreg_CloseKey, &r);
 188
 189         if (NT_STATUS_IS_ERR(status)) {
 190                 return status;
 191         }
 192
 193         /* Return variables */
 194         *handle = *r.out.handle;
 195
 196         /* Return result */
 197         return werror_to_ntstatus(r.out.result);
 198 }
 199
 200 NTSTATUS rpccli_winreg_CreateKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String name, struct winreg_String keyclass, uint32_t options, uint32_t access_mask, struct winreg_SecBuf *secdesc, struct policy_handle *new_handle, enum winreg_CreateAction **action_taken)
 201 {
 202         struct winreg_CreateKey r;
 203         NTSTATUS status;
 204
 205         /* In parameters */
 206         r.in.handle = handle;
 207         r.in.name = name;
 208         r.in.keyclass = keyclass;
 209         r.in.options = options;
 210         r.in.access_mask = access_mask;
 211         r.in.secdesc = secdesc;
 212         r.in.action_taken = *action_taken;
 213
 214         if (DEBUGLEVEL >= 10)
 215                 NDR_PRINT_IN_DEBUG(winreg_CreateKey, &r);
 216
 217         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_CREATEKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_CreateKey, (ndr_push_flags_fn_t)ndr_push_winreg_CreateKey);
 218
 219         if ( !NT_STATUS_IS_OK(status) ) {
 220                 return status;
 221         }
 222
 223         if (DEBUGLEVEL >= 10)
 224                 NDR_PRINT_OUT_DEBUG(winreg_CreateKey, &r);
 225
 226         if (NT_STATUS_IS_ERR(status)) {
 227                 return status;
 228         }
 229
 230         /* Return variables */
 231         *new_handle = *r.out.new_handle;
 232         *action_taken = r.out.action_taken;
 233
 234         /* Return result */
 235         return werror_to_ntstatus(r.out.result);
 236 }
 237
 238 NTSTATUS rpccli_winreg_DeleteKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String key)
 239 {
 240         struct winreg_DeleteKey r;
 241         NTSTATUS status;
 242
 243         /* In parameters */
 244         r.in.handle = handle;
 245         r.in.key = key;
 246
 247         if (DEBUGLEVEL >= 10)
 248                 NDR_PRINT_IN_DEBUG(winreg_DeleteKey, &r);
 249
 250         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_DELETEKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_DeleteKey, (ndr_push_flags_fn_t)ndr_push_winreg_DeleteKey);
 251
 252         if ( !NT_STATUS_IS_OK(status) ) {
 253                 return status;
 254         }
 255
 256         if (DEBUGLEVEL >= 10)
 257                 NDR_PRINT_OUT_DEBUG(winreg_DeleteKey, &r);
 258
 259         if (NT_STATUS_IS_ERR(status)) {
 260                 return status;
 261         }
 262
 263         /* Return variables */
 264
 265         /* Return result */
 266         return werror_to_ntstatus(r.out.result);
 267 }
 268
 269 NTSTATUS rpccli_winreg_DeleteValue(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String value)
 270 {
 271         struct winreg_DeleteValue r;
 272         NTSTATUS status;
 273
 274         /* In parameters */
 275         r.in.handle = handle;
 276         r.in.value = value;
 277
 278         if (DEBUGLEVEL >= 10)
 279                 NDR_PRINT_IN_DEBUG(winreg_DeleteValue, &r);
 280
 281         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_DELETEVALUE, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_DeleteValue, (ndr_push_flags_fn_t)ndr_push_winreg_DeleteValue);
 282
 283         if ( !NT_STATUS_IS_OK(status) ) {
 284                 return status;
 285         }
 286
 287         if (DEBUGLEVEL >= 10)
 288                 NDR_PRINT_OUT_DEBUG(winreg_DeleteValue, &r);
 289
 290         if (NT_STATUS_IS_ERR(status)) {
 291                 return status;
 292         }
 293
 294         /* Return variables */
 295
 296         /* Return result */
 297         return werror_to_ntstatus(r.out.result);
 298 }
 299
 300 NTSTATUS rpccli_winreg_EnumKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t enum_index, struct winreg_StringBuf *name, struct winreg_StringBuf **keyclass, NTTIME **last_changed_time)
 301 {
 302         struct winreg_EnumKey r;
 303         NTSTATUS status;
 304
 305         /* In parameters */
 306         r.in.handle = handle;
 307         r.in.enum_index = enum_index;
 308         r.in.name = name;
 309         r.in.keyclass = *keyclass;
 310         r.in.last_changed_time = *last_changed_time;
 311
 312         if (DEBUGLEVEL >= 10)
 313                 NDR_PRINT_IN_DEBUG(winreg_EnumKey, &r);
 314
 315         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_ENUMKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_EnumKey, (ndr_push_flags_fn_t)ndr_push_winreg_EnumKey);
 316
 317         if ( !NT_STATUS_IS_OK(status) ) {
 318                 return status;
 319         }
 320
 321         if (DEBUGLEVEL >= 10)
 322                 NDR_PRINT_OUT_DEBUG(winreg_EnumKey, &r);
 323
 324         if (NT_STATUS_IS_ERR(status)) {
 325                 return status;
 326         }
 327
 328         /* Return variables */
 329         *name = *r.out.name;
 330         *keyclass = r.out.keyclass;
 331         *last_changed_time = r.out.last_changed_time;
 332
 333         /* Return result */
 334         return werror_to_ntstatus(r.out.result);
 335 }
 336
 337 NTSTATUS rpccli_winreg_EnumValue(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t enum_index, struct winreg_StringBuf *name, enum winreg_Type **type, uint8_t **data, uint32_t **data_size, uint32_t **value_length)
 338 {
 339         struct winreg_EnumValue r;
 340         NTSTATUS status;
 341
 342         /* In parameters */
 343         r.in.handle = handle;
 344         r.in.enum_index = enum_index;
 345         r.in.name = name;
 346         r.in.type = *type;
 347         r.in.data = *data;
 348         r.in.data_size = *data_size;
 349         r.in.value_length = *value_length;
 350
 351         if (DEBUGLEVEL >= 10)
 352                 NDR_PRINT_IN_DEBUG(winreg_EnumValue, &r);
 353
 354         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_ENUMVALUE, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_EnumValue, (ndr_push_flags_fn_t)ndr_push_winreg_EnumValue);
 355
 356         if ( !NT_STATUS_IS_OK(status) ) {
 357                 return status;
 358         }
 359
 360         if (DEBUGLEVEL >= 10)
 361                 NDR_PRINT_OUT_DEBUG(winreg_EnumValue, &r);
 362
 363         if (NT_STATUS_IS_ERR(status)) {
 364                 return status;
 365         }
 366
 367         /* Return variables */
 368         *name = *r.out.name;
 369         *type = r.out.type;
 370         *data = r.out.data;
 371         *data_size = r.out.data_size;
 372         *value_length = r.out.value_length;
 373
 374         /* Return result */
 375         return werror_to_ntstatus(r.out.result);
 376 }
 377
 378 NTSTATUS rpccli_winreg_FlushKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle)
 379 {
 380         struct winreg_FlushKey r;
 381         NTSTATUS status;
 382
 383         /* In parameters */
 384         r.in.handle = handle;
 385
 386         if (DEBUGLEVEL >= 10)
 387                 NDR_PRINT_IN_DEBUG(winreg_FlushKey, &r);
 388
 389         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_FLUSHKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_FlushKey, (ndr_push_flags_fn_t)ndr_push_winreg_FlushKey);
 390
 391         if ( !NT_STATUS_IS_OK(status) ) {
 392                 return status;
 393         }
 394
 395         if (DEBUGLEVEL >= 10)
 396                 NDR_PRINT_OUT_DEBUG(winreg_FlushKey, &r);
 397
 398         if (NT_STATUS_IS_ERR(status)) {
 399                 return status;
 400         }
 401
 402         /* Return variables */
 403
 404         /* Return result */
 405         return werror_to_ntstatus(r.out.result);
 406 }
 407
 408 NTSTATUS rpccli_winreg_GetKeySecurity(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t sec_info, struct KeySecurityData *sd)
 409 {
 410         struct winreg_GetKeySecurity r;
 411         NTSTATUS status;
 412
 413         /* In parameters */
 414         r.in.handle = handle;
 415         r.in.sec_info = sec_info;
 416         r.in.sd = sd;
 417
 418         if (DEBUGLEVEL >= 10)
 419                 NDR_PRINT_IN_DEBUG(winreg_GetKeySecurity, &r);
 420
 421         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_GETKEYSECURITY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_GetKeySecurity, (ndr_push_flags_fn_t)ndr_push_winreg_GetKeySecurity);
 422
 423         if ( !NT_STATUS_IS_OK(status) ) {
 424                 return status;
 425         }
 426
 427         if (DEBUGLEVEL >= 10)
 428                 NDR_PRINT_OUT_DEBUG(winreg_GetKeySecurity, &r);
 429
 430         if (NT_STATUS_IS_ERR(status)) {
 431                 return status;
 432         }
 433
 434         /* Return variables */
 435         *sd = *r.out.sd;
 436
 437         /* Return result */
 438         return werror_to_ntstatus(r.out.result);
 439 }
 440
 441 NTSTATUS rpccli_winreg_LoadKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String *keyname, struct winreg_String *filename)
 442 {
 443         struct winreg_LoadKey r;
 444         NTSTATUS status;
 445
 446         /* In parameters */
 447         r.in.handle = handle;
 448         r.in.keyname = keyname;
 449         r.in.filename = filename;
 450
 451         if (DEBUGLEVEL >= 10)
 452                 NDR_PRINT_IN_DEBUG(winreg_LoadKey, &r);
 453
 454         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_LOADKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_LoadKey, (ndr_push_flags_fn_t)ndr_push_winreg_LoadKey);
 455
 456         if ( !NT_STATUS_IS_OK(status) ) {
 457                 return status;
 458         }
 459
 460         if (DEBUGLEVEL >= 10)
 461                 NDR_PRINT_OUT_DEBUG(winreg_LoadKey, &r);
 462
 463         if (NT_STATUS_IS_ERR(status)) {
 464                 return status;
 465         }
 466
 467         /* Return variables */
 468
 469         /* Return result */
 470         return werror_to_ntstatus(r.out.result);
 471 }
 472
 473 NTSTATUS rpccli_winreg_NotifyChangeKeyValue(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint8_t watch_subtree, uint32_t notify_filter, uint32_t unknown, struct winreg_String string1, struct winreg_String string2, uint32_t unknown2)
 474 {
 475         struct winreg_NotifyChangeKeyValue r;
 476         NTSTATUS status;
 477
 478         /* In parameters */
 479         r.in.handle = handle;
 480         r.in.watch_subtree = watch_subtree;
 481         r.in.notify_filter = notify_filter;
 482         r.in.unknown = unknown;
 483         r.in.string1 = string1;
 484         r.in.string2 = string2;
 485         r.in.unknown2 = unknown2;
 486
 487         if (DEBUGLEVEL >= 10)
 488                 NDR_PRINT_IN_DEBUG(winreg_NotifyChangeKeyValue, &r);
 489
 490         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_NOTIFYCHANGEKEYVALUE, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_NotifyChangeKeyValue, (ndr_push_flags_fn_t)ndr_push_winreg_NotifyChangeKeyValue);
 491
 492         if ( !NT_STATUS_IS_OK(status) ) {
 493                 return status;
 494         }
 495
 496         if (DEBUGLEVEL >= 10)
 497                 NDR_PRINT_OUT_DEBUG(winreg_NotifyChangeKeyValue, &r);
 498
 499         if (NT_STATUS_IS_ERR(status)) {
 500                 return status;
 501         }
 502
 503         /* Return variables */
 504
 505         /* Return result */
 506         return werror_to_ntstatus(r.out.result);
 507 }
 508
 509 NTSTATUS rpccli_winreg_OpenKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *parent_handle, struct winreg_String keyname, uint32_t unknown, uint32_t access_mask, struct policy_handle *handle)
 510 {
 511         struct winreg_OpenKey r;
 512         NTSTATUS status;
 513
 514         /* In parameters */
 515         r.in.parent_handle = parent_handle;
 516         r.in.keyname = keyname;
 517         r.in.unknown = unknown;
 518         r.in.access_mask = access_mask;
 519
 520         if (DEBUGLEVEL >= 10)
 521                 NDR_PRINT_IN_DEBUG(winreg_OpenKey, &r);
 522
 523         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenKey, (ndr_push_flags_fn_t)ndr_push_winreg_OpenKey);
 524
 525         if ( !NT_STATUS_IS_OK(status) ) {
 526                 return status;
 527         }
 528
 529         if (DEBUGLEVEL >= 10)
 530                 NDR_PRINT_OUT_DEBUG(winreg_OpenKey, &r);
 531
 532         if (NT_STATUS_IS_ERR(status)) {
 533                 return status;
 534         }
 535
 536         /* Return variables */
 537         *handle = *r.out.handle;
 538
 539         /* Return result */
 540         return werror_to_ntstatus(r.out.result);
 541 }
 542
 543 NTSTATUS rpccli_winreg_QueryInfoKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String *classname, uint32_t *num_subkeys, uint32_t *max_subkeylen, uint32_t *max_classlen, uint32_t *num_values, uint32_t *max_valnamelen, uint32_t *max_valbufsize, uint32_t *secdescsize, NTTIME *last_changed_time)
 544 {
 545         struct winreg_QueryInfoKey r;
 546         NTSTATUS status;
 547
 548         /* In parameters */
 549         r.in.handle = handle;
 550         r.in.classname = classname;
 551
 552         if (DEBUGLEVEL >= 10)
 553                 NDR_PRINT_IN_DEBUG(winreg_QueryInfoKey, &r);
 554
 555         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_QUERYINFOKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_QueryInfoKey, (ndr_push_flags_fn_t)ndr_push_winreg_QueryInfoKey);
 556
 557         if ( !NT_STATUS_IS_OK(status) ) {
 558                 return status;
 559         }
 560
 561         if (DEBUGLEVEL >= 10)
 562                 NDR_PRINT_OUT_DEBUG(winreg_QueryInfoKey, &r);
 563
 564         if (NT_STATUS_IS_ERR(status)) {
 565                 return status;
 566         }
 567
 568         /* Return variables */
 569         *classname = *r.out.classname;
 570         *num_subkeys = *r.out.num_subkeys;
 571         *max_subkeylen = *r.out.max_subkeylen;
 572         *max_classlen = *r.out.max_classlen;
 573         *num_values = *r.out.num_values;
 574         *max_valnamelen = *r.out.max_valnamelen;
 575         *max_valbufsize = *r.out.max_valbufsize;
 576         *secdescsize = *r.out.secdescsize;
 577         *last_changed_time = *r.out.last_changed_time;
 578
 579         /* Return result */
 580         return werror_to_ntstatus(r.out.result);
 581 }
 582
 583 NTSTATUS rpccli_winreg_QueryValue(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String value_name, enum winreg_Type **type, uint8_t **data, uint32_t **data_size, uint32_t **value_length)
 584 {
 585         struct winreg_QueryValue r;
 586         NTSTATUS status;
 587
 588         /* In parameters */
 589         r.in.handle = handle;
 590         r.in.value_name = value_name;
 591         r.in.type = *type;
 592         r.in.data = *data;
 593         r.in.data_size = *data_size;
 594         r.in.value_length = *value_length;
 595
 596         if (DEBUGLEVEL >= 10)
 597                 NDR_PRINT_IN_DEBUG(winreg_QueryValue, &r);
 598
 599         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_QUERYVALUE, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_QueryValue, (ndr_push_flags_fn_t)ndr_push_winreg_QueryValue);
 600
 601         if ( !NT_STATUS_IS_OK(status) ) {
 602                 return status;
 603         }
 604
 605         if (DEBUGLEVEL >= 10)
 606                 NDR_PRINT_OUT_DEBUG(winreg_QueryValue, &r);
 607
 608         if (NT_STATUS_IS_ERR(status)) {
 609                 return status;
 610         }
 611
 612         /* Return variables */
 613         *type = r.out.type;
 614         *data = r.out.data;
 615         *data_size = r.out.data_size;
 616         *value_length = r.out.value_length;
 617
 618         /* Return result */
 619         return werror_to_ntstatus(r.out.result);
 620 }
 621
 622 NTSTATUS rpccli_winreg_ReplaceKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
 623 {
 624         struct winreg_ReplaceKey r;
 625         NTSTATUS status;
 626
 627         /* In parameters */
 628
 629         if (DEBUGLEVEL >= 10)
 630                 NDR_PRINT_IN_DEBUG(winreg_ReplaceKey, &r);
 631
 632         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_REPLACEKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_ReplaceKey, (ndr_push_flags_fn_t)ndr_push_winreg_ReplaceKey);
 633
 634         if ( !NT_STATUS_IS_OK(status) ) {
 635                 return status;
 636         }
 637
 638         if (DEBUGLEVEL >= 10)
 639                 NDR_PRINT_OUT_DEBUG(winreg_ReplaceKey, &r);
 640
 641         if (NT_STATUS_IS_ERR(status)) {
 642                 return status;
 643         }
 644
 645         /* Return variables */
 646
 647         /* Return result */
 648         return werror_to_ntstatus(r.out.result);
 649 }
 650
 651 NTSTATUS rpccli_winreg_RestoreKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String *filename, uint32_t flags)
 652 {
 653         struct winreg_RestoreKey r;
 654         NTSTATUS status;
 655
 656         /* In parameters */
 657         r.in.handle = handle;
 658         r.in.filename = filename;
 659         r.in.flags = flags;
 660
 661         if (DEBUGLEVEL >= 10)
 662                 NDR_PRINT_IN_DEBUG(winreg_RestoreKey, &r);
 663
 664         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_RESTOREKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_RestoreKey, (ndr_push_flags_fn_t)ndr_push_winreg_RestoreKey);
 665
 666         if ( !NT_STATUS_IS_OK(status) ) {
 667                 return status;
 668         }
 669
 670         if (DEBUGLEVEL >= 10)
 671                 NDR_PRINT_OUT_DEBUG(winreg_RestoreKey, &r);
 672
 673         if (NT_STATUS_IS_ERR(status)) {
 674                 return status;
 675         }
 676
 677         /* Return variables */
 678
 679         /* Return result */
 680         return werror_to_ntstatus(r.out.result);
 681 }
 682
 683 NTSTATUS rpccli_winreg_SaveKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String *filename, struct KeySecurityAttribute *sec_attrib)
 684 {
 685         struct winreg_SaveKey r;
 686         NTSTATUS status;
 687
 688         /* In parameters */
 689         r.in.handle = handle;
 690         r.in.filename = filename;
 691         r.in.sec_attrib = sec_attrib;
 692
 693         if (DEBUGLEVEL >= 10)
 694                 NDR_PRINT_IN_DEBUG(winreg_SaveKey, &r);
 695
 696         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_SAVEKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_SaveKey, (ndr_push_flags_fn_t)ndr_push_winreg_SaveKey);
 697
 698         if ( !NT_STATUS_IS_OK(status) ) {
 699                 return status;
 700         }
 701
 702         if (DEBUGLEVEL >= 10)
 703                 NDR_PRINT_OUT_DEBUG(winreg_SaveKey, &r);
 704
 705         if (NT_STATUS_IS_ERR(status)) {
 706                 return status;
 707         }
 708
 709         /* Return variables */
 710
 711         /* Return result */
 712         return werror_to_ntstatus(r.out.result);
 713 }
 714
 715 NTSTATUS rpccli_winreg_SetKeySecurity(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t access_mask, struct KeySecurityData *sd)
 716 {
 717         struct winreg_SetKeySecurity r;
 718         NTSTATUS status;
 719
 720         /* In parameters */
 721         r.in.handle = handle;
 722         r.in.access_mask = access_mask;
 723         r.in.sd = sd;
 724
 725         if (DEBUGLEVEL >= 10)
 726                 NDR_PRINT_IN_DEBUG(winreg_SetKeySecurity, &r);
 727
 728         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_SETKEYSECURITY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_SetKeySecurity, (ndr_push_flags_fn_t)ndr_push_winreg_SetKeySecurity);
 729
 730         if ( !NT_STATUS_IS_OK(status) ) {
 731                 return status;
 732         }
 733
 734         if (DEBUGLEVEL >= 10)
 735                 NDR_PRINT_OUT_DEBUG(winreg_SetKeySecurity, &r);
 736
 737         if (NT_STATUS_IS_ERR(status)) {
 738                 return status;
 739         }
 740
 741         /* Return variables */
 742         *sd = *r.out.sd;
 743
 744         /* Return result */
 745         return werror_to_ntstatus(r.out.result);
 746 }
 747
 748 NTSTATUS rpccli_winreg_SetValue(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String name, enum winreg_Type type, uint8_t *data, uint32_t size)
 749 {
 750         struct winreg_SetValue r;
 751         NTSTATUS status;
 752
 753         /* In parameters */
 754         r.in.handle = handle;
 755         r.in.name = name;
 756         r.in.type = type;
 757         r.in.data = data;
 758         r.in.size = size;
 759
 760         if (DEBUGLEVEL >= 10)
 761                 NDR_PRINT_IN_DEBUG(winreg_SetValue, &r);
 762
 763         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_SETVALUE, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_SetValue, (ndr_push_flags_fn_t)ndr_push_winreg_SetValue);
 764
 765         if ( !NT_STATUS_IS_OK(status) ) {
 766                 return status;
 767         }
 768
 769         if (DEBUGLEVEL >= 10)
 770                 NDR_PRINT_OUT_DEBUG(winreg_SetValue, &r);
 771
 772         if (NT_STATUS_IS_ERR(status)) {
 773                 return status;
 774         }
 775
 776         /* Return variables */
 777
 778         /* Return result */
 779         return werror_to_ntstatus(r.out.result);
 780 }
 781
 782 NTSTATUS rpccli_winreg_UnLoadKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
 783 {
 784         struct winreg_UnLoadKey r;
 785         NTSTATUS status;
 786
 787         /* In parameters */
 788
 789         if (DEBUGLEVEL >= 10)
 790                 NDR_PRINT_IN_DEBUG(winreg_UnLoadKey, &r);
 791
 792         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_UNLOADKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_UnLoadKey, (ndr_push_flags_fn_t)ndr_push_winreg_UnLoadKey);
 793
 794         if ( !NT_STATUS_IS_OK(status) ) {
 795                 return status;
 796         }
 797
 798         if (DEBUGLEVEL >= 10)
 799                 NDR_PRINT_OUT_DEBUG(winreg_UnLoadKey, &r);
 800
 801         if (NT_STATUS_IS_ERR(status)) {
 802                 return status;
 803         }
 804
 805         /* Return variables */
 806
 807         /* Return result */
 808         return werror_to_ntstatus(r.out.result);
 809 }
 810
 811 NTSTATUS rpccli_winreg_InitiateSystemShutdown(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot)
 812 {
 813         struct winreg_InitiateSystemShutdown r;
 814         NTSTATUS status;
 815
 816         /* In parameters */
 817         r.in.hostname = hostname;
 818         r.in.message = message;
 819         r.in.timeout = timeout;
 820         r.in.force_apps = force_apps;
 821         r.in.reboot = reboot;
 822
 823         if (DEBUGLEVEL >= 10)
 824                 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdown, &r);
 825
 826         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_INITIATESYSTEMSHUTDOWN, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_InitiateSystemShutdown, (ndr_push_flags_fn_t)ndr_push_winreg_InitiateSystemShutdown);
 827
 828         if ( !NT_STATUS_IS_OK(status) ) {
 829                 return status;
 830         }
 831
 832         if (DEBUGLEVEL >= 10)
 833                 NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdown, &r);
 834
 835         if (NT_STATUS_IS_ERR(status)) {
 836                 return status;
 837         }
 838
 839         /* Return variables */
 840
 841         /* Return result */
 842         return werror_to_ntstatus(r.out.result);
 843 }
 844
 845 NTSTATUS rpccli_winreg_AbortSystemShutdown(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16_t *server)
 846 {
 847         struct winreg_AbortSystemShutdown r;
 848         NTSTATUS status;
 849
 850         /* In parameters */
 851         r.in.server = server;
 852
 853         if (DEBUGLEVEL >= 10)
 854                 NDR_PRINT_IN_DEBUG(winreg_AbortSystemShutdown, &r);
 855
 856         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_ABORTSYSTEMSHUTDOWN, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_AbortSystemShutdown, (ndr_push_flags_fn_t)ndr_push_winreg_AbortSystemShutdown);
 857
 858         if ( !NT_STATUS_IS_OK(status) ) {
 859                 return status;
 860         }
 861
 862         if (DEBUGLEVEL >= 10)
 863                 NDR_PRINT_OUT_DEBUG(winreg_AbortSystemShutdown, &r);
 864
 865         if (NT_STATUS_IS_ERR(status)) {
 866                 return status;
 867         }
 868
 869         /* Return variables */
 870
 871         /* Return result */
 872         return werror_to_ntstatus(r.out.result);
 873 }
 874
 875 NTSTATUS rpccli_winreg_GetVersion(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t *version)
 876 {
 877         struct winreg_GetVersion r;
 878         NTSTATUS status;
 879
 880         /* In parameters */
 881         r.in.handle = handle;
 882
 883         if (DEBUGLEVEL >= 10)
 884                 NDR_PRINT_IN_DEBUG(winreg_GetVersion, &r);
 885
 886         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_GETVERSION, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_GetVersion, (ndr_push_flags_fn_t)ndr_push_winreg_GetVersion);
 887
 888         if ( !NT_STATUS_IS_OK(status) ) {
 889                 return status;
 890         }
 891
 892         if (DEBUGLEVEL >= 10)
 893                 NDR_PRINT_OUT_DEBUG(winreg_GetVersion, &r);
 894
 895         if (NT_STATUS_IS_ERR(status)) {
 896                 return status;
 897         }
 898
 899         /* Return variables */
 900         *version = *r.out.version;
 901
 902         /* Return result */
 903         return werror_to_ntstatus(r.out.result);
 904 }
 905
 906 NTSTATUS rpccli_winreg_OpenHKCC(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
 907 {
 908         struct winreg_OpenHKCC r;
 909         NTSTATUS status;
 910
 911         /* In parameters */
 912         r.in.system_name = system_name;
 913         r.in.access_mask = access_mask;
 914
 915         if (DEBUGLEVEL >= 10)
 916                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCC, &r);
 917
 918         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKCC, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKCC, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKCC);
 919
 920         if ( !NT_STATUS_IS_OK(status) ) {
 921                 return status;
 922         }
 923
 924         if (DEBUGLEVEL >= 10)
 925                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCC, &r);
 926
 927         if (NT_STATUS_IS_ERR(status)) {
 928                 return status;
 929         }
 930
 931         /* Return variables */
 932         *handle = *r.out.handle;
 933
 934         /* Return result */
 935         return werror_to_ntstatus(r.out.result);
 936 }
 937
 938 NTSTATUS rpccli_winreg_OpenHKDD(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
 939 {
 940         struct winreg_OpenHKDD r;
 941         NTSTATUS status;
 942
 943         /* In parameters */
 944         r.in.system_name = system_name;
 945         r.in.access_mask = access_mask;
 946
 947         if (DEBUGLEVEL >= 10)
 948                 NDR_PRINT_IN_DEBUG(winreg_OpenHKDD, &r);
 949
 950         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKDD, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKDD, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKDD);
 951
 952         if ( !NT_STATUS_IS_OK(status) ) {
 953                 return status;
 954         }
 955
 956         if (DEBUGLEVEL >= 10)
 957                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKDD, &r);
 958
 959         if (NT_STATUS_IS_ERR(status)) {
 960                 return status;
 961         }
 962
 963         /* Return variables */
 964         *handle = *r.out.handle;
 965
 966         /* Return result */
 967         return werror_to_ntstatus(r.out.result);
 968 }
 969
 970 NTSTATUS rpccli_winreg_QueryMultipleValues(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *key_handle, struct QueryMultipleValue *values, uint32_t num_values, uint8_t **buffer, uint32_t *buffer_size)
 971 {
 972         struct winreg_QueryMultipleValues r;
 973         NTSTATUS status;
 974
 975         /* In parameters */
 976         r.in.key_handle = key_handle;
 977         r.in.values = values;
 978         r.in.num_values = num_values;
 979         r.in.buffer = *buffer;
 980         r.in.buffer_size = buffer_size;
 981
 982         if (DEBUGLEVEL >= 10)
 983                 NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues, &r);
 984
 985         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_QUERYMULTIPLEVALUES, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_QueryMultipleValues, (ndr_push_flags_fn_t)ndr_push_winreg_QueryMultipleValues);
 986
 987         if ( !NT_STATUS_IS_OK(status) ) {
 988                 return status;
 989         }
 990
 991         if (DEBUGLEVEL >= 10)
 992                 NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues, &r);
 993
 994         if (NT_STATUS_IS_ERR(status)) {
 995                 return status;
 996         }
 997
 998         /* Return variables */
 999         *values = *r.out.values;
1000         *buffer = r.out.buffer;
1001         *buffer_size = *r.out.buffer_size;
1002
1003         /* Return result */
1004         return werror_to_ntstatus(r.out.result);
1005 }
1006
1007 NTSTATUS rpccli_winreg_InitiateSystemShutdownEx(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot, uint32_t reason)
1008 {
1009         struct winreg_InitiateSystemShutdownEx r;
1010         NTSTATUS status;
1011
1012         /* In parameters */
1013         r.in.hostname = hostname;
1014         r.in.message = message;
1015         r.in.timeout = timeout;
1016         r.in.force_apps = force_apps;
1017         r.in.reboot = reboot;
1018         r.in.reason = reason;
1019
1020         if (DEBUGLEVEL >= 10)
1021                 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdownEx, &r);
1022
1023         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_INITIATESYSTEMSHUTDOWNEX, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_InitiateSystemShutdownEx, (ndr_push_flags_fn_t)ndr_push_winreg_InitiateSystemShutdownEx);
1024
1025         if ( !NT_STATUS_IS_OK(status) ) {
1026                 return status;
1027         }
1028
1029         if (DEBUGLEVEL >= 10)
1030                 NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdownEx, &r);
1031
1032         if (NT_STATUS_IS_ERR(status)) {
1033                 return status;
1034         }
1035
1036         /* Return variables */
1037
1038         /* Return result */
1039         return werror_to_ntstatus(r.out.result);
1040 }
1041
1042 NTSTATUS rpccli_winreg_SaveKeyEx(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
1043 {
1044         struct winreg_SaveKeyEx r;
1045         NTSTATUS status;
1046
1047         /* In parameters */
1048
1049         if (DEBUGLEVEL >= 10)
1050                 NDR_PRINT_IN_DEBUG(winreg_SaveKeyEx, &r);
1051
1052         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_SAVEKEYEX, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_SaveKeyEx, (ndr_push_flags_fn_t)ndr_push_winreg_SaveKeyEx);
1053
1054         if ( !NT_STATUS_IS_OK(status) ) {
1055                 return status;
1056         }
1057
1058         if (DEBUGLEVEL >= 10)
1059                 NDR_PRINT_OUT_DEBUG(winreg_SaveKeyEx, &r);
1060
1061         if (NT_STATUS_IS_ERR(status)) {
1062                 return status;
1063         }
1064
1065         /* Return variables */
1066
1067         /* Return result */
1068         return werror_to_ntstatus(r.out.result);
1069 }
1070
1071 NTSTATUS rpccli_winreg_OpenHKPT(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
1072 {
1073         struct winreg_OpenHKPT r;
1074         NTSTATUS status;
1075
1076         /* In parameters */
1077         r.in.system_name = system_name;
1078         r.in.access_mask = access_mask;
1079
1080         if (DEBUGLEVEL >= 10)
1081                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPT, &r);
1082
1083         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKPT, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKPT, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKPT);
1084
1085         if ( !NT_STATUS_IS_OK(status) ) {
1086                 return status;
1087         }
1088
1089         if (DEBUGLEVEL >= 10)
1090                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPT, &r);
1091
1092         if (NT_STATUS_IS_ERR(status)) {
1093                 return status;
1094         }
1095
1096         /* Return variables */
1097         *handle = *r.out.handle;
1098
1099         /* Return result */
1100         return werror_to_ntstatus(r.out.result);
1101 }
1102
1103 NTSTATUS rpccli_winreg_OpenHKPN(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
1104 {
1105         struct winreg_OpenHKPN r;
1106         NTSTATUS status;
1107
1108         /* In parameters */
1109         r.in.system_name = system_name;
1110         r.in.access_mask = access_mask;
1111
1112         if (DEBUGLEVEL >= 10)
1113                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPN, &r);
1114
1115         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKPN, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKPN, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKPN);
1116
1117         if ( !NT_STATUS_IS_OK(status) ) {
1118                 return status;
1119         }
1120
1121         if (DEBUGLEVEL >= 10)
1122                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPN, &r);
1123
1124         if (NT_STATUS_IS_ERR(status)) {
1125                 return status;
1126         }
1127
1128         /* Return variables */
1129         *handle = *r.out.handle;
1130
1131         /* Return result */
1132         return werror_to_ntstatus(r.out.result);
1133 }
1134
1135 NTSTATUS rpccli_winreg_QueryMultipleValues2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
1136 {
1137         struct winreg_QueryMultipleValues2 r;
1138         NTSTATUS status;
1139
1140         /* In parameters */
1141
1142         if (DEBUGLEVEL >= 10)
1143                 NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues2, &r);
1144
1145         status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_QUERYMULTIPLEVALUES2, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_QueryMultipleValues2, (ndr_push_flags_fn_t)ndr_push_winreg_QueryMultipleValues2);
1146
1147         if ( !NT_STATUS_IS_OK(status) ) {
1148                 return status;
1149         }
1150
1151         if (DEBUGLEVEL >= 10)
1152                 NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues2, &r);
1153
1154         if (NT_STATUS_IS_ERR(status)) {
1155                 return status;
1156         }
1157
1158         /* Return variables */
1159
1160         /* Return result */
1161         return werror_to_ntstatus(r.out.result);
1162 }
1163