2004-11-23 20:38:32 +03:00
#include "idl_types.h"
2008-09-02 05:31:17 +04:00
import "drsuapi.idl", "misc.idl", "samr.idl", "lsa.idl";
2006-11-07 01:54:49 +03:00
2004-11-23 20:38:32 +03:00
[
2006-04-25 00:15:35 +04:00
uuid("12345778-1234-abcd-0001-00000001"),
2004-11-23 20:38:32 +03:00
version(0.0),
2005-02-13 02:03:26 +03:00
pointer_default(unique),
2006-11-07 01:54:49 +03:00
helpstring("Active Directory Replication LDAP Blobs")
2004-11-23 20:38:32 +03:00
]
interface drsblobs {
2008-01-12 03:18:53 +03:00
typedef bitmap drsuapi_DsReplicaSyncOptions drsuapi_DsReplicaSyncOptions;
typedef bitmap drsuapi_DsReplicaNeighbourFlags drsuapi_DsReplicaNeighbourFlags;
typedef [v1_enum] enum drsuapi_DsAttributeId drsuapi_DsAttributeId;
2008-09-02 05:31:17 +04:00
typedef [v1_enum] enum lsa_TrustAuthType lsa_TrustAuthType;
2004-11-24 17:33:40 +03:00
/*
* replPropertyMetaData
* w2k uses version 1
* w2k3 uses version 1
*/
2004-11-23 20:38:32 +03:00
typedef struct {
2005-03-22 17:49:11 +03:00
drsuapi_DsAttributeId attid;
2004-11-23 20:38:32 +03:00
uint32 version;
2007-03-09 13:09:37 +03:00
NTTIME_1sec originating_change_time;
GUID originating_invocation_id;
hyper originating_usn;
2005-01-27 09:33:07 +03:00
hyper local_usn;
2004-11-24 17:33:40 +03:00
} replPropertyMetaData1;
2004-11-23 20:38:32 +03:00
typedef struct {
uint32 count;
2004-11-27 18:10:57 +03:00
uint32 reserved;
2004-11-24 17:33:40 +03:00
replPropertyMetaData1 array[count];
} replPropertyMetaDataCtr1;
typedef [nodiscriminant] union {
[case(1)] replPropertyMetaDataCtr1 ctr1;
2004-11-23 20:38:32 +03:00
} replPropertyMetaDataCtr;
2004-11-24 17:33:40 +03:00
typedef [public] struct {
uint32 version;
2004-11-27 18:10:57 +03:00
uint32 reserved;
2004-11-24 17:33:40 +03:00
[switch_is(version)] replPropertyMetaDataCtr ctr;
} replPropertyMetaDataBlob;
2004-11-23 20:38:32 +03:00
void decode_replPropertyMetaData(
2004-11-24 17:33:40 +03:00
[in] replPropertyMetaDataBlob blob
);
/*
* replUpToDateVector
* w2k uses version 1
* w2k3 uses version 2
*/
typedef struct {
uint32 count;
2004-11-27 18:10:57 +03:00
uint32 reserved;
2007-01-03 18:18:17 +03:00
drsuapi_DsReplicaCursor cursors[count];
2004-11-24 17:33:40 +03:00
} replUpToDateVectorCtr1;
typedef struct {
uint32 count;
2004-11-27 18:10:57 +03:00
uint32 reserved;
2007-01-03 18:18:17 +03:00
drsuapi_DsReplicaCursor2 cursors[count];
2004-11-24 17:33:40 +03:00
} replUpToDateVectorCtr2;
typedef [nodiscriminant] union {
[case(1)] replUpToDateVectorCtr1 ctr1;
[case(2)] replUpToDateVectorCtr2 ctr2;
} replUpToDateVectorCtr;
typedef [public] struct {
uint32 version;
2004-11-27 18:10:57 +03:00
uint32 reserved;
2004-11-24 17:33:40 +03:00
[switch_is(version)] replUpToDateVectorCtr ctr;
} replUpToDateVectorBlob;
void decode_replUpToDateVector(
[in] replUpToDateVectorBlob blob
2004-11-23 20:38:32 +03:00
);
2004-11-25 14:20:09 +03:00
/*
* repsFrom/repsTo
* w2k uses version 1
* w2k3 uses version 1
*/
2005-12-25 04:33:35 +03:00
typedef [public,gensize] struct {
2008-02-14 18:07:04 +03:00
[value(strlen(dns_name)+1)] uint32 __dns_name_size;
[charset(DOS)] uint8 dns_name[__dns_name_size];
2004-11-27 18:10:57 +03:00
} repsFromTo1OtherInfo;
2005-12-25 04:33:35 +03:00
typedef [public,gensize,flag(NDR_PAHEX)] struct {
2004-11-27 18:10:57 +03:00
/* this includes the 8 bytes of the repsFromToBlob header */
2008-02-21 18:10:07 +03:00
[value(ndr_size_repsFromTo1(this, ndr->flags)+8)] uint32 blobsize;
2004-12-06 18:17:43 +03:00
uint32 consecutive_sync_failures;
2004-11-27 18:10:57 +03:00
NTTIME_1sec last_success;
NTTIME_1sec last_attempt;
WERROR result_last_attempt;
2005-03-05 21:34:18 +03:00
[relative] repsFromTo1OtherInfo *other_info;
2005-06-14 02:22:51 +04:00
[value(ndr_size_repsFromTo1OtherInfo(other_info, ndr->flags))] uint32 other_info_length;
2005-03-23 21:54:06 +03:00
drsuapi_DsReplicaNeighbourFlags replica_flags;
2004-11-27 18:10:57 +03:00
uint8 schedule[84];
uint32 reserved;
2005-03-23 21:54:06 +03:00
drsuapi_DsReplicaHighWaterMark highwatermark;
2004-12-06 18:17:43 +03:00
GUID source_dsa_obj_guid; /* the 'objectGuid' field of the CN=NTDS Settings object */
GUID source_dsa_invocation_id; /* the 'invocationId' field of the CN=NTDS Settings object */
2004-11-27 18:10:57 +03:00
GUID transport_guid;
2004-11-25 14:20:09 +03:00
} repsFromTo1;
typedef [nodiscriminant] union {
[case(1)] repsFromTo1 ctr1;
} repsFromTo;
2004-11-27 18:10:57 +03:00
typedef [public] struct {
2004-11-25 14:20:09 +03:00
uint32 version;
2004-11-27 18:10:57 +03:00
uint32 reserved;
2004-11-25 14:20:09 +03:00
[switch_is(version)] repsFromTo ctr;
} repsFromToBlob;
void decode_repsFromTo(
[in] repsFromToBlob blob
);
2005-03-17 03:33:56 +03:00
2006-12-28 22:43:43 +03:00
/*
* partialAttributeSet
* w2k uses version 1
* w2k3 uses version 1
*/
typedef struct {
uint32 count;
drsuapi_DsAttributeId array[count];
} partialAttributeSetCtr1;
typedef [nodiscriminant] union {
[case(1)] partialAttributeSetCtr1 ctr1;
} partialAttributeSetCtr;
typedef [public] struct {
uint32 version;
uint32 reserved;
[switch_is(version)] partialAttributeSetCtr ctr;
} partialAttributeSetBlob;
void decode_partialAttributeSet(
[in] partialAttributeSetBlob blob
);
2007-01-13 18:28:24 +03:00
/*
* prefixMap
* w2k unknown
* w2k3 unknown
2007-06-11 17:02:30 +04:00
* samba4 uses 0x44534442 'DSDB'
2007-01-13 18:28:24 +03:00
*
* as we windows don't return the prefixMap attribute when you ask for
* we don't know the format, but the attribute is not replicated
* so that we can choose our own format...
*/
typedef [v1_enum] enum {
2007-06-11 17:02:30 +04:00
PREFIX_MAP_VERSION_DSDB = 0x44534442
2007-01-13 18:28:24 +03:00
} prefixMapVersion;
typedef [nodiscriminant] union {
[case(PREFIX_MAP_VERSION_DSDB)] drsuapi_DsReplicaOIDMapping_Ctr dsdb;
} prefixMapCtr;
typedef [public] struct {
prefixMapVersion version;
uint32 reserved;
[switch_is(version)] prefixMapCtr ctr;
} prefixMapBlob;
void decode_prefixMap(
[in] prefixMapBlob blob
);
/*
* the cookie for the LDAP dirsync control
*/
2006-01-17 20:15:07 +03:00
typedef [nodiscriminant,gensize] union {
[case(0)];
2007-01-11 17:21:23 +03:00
[default] replUpToDateVectorBlob uptodateness_vector;
2006-01-17 20:15:07 +03:00
} ldapControlDirSyncExtra;
typedef struct {
[value(3)] uint32 u1;
2005-03-17 03:33:56 +03:00
NTTIME time;
uint32 u2;
uint32 u3;
2007-01-11 17:21:23 +03:00
[value(ndr_size_ldapControlDirSyncExtra(&extra, extra.uptodateness_vector.version, 0))]
2006-01-17 20:15:07 +03:00
uint32 extra_length;
2005-03-23 21:54:06 +03:00
drsuapi_DsReplicaHighWaterMark highwatermark;
2005-03-17 03:33:56 +03:00
GUID guid1;
2006-01-17 20:15:07 +03:00
[switch_is(extra_length)] ldapControlDirSyncExtra extra;
2005-03-17 03:33:56 +03:00
} ldapControlDirSyncBlob;
2006-01-17 20:15:07 +03:00
typedef [public,relative_base] struct {
2006-01-20 02:04:14 +03:00
[charset(DOS),value("MSDS")] uint8 msds[4];
2006-01-17 20:15:07 +03:00
[subcontext(0)] ldapControlDirSyncBlob blob;
} ldapControlDirSyncCookie;
2005-03-17 03:33:56 +03:00
void decode_ldapControlDirSync(
2006-01-17 20:15:07 +03:00
[in] ldapControlDirSyncCookie cookie
2005-03-17 03:33:56 +03:00
);
2005-03-22 17:49:11 +03:00
2007-02-14 14:28:20 +03:00
typedef struct {
2007-02-17 12:40:43 +03:00
[value(2*strlen_m(name))] uint16 name_len;
[value(strlen(data))] uint16 data_len;
2008-07-23 15:53:03 +04:00
uint16 reserved; /* 2 for 'Packages', 1 for 'Primary:*', but should be ignored */
2007-02-14 01:13:59 +03:00
[charset(UTF16)] uint8 name[name_len];
2007-02-14 14:28:20 +03:00
/*
* the data field contains data as HEX strings
*
* 'Packages':
2007-02-17 10:10:28 +03:00
* data contains the list of packages
* as non termiated UTF16 strings with
* a UTF16 NULL byte as separator
2007-02-14 14:28:20 +03:00
*
2008-07-22 14:28:07 +04:00
* 'Primary:Kerberos-Newer-Keys':
* ...
*
2007-02-14 14:28:20 +03:00
* 'Primary:Kerberos':
* ...
*
* 'Primary:WDigest':
* ...
2007-02-14 15:21:16 +03:00
*
* 'Primary:CLEARTEXT':
* data contains the cleartext password
* as UTF16 string encoded as HEX string
2007-02-14 14:28:20 +03:00
*/
[charset(DOS)] uint8 data[data_len];
2007-02-14 01:13:59 +03:00
} supplementalCredentialsPackage;
2008-07-23 15:06:32 +04:00
/* this are 0x30 (48) whitespaces (0x20) */
const string SUPPLEMENTAL_CREDENTIALS_PREFIX = " ";
typedef [flag(NDR_PAHEX)] enum {
SUPPLEMENTAL_CREDENTIALS_SIGNATURE = 0x0050
} supplementalCredentialsSignature;
2007-02-14 14:28:20 +03:00
2007-02-18 03:05:34 +03:00
typedef [gensize] struct {
2008-07-23 15:06:32 +04:00
[value(SUPPLEMENTAL_CREDENTIALS_PREFIX),charset(UTF16)] uint16 prefix[0x30];
[value(SUPPLEMENTAL_CREDENTIALS_SIGNATURE)] supplementalCredentialsSignature signature;
2007-02-14 01:13:59 +03:00
uint16 num_packages;
supplementalCredentialsPackage packages[num_packages];
} supplementalCredentialsSubBlob;
typedef [public] struct {
2007-02-14 14:28:20 +03:00
[value(0)] uint32 unknown1;
2007-02-18 03:05:34 +03:00
[value(ndr_size_supplementalCredentialsSubBlob(&sub, ndr->flags))] uint32 __ndr_size;
2007-02-14 14:28:20 +03:00
[value(0)] uint32 unknown2;
[subcontext(0),subcontext_size(__ndr_size)] supplementalCredentialsSubBlob sub;
[value(0)] uint8 unknown3;
2007-02-14 01:13:59 +03:00
} supplementalCredentialsBlob;
void decode_supplementalCredentials(
[in] supplementalCredentialsBlob blob
);
2007-02-17 12:10:32 +03:00
typedef [public] struct {
[flag(STR_NOTERM|NDR_REMAINING)] string_array names;
} package_PackagesBlob;
void decode_Packages(
[in] package_PackagesBlob blob
);
2007-02-16 15:38:08 +03:00
typedef struct {
2007-02-16 19:02:30 +03:00
[value(2*strlen_m(string))] uint16 length;
[value(2*strlen_m(string))] uint16 size;
[relative,subcontext(0),subcontext_size(size),flag(STR_NOTERM|NDR_REMAINING)] string *string;
2007-02-16 15:38:08 +03:00
} package_PrimaryKerberosString;
typedef struct {
2008-07-23 10:53:34 +04:00
[value(0)] uint16 reserved1;
[value(0)] uint16 reserved2;
[value(0)] uint32 reserved3;
2007-02-16 15:38:08 +03:00
uint32 keytype;
[value((value?value->length:0))] uint32 value_len;
[relative,subcontext(0),subcontext_size(value_len),flag(NDR_REMAINING)] DATA_BLOB *value;
2008-07-24 10:20:06 +04:00
} package_PrimaryKerberosKey3;
2007-02-16 15:38:08 +03:00
2007-02-19 03:28:11 +03:00
typedef struct {
uint16 num_keys;
uint16 num_old_keys;
2007-02-16 15:38:08 +03:00
package_PrimaryKerberosString salt;
2008-07-24 10:20:06 +04:00
package_PrimaryKerberosKey3 keys[num_keys];
package_PrimaryKerberosKey3 old_keys[num_old_keys];
2008-07-23 10:53:34 +04:00
[value(0)] uint32 padding1;
[value(0)] uint32 padding2;
[value(0)] uint32 padding3;
[value(0)] uint32 padding4;
[value(0)] uint32 padding5;
2007-02-19 03:28:11 +03:00
} package_PrimaryKerberosCtr3;
2008-07-22 14:28:07 +04:00
typedef struct {
2008-07-24 09:53:55 +04:00
[value(0)] uint16 reserved1;
[value(0)] uint16 reserved2;
[value(0)] uint32 reserved3;
uint32 iteration_count;
2008-07-22 14:28:07 +04:00
uint32 keytype;
[value((value?value->length:0))] uint32 value_len;
[relative,subcontext(0),subcontext_size(value_len),flag(NDR_REMAINING)] DATA_BLOB *value;
2008-07-24 10:20:06 +04:00
} package_PrimaryKerberosKey4;
2008-07-22 14:28:07 +04:00
typedef struct {
uint16 num_keys;
2008-07-24 09:53:55 +04:00
[value(0)] uint16 num_service_keys;
uint16 num_old_keys;
uint16 num_older_keys;
2008-07-22 14:28:07 +04:00
package_PrimaryKerberosString salt;
2008-07-24 09:53:55 +04:00
uint32 default_iteration_count;
2008-07-24 10:20:06 +04:00
package_PrimaryKerberosKey4 keys[num_keys];
package_PrimaryKerberosKey4 service_keys[num_service_keys];
package_PrimaryKerberosKey4 old_keys[num_old_keys];
package_PrimaryKerberosKey4 older_keys[num_older_keys];
} package_PrimaryKerberosCtr4;
2008-07-22 14:28:07 +04:00
typedef [nodiscriminant] union {
2008-07-24 10:20:06 +04:00
[case(3)] package_PrimaryKerberosCtr3 ctr3;
[case(4)] package_PrimaryKerberosCtr4 ctr4;
} package_PrimaryKerberosCtr;
2008-07-22 14:28:07 +04:00
typedef [public] struct {
2008-07-24 10:20:06 +04:00
uint16 version;
[value(0)] uint16 flags;
[switch_is(version)] package_PrimaryKerberosCtr ctr;
} package_PrimaryKerberosBlob;
2008-07-22 14:28:07 +04:00
2008-07-24 10:20:06 +04:00
void decode_PrimaryKerberos(
[in] package_PrimaryKerberosBlob blob
2008-07-22 14:28:07 +04:00
);
2007-02-17 12:10:32 +03:00
typedef [public] struct {
[flag(STR_NOTERM|NDR_REMAINING)] string cleartext;
} package_PrimaryCLEARTEXTBlob;
void decode_PrimaryCLEARTEXT(
[in] package_PrimaryCLEARTEXTBlob blob
);
2007-02-20 17:42:53 +03:00
typedef [flag(NDR_PAHEX)] struct {
uint8 hash[16];
} package_PrimaryWDigestHash;
typedef [public] struct {
[value(0x31)] uint16 unknown1;
[value(0x01)] uint8 unknown2;
uint8 num_hashes;
[value(0)] uint32 unknown3;
[value(0)] udlong uuknown4;
package_PrimaryWDigestHash hashes[num_hashes];
} package_PrimaryWDigestBlob;
void decode_PrimaryWDigest(
[in] package_PrimaryWDigestBlob blob
);
2007-02-14 18:21:41 +03:00
typedef struct {
2008-07-31 01:45:30 +04:00
[value(0)] uint32 size;
} AuthInfoNone;
2007-02-14 18:21:41 +03:00
typedef struct {
2008-07-31 01:45:30 +04:00
[value(16)] uint32 size;
samr_Password password;
} AuthInfoNT4Owf;
2008-09-02 05:31:17 +04:00
/*
* the secret value is encoded as UTF16 if it's a string
* but depending the AuthType, it might also be krb5 trusts have random bytes here, so converting to UTF16
* mayfail...
*
* TODO: We should try handle the case of a random buffer in all places
* we deal with cleartext passwords from windows
*
* so we don't use this:
*
* uint32 value_len;
* [charset(UTF16)] uint8 value[value_len];
*/
2008-07-31 01:45:30 +04:00
typedef struct {
uint32 size;
2008-07-31 17:17:20 +04:00
uint8 password[size];
2008-07-31 01:45:30 +04:00
} AuthInfoClear;
2007-02-14 18:21:41 +03:00
typedef struct {
2008-07-31 01:45:30 +04:00
[value(4)] uint32 size;
uint32 version;
} AuthInfoVersion;
2007-02-14 18:21:41 +03:00
typedef [nodiscriminant] union {
2008-07-31 01:45:30 +04:00
[case(TRUST_AUTH_TYPE_NONE)] AuthInfoNone none;
[case(TRUST_AUTH_TYPE_NT4OWF)] AuthInfoNT4Owf nt4owf;
[case(TRUST_AUTH_TYPE_CLEAR)] AuthInfoClear clear;
[case(TRUST_AUTH_TYPE_VERSION)] AuthInfoVersion version;
} AuthInfo;
2008-08-13 10:16:59 +04:00
typedef [public] struct {
2008-07-31 01:45:30 +04:00
NTTIME LastUpdateTime;
2008-09-02 05:31:17 +04:00
lsa_TrustAuthType AuthType;
2008-07-31 01:45:30 +04:00
[switch_is(AuthType)] AuthInfo AuthInfo;
[flag(NDR_ALIGN4)] DATA_BLOB _pad;
} AuthenticationInformation;
2007-02-14 18:21:41 +03:00
2008-08-13 10:16:59 +04:00
typedef [nopull,nopush,noprint] struct {
/* sizeis here is bogus, but this is here just for the structure */
[size_is(1)] AuthenticationInformation array[];
} AuthenticationInformationArray;
2008-07-31 17:17:20 +04:00
2008-09-04 10:06:38 +04:00
typedef [public,nopull,nopush,noprint,gensize] struct {
2008-07-31 01:45:30 +04:00
uint32 count;
2008-08-13 10:16:59 +04:00
[relative] AuthenticationInformationArray *current;
[relative] AuthenticationInformationArray *previous;
2007-02-14 18:21:41 +03:00
} trustAuthInOutBlob;
2008-09-04 10:06:38 +04:00
typedef [public] struct {
uint8 confounder[512];
trustAuthInOutBlob outgoing;
trustAuthInOutBlob incoming;
[value(ndr_size_trustAuthInOutBlob(&outgoing, ndr->flags))] uint32 outgoing_size;
[value(ndr_size_trustAuthInOutBlob(&incoming, ndr->flags))] uint32 incoming_size;
} trustAuthInAndOutBlob;
2007-02-14 18:21:41 +03:00
void decode_trustAuthInOut(
[in] trustAuthInOutBlob blob
);
2005-03-22 17:49:11 +03:00
typedef [public] struct {
uint32 marker;
DATA_BLOB data;
} DsCompressedChunk;
2008-09-09 13:27:03 +04:00
typedef struct {
uint16 __size;
[size_is(__size),charset(DOS)] uint8 *string;
} ExtendedErrorAString;
typedef struct {
uint16 __size;
[size_is(__size),charset(UTF16)] uint16 *string;
} ExtendedErrorUString;
typedef struct {
uint16 length;
[size_is(length)] uint8 *data;
} ExtendedErrorBlob;
typedef enum {
EXTENDED_ERROR_COMPUTER_NAME_PRESENT = 1,
EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT= 2
} ExtendedErrorComputerNamePresent;
typedef [switch_type(ExtendedErrorComputerNamePresent)] union {
[case(EXTENDED_ERROR_COMPUTER_NAME_PRESENT)] ExtendedErrorUString name;
[case(EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT)];
} ExtendedErrorComputerNameU;
typedef struct {
ExtendedErrorComputerNamePresent present;
[switch_is(present)] ExtendedErrorComputerNameU n;
} ExtendedErrorComputerName;
typedef enum {
EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING = 1,
EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING = 2,
EXTENDED_ERROR_PARAM_TYPE_UINT32 = 3,
EXTENDED_ERROR_PARAM_TYPE_UINT16 = 4,
EXTENDED_ERROR_PARAM_TYPE_UINT64 = 5,
EXTENDED_ERROR_PARAM_TYPE_NONE = 6,
EXTENDED_ERROR_PARAM_TYPE_BLOB = 7
} ExtendedErrorParamType;
typedef [switch_type(ExtendedErrorParamType)] union {
[case(EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING)] ExtendedErrorAString a_string;
[case(EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING)] ExtendedErrorUString u_string;
[case(EXTENDED_ERROR_PARAM_TYPE_UINT32)] uint32 uint32;
[case(EXTENDED_ERROR_PARAM_TYPE_UINT16)] uint16 uint16;
[case(EXTENDED_ERROR_PARAM_TYPE_UINT64)] hyper uint64;
[case(EXTENDED_ERROR_PARAM_TYPE_NONE)];
[case(EXTENDED_ERROR_PARAM_TYPE_BLOB)] ExtendedErrorBlob blob;
} ExtendedErrorParamU;
typedef struct {
ExtendedErrorParamType type;
[switch_is(type)] ExtendedErrorParamU p;
} ExtendedErrorParam;
2005-03-22 17:49:11 +03:00
typedef [public] struct {
2008-09-09 13:27:03 +04:00
ExtendedErrorInfo *next;
ExtendedErrorComputerName computer_name;
hyper pid;
NTTIME time;
uint32 generating_component;
WERROR status;
uint16 detection_location;
uint16 flags;
uint16 num_params;
[size_is(num_params)] ExtendedErrorParam params[];
} ExtendedErrorInfo;
typedef struct {
[unique] ExtendedErrorInfo *info;
} ExtendedErrorInfoPtr;
2005-03-22 17:49:11 +03:00
2008-09-09 13:27:03 +04:00
void decode_ExtendedErrorInfo (
[in,subcontext(0xFFFFFC01)] ExtendedErrorInfoPtr ptr
2005-03-22 17:49:11 +03:00
);
2004-11-23 20:38:32 +03:00
}