librpc/gen_ndr/winreg.h

   1 /* header auto-generated by pidl */
   2
   3 #include <stdint.h>
   4
   5 #include "libcli/util/ntstatus.h"
   6
   7 #include "librpc/gen_ndr/lsa.h"
   8 #include "librpc/gen_ndr/security.h"
   9 #ifndef _HEADER_winreg
  10 #define _HEADER_winreg
  11
  12 #define REG_KEY_READ    ( (STANDARD_RIGHTS_READ_ACCESS|KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS|KEY_NOTIFY) )
  13 #define REG_KEY_EXECUTE ( REG_KEY_READ )
  14 #define REG_KEY_WRITE   ( (STANDARD_RIGHTS_WRITE_ACCESS|KEY_SET_VALUE|KEY_CREATE_SUB_KEY) )
  15 #define REG_KEY_ALL     ( (STANDARD_RIGHTS_REQUIRED_ACCESS|REG_KEY_READ|REG_KEY_WRITE|KEY_CREATE_LINK) )
  16 /* bitmap winreg_AccessMask */
  17 #define KEY_QUERY_VALUE ( 0x00001 )
  18 #define KEY_SET_VALUE ( 0x00002 )
  19 #define KEY_CREATE_SUB_KEY ( 0x00004 )
  20 #define KEY_ENUMERATE_SUB_KEYS ( 0x00008 )
  21 #define KEY_NOTIFY ( 0x00010 )
  22 #define KEY_CREATE_LINK ( 0x00020 )
  23 #define KEY_WOW64_64KEY ( 0x00100 )
  24 #define KEY_WOW64_32KEY ( 0x00200 )
  25
  26 enum winreg_Type
  27 #ifndef USE_UINT_ENUMS
  28  {
  29         REG_NONE=(int)(0),
  30         REG_SZ=(int)(1),
  31         REG_EXPAND_SZ=(int)(2),
  32         REG_BINARY=(int)(3),
  33         REG_DWORD=(int)(4),
  34         REG_DWORD_BIG_ENDIAN=(int)(5),
  35         REG_LINK=(int)(6),
  36         REG_MULTI_SZ=(int)(7),
  37         REG_RESOURCE_LIST=(int)(8),
  38         REG_FULL_RESOURCE_DESCRIPTOR=(int)(9),
  39         REG_RESOURCE_REQUIREMENTS_LIST=(int)(10),
  40         REG_QWORD=(int)(11)
  41 }
  42 #else
  43  { __donnot_use_enum_winreg_Type=0x7FFFFFFF}
  44 #define REG_NONE ( 0 )
  45 #define REG_SZ ( 1 )
  46 #define REG_EXPAND_SZ ( 2 )
  47 #define REG_BINARY ( 3 )
  48 #define REG_DWORD ( 4 )
  49 #define REG_DWORD_BIG_ENDIAN ( 5 )
  50 #define REG_LINK ( 6 )
  51 #define REG_MULTI_SZ ( 7 )
  52 #define REG_RESOURCE_LIST ( 8 )
  53 #define REG_FULL_RESOURCE_DESCRIPTOR ( 9 )
  54 #define REG_RESOURCE_REQUIREMENTS_LIST ( 10 )
  55 #define REG_QWORD ( 11 )
  56 #endif
  57 ;
  58
  59 struct winreg_String {
  60         uint16_t name_len;/* [value(strlen_m_term(name)*2)] */
  61         uint16_t name_size;/* [value(strlen_m_term(name)*2)] */
  62         const char *name;/* [unique,charset(UTF16)] */
  63 }/* [public] */;
  64
  65 struct KeySecurityData {
  66         uint8_t *data;/* [unique,length_is(len),size_is(size)] */
  67         uint32_t size;
  68         uint32_t len;
  69 };
  70
  71 struct winreg_SecBuf {
  72         uint32_t length;
  73         struct KeySecurityData sd;
  74         uint8_t inherit;
  75 };
  76
  77 enum winreg_CreateAction
  78 #ifndef USE_UINT_ENUMS
  79  {
  80         REG_ACTION_NONE=(int)(0),
  81         REG_CREATED_NEW_KEY=(int)(1),
  82         REG_OPENED_EXISTING_KEY=(int)(2)
  83 }
  84 #else
  85  { __donnot_use_enum_winreg_CreateAction=0x7FFFFFFF}
  86 #define REG_ACTION_NONE ( 0 )
  87 #define REG_CREATED_NEW_KEY ( 1 )
  88 #define REG_OPENED_EXISTING_KEY ( 2 )
  89 #endif
  90 ;
  91
  92 struct winreg_StringBuf {
  93         uint16_t length;/* [value(strlen_m_term_null(name)*2)] */
  94         uint16_t size;
  95         const char *name;/* [unique,length_is(length/2),charset(UTF16),size_is(size/2)] */
  96 };
  97
  98 struct winreg_ValNameBuf {
  99         uint16_t length;/* [value(strlen_m_term(name)*2)] */
 100         uint16_t size;
 101         const char *name;/* [unique,length_is(length/2),charset(UTF16),size_is(size/2)] */
 102 };
 103
 104 /* bitmap winreg_NotifyChangeType */
 105 #define REG_NOTIFY_CHANGE_NAME ( 0x00000001 )
 106 #define REG_NOTIFY_CHANGE_ATTRIBUTES ( 0x00000002 )
 107 #define REG_NOTIFY_CHANGE_LAST_SET ( 0x00000004 )
 108 #define REG_NOTIFY_CHANGE_SECURITY ( 0x00000008 )
 109
 110 struct KeySecurityAttribute {
 111         uint32_t data_size;
 112         struct KeySecurityData sec_data;
 113         uint8_t inherit;
 114 };
 115
 116 struct QueryMultipleValue {
 117         struct winreg_String *name;/* [unique] */
 118         enum winreg_Type type;
 119         uint32_t offset;
 120         uint32_t length;
 121 };
 122
 123
 124 struct winreg_OpenHKCR {
 125         struct {
 126                 uint16_t *system_name;/* [unique] */
 127                 uint32_t access_mask;
 128         } in;
 129
 130         struct {
 131                 struct policy_handle *handle;/* [ref] */
 132                 WERROR result;
 133         } out;
 134
 135 };
 136
 137
 138 struct winreg_OpenHKCU {
 139         struct {
 140                 uint16_t *system_name;/* [unique] */
 141                 uint32_t access_mask;
 142         } in;
 143
 144         struct {
 145                 struct policy_handle *handle;/* [ref] */
 146                 WERROR result;
 147         } out;
 148
 149 };
 150
 151
 152 struct winreg_OpenHKLM {
 153         struct {
 154                 uint16_t *system_name;/* [unique] */
 155                 uint32_t access_mask;
 156         } in;
 157
 158         struct {
 159                 struct policy_handle *handle;/* [ref] */
 160                 WERROR result;
 161         } out;
 162
 163 };
 164
 165
 166 struct winreg_OpenHKPD {
 167         struct {
 168                 uint16_t *system_name;/* [unique] */
 169                 uint32_t access_mask;
 170         } in;
 171
 172         struct {
 173                 struct policy_handle *handle;/* [ref] */
 174                 WERROR result;
 175         } out;
 176
 177 };
 178
 179
 180 struct winreg_OpenHKU {
 181         struct {
 182                 uint16_t *system_name;/* [unique] */
 183                 uint32_t access_mask;
 184         } in;
 185
 186         struct {
 187                 struct policy_handle *handle;/* [ref] */
 188                 WERROR result;
 189         } out;
 190
 191 };
 192
 193
 194 struct winreg_CloseKey {
 195         struct {
 196                 struct policy_handle *handle;/* [ref] */
 197         } in;
 198
 199         struct {
 200                 struct policy_handle *handle;/* [ref] */
 201                 WERROR result;
 202         } out;
 203
 204 };
 205
 206
 207 struct winreg_CreateKey {
 208         struct {
 209                 struct policy_handle *handle;/* [ref] */
 210                 struct winreg_String name;
 211                 struct winreg_String keyclass;
 212                 uint32_t options;
 213                 uint32_t access_mask;
 214                 struct winreg_SecBuf *secdesc;/* [unique] */
 215                 enum winreg_CreateAction *action_taken;/* [unique] */
 216         } in;
 217
 218         struct {
 219                 struct policy_handle *new_handle;/* [ref] */
 220                 enum winreg_CreateAction *action_taken;/* [unique] */
 221                 WERROR result;
 222         } out;
 223
 224 };
 225
 226
 227 struct winreg_DeleteKey {
 228         struct {
 229                 struct policy_handle *handle;/* [ref] */
 230                 struct winreg_String key;
 231         } in;
 232
 233         struct {
 234                 WERROR result;
 235         } out;
 236
 237 };
 238
 239
 240 struct winreg_DeleteValue {
 241         struct {
 242                 struct policy_handle *handle;/* [ref] */
 243                 struct winreg_String value;
 244         } in;
 245
 246         struct {
 247                 WERROR result;
 248         } out;
 249
 250 };
 251
 252
 253 struct winreg_EnumKey {
 254         struct {
 255                 struct policy_handle *handle;/* [ref] */
 256                 uint32_t enum_index;
 257                 struct winreg_StringBuf *name;/* [ref] */
 258                 struct winreg_StringBuf *keyclass;/* [unique] */
 259                 NTTIME *last_changed_time;/* [unique] */
 260         } in;
 261
 262         struct {
 263                 struct winreg_StringBuf *name;/* [ref] */
 264                 struct winreg_StringBuf *keyclass;/* [unique] */
 265                 NTTIME *last_changed_time;/* [unique] */
 266                 WERROR result;
 267         } out;
 268
 269 };
 270
 271
 272 struct winreg_EnumValue {
 273         struct {
 274                 struct policy_handle *handle;/* [ref] */
 275                 uint32_t enum_index;
 276                 struct winreg_ValNameBuf *name;/* [ref] */
 277                 enum winreg_Type *type;/* [unique] */
 278                 uint8_t *value;/* [unique,length_is(*length),size_is(*size)] */
 279                 uint32_t *size;/* [unique] */
 280                 uint32_t *length;/* [unique] */
 281         } in;
 282
 283         struct {
 284                 struct winreg_ValNameBuf *name;/* [ref] */
 285                 enum winreg_Type *type;/* [unique] */
 286                 uint8_t *value;/* [unique,length_is(*length),size_is(*size)] */
 287                 uint32_t *size;/* [unique] */
 288                 uint32_t *length;/* [unique] */
 289                 WERROR result;
 290         } out;
 291
 292 };
 293
 294
 295 struct winreg_FlushKey {
 296         struct {
 297                 struct policy_handle *handle;/* [ref] */
 298         } in;
 299
 300         struct {
 301                 WERROR result;
 302         } out;
 303
 304 };
 305
 306
 307 struct winreg_GetKeySecurity {
 308         struct {
 309                 struct policy_handle *handle;/* [ref] */
 310                 uint32_t sec_info;
 311                 struct KeySecurityData *sd;/* [ref] */
 312         } in;
 313
 314         struct {
 315                 struct KeySecurityData *sd;/* [ref] */
 316                 WERROR result;
 317         } out;
 318
 319 };
 320
 321
 322 struct winreg_LoadKey {
 323         struct {
 324                 struct policy_handle *handle;/* [ref] */
 325                 struct winreg_String *keyname;/* [unique] */
 326                 struct winreg_String *filename;/* [unique] */
 327         } in;
 328
 329         struct {
 330                 WERROR result;
 331         } out;
 332
 333 };
 334
 335
 336 struct winreg_NotifyChangeKeyValue {
 337         struct {
 338                 struct policy_handle *handle;/* [ref] */
 339                 uint8_t watch_subtree;
 340                 uint32_t notify_filter;
 341                 uint32_t unknown;
 342                 struct winreg_String string1;
 343                 struct winreg_String string2;
 344                 uint32_t unknown2;
 345         } in;
 346
 347         struct {
 348                 WERROR result;
 349         } out;
 350
 351 };
 352
 353
 354 struct winreg_OpenKey {
 355         struct {
 356                 struct policy_handle *parent_handle;/* [ref] */
 357                 struct winreg_String keyname;
 358                 uint32_t unknown;
 359                 uint32_t access_mask;
 360         } in;
 361
 362         struct {
 363                 struct policy_handle *handle;/* [ref] */
 364                 WERROR result;
 365         } out;
 366
 367 };
 368
 369
 370 struct winreg_QueryInfoKey {
 371         struct {
 372                 struct policy_handle *handle;/* [ref] */
 373                 struct winreg_String *classname;/* [ref] */
 374         } in;
 375
 376         struct {
 377                 uint32_t *num_subkeys;/* [ref] */
 378                 uint32_t *max_subkeylen;/* [ref] */
 379                 uint32_t *max_classlen;/* [ref] */
 380                 uint32_t *num_values;/* [ref] */
 381                 uint32_t *max_valnamelen;/* [ref] */
 382                 uint32_t *max_valbufsize;/* [ref] */
 383                 uint32_t *secdescsize;/* [ref] */
 384                 NTTIME *last_changed_time;/* [ref] */
 385                 struct winreg_String *classname;/* [ref] */
 386                 WERROR result;
 387         } out;
 388
 389 };
 390
 391
 392 struct winreg_QueryValue {
 393         struct {
 394                 struct policy_handle *handle;/* [ref] */
 395                 struct winreg_String *value_name;/* [ref] */
 396                 enum winreg_Type *type;/* [unique] */
 397                 uint8_t *data;/* [unique,length_is(*data_length),size_is(*data_size)] */
 398                 uint32_t *data_size;/* [unique] */
 399                 uint32_t *data_length;/* [unique] */
 400         } in;
 401
 402         struct {
 403                 enum winreg_Type *type;/* [unique] */
 404                 uint8_t *data;/* [unique,length_is(*data_length),size_is(*data_size)] */
 405                 uint32_t *data_size;/* [unique] */
 406                 uint32_t *data_length;/* [unique] */
 407                 WERROR result;
 408         } out;
 409
 410 };
 411
 412
 413 struct winreg_ReplaceKey {
 414         struct {
 415                 WERROR result;
 416         } out;
 417
 418 };
 419
 420
 421 struct winreg_RestoreKey {
 422         struct {
 423                 struct policy_handle *handle;/* [ref] */
 424                 struct winreg_String *filename;/* [ref] */
 425                 uint32_t flags;
 426         } in;
 427
 428         struct {
 429                 WERROR result;
 430         } out;
 431
 432 };
 433
 434
 435 struct winreg_SaveKey {
 436         struct {
 437                 struct policy_handle *handle;/* [ref] */
 438                 struct winreg_String *filename;/* [ref] */
 439                 struct KeySecurityAttribute *sec_attrib;/* [unique] */
 440         } in;
 441
 442         struct {
 443                 WERROR result;
 444         } out;
 445
 446 };
 447
 448
 449 struct winreg_SetKeySecurity {
 450         struct {
 451                 struct policy_handle *handle;/* [ref] */
 452                 uint32_t sec_info;
 453                 struct KeySecurityData *sd;/* [ref] */
 454         } in;
 455
 456         struct {
 457                 WERROR result;
 458         } out;
 459
 460 };
 461
 462
 463 struct winreg_SetValue {
 464         struct {
 465                 struct policy_handle *handle;/* [ref] */
 466                 struct winreg_String name;
 467                 enum winreg_Type type;
 468                 uint8_t *data;/* [ref,size_is(size)] */
 469                 uint32_t size;
 470         } in;
 471
 472         struct {
 473                 WERROR result;
 474         } out;
 475
 476 };
 477
 478
 479 struct winreg_UnLoadKey {
 480         struct {
 481                 WERROR result;
 482         } out;
 483
 484 };
 485
 486
 487 struct winreg_InitiateSystemShutdown {
 488         struct {
 489                 uint16_t *hostname;/* [unique] */
 490                 struct lsa_StringLarge *message;/* [unique] */
 491                 uint32_t timeout;
 492                 uint8_t force_apps;
 493                 uint8_t do_reboot;
 494         } in;
 495
 496         struct {
 497                 WERROR result;
 498         } out;
 499
 500 };
 501
 502
 503 struct winreg_AbortSystemShutdown {
 504         struct {
 505                 uint16_t *server;/* [unique] */
 506         } in;
 507
 508         struct {
 509                 WERROR result;
 510         } out;
 511
 512 };
 513
 514
 515 struct winreg_GetVersion {
 516         struct {
 517                 struct policy_handle *handle;/* [ref] */
 518         } in;
 519
 520         struct {
 521                 uint32_t *version;/* [ref] */
 522                 WERROR result;
 523         } out;
 524
 525 };
 526
 527
 528 struct winreg_OpenHKCC {
 529         struct {
 530                 uint16_t *system_name;/* [unique] */
 531                 uint32_t access_mask;
 532         } in;
 533
 534         struct {
 535                 struct policy_handle *handle;/* [ref] */
 536                 WERROR result;
 537         } out;
 538
 539 };
 540
 541
 542 struct winreg_OpenHKDD {
 543         struct {
 544                 uint16_t *system_name;/* [unique] */
 545                 uint32_t access_mask;
 546         } in;
 547
 548         struct {
 549                 struct policy_handle *handle;/* [ref] */
 550                 WERROR result;
 551         } out;
 552
 553 };
 554
 555
 556 struct winreg_QueryMultipleValues {
 557         struct {
 558                 struct policy_handle *key_handle;/* [ref] */
 559                 uint32_t num_values;
 560                 struct QueryMultipleValue *values;/* [ref,length_is(num_values),size_is(num_values)] */
 561                 uint8_t *buffer;/* [unique,length_is(*buffer_size),size_is(*buffer_size)] */
 562                 uint32_t *buffer_size;/* [ref] */
 563         } in;
 564
 565         struct {
 566                 struct QueryMultipleValue *values;/* [ref,length_is(num_values),size_is(num_values)] */
 567                 uint8_t *buffer;/* [unique,length_is(*buffer_size),size_is(*buffer_size)] */
 568                 uint32_t *buffer_size;/* [ref] */
 569                 WERROR result;
 570         } out;
 571
 572 };
 573
 574
 575 struct winreg_InitiateSystemShutdownEx {
 576         struct {
 577                 uint16_t *hostname;/* [unique] */
 578                 struct lsa_StringLarge *message;/* [unique] */
 579                 uint32_t timeout;
 580                 uint8_t force_apps;
 581                 uint8_t do_reboot;
 582                 uint32_t reason;
 583         } in;
 584
 585         struct {
 586                 WERROR result;
 587         } out;
 588
 589 };
 590
 591
 592 struct winreg_SaveKeyEx {
 593         struct {
 594                 WERROR result;
 595         } out;
 596
 597 };
 598
 599
 600 struct winreg_OpenHKPT {
 601         struct {
 602                 uint16_t *system_name;/* [unique] */
 603                 uint32_t access_mask;
 604         } in;
 605
 606         struct {
 607                 struct policy_handle *handle;/* [ref] */
 608                 WERROR result;
 609         } out;
 610
 611 };
 612
 613
 614 struct winreg_OpenHKPN {
 615         struct {
 616                 uint16_t *system_name;/* [unique] */
 617                 uint32_t access_mask;
 618         } in;
 619
 620         struct {
 621                 struct policy_handle *handle;/* [ref] */
 622                 WERROR result;
 623         } out;
 624
 625 };
 626
 627
 628 struct winreg_QueryMultipleValues2 {
 629         struct {
 630                 WERROR result;
 631         } out;
 632
 633 };
 634
 635 #endif /* _HEADER_winreg */