31fe8a359e848d0e7cdf1e61cc91662ec8882fe5
[kai/samba.git] / source4 / librpc / idl / drsblobs.idl
1 #include "idl_types.h"
2
3 import "drsuapi.idl", "misc.idl", "samr.idl", "lsa.idl";
4
5 [
6   uuid("12345778-1234-abcd-0001-00000001"),
7   version(0.0),
8   pointer_default(unique),
9   helpstring("Active Directory Replication LDAP Blobs")
10 ]
11 interface drsblobs {
12         typedef bitmap drsuapi_DsReplicaSyncOptions drsuapi_DsReplicaSyncOptions;
13         typedef bitmap drsuapi_DsReplicaNeighbourFlags drsuapi_DsReplicaNeighbourFlags;
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                 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                 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                 uint32 reserved;
58                 drsuapi_DsReplicaCursor cursors[count];
59         } replUpToDateVectorCtr1;
60
61         typedef struct {
62                 uint32 count;
63                 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                 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          */
87         typedef [public,gensize] struct {
88                 [value(strlen(dns_name)+1)] uint32 __dns_name_size;
89                 [charset(DOS)] uint8 dns_name[__dns_name_size];
90         } repsFromTo1OtherInfo;
91
92         typedef [public,gensize,flag(NDR_PAHEX)] struct {
93                 /* this includes the 8 bytes of the repsFromToBlob header */
94                 [value(ndr_size_repsFromTo1(this, ndr->flags)+8)] uint32 blobsize;
95                 uint32 consecutive_sync_failures;
96                 NTTIME_1sec last_success;
97                 NTTIME_1sec last_attempt;
98                 WERROR result_last_attempt;
99                 [relative] repsFromTo1OtherInfo *other_info;
100                 [value(ndr_size_repsFromTo1OtherInfo(other_info, ndr->flags))] uint32 other_info_length;
101                 drsuapi_DsReplicaNeighbourFlags replica_flags;
102                 uint8 schedule[84];
103                 uint32 reserved;
104                 drsuapi_DsReplicaHighWaterMark highwatermark;
105                 GUID source_dsa_obj_guid; /* the 'objectGuid' field of the CN=NTDS Settings object */
106                 GUID source_dsa_invocation_id; /* the 'invocationId' field of the CN=NTDS Settings object */
107                 GUID transport_guid;
108         } repsFromTo1;
109
110         typedef [nodiscriminant] union {
111                 [case(1)] repsFromTo1 ctr1;
112         } repsFromTo;
113
114         typedef [public] struct {
115                 uint32 version;
116                 uint32 reserved;
117                 [switch_is(version)] repsFromTo ctr;
118         } repsFromToBlob;
119
120         void decode_repsFromTo(
121                 [in] repsFromToBlob blob
122                 );
123
124         /*
125          * partialAttributeSet
126          * w2k  uses version 1
127          * w2k3 uses version 1
128          */
129         typedef struct {
130                 uint32 count;
131                 drsuapi_DsAttributeId array[count];
132         } partialAttributeSetCtr1;
133
134         typedef [nodiscriminant] union {
135                 [case(1)] partialAttributeSetCtr1 ctr1;
136         } partialAttributeSetCtr;
137
138         typedef [public] struct {
139                 uint32 version;
140                 uint32 reserved;
141                 [switch_is(version)] partialAttributeSetCtr ctr;
142         } partialAttributeSetBlob;
143
144         void decode_partialAttributeSet(
145                 [in] partialAttributeSetBlob blob
146                 );
147
148         /*
149          * prefixMap
150          * w2k  unknown
151          * w2k3 unknown
152          * samba4 uses 0x44534442 'DSDB'
153          *
154          * as we windows don't return the prefixMap attribute when you ask for
155          * we don't know the format, but the attribute is not replicated
156          * so that we can choose our own format...
157          */
158         typedef [v1_enum] enum {
159                 PREFIX_MAP_VERSION_DSDB = 0x44534442
160         } prefixMapVersion;
161
162         typedef [nodiscriminant] union {
163                 [case(PREFIX_MAP_VERSION_DSDB)] drsuapi_DsReplicaOIDMapping_Ctr dsdb;
164         } prefixMapCtr;
165
166         typedef [public] struct {
167                 prefixMapVersion version;
168                 uint32 reserved;
169                 [switch_is(version)] prefixMapCtr ctr;
170         } prefixMapBlob;
171
172         void decode_prefixMap(
173                 [in] prefixMapBlob blob
174                 );
175
176         /*
177          * the cookie for the LDAP dirsync control
178          */
179         typedef [nodiscriminant,gensize] union {
180                 [case(0)];
181                 [default] replUpToDateVectorBlob uptodateness_vector;
182         } ldapControlDirSyncExtra;
183
184         typedef struct {
185                 [value(3)] uint32 u1;
186                 NTTIME time;
187                 uint32 u2;
188                 uint32 u3;
189                 [value(ndr_size_ldapControlDirSyncExtra(&extra, extra.uptodateness_vector.version, 0))] 
190                         uint32 extra_length;
191                 drsuapi_DsReplicaHighWaterMark highwatermark;
192                 GUID guid1;
193                 [switch_is(extra_length)] ldapControlDirSyncExtra extra;
194         } ldapControlDirSyncBlob;
195
196         typedef [public,relative_base] struct {
197                 [charset(DOS),value("MSDS")] uint8 msds[4];
198                 [subcontext(0)] ldapControlDirSyncBlob blob;
199         } ldapControlDirSyncCookie;
200
201         void decode_ldapControlDirSync(
202                 [in] ldapControlDirSyncCookie cookie
203                 );
204
205         typedef struct {
206                 [value(2*strlen_m(name))] uint16 name_len;
207                 [value(strlen(data))] uint16 data_len;
208                 uint16 reserved; /* 2 for 'Packages', 1 for 'Primary:*', but should be ignored */
209                 [charset(UTF16)] uint8 name[name_len];
210                 /* 
211                  * the data field contains data as HEX strings
212                  *
213                  * 'Packages':
214                  *   data contains the list of packages
215                  *   as non termiated UTF16 strings with
216                  *   a UTF16 NULL byte as separator
217                  *
218                  * 'Primary:Kerberos-Newer-Keys':
219                  *    ...
220                  *
221                  * 'Primary:Kerberos':
222                  *    ...
223                  *
224                  * 'Primary:WDigest':
225                  *    ...
226                  *
227                  * 'Primary:CLEARTEXT':
228                  *    data contains the cleartext password
229                  *    as UTF16 string encoded as HEX string
230                  */
231                 [charset(DOS)] uint8 data[data_len];
232         } supplementalCredentialsPackage;
233
234         /* this are 0x30 (48) whitespaces (0x20) */
235         const string SUPPLEMENTAL_CREDENTIALS_PREFIX = "                                                ";
236
237         typedef [flag(NDR_PAHEX)] enum {
238                 SUPPLEMENTAL_CREDENTIALS_SIGNATURE = 0x0050
239         } supplementalCredentialsSignature;
240
241         typedef [gensize] struct {
242                 [value(SUPPLEMENTAL_CREDENTIALS_PREFIX),charset(UTF16)] uint16 prefix[0x30];
243                 [value(SUPPLEMENTAL_CREDENTIALS_SIGNATURE)] supplementalCredentialsSignature signature;
244                 uint16 num_packages;
245                 supplementalCredentialsPackage packages[num_packages];
246         } supplementalCredentialsSubBlob;
247
248         typedef [public] struct {
249                 [value(0)] uint32 unknown1;
250                 [value(ndr_size_supplementalCredentialsSubBlob(&sub, ndr->flags))] uint32 __ndr_size;
251                 [value(0)] uint32 unknown2;
252                 [subcontext(0),subcontext_size(__ndr_size)] supplementalCredentialsSubBlob sub;
253                 [value(0)] uint8 unknown3;
254         } supplementalCredentialsBlob;
255
256         void decode_supplementalCredentials(
257                 [in] supplementalCredentialsBlob blob
258                 );
259
260         typedef [public] struct {
261                 [flag(STR_NOTERM|NDR_REMAINING)] string_array names;
262         } package_PackagesBlob;
263
264         void decode_Packages(
265                 [in] package_PackagesBlob blob
266                 );
267
268         typedef struct {
269                 [value(2*strlen_m(string))] uint16 length;
270                 [value(2*strlen_m(string))] uint16 size;
271                 [relative,subcontext(0),subcontext_size(size),flag(STR_NOTERM|NDR_REMAINING)] string *string;
272         } package_PrimaryKerberosString;
273
274         typedef struct {
275                 [value(0)] uint16 reserved1;
276                 [value(0)] uint16 reserved2;
277                 [value(0)] uint32 reserved3;
278                 uint32 keytype;
279                 [value((value?value->length:0))] uint32 value_len;
280                 [relative,subcontext(0),subcontext_size(value_len),flag(NDR_REMAINING)] DATA_BLOB *value;
281         } package_PrimaryKerberosKey3;
282
283         typedef struct {
284                 uint16 num_keys;
285                 uint16 num_old_keys;
286                 package_PrimaryKerberosString salt;
287                 package_PrimaryKerberosKey3 keys[num_keys];
288                 package_PrimaryKerberosKey3 old_keys[num_old_keys];
289                 [value(0)] uint32 padding1;
290                 [value(0)] uint32 padding2;
291                 [value(0)] uint32 padding3;
292                 [value(0)] uint32 padding4;
293                 [value(0)] uint32 padding5;
294         } package_PrimaryKerberosCtr3;
295
296         typedef struct {
297                 [value(0)] uint16 reserved1;
298                 [value(0)] uint16 reserved2;
299                 [value(0)] uint32 reserved3;
300                 uint32 iteration_count;
301                 uint32 keytype;
302                 [value((value?value->length:0))] uint32 value_len;
303                 [relative,subcontext(0),subcontext_size(value_len),flag(NDR_REMAINING)] DATA_BLOB *value;
304         } package_PrimaryKerberosKey4;
305
306         typedef struct {
307                 uint16 num_keys;
308                 [value(0)] uint16 num_service_keys;
309                 uint16 num_old_keys;
310                 uint16 num_older_keys;
311                 package_PrimaryKerberosString salt;
312                 uint32 default_iteration_count;
313                 package_PrimaryKerberosKey4 keys[num_keys];
314                 package_PrimaryKerberosKey4 service_keys[num_service_keys];
315                 package_PrimaryKerberosKey4 old_keys[num_old_keys];
316                 package_PrimaryKerberosKey4 older_keys[num_older_keys];
317         } package_PrimaryKerberosCtr4;
318
319         typedef [nodiscriminant] union {
320                 [case(3)] package_PrimaryKerberosCtr3 ctr3;
321                 [case(4)] package_PrimaryKerberosCtr4 ctr4;
322         } package_PrimaryKerberosCtr;
323
324         typedef [public] struct {
325                 uint16 version;
326                 [value(0)] uint16 flags;
327                 [switch_is(version)] package_PrimaryKerberosCtr ctr;
328         } package_PrimaryKerberosBlob;
329
330         void decode_PrimaryKerberos(
331                 [in] package_PrimaryKerberosBlob blob
332                 );
333
334         typedef [public] struct {
335                 [flag(STR_NOTERM|NDR_REMAINING)] string cleartext;
336         } package_PrimaryCLEARTEXTBlob;
337
338         void decode_PrimaryCLEARTEXT(
339                 [in] package_PrimaryCLEARTEXTBlob blob
340                 );
341
342         typedef [flag(NDR_PAHEX)] struct {
343                 uint8 hash[16];
344         } package_PrimaryWDigestHash;
345
346         typedef [public] struct {
347                 [value(0x31)] uint16 unknown1;
348                 [value(0x01)] uint8  unknown2;
349                 uint8  num_hashes;
350                 [value(0)] uint32 unknown3;
351                 [value(0)] udlong uuknown4;
352                 package_PrimaryWDigestHash hashes[num_hashes];
353         } package_PrimaryWDigestBlob;
354
355         void decode_PrimaryWDigest(
356                 [in] package_PrimaryWDigestBlob blob
357                 );
358
359         typedef struct {
360                 [value(0)] uint32 size;
361         } AuthInfoNone;
362
363         typedef struct {
364                 [value(16)] uint32 size;
365                 samr_Password password;
366         } AuthInfoNT4Owf;
367
368         /* 
369          * the secret value is encoded as UTF16 if it's a string
370          * but depending the AuthType, it might also be krb5 trusts have random bytes here, so converting to UTF16
371          * mayfail...
372          *
373          * TODO: We should try handle the case of a random buffer in all places
374          *       we deal with cleartext passwords from windows
375          *
376          * so we don't use this:
377          *
378          * uint32 value_len;
379          * [charset(UTF16)] uint8 value[value_len];
380          */
381
382         typedef struct {
383                 uint32 size;
384                 uint8 password[size];
385         } AuthInfoClear;
386
387         typedef struct {
388                 [value(4)] uint32 size;
389                  uint32 version;
390         } AuthInfoVersion;
391
392         typedef [nodiscriminant] union {
393                 [case(TRUST_AUTH_TYPE_NONE)] AuthInfoNone none;
394                 [case(TRUST_AUTH_TYPE_NT4OWF)] AuthInfoNT4Owf nt4owf;
395                 [case(TRUST_AUTH_TYPE_CLEAR)] AuthInfoClear clear;
396                 [case(TRUST_AUTH_TYPE_VERSION)] AuthInfoVersion version;
397         } AuthInfo;
398
399         typedef [public] struct {
400                 NTTIME LastUpdateTime;
401                 lsa_TrustAuthType AuthType;
402                 
403                 [switch_is(AuthType)] AuthInfo AuthInfo;
404                 [flag(NDR_ALIGN4)] DATA_BLOB _pad;
405         } AuthenticationInformation;
406
407         typedef [nopull,nopush,noprint] struct {
408                 /* sizeis here is bogus, but this is here just for the structure */
409                 [size_is(1)] AuthenticationInformation array[];
410         } AuthenticationInformationArray;
411
412         typedef [public,nopull,nopush,noprint,gensize] struct {
413                 uint32 count;
414                 [relative] AuthenticationInformationArray *current;
415                 [relative] AuthenticationInformationArray *previous;
416         } trustAuthInOutBlob;
417
418         typedef [public,gensize] struct {
419                 uint32 count;
420                 [relative] AuthenticationInformation *current[count];
421         } trustCurrentPasswords;
422
423         void decode_trustAuthInOut(
424                 [in] trustAuthInOutBlob blob
425                 );
426
427         typedef [public,nopull] struct {
428                 uint8 confounder[512];
429                 [subcontext(0),subcontext_size(outgoing_size)] trustCurrentPasswords outgoing;
430                 [subcontext(0),subcontext_size(incoming_size)] trustCurrentPasswords incoming;
431                 [value(ndr_size_trustCurrentPasswords(&outgoing, ndr->flags))] uint32 outgoing_size;
432                 [value(ndr_size_trustCurrentPasswords(&incoming, ndr->flags))] uint32 incoming_size;
433         } trustDomainPasswords;
434
435         void decode_trustDomainPasswords(
436                 [in] trustDomainPasswords blob
437                 );
438
439         typedef [public] struct {
440                 uint32 marker;
441                 DATA_BLOB data;
442         } DsCompressedChunk;
443
444         typedef struct {
445                 uint16 __size;
446                 [size_is(__size),charset(DOS)] uint8 *string;
447         } ExtendedErrorAString;
448
449         typedef struct {
450                 uint16 __size;
451                 [size_is(__size),charset(UTF16)] uint16 *string;
452         } ExtendedErrorUString;
453
454         typedef struct {
455                 uint16 length;
456                 [size_is(length)] uint8 *data;
457         } ExtendedErrorBlob;
458
459         typedef enum {
460                 EXTENDED_ERROR_COMPUTER_NAME_PRESENT    = 1,
461                 EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT= 2
462         } ExtendedErrorComputerNamePresent;
463
464         typedef [switch_type(ExtendedErrorComputerNamePresent)] union {
465         [case(EXTENDED_ERROR_COMPUTER_NAME_PRESENT)] ExtendedErrorUString name;
466         [case(EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT)];
467         } ExtendedErrorComputerNameU;
468
469         typedef struct {
470                 ExtendedErrorComputerNamePresent present;
471                 [switch_is(present)] ExtendedErrorComputerNameU n;
472         } ExtendedErrorComputerName;
473
474         typedef enum {
475                 EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING          = 1,
476                 EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING        = 2,
477                 EXTENDED_ERROR_PARAM_TYPE_UINT32                = 3,
478                 EXTENDED_ERROR_PARAM_TYPE_UINT16                = 4,
479                 EXTENDED_ERROR_PARAM_TYPE_UINT64                = 5,
480                 EXTENDED_ERROR_PARAM_TYPE_NONE                  = 6,
481                 EXTENDED_ERROR_PARAM_TYPE_BLOB                  = 7
482         } ExtendedErrorParamType;
483
484         typedef [switch_type(ExtendedErrorParamType)] union {
485         [case(EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING)] ExtendedErrorAString a_string;
486         [case(EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING)] ExtendedErrorUString u_string;
487         [case(EXTENDED_ERROR_PARAM_TYPE_UINT32)] uint32 uint32;
488         [case(EXTENDED_ERROR_PARAM_TYPE_UINT16)] uint16 uint16;
489         [case(EXTENDED_ERROR_PARAM_TYPE_UINT64)] hyper uint64;
490         [case(EXTENDED_ERROR_PARAM_TYPE_NONE)];
491         [case(EXTENDED_ERROR_PARAM_TYPE_BLOB)] ExtendedErrorBlob blob;
492         } ExtendedErrorParamU;
493
494         typedef struct {
495                 ExtendedErrorParamType type;
496                 [switch_is(type)] ExtendedErrorParamU p;
497         } ExtendedErrorParam;
498
499         typedef [public] struct {
500                 ExtendedErrorInfo *next;
501                 ExtendedErrorComputerName computer_name;
502                 hyper pid;
503                 NTTIME time;
504                 uint32 generating_component;
505                 WERROR status;
506                 uint16 detection_location;
507                 uint16 flags;
508                 uint16 num_params;
509                 [size_is(num_params)] ExtendedErrorParam params[];
510         } ExtendedErrorInfo;
511
512         typedef struct {
513                 [unique] ExtendedErrorInfo *info;
514         } ExtendedErrorInfoPtr;
515
516         void decode_ExtendedErrorInfo (
517                 [in,subcontext(0xFFFFFC01)] ExtendedErrorInfoPtr ptr
518                 );
519 }