librpc/idl/drsblobs.idl

   1 #include "idl_types.h"
   2
   3 import "drsuapi.idl", "misc.idl", "samr.idl", "lsa.idl", "security.idl";
   4
   5 [
   6   uuid("12345778-1234-abcd-0001-00000001"),
   7   version(0.0),
   8   pointer_default(unique),
   9   helper("../librpc/ndr/ndr_drsblobs.h"),
  10   helpstring("Active Directory Replication LDAP Blobs")
  11 ]
  12 interface drsblobs {
  13         typedef bitmap drsuapi_DrsOptions drsuapi_DrsOptions;
  14         typedef [v1_enum] enum drsuapi_DsAttributeId drsuapi_DsAttributeId;
  15         typedef [v1_enum] enum lsa_TrustAuthType lsa_TrustAuthType;
  16         /*
  17          * replPropertyMetaData
  18          * w2k  uses version 1
  19          * w2k3 uses version 1
  20          */
  21         typedef struct {
  22                 drsuapi_DsAttributeId attid;
  23                 uint32 version;
  24                 NTTIME_1sec originating_change_time;
  25                 GUID originating_invocation_id;
  26                 hyper originating_usn;
  27                 hyper local_usn;
  28         } replPropertyMetaData1;
  29
  30         typedef struct {
  31                 uint32 count;
  32                 [value(0)] uint32 reserved;
  33                 replPropertyMetaData1 array[count];
  34         } replPropertyMetaDataCtr1;
  35
  36         typedef [nodiscriminant] union {
  37                 [case(1)] replPropertyMetaDataCtr1 ctr1;
  38         } replPropertyMetaDataCtr;
  39
  40         typedef [public] struct {
  41                 uint32 version;
  42                 [value(0)] uint32 reserved;
  43                 [switch_is(version)] replPropertyMetaDataCtr ctr;
  44         } replPropertyMetaDataBlob;
  45
  46         void decode_replPropertyMetaData(
  47                 [in] replPropertyMetaDataBlob blob
  48                 );
  49
  50         /*
  51          * replUpToDateVector
  52          * w2k  uses version 1
  53          * w2k3 uses version 2
  54          */
  55         typedef struct {
  56                 uint32 count;
  57                 [value(0)] uint32 reserved;
  58                 drsuapi_DsReplicaCursor cursors[count];
  59         } replUpToDateVectorCtr1;
  60
  61         typedef struct {
  62                 uint32 count;
  63                 [value(0)] uint32 reserved;
  64                 drsuapi_DsReplicaCursor2 cursors[count];
  65         } replUpToDateVectorCtr2;
  66
  67         typedef [nodiscriminant] union {
  68                 [case(1)] replUpToDateVectorCtr1 ctr1;
  69                 [case(2)] replUpToDateVectorCtr2 ctr2;
  70         } replUpToDateVectorCtr;
  71
  72         typedef [public] struct {
  73                 uint32 version;
  74                 [value(0)] uint32 reserved;
  75                 [switch_is(version)] replUpToDateVectorCtr ctr;
  76         } replUpToDateVectorBlob;
  77
  78         void decode_replUpToDateVector(
  79                 [in] replUpToDateVectorBlob blob
  80                 );
  81
  82         /*
  83          * repsFrom/repsTo
  84          * w2k  uses version 1
  85          * w2k3 uses version 1
  86          * w2k8 uses version 2
  87          */
  88         typedef [public,gensize] struct {
  89                 [value(strlen(dns_name)+1)] uint32 __dns_name_size;
  90                 [charset(DOS)] uint8 dns_name[__dns_name_size];
  91         } repsFromTo1OtherInfo;
  92
  93         typedef [public,gensize,flag(NDR_PAHEX)] struct {
  94                 /* this includes the 8 bytes of the repsFromToBlob header */
  95                 [value(ndr_size_repsFromTo1(this, ndr->flags)+8)] uint32 blobsize;
  96                 uint32 consecutive_sync_failures;
  97                 NTTIME_1sec last_success;
  98                 NTTIME_1sec last_attempt;
  99                 WERROR result_last_attempt;
 100                 [relative] repsFromTo1OtherInfo *other_info;
 101                 [value(ndr_size_repsFromTo1OtherInfo(other_info, ndr->flags))] uint32 other_info_length;
 102                 drsuapi_DrsOptions replica_flags;
 103                 uint8 schedule[84];
 104                 [value(0)] uint32 reserved;
 105                 drsuapi_DsReplicaHighWaterMark highwatermark;
 106                 GUID source_dsa_obj_guid; /* the 'objectGuid' field of the CN=NTDS Settings object */
 107                 GUID source_dsa_invocation_id; /* the 'invocationId' field of the CN=NTDS Settings object */
 108                 GUID transport_guid;
 109         } repsFromTo1;
 110
 111         typedef [public,relative_base,gensize] struct {
 112                 [value(ndr_size_repsFromTo2OtherInfo(this,ndr->flags))]
 113                         uint32 __ndr_size;
 114                 [relative] nstring *dns_name1;
 115                 uint32 unknown1;
 116                 [relative] nstring *dns_name2;
 117                 hyper unknown2;
 118         } repsFromTo2OtherInfo;
 119
 120         typedef [public,gensize,flag(NDR_PAHEX)] struct {
 121                 /* this includes the 8 bytes of the repsFromToBlob header */
 122                 [value(ndr_size_repsFromTo2(this, ndr->flags)+8)] uint32 blobsize;
 123                 uint32 consecutive_sync_failures;
 124                 NTTIME_1sec last_success;
 125                 NTTIME_1sec last_attempt;
 126                 WERROR result_last_attempt;
 127                 [relative] repsFromTo2OtherInfo *other_info;
 128                 [value(ndr_size_repsFromTo2OtherInfo(other_info, ndr->flags))] uint32 other_info_length;
 129                 drsuapi_DrsOptions replica_flags;
 130                 uint8 schedule[84];
 131                 [value(0)] uint32 reserved;
 132                 drsuapi_DsReplicaHighWaterMark highwatermark;
 133                 GUID source_dsa_obj_guid; /* the 'objectGuid' field of the CN=NTDS Settings object */
 134                 GUID source_dsa_invocation_id; /* the 'invocationId' field of the CN=NTDS Settings object */
 135                 GUID transport_guid;
 136                 hyper unknown1;
 137         } repsFromTo2;
 138
 139         typedef [nodiscriminant] union {
 140                 [case(1)] repsFromTo1 ctr1;
 141                 [case(2)] repsFromTo2 ctr2;
 142         } repsFromTo;
 143
 144         typedef [public] struct {
 145                 uint32 version;
 146                 [value(0)] uint32 reserved;
 147                 [switch_is(version)] repsFromTo ctr;
 148         } repsFromToBlob;
 149
 150         void decode_repsFromTo(
 151                 [in] repsFromToBlob blob
 152                 );
 153
 154         /* Replication schedule structures as defined in MS-ADTS 7.1.4.5
 155          * Appears as attribute of NTDSConnection object
 156          */
 157         typedef [public] struct {
 158                 [value(0)] uint32 type;      /* always 0 */
 159                 uint32            offset;
 160         } scheduleHeader;
 161
 162         typedef [public] struct {
 163                 uint8 slots[168];
 164         } scheduleSlots;
 165
 166         typedef [public] struct {
 167                 uint32             size;
 168                 [value(0)] uint32  bandwidth;         /* ignored */
 169                 [value(1)] uint32  numberOfSchedules; /* always 1 */
 170                 scheduleHeader     headerArray[numberOfSchedules];
 171                 scheduleSlots      dataArray[numberOfSchedules];
 172         } schedule;
 173
 174         /*
 175          * partialAttributeSet
 176          * w2k  uses version 1
 177          * w2k3 uses version 1
 178          */
 179         typedef struct {
 180                 uint32 count;
 181                 drsuapi_DsAttributeId array[count];
 182         } partialAttributeSetCtr1;
 183
 184         typedef [nodiscriminant] union {
 185                 [case(1)] partialAttributeSetCtr1 ctr1;
 186         } partialAttributeSetCtr;
 187
 188         typedef [public] struct {
 189                 uint32 version;
 190                 [value(0)] uint32 reserved;
 191                 [switch_is(version)] partialAttributeSetCtr ctr;
 192         } partialAttributeSetBlob;
 193
 194         void decode_partialAttributeSet(
 195                 [in] partialAttributeSetBlob blob
 196                 );
 197
 198
 199         /*
 200          * schemaInfo attribute
 201          *
 202          * Used as an attribute on Schema.
 203          * Also during replication as part of
 204          * prefixMap to identify what revision
 205          * of Schema source DC has
 206          */
 207         typedef [public,flag(NDR_NOALIGN)] struct {
 208                 [value(0xFF)] uint8 marker;
 209                 [flag(NDR_BIG_ENDIAN)] uint32 revision;
 210                 GUID   invocation_id;
 211         } schemaInfoBlob;
 212
 213
 214         /*
 215          * MS w2k3 and w2k8 prefixMap format
 216          * There is no version number. Format is:
 217          *   uint32 - number of entries in the map
 218          *   uint32 - total bytes that structure occupies
 219          *   ENTRIES:
 220          *     uint16 - prefix ID (OID's last sub-id encoded. see prefixMap)
 221          *     uint16 - number of bytes in prefix N
 222          *     uint8[N] - BER encoded prefix
 223          */
 224         typedef [noprint,flag(NDR_NOALIGN)] struct {
 225                 uint16 entryID;
 226                 uint16 length;
 227                 uint8 binary_oid[length];
 228         } drsuapi_MSPrefixMap_Entry;
 229
 230         typedef [public,gensize] struct {
 231                 uint32 num_entries;
 232                 [value(ndr_size_drsuapi_MSPrefixMap_Ctr(r, ndr->flags))] uint32 __ndr_size;
 233                 drsuapi_MSPrefixMap_Entry entries[num_entries];
 234         } drsuapi_MSPrefixMap_Ctr;
 235
 236         /*
 237          * prefixMap
 238          * w2k  unknown
 239          * w2k3 unknown
 240          * samba4 uses 0x44534442 'DSDB'
 241          *
 242          * as we windows don't return the prefixMap attribute when you ask for
 243          * we don't know the format, but the attribute is not replicated
 244          * so that we can choose our own format...
 245          */
 246         typedef [v1_enum] enum {
 247                 PREFIX_MAP_VERSION_DSDB = 0x44534442
 248         } prefixMapVersion;
 249
 250         typedef [nodiscriminant] union {
 251                 [case(PREFIX_MAP_VERSION_DSDB)] drsuapi_DsReplicaOIDMapping_Ctr dsdb;
 252         } prefixMapCtr;
 253
 254         typedef [public] struct {
 255                 prefixMapVersion version;
 256                 [value(0)] uint32 reserved;
 257                 [switch_is(version)] prefixMapCtr ctr;
 258         } prefixMapBlob;
 259
 260         void decode_prefixMap(
 261                 [in] prefixMapBlob blob
 262                 );
 263
 264
 265         /*
 266          * the cookie for the LDAP dirsync control
 267          */
 268         typedef [nodiscriminant,gensize] union {
 269                 [case(0)];
 270                 [default] replUpToDateVectorBlob uptodateness_vector;
 271         } ldapControlDirSyncExtra;
 272
 273         typedef struct {
 274                 [value(3)] uint32 u1;
 275                 NTTIME time;
 276                 uint32 u2;
 277                 uint32 u3;
 278                 [value(ndr_size_ldapControlDirSyncExtra(&extra, extra.uptodateness_vector.version, 0))]
 279                         uint32 extra_length;
 280                 drsuapi_DsReplicaHighWaterMark highwatermark;
 281                 GUID guid1;
 282                 [switch_is(extra_length)] ldapControlDirSyncExtra extra;
 283         } ldapControlDirSyncBlob;
 284
 285         typedef [public,relative_base] struct {
 286                 [charset(DOS),value("MSDS")] uint8 msds[4];
 287                 [subcontext(0)] ldapControlDirSyncBlob blob;
 288         } ldapControlDirSyncCookie;
 289
 290         void decode_ldapControlDirSync(
 291                 [in] ldapControlDirSyncCookie cookie
 292                 );
 293
 294         typedef struct {
 295                 [value(2*strlen_m(name))] uint16 name_len;
 296                 [value(strlen(data))] uint16 data_len;
 297                 uint16 reserved; /* 2 for 'Packages', 1 for 'Primary:*', but should be ignored */
 298                 [charset(UTF16)] uint8 name[name_len];
 299                 /*
 300                  * the data field contains data as HEX strings
 301                  *
 302                  * 'Packages':
 303                  *   data contains the list of packages
 304                  *   as non termiated UTF16 strings with
 305                  *   a UTF16 NULL byte as separator
 306                  *
 307                  * 'Primary:Kerberos-Newer-Keys':
 308                  *    ...
 309                  *
 310                  * 'Primary:Kerberos':
 311                  *    ...
 312                  *
 313                  * 'Primary:WDigest':
 314                  *    ...
 315                  *
 316                  * 'Primary:CLEARTEXT':
 317                  *    data contains the cleartext password
 318                  *    as UTF16 string encoded as HEX string
 319                  */
 320                 [charset(DOS)] uint8 data[data_len];
 321         } supplementalCredentialsPackage;
 322
 323         /* this are 0x30 (48) whitespaces (0x20) */
 324         const string SUPPLEMENTAL_CREDENTIALS_PREFIX = "                                                ";
 325
 326         typedef [flag(NDR_PAHEX)] enum {
 327                 SUPPLEMENTAL_CREDENTIALS_SIGNATURE = 0x0050
 328         } supplementalCredentialsSignature;
 329
 330         typedef [gensize] struct {
 331                 [value(SUPPLEMENTAL_CREDENTIALS_PREFIX),charset(UTF16)] uint16 prefix[0x30];
 332                 [value(SUPPLEMENTAL_CREDENTIALS_SIGNATURE)] supplementalCredentialsSignature signature;
 333                 uint16 num_packages;
 334                 supplementalCredentialsPackage packages[num_packages];
 335         } supplementalCredentialsSubBlob;
 336
 337         typedef [public] struct {
 338                 [value(0)] uint32 unknown1;
 339                 [value(ndr_size_supplementalCredentialsSubBlob(&sub, ndr->flags))] uint32 __ndr_size;
 340                 [value(0)] uint32 unknown2;
 341                 [subcontext(0),subcontext_size(__ndr_size)] supplementalCredentialsSubBlob sub;
 342                 [value(0)] uint8 unknown3;
 343         } supplementalCredentialsBlob;
 344
 345         void decode_supplementalCredentials(
 346                 [in] supplementalCredentialsBlob blob
 347                 );
 348
 349         typedef [public] struct {
 350                 [flag(STR_NOTERM|NDR_REMAINING)] string_array names;
 351         } package_PackagesBlob;
 352
 353         void decode_Packages(
 354                 [in] package_PackagesBlob blob
 355                 );
 356
 357         typedef struct {
 358                 [value(2*strlen_m(string))] uint16 length;
 359                 [value(2*strlen_m(string))] uint16 size;
 360                 [relative,subcontext(0),subcontext_size(size),flag(STR_NOTERM|NDR_REMAINING)] string *string;
 361         } package_PrimaryKerberosString;
 362
 363         typedef struct {
 364                 [value(0)] uint16 reserved1;
 365                 [value(0)] uint16 reserved2;
 366                 [value(0)] uint32 reserved3;
 367                 uint32 keytype;
 368                 [value((value?value->length:0))] uint32 value_len;
 369                 [relative,subcontext(0),subcontext_size(value_len),flag(NDR_REMAINING)] DATA_BLOB *value;
 370         } package_PrimaryKerberosKey3;
 371
 372         typedef struct {
 373                 uint16 num_keys;
 374                 uint16 num_old_keys;
 375                 package_PrimaryKerberosString salt;
 376                 package_PrimaryKerberosKey3 keys[num_keys];
 377                 package_PrimaryKerberosKey3 old_keys[num_old_keys];
 378                 [value(0)] uint32 padding1;
 379                 [value(0)] uint32 padding2;
 380                 [value(0)] uint32 padding3;
 381                 [value(0)] uint32 padding4;
 382                 [value(0)] uint32 padding5;
 383         } package_PrimaryKerberosCtr3;
 384
 385         typedef struct {
 386                 [value(0)] uint16 reserved1;
 387                 [value(0)] uint16 reserved2;
 388                 [value(0)] uint32 reserved3;
 389                 uint32 iteration_count;
 390                 uint32 keytype;
 391                 [value((value?value->length:0))] uint32 value_len;
 392                 [relative,subcontext(0),subcontext_size(value_len),flag(NDR_REMAINING)] DATA_BLOB *value;
 393         } package_PrimaryKerberosKey4;
 394
 395         typedef struct {
 396                 uint16 num_keys;
 397                 [value(0)] uint16 num_service_keys;
 398                 uint16 num_old_keys;
 399                 uint16 num_older_keys;
 400                 package_PrimaryKerberosString salt;
 401                 uint32 default_iteration_count;
 402                 package_PrimaryKerberosKey4 keys[num_keys];
 403                 package_PrimaryKerberosKey4 service_keys[num_service_keys];
 404                 package_PrimaryKerberosKey4 old_keys[num_old_keys];
 405                 package_PrimaryKerberosKey4 older_keys[num_older_keys];
 406         } package_PrimaryKerberosCtr4;
 407
 408         typedef [nodiscriminant] union {
 409                 [case(3)] package_PrimaryKerberosCtr3 ctr3;
 410                 [case(4)] package_PrimaryKerberosCtr4 ctr4;
 411         } package_PrimaryKerberosCtr;
 412
 413         typedef [public] struct {
 414                 uint16 version;
 415                 [value(0)] uint16 flags;
 416                 [switch_is(version)] package_PrimaryKerberosCtr ctr;
 417         } package_PrimaryKerberosBlob;
 418
 419         void decode_PrimaryKerberos(
 420                 [in] package_PrimaryKerberosBlob blob
 421                 );
 422
 423         typedef [public] struct {
 424                 [flag(NDR_REMAINING)] DATA_BLOB cleartext;
 425         } package_PrimaryCLEARTEXTBlob;
 426
 427         void decode_PrimaryCLEARTEXT(
 428                 [in] package_PrimaryCLEARTEXTBlob blob
 429                 );
 430
 431         typedef [flag(NDR_PAHEX)] struct {
 432                 uint8 hash[16];
 433         } package_PrimaryWDigestHash;
 434
 435         typedef [public] struct {
 436                 [value(0x31)] uint16 unknown1;
 437                 [value(0x01)] uint8  unknown2;
 438                 uint8  num_hashes;
 439                 [value(0)] uint32 unknown3;
 440                 [value(0)] udlong uuknown4;
 441                 package_PrimaryWDigestHash hashes[num_hashes];
 442         } package_PrimaryWDigestBlob;
 443
 444         void decode_PrimaryWDigest(
 445                 [in] package_PrimaryWDigestBlob blob
 446                 );
 447
 448         typedef struct {
 449                 [value(0)] uint32 size;
 450         } AuthInfoNone;
 451
 452         typedef struct {
 453                 [value(16)] uint32 size;
 454                 samr_Password password;
 455         } AuthInfoNT4Owf;
 456
 457         /*
 458          * the secret value is encoded as UTF16 if it's a string
 459          * but depending the AuthType, it might also be krb5 trusts have random bytes here, so converting to UTF16
 460          * mayfail...
 461          *
 462          * TODO: We should try handle the case of a random buffer in all places
 463          *       we deal with cleartext passwords from windows
 464          *
 465          * so we don't use this:
 466          *
 467          * uint32 value_len;
 468          * [charset(UTF16)] uint8 value[value_len];
 469          */
 470
 471         typedef struct {
 472                 uint32 size;
 473                 uint8 password[size];
 474         } AuthInfoClear;
 475
 476         typedef struct {
 477                 [value(4)] uint32 size;
 478                  uint32 version;
 479         } AuthInfoVersion;
 480
 481         typedef [nodiscriminant] union {
 482                 [case(TRUST_AUTH_TYPE_NONE)] AuthInfoNone none;
 483                 [case(TRUST_AUTH_TYPE_NT4OWF)] AuthInfoNT4Owf nt4owf;
 484                 [case(TRUST_AUTH_TYPE_CLEAR)] AuthInfoClear clear;
 485                 [case(TRUST_AUTH_TYPE_VERSION)] AuthInfoVersion version;
 486         } AuthInfo;
 487
 488         typedef [public] struct {
 489                 NTTIME LastUpdateTime;
 490                 lsa_TrustAuthType AuthType;
 491                 [switch_is(AuthType)] AuthInfo AuthInfo;
 492                 [flag(NDR_ALIGN4)] DATA_BLOB _pad;
 493         } AuthenticationInformation;
 494
 495         /* count is not on the wire */
 496         typedef [public,nopull,nopush,gensize] struct {
 497                 uint32 count;
 498                 AuthenticationInformation array[count];
 499         } AuthenticationInformationArray;
 500
 501         /* we cannot use [relative] pointers here because Windows expects the
 502          * previous_offset to match the total size of the struct in case
 503          * the previous array is empty, see MS-LSAD 2.2.7.16 - gd */
 504         typedef [public,gensize,nopush] struct {
 505                 uint32 count;
 506                 [value((count > 0) ? 12 : 0)] uint32 current_offset;
 507                 [value((count > 0) ? 12 + ndr_size_AuthenticationInformationArray(&current, ndr->flags) : 0)] uint32 previous_offset;
 508                 [subcontext(0),subcontext_size((previous_offset)-(current_offset))] AuthenticationInformationArray current;
 509                 [subcontext(0)] [flag(NDR_REMAINING)] AuthenticationInformationArray previous;
 510         } trustAuthInOutBlob;
 511
 512         [nopython] void decode_trustAuthInOut(
 513                 [in] trustAuthInOutBlob blob
 514                 );
 515
 516         typedef [public,nopull] struct {
 517                 uint8 confounder[512];
 518                 [subcontext(0),subcontext_size(outgoing_size)] trustAuthInOutBlob outgoing;
 519                 [subcontext(0),subcontext_size(incoming_size)] trustAuthInOutBlob incoming;
 520                 [value(ndr_size_trustAuthInOutBlob(&outgoing, ndr->flags))] uint32 outgoing_size;
 521                 [value(ndr_size_trustAuthInOutBlob(&incoming, ndr->flags))] uint32 incoming_size;
 522         } trustDomainPasswords;
 523
 524         [nopython] void decode_trustDomainPasswords(
 525                 [in] trustDomainPasswords blob
 526                 );
 527
 528         typedef [public] struct {
 529                 uint32 marker;
 530                 DATA_BLOB data;
 531         } DsCompressedChunk;
 532
 533         typedef struct {
 534                 uint16 __size;
 535                 [size_is(__size),charset(DOS)] uint8 *string;
 536         } ExtendedErrorAString;
 537
 538         typedef struct {
 539                 uint16 __size;
 540                 [size_is(__size),charset(UTF16)] uint16 *string;
 541         } ExtendedErrorUString;
 542
 543         typedef struct {
 544                 uint16 length;
 545                 [size_is(length)] uint8 *data;
 546         } ExtendedErrorBlob;
 547
 548         typedef enum {
 549                 EXTENDED_ERROR_COMPUTER_NAME_PRESENT    = 1,
 550                 EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT= 2
 551         } ExtendedErrorComputerNamePresent;
 552
 553         typedef [switch_type(ExtendedErrorComputerNamePresent)] union {
 554         [case(EXTENDED_ERROR_COMPUTER_NAME_PRESENT)] ExtendedErrorUString name;
 555         [case(EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT)];
 556         } ExtendedErrorComputerNameU;
 557
 558         typedef struct {
 559                 ExtendedErrorComputerNamePresent present;
 560                 [switch_is(present)] ExtendedErrorComputerNameU n;
 561         } ExtendedErrorComputerName;
 562
 563         typedef enum {
 564                 EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING          = 1,
 565                 EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING        = 2,
 566                 EXTENDED_ERROR_PARAM_TYPE_UINT32                = 3,
 567                 EXTENDED_ERROR_PARAM_TYPE_UINT16                = 4,
 568                 EXTENDED_ERROR_PARAM_TYPE_UINT64                = 5,
 569                 EXTENDED_ERROR_PARAM_TYPE_NONE                  = 6,
 570                 EXTENDED_ERROR_PARAM_TYPE_BLOB                  = 7
 571         } ExtendedErrorParamType;
 572
 573         typedef [switch_type(ExtendedErrorParamType)] union {
 574         [case(EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING)] ExtendedErrorAString a_string;
 575         [case(EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING)] ExtendedErrorUString u_string;
 576         [case(EXTENDED_ERROR_PARAM_TYPE_UINT32)] uint32 uint32;
 577         [case(EXTENDED_ERROR_PARAM_TYPE_UINT16)] uint16 uint16;
 578         [case(EXTENDED_ERROR_PARAM_TYPE_UINT64)] hyper uint64;
 579         [case(EXTENDED_ERROR_PARAM_TYPE_NONE)];
 580         [case(EXTENDED_ERROR_PARAM_TYPE_BLOB)] ExtendedErrorBlob blob;
 581         } ExtendedErrorParamU;
 582
 583         typedef struct {
 584                 ExtendedErrorParamType type;
 585                 [switch_is(type)] ExtendedErrorParamU p;
 586         } ExtendedErrorParam;
 587
 588         typedef [public] struct {
 589                 ExtendedErrorInfo *next;
 590                 ExtendedErrorComputerName computer_name;
 591                 hyper pid;
 592                 NTTIME time;
 593                 uint32 generating_component;
 594                 WERROR status;
 595                 uint16 detection_location;
 596                 uint16 flags;
 597                 uint16 num_params;
 598                 [size_is(num_params)] ExtendedErrorParam params[];
 599         } ExtendedErrorInfo;
 600
 601         typedef struct {
 602                 [unique] ExtendedErrorInfo *info;
 603         } ExtendedErrorInfoPtr;
 604
 605         [nopython] void decode_ExtendedErrorInfo (
 606                 [in,subcontext(0xFFFFFC01)] ExtendedErrorInfoPtr ptr
 607                 );
 608
 609         /* MS-ADTS 7.1.6.9.3 msDS-TrustForestTrustInfo Attribute */
 610
 611         typedef struct {
 612                 [value(strlen_m(string))] uint32 size;
 613                 [charset(UTF8)] uint8 string[size];
 614         } ForestTrustString;
 615
 616         typedef [flag(NDR_NOALIGN)] struct {
 617                 [value(ndr_size_dom_sid0(&sid, ndr->flags))] uint32 sid_size;
 618                 [subcontext(0),subcontext_size(sid_size)] dom_sid sid;
 619                 ForestTrustString dns_name;
 620                 ForestTrustString netbios_name;
 621         } ForestTrustDataDomainInfo;
 622
 623         typedef [flag(NDR_NOALIGN)] struct {
 624                 uint32 size;
 625                 uint8 data[size];
 626         } ForestTrustDataBinaryData;
 627
 628         typedef [nodiscriminant] union {
 629                 [case(FOREST_TRUST_TOP_LEVEL_NAME)] ForestTrustString name;
 630                 [case(FOREST_TRUST_TOP_LEVEL_NAME_EX)] ForestTrustString name;
 631                 [case(FOREST_TRUST_DOMAIN_INFO)] ForestTrustDataDomainInfo info;
 632                 [default] ForestTrustDataBinaryData data;
 633         } ForestTrustData;
 634
 635         /* same as lsa_ForestTrustRecordType */
 636         typedef [enum8bit] enum {
 637                 FOREST_TRUST_TOP_LEVEL_NAME = 0,
 638                 FOREST_TRUST_TOP_LEVEL_NAME_EX = 1,
 639                 FOREST_TRUST_DOMAIN_INFO = 2
 640         } ForestTrustInfoRecordType;
 641
 642         /* meaning of flags depends on record type and values are
 643            the same as in lsa.idl, see collision record types */
 644         typedef [public,gensize,flag(NDR_NOALIGN)] struct {
 645                 uint32 flags;
 646                 NTTIME timestamp;
 647                 ForestTrustInfoRecordType type;
 648                 [switch_is(type)] ForestTrustData data;
 649         } ForestTrustInfoRecord;
 650
 651         typedef [flag(NDR_NOALIGN)] struct {
 652                 [value(ndr_size_ForestTrustInfoRecord(&record, ndr->flags))] uint32 record_size;
 653                 ForestTrustInfoRecord record;
 654         } ForestTrustInfoRecordArmor;
 655
 656         typedef [public,flag(NDR_NOALIGN)] struct {
 657                 uint32 version;
 658                 uint32 count;
 659                 ForestTrustInfoRecordArmor records[count];
 660         } ForestTrustInfo;
 661
 662         [nopython] void decode_ForestTrustInfo(
 663                 [in] ForestTrustInfo blob
 664                 );
 665 }