source3/librpc/gen_ndr/winreg.h

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