← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/netlogon.h

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
librpc/gen_ndr/netlogon.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/misc.h"
 
8
#include "librpc/gen_ndr/lsa.h"
 
9
#include "librpc/gen_ndr/samr.h"
 
10
#include "librpc/gen_ndr/security.h"
 
11
#include "librpc/gen_ndr/nbt.h"
 
12
#define netr_DeltaEnum8Bit netr_DeltaEnum
 
13
#define netr_SamDatabaseID8Bit netr_SamDatabaseID
 
14
#ifndef _HEADER_netlogon
 
15
#define _HEADER_netlogon
 
16
 
 
17
#define NETLOGON_NEG_128BIT     ( NETLOGON_NEG_STRONG_KEYS )
 
18
#define NETLOGON_NEG_SCHANNEL   ( NETLOGON_NEG_AUTHENTICATED_RPC )
 
19
#define DSGETDC_VALID_FLAGS     ( (DS_FORCE_REDISCOVERY|DS_DIRECTORY_SERVICE_REQUIRED|DS_DIRECTORY_SERVICE_PREFERRED|DS_GC_SERVER_REQUIRED|DS_PDC_REQUIRED|DS_BACKGROUND_ONLY|DS_IP_REQUIRED|DS_KDC_REQUIRED|DS_TIMESERV_REQUIRED|DS_WRITABLE_REQUIRED|DS_GOOD_TIMESERV_PREFERRED|DS_AVOID_SELF|DS_ONLY_LDAP_NEEDED|DS_IS_FLAT_NAME|DS_IS_DNS_NAME|DS_RETURN_FLAT_NAME|DS_RETURN_DNS_NAME) )
 
20
#define DS_GFTI_UPDATE_TDO      ( 0x1 )
 
21
struct netr_UasInfo {
 
22
        const char *account_name;/* [unique,charset(UTF16)] */
 
23
        uint32_t priv;
 
24
        uint32_t auth_flags;
 
25
        uint32_t logon_count;
 
26
        uint32_t bad_pw_count;
 
27
        time_t last_logon;
 
28
        time_t last_logoff;
 
29
        time_t logoff_time;
 
30
        time_t kickoff_time;
 
31
        uint32_t password_age;
 
32
        time_t pw_can_change;
 
33
        time_t pw_must_change;
 
34
        const char *computer;/* [unique,charset(UTF16)] */
 
35
        const char *domain;/* [unique,charset(UTF16)] */
 
36
        const char *script_path;/* [unique,charset(UTF16)] */
 
37
        uint32_t unknown;
 
38
};
 
39
 
 
40
struct netr_UasLogoffInfo {
 
41
        uint32_t duration;
 
42
        uint16_t logon_count;
 
43
};
 
44
 
 
45
struct netr_AcctLockStr {
 
46
        int64_t lockout_duration;
 
47
        uint64_t reset_count;
 
48
        uint32_t bad_attempt_lockout;
 
49
        uint32_t dummy;
 
50
}/* [public] */;
 
51
 
 
52
/* bitmap netr_LogonParameterControl */
 
53
#define MSV1_0_CLEARTEXT_PASSWORD_ALLOWED ( 0x00000002 )
 
54
#define MSV1_0_UPDATE_LOGON_STATISTICS ( 0x00000004 )
 
55
#define MSV1_0_RETURN_USER_PARAMETERS ( 0x00000008 )
 
56
#define MSV1_0_ALLOW_SERVER_TRUST_ACCOUNT ( 0x00000020 )
 
57
#define MSV1_0_RETURN_PROFILE_PATH ( 0x00000200 )
 
58
#define MSV1_0_ALLOW_WORKSTATION_TRUST_ACCOUNT ( 0x00000800 )
 
59
 
 
60
struct netr_IdentityInfo {
 
61
        struct lsa_String domain_name;
 
62
        uint32_t parameter_control;
 
63
        uint32_t logon_id_low;
 
64
        uint32_t logon_id_high;
 
65
        struct lsa_String account_name;
 
66
        struct lsa_String workstation;
 
67
};
 
68
 
 
69
struct netr_PasswordInfo {
 
70
        struct netr_IdentityInfo identity_info;
 
71
        struct samr_Password lmpassword;
 
72
        struct samr_Password ntpassword;
 
73
};
 
74
 
 
75
struct netr_ChallengeResponse {
 
76
        uint16_t length;
 
77
        uint16_t size;/* [value(length)] */
 
78
        uint8_t *data;/* [unique,length_is(length),size_is(length)] */
 
79
}/* [flag(LIBNDR_PRINT_ARRAY_HEX)] */;
 
80
 
 
81
struct netr_NetworkInfo {
 
82
        struct netr_IdentityInfo identity_info;
 
83
        uint8_t challenge[8];
 
84
        struct netr_ChallengeResponse nt;
 
85
        struct netr_ChallengeResponse lm;
 
86
}/* [flag(LIBNDR_PRINT_ARRAY_HEX)] */;
 
87
 
 
88
struct netr_GenericInfo {
 
89
        struct netr_IdentityInfo identity_info;
 
90
        struct lsa_String package_name;
 
91
        uint32_t length;
 
92
        uint8_t *data;/* [unique,size_is(length)] */
 
93
}/* [flag(LIBNDR_PRINT_ARRAY_HEX)] */;
 
94
 
 
95
enum netr_LogonInfoClass
 
96
#ifndef USE_UINT_ENUMS
 
97
 {
 
98
        NetlogonInteractiveInformation=1,
 
99
        NetlogonNetworkInformation=2,
 
100
        NetlogonServiceInformation=3,
 
101
        NetlogonGenericInformation=4,
 
102
        NetlogonInteractiveTransitiveInformation=5,
 
103
        NetlogonNetworkTransitiveInformation=6,
 
104
        NetlogonServiceTransitiveInformation=7
 
105
}
 
106
#else
 
107
 { __donnot_use_enum_netr_LogonInfoClass=0x7FFFFFFF}
 
108
#define NetlogonInteractiveInformation ( 1 )
 
109
#define NetlogonNetworkInformation ( 2 )
 
110
#define NetlogonServiceInformation ( 3 )
 
111
#define NetlogonGenericInformation ( 4 )
 
112
#define NetlogonInteractiveTransitiveInformation ( 5 )
 
113
#define NetlogonNetworkTransitiveInformation ( 6 )
 
114
#define NetlogonServiceTransitiveInformation ( 7 )
 
115
#endif
 
116
;
 
117
 
 
118
union netr_LogonLevel {
 
119
        struct netr_PasswordInfo *password;/* [unique,case(NetlogonInteractiveInformation)] */
 
120
        struct netr_NetworkInfo *network;/* [unique,case(NetlogonNetworkInformation)] */
 
121
        struct netr_GenericInfo *generic;/* [unique,case(NetlogonGenericInformation)] */
 
122
}/* [public,switch_type(netr_LogonInfoClass)] */;
 
123
 
 
124
struct netr_UserSessionKey {
 
125
        uint8_t key[16];
 
126
}/* [public,flag(LIBNDR_PRINT_ARRAY_HEX)] */;
 
127
 
 
128
struct netr_LMSessionKey {
 
129
        uint8_t key[8];
 
130
}/* [public,flag(LIBNDR_PRINT_ARRAY_HEX)] */;
 
131
 
 
132
/* bitmap netr_UserFlags */
 
133
#define NETLOGON_GUEST ( 0x00000001 )
 
134
#define NETLOGON_NOENCRYPTION ( 0x00000002 )
 
135
#define NETLOGON_CACHED_ACCOUNT ( 0x00000004 )
 
136
#define NETLOGON_USED_LM_PASSWORD ( 0x00000008 )
 
137
#define NETLOGON_EXTRA_SIDS ( 0x00000020 )
 
138
#define NETLOGON_SUBAUTH_SESSION_KEY ( 0x00000040 )
 
139
#define NETLOGON_SERVER_TRUST_ACCOUNT ( 0x00000080 )
 
140
#define NETLOGON_NTLMV2_ENABLED ( 0x00000100 )
 
141
#define NETLOGON_RESOURCE_GROUPS ( 0x00000200 )
 
142
#define NETLOGON_PROFILE_PATH_RETURNED ( 0x00000400 )
 
143
#define NETLOGON_GRACE_LOGON ( 0x01000000 )
 
144
 
 
145
struct netr_SamBaseInfo {
 
146
        NTTIME last_logon;
 
147
        NTTIME last_logoff;
 
148
        NTTIME acct_expiry;
 
149
        NTTIME last_password_change;
 
150
        NTTIME allow_password_change;
 
151
        NTTIME force_password_change;
 
152
        struct lsa_String account_name;
 
153
        struct lsa_String full_name;
 
154
        struct lsa_String logon_script;
 
155
        struct lsa_String profile_path;
 
156
        struct lsa_String home_directory;
 
157
        struct lsa_String home_drive;
 
158
        uint16_t logon_count;
 
159
        uint16_t bad_password_count;
 
160
        uint32_t rid;
 
161
        uint32_t primary_gid;
 
162
        struct samr_RidWithAttributeArray groups;
 
163
        uint32_t user_flags;
 
164
        struct netr_UserSessionKey key;
 
165
        struct lsa_StringLarge logon_server;
 
166
        struct lsa_StringLarge domain;
 
167
        struct dom_sid2 *domain_sid;/* [unique] */
 
168
        struct netr_LMSessionKey LMSessKey;
 
169
        uint32_t acct_flags;
 
170
        uint32_t unknown[7];
 
171
};
 
172
 
 
173
struct netr_SamInfo2 {
 
174
        struct netr_SamBaseInfo base;
 
175
};
 
176
 
 
177
struct netr_SidAttr {
 
178
        struct dom_sid2 *sid;/* [unique] */
 
179
        uint32_t attributes;
 
180
};
 
181
 
 
182
struct netr_SamInfo3 {
 
183
        struct netr_SamBaseInfo base;
 
184
        uint32_t sidcount;
 
185
        struct netr_SidAttr *sids;/* [unique,size_is(sidcount)] */
 
186
}/* [public] */;
 
187
 
 
188
struct netr_SamInfo6 {
 
189
        struct netr_SamBaseInfo base;
 
190
        uint32_t sidcount;
 
191
        struct netr_SidAttr *sids;/* [unique,size_is(sidcount)] */
 
192
        struct lsa_String forest;
 
193
        struct lsa_String principle;
 
194
        uint32_t unknown4[20];
 
195
};
 
196
 
 
197
struct netr_PacInfo {
 
198
        uint32_t pac_size;
 
199
        uint8_t *pac;/* [unique,size_is(pac_size)] */
 
200
        struct lsa_String logon_domain;
 
201
        struct lsa_String logon_server;
 
202
        struct lsa_String principal_name;
 
203
        uint32_t auth_size;
 
204
        uint8_t *auth;/* [unique,size_is(auth_size)] */
 
205
        struct netr_UserSessionKey user_session_key;
 
206
        uint32_t expansionroom[10];
 
207
        struct lsa_String unknown1;
 
208
        struct lsa_String unknown2;
 
209
        struct lsa_String unknown3;
 
210
        struct lsa_String unknown4;
 
211
};
 
212
 
 
213
struct netr_GenericInfo2 {
 
214
        uint32_t length;
 
215
        uint8_t *data;/* [unique,size_is(length)] */
 
216
}/* [flag(LIBNDR_PRINT_ARRAY_HEX)] */;
 
217
 
 
218
enum netr_ValidationInfoClass
 
219
#ifndef USE_UINT_ENUMS
 
220
 {
 
221
        NetlogonValidationUasInfo=1,
 
222
        NetlogonValidationSamInfo=2,
 
223
        NetlogonValidationSamInfo2=3,
 
224
        NetlogonValidationGenericInfo2=5,
 
225
        NetlogonValidationSamInfo4=6
 
226
}
 
227
#else
 
228
 { __donnot_use_enum_netr_ValidationInfoClass=0x7FFFFFFF}
 
229
#define NetlogonValidationUasInfo ( 1 )
 
230
#define NetlogonValidationSamInfo ( 2 )
 
231
#define NetlogonValidationSamInfo2 ( 3 )
 
232
#define NetlogonValidationGenericInfo2 ( 5 )
 
233
#define NetlogonValidationSamInfo4 ( 6 )
 
234
#endif
 
235
;
 
236
 
 
237
union netr_Validation {
 
238
        struct netr_SamInfo2 *sam2;/* [unique,case(NetlogonValidationSamInfo)] */
 
239
        struct netr_SamInfo3 *sam3;/* [unique,case(NetlogonValidationSamInfo2)] */
 
240
        struct netr_PacInfo *pac;/* [unique,case(4)] */
 
241
        struct netr_GenericInfo2 *generic;/* [unique,case(NetlogonValidationGenericInfo2)] */
 
242
        struct netr_SamInfo6 *sam6;/* [unique,case(NetlogonValidationSamInfo4)] */
 
243
}/* [public,switch_type(uint16)] */;
 
244
 
 
245
struct netr_Credential {
 
246
        uint8_t data[8];
 
247
}/* [public,flag(LIBNDR_PRINT_ARRAY_HEX)] */;
 
248
 
 
249
struct netr_Authenticator {
 
250
        struct netr_Credential cred;
 
251
        time_t timestamp;
 
252
}/* [public] */;
 
253
 
 
254
struct netr_DELTA_DELETE_USER {
 
255
        const char *account_name;/* [unique,charset(UTF16)] */
 
256
        struct lsa_String unknown1;
 
257
        struct lsa_String unknown2;
 
258
        struct lsa_String unknown3;
 
259
        struct lsa_String unknown4;
 
260
        uint32_t unknown5;
 
261
        uint32_t unknown6;
 
262
        uint32_t unknown7;
 
263
        uint32_t unknown8;
 
264
};
 
265
 
 
266
struct netr_USER_KEY16 {
 
267
        uint16_t length;
 
268
        uint16_t size;/* [value(length)] */
 
269
        uint32_t flags;
 
270
        struct samr_Password pwd;
 
271
};
 
272
 
 
273
struct netr_PasswordHistory {
 
274
        uint16_t nt_length;
 
275
        uint16_t nt_size;/* [value(nt_length)] */
 
276
        uint32_t nt_flags;
 
277
        uint16_t lm_length;
 
278
        uint16_t lm_size;/* [value(lm_length)] */
 
279
        uint32_t lm_flags;
 
280
        uint8_t *nt_history;
 
281
        uint8_t *lm_history;
 
282
};
 
283
 
 
284
struct netr_USER_KEYS2 {
 
285
        struct netr_USER_KEY16 lmpassword;
 
286
        struct netr_USER_KEY16 ntpassword;
 
287
        struct netr_PasswordHistory history;
 
288
};
 
289
 
 
290
struct netr_USER_KEY_UNION {
 
291
        struct netr_USER_KEYS2 keys2;
 
292
};
 
293
 
 
294
struct netr_USER_KEYS {
 
295
        uint32_t version;
 
296
        struct netr_USER_KEY_UNION keys;
 
297
}/* [public] */;
 
298
 
 
299
struct netr_USER_PRIVATE_INFO {
 
300
        uint8_t SensitiveDataFlag;
 
301
        uint32_t DataLength;
 
302
        uint8_t *SensitiveData;/* [unique,flag(LIBNDR_PRINT_ARRAY_HEX),size_is(DataLength)] */
 
303
};
 
304
 
 
305
struct netr_DELTA_USER {
 
306
        struct lsa_String account_name;
 
307
        struct lsa_String full_name;
 
308
        uint32_t rid;
 
309
        uint32_t primary_gid;
 
310
        struct lsa_String home_directory;
 
311
        struct lsa_String home_drive;
 
312
        struct lsa_String logon_script;
 
313
        struct lsa_String description;
 
314
        struct lsa_String workstations;
 
315
        NTTIME last_logon;
 
316
        NTTIME last_logoff;
 
317
        struct samr_LogonHours logon_hours;
 
318
        uint16_t bad_password_count;
 
319
        uint16_t logon_count;
 
320
        NTTIME last_password_change;
 
321
        NTTIME acct_expiry;
 
322
        uint32_t acct_flags;
 
323
        struct samr_Password lmpassword;
 
324
        struct samr_Password ntpassword;
 
325
        uint8_t nt_password_present;
 
326
        uint8_t lm_password_present;
 
327
        uint8_t password_expired;
 
328
        struct lsa_String comment;
 
329
        struct lsa_BinaryString parameters;
 
330
        uint16_t country_code;
 
331
        uint16_t code_page;
 
332
        struct netr_USER_PRIVATE_INFO user_private_info;
 
333
        uint32_t SecurityInformation;
 
334
        struct sec_desc_buf sdbuf;
 
335
        struct lsa_String profile_path;
 
336
        struct lsa_String unknown2;
 
337
        struct lsa_String unknown3;
 
338
        struct lsa_String unknown4;
 
339
        uint32_t unknown5;
 
340
        uint32_t unknown6;
 
341
        uint32_t unknown7;
 
342
        uint32_t unknown8;
 
343
};
 
344
 
 
345
struct netr_DELTA_DOMAIN {
 
346
        struct lsa_String domain_name;
 
347
        struct lsa_String oem_information;
 
348
        int64_t force_logoff_time;
 
349
        uint16_t min_password_length;
 
350
        uint16_t password_history_length;
 
351
        int64_t max_password_age;
 
352
        int64_t min_password_age;
 
353
        uint64_t sequence_num;
 
354
        NTTIME domain_create_time;
 
355
        uint32_t SecurityInformation;
 
356
        struct sec_desc_buf sdbuf;
 
357
        struct lsa_BinaryString account_lockout;
 
358
        struct lsa_String unknown2;
 
359
        struct lsa_String unknown3;
 
360
        struct lsa_String unknown4;
 
361
        uint32_t logon_to_chgpass;
 
362
        uint32_t unknown6;
 
363
        uint32_t unknown7;
 
364
        uint32_t unknown8;
 
365
};
 
366
 
 
367
struct netr_DELTA_GROUP {
 
368
        struct lsa_String group_name;
 
369
        uint32_t rid;
 
370
        uint32_t attributes;
 
371
        struct lsa_String description;
 
372
        uint32_t SecurityInformation;
 
373
        struct sec_desc_buf sdbuf;
 
374
        struct lsa_String unknown1;
 
375
        struct lsa_String unknown2;
 
376
        struct lsa_String unknown3;
 
377
        struct lsa_String unknown4;
 
378
        uint32_t unknown5;
 
379
        uint32_t unknown6;
 
380
        uint32_t unknown7;
 
381
        uint32_t unknown8;
 
382
};
 
383
 
 
384
struct netr_DELTA_RENAME {
 
385
        struct lsa_String OldName;
 
386
        struct lsa_String NewName;
 
387
        struct lsa_String unknown1;
 
388
        struct lsa_String unknown2;
 
389
        struct lsa_String unknown3;
 
390
        struct lsa_String unknown4;
 
391
        uint32_t unknown5;
 
392
        uint32_t unknown6;
 
393
        uint32_t unknown7;
 
394
        uint32_t unknown8;
 
395
};
 
396
 
 
397
struct netr_DELTA_GROUP_MEMBER {
 
398
        uint32_t *rids;/* [unique,size_is(num_rids)] */
 
399
        uint32_t *attribs;/* [unique,size_is(num_rids)] */
 
400
        uint32_t num_rids;
 
401
        uint32_t unknown1;
 
402
        uint32_t unknown2;
 
403
        uint32_t unknown3;
 
404
        uint32_t unknown4;
 
405
};
 
406
 
 
407
struct netr_DELTA_ALIAS {
 
408
        struct lsa_String alias_name;
 
409
        uint32_t rid;
 
410
        uint32_t SecurityInformation;
 
411
        struct sec_desc_buf sdbuf;
 
412
        struct lsa_String description;
 
413
        struct lsa_String unknown2;
 
414
        struct lsa_String unknown3;
 
415
        struct lsa_String unknown4;
 
416
        uint32_t unknown5;
 
417
        uint32_t unknown6;
 
418
        uint32_t unknown7;
 
419
        uint32_t unknown8;
 
420
};
 
421
 
 
422
struct netr_DELTA_ALIAS_MEMBER {
 
423
        struct lsa_SidArray sids;
 
424
        uint32_t unknown1;
 
425
        uint32_t unknown2;
 
426
        uint32_t unknown3;
 
427
        uint32_t unknown4;
 
428
};
 
429
 
 
430
struct netr_QUOTA_LIMITS {
 
431
        uint32_t pagedpoollimit;
 
432
        uint32_t nonpagedpoollimit;
 
433
        uint32_t minimumworkingsetsize;
 
434
        uint32_t maximumworkingsetsize;
 
435
        uint32_t pagefilelimit;
 
436
        NTTIME timelimit;
 
437
};
 
438
 
 
439
struct netr_DELTA_POLICY {
 
440
        uint32_t maxlogsize;
 
441
        NTTIME auditretentionperiod;
 
442
        uint8_t auditingmode;
 
443
        uint32_t maxauditeventcount;
 
444
        uint32_t *eventauditoptions;/* [unique,size_is(maxauditeventcount+1)] */
 
445
        struct lsa_String primary_domain_name;
 
446
        struct dom_sid2 *sid;/* [unique] */
 
447
        struct netr_QUOTA_LIMITS quota_limits;
 
448
        uint64_t sequence_num;
 
449
        NTTIME db_create_time;
 
450
        uint32_t SecurityInformation;
 
451
        struct sec_desc_buf sdbuf;
 
452
        struct lsa_String unknown1;
 
453
        struct lsa_String unknown2;
 
454
        struct lsa_String unknown3;
 
455
        struct lsa_String unknown4;
 
456
        uint32_t unknown5;
 
457
        uint32_t unknown6;
 
458
        uint32_t unknown7;
 
459
        uint32_t unknown8;
 
460
};
 
461
 
 
462
struct netr_DELTA_TRUSTED_DOMAIN {
 
463
        struct lsa_String domain_name;
 
464
        uint32_t num_controllers;
 
465
        struct lsa_String *controller_names;/* [unique,size_is(num_controllers)] */
 
466
        uint32_t SecurityInformation;
 
467
        struct sec_desc_buf sdbuf;
 
468
        struct lsa_String unknown1;
 
469
        struct lsa_String unknown2;
 
470
        struct lsa_String unknown3;
 
471
        struct lsa_String unknown4;
 
472
        uint32_t posix_offset;
 
473
        uint32_t unknown6;
 
474
        uint32_t unknown7;
 
475
        uint32_t unknown8;
 
476
};
 
477
 
 
478
struct netr_DELTA_DELETE_TRUST {
 
479
        uint16_t unknown;
 
480
};
 
481
 
 
482
struct netr_DELTA_ACCOUNT {
 
483
        uint32_t privilege_entries;
 
484
        uint32_t privilege_control;
 
485
        uint32_t *privilege_attrib;/* [unique,size_is(privilege_entries)] */
 
486
        struct lsa_String *privilege_name;/* [unique,size_is(privilege_entries)] */
 
487
        struct netr_QUOTA_LIMITS quotalimits;
 
488
        uint32_t system_flags;
 
489
        uint32_t SecurityInformation;
 
490
        struct sec_desc_buf sdbuf;
 
491
        struct lsa_String unknown1;
 
492
        struct lsa_String unknown2;
 
493
        struct lsa_String unknown3;
 
494
        struct lsa_String unknown4;
 
495
        uint32_t unknown5;
 
496
        uint32_t unknown6;
 
497
        uint32_t unknown7;
 
498
        uint32_t unknown8;
 
499
};
 
500
 
 
501
struct netr_DELTA_DELETE_ACCOUNT {
 
502
        uint16_t unknown;
 
503
};
 
504
 
 
505
struct netr_DELTA_DELETE_SECRET {
 
506
        uint16_t unknown;
 
507
};
 
508
 
 
509
struct netr_CIPHER_VALUE {
 
510
        uint32_t len;
 
511
        uint32_t maxlen;
 
512
        uint8_t *cipher_data;/* [unique,length_is(len),size_is(maxlen)] */
 
513
};
 
514
 
 
515
struct netr_DELTA_SECRET {
 
516
        struct netr_CIPHER_VALUE current_cipher;
 
517
        NTTIME current_cipher_set_time;
 
518
        struct netr_CIPHER_VALUE old_cipher;
 
519
        NTTIME old_cipher_set_time;
 
520
        uint32_t SecurityInformation;
 
521
        struct sec_desc_buf sdbuf;
 
522
        struct lsa_String unknown1;
 
523
        struct lsa_String unknown2;
 
524
        struct lsa_String unknown3;
 
525
        struct lsa_String unknown4;
 
526
        uint32_t unknown5;
 
527
        uint32_t unknown6;
 
528
        uint32_t unknown7;
 
529
        uint32_t unknown8;
 
530
};
 
531
 
 
532
enum netr_DeltaEnum
 
533
#ifndef USE_UINT_ENUMS
 
534
 {
 
535
        NETR_DELTA_DOMAIN=1,
 
536
        NETR_DELTA_GROUP=2,
 
537
        NETR_DELTA_DELETE_GROUP=3,
 
538
        NETR_DELTA_RENAME_GROUP=4,
 
539
        NETR_DELTA_USER=5,
 
540
        NETR_DELTA_DELETE_USER=6,
 
541
        NETR_DELTA_RENAME_USER=7,
 
542
        NETR_DELTA_GROUP_MEMBER=8,
 
543
        NETR_DELTA_ALIAS=9,
 
544
        NETR_DELTA_DELETE_ALIAS=10,
 
545
        NETR_DELTA_RENAME_ALIAS=11,
 
546
        NETR_DELTA_ALIAS_MEMBER=12,
 
547
        NETR_DELTA_POLICY=13,
 
548
        NETR_DELTA_TRUSTED_DOMAIN=14,
 
549
        NETR_DELTA_DELETE_TRUST=15,
 
550
        NETR_DELTA_ACCOUNT=16,
 
551
        NETR_DELTA_DELETE_ACCOUNT=17,
 
552
        NETR_DELTA_SECRET=18,
 
553
        NETR_DELTA_DELETE_SECRET=19,
 
554
        NETR_DELTA_DELETE_GROUP2=20,
 
555
        NETR_DELTA_DELETE_USER2=21,
 
556
        NETR_DELTA_MODIFY_COUNT=22
 
557
}
 
558
#else
 
559
 { __donnot_use_enum_netr_DeltaEnum=0x7FFFFFFF}
 
560
#define NETR_DELTA_DOMAIN ( 1 )
 
561
#define NETR_DELTA_GROUP ( 2 )
 
562
#define NETR_DELTA_DELETE_GROUP ( 3 )
 
563
#define NETR_DELTA_RENAME_GROUP ( 4 )
 
564
#define NETR_DELTA_USER ( 5 )
 
565
#define NETR_DELTA_DELETE_USER ( 6 )
 
566
#define NETR_DELTA_RENAME_USER ( 7 )
 
567
#define NETR_DELTA_GROUP_MEMBER ( 8 )
 
568
#define NETR_DELTA_ALIAS ( 9 )
 
569
#define NETR_DELTA_DELETE_ALIAS ( 10 )
 
570
#define NETR_DELTA_RENAME_ALIAS ( 11 )
 
571
#define NETR_DELTA_ALIAS_MEMBER ( 12 )
 
572
#define NETR_DELTA_POLICY ( 13 )
 
573
#define NETR_DELTA_TRUSTED_DOMAIN ( 14 )
 
574
#define NETR_DELTA_DELETE_TRUST ( 15 )
 
575
#define NETR_DELTA_ACCOUNT ( 16 )
 
576
#define NETR_DELTA_DELETE_ACCOUNT ( 17 )
 
577
#define NETR_DELTA_SECRET ( 18 )
 
578
#define NETR_DELTA_DELETE_SECRET ( 19 )
 
579
#define NETR_DELTA_DELETE_GROUP2 ( 20 )
 
580
#define NETR_DELTA_DELETE_USER2 ( 21 )
 
581
#define NETR_DELTA_MODIFY_COUNT ( 22 )
 
582
#endif
 
583
;
 
584
 
 
585
union netr_DELTA_UNION {
 
586
        struct netr_DELTA_DOMAIN *domain;/* [unique,case(NETR_DELTA_DOMAIN)] */
 
587
        struct netr_DELTA_GROUP *group;/* [unique,case(NETR_DELTA_GROUP)] */
 
588
        struct netr_DELTA_RENAME *rename_group;/* [unique,case(NETR_DELTA_RENAME_GROUP)] */
 
589
        struct netr_DELTA_USER *user;/* [unique,case(NETR_DELTA_USER)] */
 
590
        struct netr_DELTA_RENAME *rename_user;/* [unique,case(NETR_DELTA_RENAME_USER)] */
 
591
        struct netr_DELTA_GROUP_MEMBER *group_member;/* [unique,case(NETR_DELTA_GROUP_MEMBER)] */
 
592
        struct netr_DELTA_ALIAS *alias;/* [unique,case(NETR_DELTA_ALIAS)] */
 
593
        struct netr_DELTA_RENAME *rename_alias;/* [unique,case(NETR_DELTA_RENAME_ALIAS)] */
 
594
        struct netr_DELTA_ALIAS_MEMBER *alias_member;/* [unique,case(NETR_DELTA_ALIAS_MEMBER)] */
 
595
        struct netr_DELTA_POLICY *policy;/* [unique,case(NETR_DELTA_POLICY)] */
 
596
        struct netr_DELTA_TRUSTED_DOMAIN *trusted_domain;/* [unique,case(NETR_DELTA_TRUSTED_DOMAIN)] */
 
597
        struct netr_DELTA_DELETE_TRUST delete_trust;/* [case(NETR_DELTA_DELETE_TRUST)] */
 
598
        struct netr_DELTA_ACCOUNT *account;/* [unique,case(NETR_DELTA_ACCOUNT)] */
 
599
        struct netr_DELTA_DELETE_ACCOUNT delete_account;/* [case(NETR_DELTA_DELETE_ACCOUNT)] */
 
600
        struct netr_DELTA_SECRET *secret;/* [unique,case(NETR_DELTA_SECRET)] */
 
601
        struct netr_DELTA_DELETE_SECRET delete_secret;/* [case(NETR_DELTA_DELETE_SECRET)] */
 
602
        struct netr_DELTA_DELETE_USER *delete_group;/* [unique,case(NETR_DELTA_DELETE_GROUP2)] */
 
603
        struct netr_DELTA_DELETE_USER *delete_user;/* [unique,case(NETR_DELTA_DELETE_USER2)] */
 
604
        uint64_t *modified_count;/* [unique,case(NETR_DELTA_MODIFY_COUNT)] */
 
605
}/* [switch_type(netr_DeltaEnum)] */;
 
606
 
 
607
union netr_DELTA_ID_UNION {
 
608
        uint32_t rid;/* [case(NETR_DELTA_DOMAIN)] */
 
609
        struct dom_sid2 *sid;/* [unique,case(NETR_DELTA_POLICY)] */
 
610
        const char *name;/* [unique,charset(UTF16),case(NETR_DELTA_SECRET)] */
 
611
}/* [switch_type(netr_DeltaEnum)] */;
 
612
 
 
613
struct netr_DELTA_ENUM {
 
614
        enum netr_DeltaEnum delta_type;
 
615
        union netr_DELTA_ID_UNION delta_id_union;/* [switch_is(delta_type)] */
 
616
        union netr_DELTA_UNION delta_union;/* [switch_is(delta_type)] */
 
617
};
 
618
 
 
619
struct netr_DELTA_ENUM_ARRAY {
 
620
        uint32_t num_deltas;
 
621
        struct netr_DELTA_ENUM *delta_enum;/* [unique,size_is(num_deltas)] */
 
622
};
 
623
 
 
624
struct netr_UAS_INFO_0 {
 
625
        uint8_t computer_name[16];
 
626
        uint32_t timecreated;
 
627
        uint32_t serial_number;
 
628
}/* [flag(LIBNDR_PRINT_ARRAY_HEX)] */;
 
629
 
 
630
struct netr_AccountBuffer {
 
631
        DATA_BLOB blob;/* [flag(LIBNDR_FLAG_REMAINING)] */
 
632
};
 
633
 
 
634
/* bitmap netr_InfoFlags */
 
635
#define NETLOGON_CTRL_REPL_NEEDED ( 0x0001 )
 
636
#define NETLOGON_CTRL_REPL_IN_PROGRESS ( 0x0002 )
 
637
#define NETLOGON_CTRL_REPL_FULL_SYNC ( 0x0004 )
 
638
 
 
639
struct netr_NETLOGON_INFO_1 {
 
640
        uint32_t flags;
 
641
        uint32_t pdc_connection_status;
 
642
};
 
643
 
 
644
struct netr_NETLOGON_INFO_2 {
 
645
        uint32_t flags;
 
646
        uint32_t pdc_connection_status;
 
647
        const char *trusted_dc_name;/* [unique,charset(UTF16)] */
 
648
        uint32_t tc_connection_status;
 
649
};
 
650
 
 
651
struct netr_NETLOGON_INFO_3 {
 
652
        uint32_t flags;
 
653
        uint32_t logon_attempts;
 
654
        uint32_t unknown1;
 
655
        uint32_t unknown2;
 
656
        uint32_t unknown3;
 
657
        uint32_t unknown4;
 
658
        uint32_t unknown5;
 
659
};
 
660
 
 
661
struct netr_NETLOGON_INFO_4 {
 
662
        const char *trusted_dc_name;/* [unique,charset(UTF16)] */
 
663
        const char *trusted_domain_name;/* [unique,charset(UTF16)] */
 
664
};
 
665
 
 
666
union netr_CONTROL_QUERY_INFORMATION {
 
667
        struct netr_NETLOGON_INFO_1 *info1;/* [unique,case] */
 
668
        struct netr_NETLOGON_INFO_2 *info2;/* [unique,case(2)] */
 
669
        struct netr_NETLOGON_INFO_3 *info3;/* [unique,case(3)] */
 
670
        struct netr_NETLOGON_INFO_4 *info4;/* [unique,case(4)] */
 
671
};
 
672
 
 
673
enum netr_LogonControlCode
 
674
#ifndef USE_UINT_ENUMS
 
675
 {
 
676
        NETLOGON_CONTROL_QUERY=0x00000001,
 
677
        NETLOGON_CONTROL_REPLICATE=0x00000002,
 
678
        NETLOGON_CONTROL_SYNCHRONIZE=0x00000003,
 
679
        NETLOGON_CONTROL_PDC_REPLICATE=0x00000004,
 
680
        NETLOGON_CONTROL_REDISCOVER=0x00000005,
 
681
        NETLOGON_CONTROL_TC_QUERY=0x00000006,
 
682
        NETLOGON_CONTROL_TRANSPORT_NOTIFY=0x00000007,
 
683
        NETLOGON_CONTROL_FIND_USER=0x00000008,
 
684
        NETLOGON_CONTROL_CHANGE_PASSWORD=0x00000009,
 
685
        NETLOGON_CONTROL_TC_VERIFY=0x0000000A,
 
686
        NETLOGON_CONTROL_FORCE_DNS_REG=0x0000000B,
 
687
        NETLOGON_CONTROL_QUERY_DNS_REG=0x0000000C,
 
688
        NETLOGON_CONTROL_BACKUP_CHANGE_LOG=0x0000FFFC,
 
689
        NETLOGON_CONTROL_TRUNCATE_LOG=0x0000FFFD,
 
690
        NETLOGON_CONTROL_SET_DBFLAG=0x0000FFFE,
 
691
        NETLOGON_CONTROL_BREAKPOINT=0x0000FFFF
 
692
}
 
693
#else
 
694
 { __donnot_use_enum_netr_LogonControlCode=0x7FFFFFFF}
 
695
#define NETLOGON_CONTROL_QUERY ( 0x00000001 )
 
696
#define NETLOGON_CONTROL_REPLICATE ( 0x00000002 )
 
697
#define NETLOGON_CONTROL_SYNCHRONIZE ( 0x00000003 )
 
698
#define NETLOGON_CONTROL_PDC_REPLICATE ( 0x00000004 )
 
699
#define NETLOGON_CONTROL_REDISCOVER ( 0x00000005 )
 
700
#define NETLOGON_CONTROL_TC_QUERY ( 0x00000006 )
 
701
#define NETLOGON_CONTROL_TRANSPORT_NOTIFY ( 0x00000007 )
 
702
#define NETLOGON_CONTROL_FIND_USER ( 0x00000008 )
 
703
#define NETLOGON_CONTROL_CHANGE_PASSWORD ( 0x00000009 )
 
704
#define NETLOGON_CONTROL_TC_VERIFY ( 0x0000000A )
 
705
#define NETLOGON_CONTROL_FORCE_DNS_REG ( 0x0000000B )
 
706
#define NETLOGON_CONTROL_QUERY_DNS_REG ( 0x0000000C )
 
707
#define NETLOGON_CONTROL_BACKUP_CHANGE_LOG ( 0x0000FFFC )
 
708
#define NETLOGON_CONTROL_TRUNCATE_LOG ( 0x0000FFFD )
 
709
#define NETLOGON_CONTROL_SET_DBFLAG ( 0x0000FFFE )
 
710
#define NETLOGON_CONTROL_BREAKPOINT ( 0x0000FFFF )
 
711
#endif
 
712
;
 
713
 
 
714
union netr_CONTROL_DATA_INFORMATION {
 
715
        const char *domain;/* [unique,charset(UTF16),case(NETLOGON_CONTROL_REDISCOVER)] */
 
716
        const char *user;/* [unique,charset(UTF16),case(NETLOGON_CONTROL_FIND_USER)] */
 
717
        uint32_t debug_level;/* [case(NETLOGON_CONTROL_SET_DBFLAG)] */
 
718
};
 
719
 
 
720
/* bitmap netr_NegotiateFlags */
 
721
#define NETLOGON_NEG_ACCOUNT_LOCKOUT ( 0x00000001 )
 
722
#define NETLOGON_NEG_PERSISTENT_SAMREPL ( 0x00000002 )
 
723
#define NETLOGON_NEG_ARCFOUR ( 0x00000004 )
 
724
#define NETLOGON_NEG_PROMOTION_COUNT ( 0x00000008 )
 
725
#define NETLOGON_NEG_CHANGELOG_BDC ( 0x00000010 )
 
726
#define NETLOGON_NEG_FULL_SYNC_REPL ( 0x00000020 )
 
727
#define NETLOGON_NEG_MULTIPLE_SIDS ( 0x00000040 )
 
728
#define NETLOGON_NEG_REDO ( 0x00000080 )
 
729
#define NETLOGON_NEG_PASSWORD_CHANGE_REFUSAL ( 0x00000100 )
 
730
#define NETLOGON_NEG_SEND_PASSWORD_INFO_PDC ( 0x00000200 )
 
731
#define NETLOGON_NEG_GENERIC_PASSTHROUGH ( 0x00000400 )
 
732
#define NETLOGON_NEG_CONCURRENT_RPC ( 0x00000800 )
 
733
#define NETLOGON_NEG_AVOID_ACCOUNT_DB_REPL ( 0x00001000 )
 
734
#define NETLOGON_NEG_AVOID_SECURITYAUTH_DB_REPL ( 0x00002000 )
 
735
#define NETLOGON_NEG_STRONG_KEYS ( 0x00004000 )
 
736
#define NETLOGON_NEG_TRANSITIVE_TRUSTS ( 0x00008000 )
 
737
#define NETLOGON_NEG_DNS_DOMAIN_TRUSTS ( 0x00010000 )
 
738
#define NETLOGON_NEG_PASSWORD_SET2 ( 0x00020000 )
 
739
#define NETLOGON_NEG_GETDOMAININFO ( 0x00040000 )
 
740
#define NETLOGON_NEG_CROSS_FOREST_TRUSTS ( 0x00080000 )
 
741
#define NETLOGON_NEG_NEUTRALIZE_NT4_EMULATION ( 0x00100000 )
 
742
#define NETLOGON_NEG_RODC_PASSTHROUGH ( 0x00200000 )
 
743
#define NETLOGON_NEG_SUPPORTS_AES_SHA2 ( 0x00400000 )
 
744
#define NETLOGON_NEG_AUTHENTICATED_RPC_LSASS ( 0x20000000 )
 
745
#define NETLOGON_NEG_AUTHENTICATED_RPC ( 0x40000000 )
 
746
 
 
747
/* bitmap netr_ChangeLogFlags */
 
748
#define NETR_CHANGELOG_IMMEDIATE_REPL_REQUIRED ( 0x0001 )
 
749
#define NETR_CHANGELOG_CHANGED_PASSWORD ( 0x0002 )
 
750
#define NETR_CHANGELOG_SID_INCLUDED ( 0x0004 )
 
751
#define NETR_CHANGELOG_NAME_INCLUDED ( 0x0008 )
 
752
#define NETR_CHANGELOG_FIRST_PROMOTION_OBJ ( 0x0010 )
 
753
 
 
754
union netr_ChangeLogObject {
 
755
        struct dom_sid object_sid;/* [case(NETR_CHANGELOG_SID_INCLUDED)] */
 
756
        const char * object_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM),case(NETR_CHANGELOG_NAME_INCLUDED)] */
 
757
}/* [nodiscriminant] */;
 
758
 
 
759
struct netr_ChangeLogEntry {
 
760
        uint32_t serial_number1;
 
761
        uint32_t serial_number2;
 
762
        uint32_t object_rid;
 
763
        uint16_t flags;
 
764
        enum netr_SamDatabaseID8Bit db_index;
 
765
        enum netr_DeltaEnum8Bit delta_type;
 
766
        union netr_ChangeLogObject object;/* [switch_is(flags&(NETR_CHANGELOG_SID_INCLUDED|NETR_CHANGELOG_NAME_INCLUDED))] */
 
767
}/* [gensize,public] */;
 
768
 
 
769
struct netr_Blob {
 
770
        uint32_t length;
 
771
        uint8_t *data;/* [unique,size_is(length)] */
 
772
};
 
773
 
 
774
/* bitmap netr_DsRGetDCName_flags */
 
775
#define DS_FORCE_REDISCOVERY ( 0x00000001 )
 
776
#define DS_DIRECTORY_SERVICE_REQUIRED ( 0x00000010 )
 
777
#define DS_DIRECTORY_SERVICE_PREFERRED ( 0x00000020 )
 
778
#define DS_GC_SERVER_REQUIRED ( 0x00000040 )
 
779
#define DS_PDC_REQUIRED ( 0x00000080 )
 
780
#define DS_BACKGROUND_ONLY ( 0x00000100 )
 
781
#define DS_IP_REQUIRED ( 0x00000200 )
 
782
#define DS_KDC_REQUIRED ( 0x00000400 )
 
783
#define DS_TIMESERV_REQUIRED ( 0x00000800 )
 
784
#define DS_WRITABLE_REQUIRED ( 0x00001000 )
 
785
#define DS_GOOD_TIMESERV_PREFERRED ( 0x00002000 )
 
786
#define DS_AVOID_SELF ( 0x00004000 )
 
787
#define DS_ONLY_LDAP_NEEDED ( 0x00008000 )
 
788
#define DS_IS_FLAT_NAME ( 0x00010000 )
 
789
#define DS_IS_DNS_NAME ( 0x00020000 )
 
790
#define DS_TRY_NEXTCLOSEST_SITE ( 0x00040000 )
 
791
#define DS_DIRECTORY_SERVICE_6_REQUIRED ( 0x00080000 )
 
792
#define DS_RETURN_DNS_NAME ( 0x40000000 )
 
793
#define DS_RETURN_FLAT_NAME ( 0x80000000 )
 
794
 
 
795
enum netr_DsRGetDCNameInfo_AddressType
 
796
#ifndef USE_UINT_ENUMS
 
797
 {
 
798
        DS_ADDRESS_TYPE_INET=1,
 
799
        DS_ADDRESS_TYPE_NETBIOS=2
 
800
}
 
801
#else
 
802
 { __donnot_use_enum_netr_DsRGetDCNameInfo_AddressType=0x7FFFFFFF}
 
803
#define DS_ADDRESS_TYPE_INET ( 1 )
 
804
#define DS_ADDRESS_TYPE_NETBIOS ( 2 )
 
805
#endif
 
806
;
 
807
 
 
808
/* bitmap netr_DsR_DcFlags */
 
809
#define DS_SERVER_PDC ( NBT_SERVER_PDC )
 
810
#define DS_SERVER_GC ( NBT_SERVER_GC )
 
811
#define DS_SERVER_LDAP ( NBT_SERVER_LDAP )
 
812
#define DS_SERVER_DS ( NBT_SERVER_DS )
 
813
#define DS_SERVER_KDC ( NBT_SERVER_KDC )
 
814
#define DS_SERVER_TIMESERV ( NBT_SERVER_TIMESERV )
 
815
#define DS_SERVER_CLOSEST ( NBT_SERVER_CLOSEST )
 
816
#define DS_SERVER_WRITABLE ( NBT_SERVER_WRITABLE )
 
817
#define DS_SERVER_GOOD_TIMESERV ( NBT_SERVER_GOOD_TIMESERV )
 
818
#define DS_SERVER_NDNC ( NBT_SERVER_NDNC )
 
819
#define DS_SERVER_SELECT_SECRET_DOMAIN_6 ( NBT_SERVER_SELECT_SECRET_DOMAIN_6 )
 
820
#define DS_SERVER_FULL_SECRET_DOMAIN_6 ( NBT_SERVER_FULL_SECRET_DOMAIN_6 )
 
821
#define DS_DNS_CONTROLLER ( 0x20000000 )
 
822
#define DS_DNS_DOMAIN ( 0x40000000 )
 
823
#define DS_DNS_FOREST ( 0x80000000 )
 
824
 
 
825
struct netr_DsRGetDCNameInfo {
 
826
        const char *dc_unc;/* [unique,charset(UTF16)] */
 
827
        const char *dc_address;/* [unique,charset(UTF16)] */
 
828
        enum netr_DsRGetDCNameInfo_AddressType dc_address_type;
 
829
        struct GUID domain_guid;
 
830
        const char *domain_name;/* [unique,charset(UTF16)] */
 
831
        const char *forest_name;/* [unique,charset(UTF16)] */
 
832
        uint32_t dc_flags;
 
833
        const char *dc_site_name;/* [unique,charset(UTF16)] */
 
834
        const char *client_site_name;/* [unique,charset(UTF16)] */
 
835
}/* [public] */;
 
836
 
 
837
union netr_Capabilities {
 
838
        uint32_t server_capabilities;/* [case] */
 
839
}/* [switch_type(uint32)] */;
 
840
 
 
841
/* bitmap netr_TrustFlags */
 
842
#define NETR_TRUST_FLAG_IN_FOREST ( 0x00000001 )
 
843
#define NETR_TRUST_FLAG_OUTBOUND ( 0x00000002 )
 
844
#define NETR_TRUST_FLAG_TREEROOT ( 0x00000004 )
 
845
#define NETR_TRUST_FLAG_PRIMARY ( 0x00000008 )
 
846
#define NETR_TRUST_FLAG_NATIVE ( 0x00000010 )
 
847
#define NETR_TRUST_FLAG_INBOUND ( 0x00000020 )
 
848
#define NETR_TRUST_FLAG_MIT_KRB5 ( 0x00000080 )
 
849
#define NETR_TRUST_FLAG_AES ( 0x00000100 )
 
850
 
 
851
struct netr_DomainQuery1 {
 
852
        struct netr_Blob blob;
 
853
        const char *workstation_domain;/* [unique,charset(UTF16)] */
 
854
        const char *workstation_site;/* [unique,charset(UTF16)] */
 
855
        const char *unknown1;/* [unique,charset(UTF16)] */
 
856
        const char *unknown2;/* [unique,charset(UTF16)] */
 
857
        const char *unknown3;/* [unique,charset(UTF16)] */
 
858
        const char *unknown4;/* [unique,charset(UTF16)] */
 
859
        struct lsa_BinaryString blob2;
 
860
        struct lsa_String product;
 
861
        struct lsa_String unknown5;
 
862
        struct lsa_String unknown6;
 
863
        uint32_t unknown7[4];
 
864
};
 
865
 
 
866
union netr_DomainQuery {
 
867
        struct netr_DomainQuery1 *query1;/* [unique,case] */
 
868
};
 
869
 
 
870
struct netr_trust_extension {
 
871
        uint32_t length;/* [value(8)] */
 
872
        uint32_t dummy;/* [value(0)] */
 
873
        uint32_t size;/* [value(8)] */
 
874
        uint32_t flags;
 
875
        uint32_t parent_index;
 
876
        uint32_t trust_type;
 
877
        uint32_t trust_attributes;
 
878
};
 
879
 
 
880
struct netr_trust_extension_container {
 
881
        uint16_t length;
 
882
        uint16_t size;/* [value(length)] */
 
883
        struct netr_trust_extension *info;/* [unique] */
 
884
};
 
885
 
 
886
struct netr_DomainTrustInfo {
 
887
        struct lsa_String domainname;
 
888
        struct lsa_String fulldomainname;
 
889
        struct lsa_String forest;
 
890
        struct GUID guid;
 
891
        struct dom_sid2 *sid;/* [unique] */
 
892
        struct netr_trust_extension_container trust_extension;
 
893
        struct lsa_String dummystring[3];
 
894
        uint32_t dummy[4];
 
895
};
 
896
 
 
897
struct netr_LsaPolicyInfo {
 
898
        uint32_t policy_size;
 
899
        uint8_t *policy;/* [unique,size_is(policy_size)] */
 
900
};
 
901
 
 
902
/* bitmap netr_WorkstationFlags */
 
903
#define NETR_WS_FLAG_HANDLES_INBOUND_TRUSTS ( 0x00000001 )
 
904
#define NETR_WS_FLAG_HANDLES_SPN_UPDATE ( 0x00000002 )
 
905
 
 
906
struct netr_DomainInfo1 {
 
907
        struct netr_DomainTrustInfo domaininfo;
 
908
        uint32_t num_trusts;
 
909
        struct netr_DomainTrustInfo *trusts;/* [unique,size_is(num_trusts)] */
 
910
        struct netr_LsaPolicyInfo lsa_policy;
 
911
        struct lsa_String dns_hostname;
 
912
        struct lsa_String dummystring[3];
 
913
        uint32_t workstation_flags;
 
914
        uint32_t supported_enc_types;
 
915
        uint32_t dummy[2];
 
916
};
 
917
 
 
918
union netr_DomainInfo {
 
919
        struct netr_DomainInfo1 *info1;/* [unique,case] */
 
920
        struct netr_DomainInfo1 *info2;/* [unique,case(2)] */
 
921
};
 
922
 
 
923
struct netr_CryptPassword {
 
924
        uint8_t data[512];
 
925
        uint32_t length;
 
926
}/* [flag(LIBNDR_PRINT_ARRAY_HEX)] */;
 
927
 
 
928
struct netr_DsRAddressToSitenamesWCtr {
 
929
        uint32_t count;
 
930
        struct lsa_String *sitename;/* [unique,size_is(count)] */
 
931
};
 
932
 
 
933
struct netr_DsRAddress {
 
934
        uint8_t *buffer;/* [unique,size_is(size)] */
 
935
        uint32_t size;
 
936
};
 
937
 
 
938
enum netr_TrustType
 
939
#ifndef USE_UINT_ENUMS
 
940
 {
 
941
        NETR_TRUST_TYPE_DOWNLEVEL=1,
 
942
        NETR_TRUST_TYPE_UPLEVEL=2,
 
943
        NETR_TRUST_TYPE_MIT=3,
 
944
        NETR_TRUST_TYPE_DCE=4
 
945
}
 
946
#else
 
947
 { __donnot_use_enum_netr_TrustType=0x7FFFFFFF}
 
948
#define NETR_TRUST_TYPE_DOWNLEVEL ( 1 )
 
949
#define NETR_TRUST_TYPE_UPLEVEL ( 2 )
 
950
#define NETR_TRUST_TYPE_MIT ( 3 )
 
951
#define NETR_TRUST_TYPE_DCE ( 4 )
 
952
#endif
 
953
;
 
954
 
 
955
/* bitmap netr_TrustAttributes */
 
956
#define NETR_TRUST_ATTRIBUTE_NON_TRANSITIVE ( 0x00000001 )
 
957
#define NETR_TRUST_ATTRIBUTE_UPLEVEL_ONLY ( 0x00000002 )
 
958
#define NETR_TRUST_ATTRIBUTE_QUARANTINED_DOMAIN ( 0x00000004 )
 
959
#define NETR_TRUST_ATTRIBUTE_FOREST_TRANSITIVE ( 0x00000008 )
 
960
#define NETR_TRUST_ATTRIBUTE_CROSS_ORGANIZATION ( 0x00000010 )
 
961
#define NETR_TRUST_ATTRIBUTE_WITHIN_FOREST ( 0x00000020 )
 
962
#define NETR_TRUST_ATTRIBUTE_TREAT_AS_EXTERNAL ( 0x00000040 )
 
963
 
 
964
struct netr_DomainTrust {
 
965
        const char *netbios_name;/* [unique,charset(UTF16)] */
 
966
        const char *dns_name;/* [unique,charset(UTF16)] */
 
967
        uint32_t trust_flags;
 
968
        uint32_t parent_index;
 
969
        enum netr_TrustType trust_type;
 
970
        uint32_t trust_attributes;
 
971
        struct dom_sid2 *sid;/* [unique] */
 
972
        struct GUID guid;
 
973
};
 
974
 
 
975
struct netr_DomainTrustList {
 
976
        uint32_t count;
 
977
        struct netr_DomainTrust *array;/* [unique,size_is(count)] */
 
978
};
 
979
 
 
980
struct netr_DsRAddressToSitenamesExWCtr {
 
981
        uint32_t count;
 
982
        struct lsa_String *sitename;/* [unique,size_is(count)] */
 
983
        struct lsa_String *subnetname;/* [unique,size_is(count)] */
 
984
};
 
985
 
 
986
struct DcSitesCtr {
 
987
        uint32_t num_sites;
 
988
        struct lsa_String *sites;/* [unique,size_is(num_sites)] */
 
989
};
 
990
 
 
991
struct netr_TrustInfo {
 
992
        uint32_t count;
 
993
        uint32_t *data;/* [unique,size_is(count)] */
 
994
        uint32_t entry_count;
 
995
        struct lsa_String *entries;/* [unique,size_is(count)] */
 
996
};
 
997
 
 
998
 
 
999
struct netr_LogonUasLogon {
 
1000
        struct {
 
1001
                const char *server_name;/* [unique,charset(UTF16)] */
 
1002
                const char *account_name;/* [charset(UTF16)] */
 
1003
                const char *workstation;/* [charset(UTF16)] */
 
1004
        } in;
 
1005
 
 
1006
        struct {
 
1007
                struct netr_UasInfo **info;/* [ref] */
 
1008
                WERROR result;
 
1009
        } out;
 
1010
 
 
1011
};
 
1012
 
 
1013
 
 
1014
struct netr_LogonUasLogoff {
 
1015
        struct {
 
1016
                const char *server_name;/* [unique,charset(UTF16)] */
 
1017
                const char *account_name;/* [charset(UTF16)] */
 
1018
                const char *workstation;/* [charset(UTF16)] */
 
1019
        } in;
 
1020
 
 
1021
        struct {
 
1022
                struct netr_UasLogoffInfo *info;/* [ref] */
 
1023
                WERROR result;
 
1024
        } out;
 
1025
 
 
1026
};
 
1027
 
 
1028
 
 
1029
struct netr_LogonSamLogon {
 
1030
        struct {
 
1031
                const char *server_name;/* [unique,charset(UTF16)] */
 
1032
                const char *computer_name;/* [unique,charset(UTF16)] */
 
1033
                struct netr_Authenticator *credential;/* [unique] */
 
1034
                enum netr_LogonInfoClass logon_level;
 
1035
                union netr_LogonLevel *logon;/* [ref,switch_is(logon_level)] */
 
1036
                uint16_t validation_level;
 
1037
                struct netr_Authenticator *return_authenticator;/* [unique] */
 
1038
        } in;
 
1039
 
 
1040
        struct {
 
1041
                union netr_Validation *validation;/* [ref,switch_is(validation_level)] */
 
1042
                uint8_t *authoritative;/* [ref] */
 
1043
                struct netr_Authenticator *return_authenticator;/* [unique] */
 
1044
                NTSTATUS result;
 
1045
        } out;
 
1046
 
 
1047
};
 
1048
 
 
1049
 
 
1050
struct netr_LogonSamLogoff {
 
1051
        struct {
 
1052
                const char *server_name;/* [unique,charset(UTF16)] */
 
1053
                const char *computer_name;/* [unique,charset(UTF16)] */
 
1054
                struct netr_Authenticator *credential;/* [unique] */
 
1055
                enum netr_LogonInfoClass logon_level;
 
1056
                union netr_LogonLevel logon;/* [switch_is(logon_level)] */
 
1057
                struct netr_Authenticator *return_authenticator;/* [unique] */
 
1058
        } in;
 
1059
 
 
1060
        struct {
 
1061
                struct netr_Authenticator *return_authenticator;/* [unique] */
 
1062
                NTSTATUS result;
 
1063
        } out;
 
1064
 
 
1065
};
 
1066
 
 
1067
 
 
1068
struct netr_ServerReqChallenge {
 
1069
        struct {
 
1070
                const char *server_name;/* [unique,charset(UTF16)] */
 
1071
                const char *computer_name;/* [charset(UTF16)] */
 
1072
                struct netr_Credential *credentials;/* [ref] */
 
1073
        } in;
 
1074
 
 
1075
        struct {
 
1076
                struct netr_Credential *return_credentials;/* [ref] */
 
1077
                NTSTATUS result;
 
1078
        } out;
 
1079
 
 
1080
};
 
1081
 
 
1082
 
 
1083
struct netr_ServerAuthenticate {
 
1084
        struct {
 
1085
                const char *server_name;/* [unique,charset(UTF16)] */
 
1086
                const char *account_name;/* [charset(UTF16)] */
 
1087
                enum netr_SchannelType secure_channel_type;
 
1088
                const char *computer_name;/* [charset(UTF16)] */
 
1089
                struct netr_Credential *credentials;/* [ref] */
 
1090
        } in;
 
1091
 
 
1092
        struct {
 
1093
                struct netr_Credential *return_credentials;/* [ref] */
 
1094
                NTSTATUS result;
 
1095
        } out;
 
1096
 
 
1097
};
 
1098
 
 
1099
 
 
1100
struct netr_ServerPasswordSet {
 
1101
        struct {
 
1102
                const char *server_name;/* [unique,charset(UTF16)] */
 
1103
                const char *account_name;/* [charset(UTF16)] */
 
1104
                enum netr_SchannelType secure_channel_type;
 
1105
                const char *computer_name;/* [charset(UTF16)] */
 
1106
                struct netr_Authenticator *credential;/* [ref] */
 
1107
                struct samr_Password *new_password;/* [ref] */
 
1108
        } in;
 
1109
 
 
1110
        struct {
 
1111
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1112
                NTSTATUS result;
 
1113
        } out;
 
1114
 
 
1115
};
 
1116
 
 
1117
 
 
1118
struct netr_DatabaseDeltas {
 
1119
        struct {
 
1120
                const char *logon_server;/* [charset(UTF16)] */
 
1121
                const char *computername;/* [charset(UTF16)] */
 
1122
                struct netr_Authenticator *credential;/* [ref] */
 
1123
                enum netr_SamDatabaseID database_id;
 
1124
                uint32_t preferredmaximumlength;
 
1125
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1126
                uint64_t *sequence_num;/* [ref] */
 
1127
        } in;
 
1128
 
 
1129
        struct {
 
1130
                struct netr_DELTA_ENUM_ARRAY **delta_enum_array;/* [ref] */
 
1131
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1132
                uint64_t *sequence_num;/* [ref] */
 
1133
                NTSTATUS result;
 
1134
        } out;
 
1135
 
 
1136
};
 
1137
 
 
1138
 
 
1139
struct netr_DatabaseSync {
 
1140
        struct {
 
1141
                const char *logon_server;/* [charset(UTF16)] */
 
1142
                const char *computername;/* [charset(UTF16)] */
 
1143
                struct netr_Authenticator *credential;/* [ref] */
 
1144
                enum netr_SamDatabaseID database_id;
 
1145
                uint32_t preferredmaximumlength;
 
1146
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1147
                uint32_t *sync_context;/* [ref] */
 
1148
        } in;
 
1149
 
 
1150
        struct {
 
1151
                struct netr_DELTA_ENUM_ARRAY **delta_enum_array;/* [ref] */
 
1152
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1153
                uint32_t *sync_context;/* [ref] */
 
1154
                NTSTATUS result;
 
1155
        } out;
 
1156
 
 
1157
};
 
1158
 
 
1159
 
 
1160
struct netr_AccountDeltas {
 
1161
        struct {
 
1162
                const char *logon_server;/* [unique,charset(UTF16)] */
 
1163
                const char *computername;/* [charset(UTF16)] */
 
1164
                struct netr_Authenticator credential;
 
1165
                struct netr_UAS_INFO_0 uas;
 
1166
                uint32_t count;
 
1167
                uint32_t level;
 
1168
                uint32_t buffersize;
 
1169
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1170
        } in;
 
1171
 
 
1172
        struct {
 
1173
                struct netr_AccountBuffer *buffer;/* [ref,subcontext(4)] */
 
1174
                uint32_t *count_returned;/* [ref] */
 
1175
                uint32_t *total_entries;/* [ref] */
 
1176
                struct netr_UAS_INFO_0 *recordid;/* [ref] */
 
1177
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1178
                NTSTATUS result;
 
1179
        } out;
 
1180
 
 
1181
};
 
1182
 
 
1183
 
 
1184
struct netr_AccountSync {
 
1185
        struct {
 
1186
                const char *logon_server;/* [unique,charset(UTF16)] */
 
1187
                const char *computername;/* [charset(UTF16)] */
 
1188
                struct netr_Authenticator credential;
 
1189
                uint32_t reference;
 
1190
                uint32_t level;
 
1191
                uint32_t buffersize;
 
1192
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1193
                struct netr_UAS_INFO_0 *recordid;/* [ref] */
 
1194
        } in;
 
1195
 
 
1196
        struct {
 
1197
                struct netr_AccountBuffer *buffer;/* [ref,subcontext(4)] */
 
1198
                uint32_t *count_returned;/* [ref] */
 
1199
                uint32_t *total_entries;/* [ref] */
 
1200
                uint32_t *next_reference;/* [ref] */
 
1201
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1202
                struct netr_UAS_INFO_0 *recordid;/* [ref] */
 
1203
                NTSTATUS result;
 
1204
        } out;
 
1205
 
 
1206
};
 
1207
 
 
1208
 
 
1209
struct netr_GetDcName {
 
1210
        struct {
 
1211
                const char *logon_server;/* [charset(UTF16)] */
 
1212
                const char *domainname;/* [unique,charset(UTF16)] */
 
1213
        } in;
 
1214
 
 
1215
        struct {
 
1216
                const char **dcname;/* [ref,charset(UTF16)] */
 
1217
                WERROR result;
 
1218
        } out;
 
1219
 
 
1220
};
 
1221
 
 
1222
 
 
1223
struct netr_LogonControl {
 
1224
        struct {
 
1225
                const char *logon_server;/* [unique,charset(UTF16)] */
 
1226
                enum netr_LogonControlCode function_code;
 
1227
                uint32_t level;
 
1228
        } in;
 
1229
 
 
1230
        struct {
 
1231
                union netr_CONTROL_QUERY_INFORMATION *info;/* [ref,switch_is(level)] */
 
1232
                WERROR result;
 
1233
        } out;
 
1234
 
 
1235
};
 
1236
 
 
1237
 
 
1238
struct netr_GetAnyDCName {
 
1239
        struct {
 
1240
                const char *logon_server;/* [unique,charset(UTF16)] */
 
1241
                const char *domainname;/* [unique,charset(UTF16)] */
 
1242
        } in;
 
1243
 
 
1244
        struct {
 
1245
                const char **dcname;/* [ref,charset(UTF16)] */
 
1246
                WERROR result;
 
1247
        } out;
 
1248
 
 
1249
};
 
1250
 
 
1251
 
 
1252
struct netr_LogonControl2 {
 
1253
        struct {
 
1254
                const char *logon_server;/* [unique,charset(UTF16)] */
 
1255
                enum netr_LogonControlCode function_code;
 
1256
                uint32_t level;
 
1257
                union netr_CONTROL_DATA_INFORMATION *data;/* [ref,switch_is(function_code)] */
 
1258
        } in;
 
1259
 
 
1260
        struct {
 
1261
                union netr_CONTROL_QUERY_INFORMATION *query;/* [ref,switch_is(level)] */
 
1262
                WERROR result;
 
1263
        } out;
 
1264
 
 
1265
};
 
1266
 
 
1267
 
 
1268
struct netr_ServerAuthenticate2 {
 
1269
        struct {
 
1270
                const char *server_name;/* [unique,charset(UTF16)] */
 
1271
                const char *account_name;/* [charset(UTF16)] */
 
1272
                enum netr_SchannelType secure_channel_type;
 
1273
                const char *computer_name;/* [charset(UTF16)] */
 
1274
                struct netr_Credential *credentials;/* [ref] */
 
1275
                uint32_t *negotiate_flags;/* [ref] */
 
1276
        } in;
 
1277
 
 
1278
        struct {
 
1279
                struct netr_Credential *return_credentials;/* [ref] */
 
1280
                uint32_t *negotiate_flags;/* [ref] */
 
1281
                NTSTATUS result;
 
1282
        } out;
 
1283
 
 
1284
};
 
1285
 
 
1286
 
 
1287
struct netr_DatabaseSync2 {
 
1288
        struct {
 
1289
                const char *logon_server;/* [charset(UTF16)] */
 
1290
                const char *computername;/* [charset(UTF16)] */
 
1291
                struct netr_Authenticator *credential;/* [ref] */
 
1292
                enum netr_SamDatabaseID database_id;
 
1293
                uint16_t restart_state;
 
1294
                uint32_t preferredmaximumlength;
 
1295
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1296
                uint32_t *sync_context;/* [ref] */
 
1297
        } in;
 
1298
 
 
1299
        struct {
 
1300
                struct netr_DELTA_ENUM_ARRAY **delta_enum_array;/* [ref] */
 
1301
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1302
                uint32_t *sync_context;/* [ref] */
 
1303
                NTSTATUS result;
 
1304
        } out;
 
1305
 
 
1306
};
 
1307
 
 
1308
 
 
1309
struct netr_DatabaseRedo {
 
1310
        struct {
 
1311
                const char *logon_server;/* [charset(UTF16)] */
 
1312
                const char *computername;/* [charset(UTF16)] */
 
1313
                struct netr_Authenticator *credential;/* [ref] */
 
1314
                struct netr_ChangeLogEntry change_log_entry;/* [subcontext_size(change_log_entry_size),subcontext(4)] */
 
1315
                uint32_t change_log_entry_size;/* [value(ndr_size_netr_ChangeLogEntry(&change_log_entry,ndr->iconv_convenience,ndr->flags))] */
 
1316
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1317
        } in;
 
1318
 
 
1319
        struct {
 
1320
                struct netr_DELTA_ENUM_ARRAY **delta_enum_array;/* [ref] */
 
1321
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1322
                NTSTATUS result;
 
1323
        } out;
 
1324
 
 
1325
};
 
1326
 
 
1327
 
 
1328
struct netr_LogonControl2Ex {
 
1329
        struct {
 
1330
                const char *logon_server;/* [unique,charset(UTF16)] */
 
1331
                enum netr_LogonControlCode function_code;
 
1332
                uint32_t level;
 
1333
                union netr_CONTROL_DATA_INFORMATION *data;/* [ref,switch_is(function_code)] */
 
1334
        } in;
 
1335
 
 
1336
        struct {
 
1337
                union netr_CONTROL_QUERY_INFORMATION *query;/* [ref,switch_is(level)] */
 
1338
                WERROR result;
 
1339
        } out;
 
1340
 
 
1341
};
 
1342
 
 
1343
 
 
1344
struct netr_NetrEnumerateTrustedDomains {
 
1345
        struct {
 
1346
                const char *server_name;/* [unique,charset(UTF16)] */
 
1347
        } in;
 
1348
 
 
1349
        struct {
 
1350
                struct netr_Blob *trusted_domains_blob;/* [ref] */
 
1351
                WERROR result;
 
1352
        } out;
 
1353
 
 
1354
};
 
1355
 
 
1356
 
 
1357
struct netr_DsRGetDCName {
 
1358
        struct {
 
1359
                const char *server_unc;/* [unique,charset(UTF16)] */
 
1360
                const char *domain_name;/* [unique,charset(UTF16)] */
 
1361
                struct GUID *domain_guid;/* [unique] */
 
1362
                struct GUID *site_guid;/* [unique] */
 
1363
                uint32_t flags;
 
1364
        } in;
 
1365
 
 
1366
        struct {
 
1367
                struct netr_DsRGetDCNameInfo **info;/* [ref] */
 
1368
                WERROR result;
 
1369
        } out;
 
1370
 
 
1371
};
 
1372
 
 
1373
 
 
1374
struct netr_LogonGetCapabilities {
 
1375
        struct {
 
1376
                const char *server_name;/* [charset(UTF16)] */
 
1377
                const char *computer_name;/* [unique,charset(UTF16)] */
 
1378
                struct netr_Authenticator *credential;/* [ref] */
 
1379
                uint32_t query_level;
 
1380
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1381
        } in;
 
1382
 
 
1383
        struct {
 
1384
                union netr_Capabilities *capabilities;/* [ref,switch_is(query_level)] */
 
1385
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1386
                NTSTATUS result;
 
1387
        } out;
 
1388
 
 
1389
};
 
1390
 
 
1391
 
 
1392
struct netr_NETRLOGONSETSERVICEBITS {
 
1393
        struct {
 
1394
                WERROR result;
 
1395
        } out;
 
1396
 
 
1397
};
 
1398
 
 
1399
 
 
1400
struct netr_LogonGetTrustRid {
 
1401
        struct {
 
1402
                const char *server_name;/* [unique,charset(UTF16)] */
 
1403
                const char *domain_name;/* [unique,charset(UTF16)] */
 
1404
        } in;
 
1405
 
 
1406
        struct {
 
1407
                uint32_t *rid;/* [ref] */
 
1408
                WERROR result;
 
1409
        } out;
 
1410
 
 
1411
};
 
1412
 
 
1413
 
 
1414
struct netr_NETRLOGONCOMPUTESERVERDIGEST {
 
1415
        struct {
 
1416
                WERROR result;
 
1417
        } out;
 
1418
 
 
1419
};
 
1420
 
 
1421
 
 
1422
struct netr_NETRLOGONCOMPUTECLIENTDIGEST {
 
1423
        struct {
 
1424
                WERROR result;
 
1425
        } out;
 
1426
 
 
1427
};
 
1428
 
 
1429
 
 
1430
struct netr_ServerAuthenticate3 {
 
1431
        struct {
 
1432
                const char *server_name;/* [unique,charset(UTF16)] */
 
1433
                const char *account_name;/* [charset(UTF16)] */
 
1434
                enum netr_SchannelType secure_channel_type;
 
1435
                const char *computer_name;/* [charset(UTF16)] */
 
1436
                struct netr_Credential *credentials;/* [ref] */
 
1437
                uint32_t *negotiate_flags;/* [ref] */
 
1438
        } in;
 
1439
 
 
1440
        struct {
 
1441
                struct netr_Credential *return_credentials;/* [ref] */
 
1442
                uint32_t *rid;/* [ref] */
 
1443
                uint32_t *negotiate_flags;/* [ref] */
 
1444
                NTSTATUS result;
 
1445
        } out;
 
1446
 
 
1447
};
 
1448
 
 
1449
 
 
1450
struct netr_DsRGetDCNameEx {
 
1451
        struct {
 
1452
                const char *server_unc;/* [unique,charset(UTF16)] */
 
1453
                const char *domain_name;/* [unique,charset(UTF16)] */
 
1454
                struct GUID *domain_guid;/* [unique] */
 
1455
                const char *site_name;/* [unique,charset(UTF16)] */
 
1456
                uint32_t flags;
 
1457
        } in;
 
1458
 
 
1459
        struct {
 
1460
                struct netr_DsRGetDCNameInfo **info;/* [ref] */
 
1461
                WERROR result;
 
1462
        } out;
 
1463
 
 
1464
};
 
1465
 
 
1466
 
 
1467
struct netr_DsRGetSiteName {
 
1468
        struct {
 
1469
                const char *computer_name;/* [unique,charset(UTF16)] */
 
1470
        } in;
 
1471
 
 
1472
        struct {
 
1473
                const char **site;/* [ref,charset(UTF16)] */
 
1474
                WERROR result;
 
1475
        } out;
 
1476
 
 
1477
};
 
1478
 
 
1479
 
 
1480
struct netr_LogonGetDomainInfo {
 
1481
        struct {
 
1482
                const char *server_name;/* [charset(UTF16)] */
 
1483
                const char *computer_name;/* [unique,charset(UTF16)] */
 
1484
                struct netr_Authenticator *credential;/* [ref] */
 
1485
                uint32_t level;
 
1486
                union netr_DomainQuery query;/* [switch_is(level)] */
 
1487
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1488
        } in;
 
1489
 
 
1490
        struct {
 
1491
                union netr_DomainInfo *info;/* [ref,switch_is(level)] */
 
1492
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1493
                NTSTATUS result;
 
1494
        } out;
 
1495
 
 
1496
};
 
1497
 
 
1498
 
 
1499
struct netr_ServerPasswordSet2 {
 
1500
        struct {
 
1501
                const char *server_name;/* [unique,charset(UTF16)] */
 
1502
                const char *account_name;/* [charset(UTF16)] */
 
1503
                enum netr_SchannelType secure_channel_type;
 
1504
                const char *computer_name;/* [charset(UTF16)] */
 
1505
                struct netr_Authenticator *credential;/* [ref] */
 
1506
                struct netr_CryptPassword *new_password;/* [ref] */
 
1507
        } in;
 
1508
 
 
1509
        struct {
 
1510
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1511
                NTSTATUS result;
 
1512
        } out;
 
1513
 
 
1514
};
 
1515
 
 
1516
 
 
1517
struct netr_ServerPasswordGet {
 
1518
        struct {
 
1519
                const char *server_name;/* [unique,charset(UTF16)] */
 
1520
                const char *account_name;/* [charset(UTF16)] */
 
1521
                enum netr_SchannelType secure_channel_type;
 
1522
                const char *computer_name;/* [charset(UTF16)] */
 
1523
                struct netr_Authenticator *credential;/* [ref] */
 
1524
        } in;
 
1525
 
 
1526
        struct {
 
1527
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1528
                struct samr_Password *password;/* [ref] */
 
1529
                WERROR result;
 
1530
        } out;
 
1531
 
 
1532
};
 
1533
 
 
1534
 
 
1535
struct netr_NETRLOGONSENDTOSAM {
 
1536
        struct {
 
1537
                WERROR result;
 
1538
        } out;
 
1539
 
 
1540
};
 
1541
 
 
1542
 
 
1543
struct netr_DsRAddressToSitenamesW {
 
1544
        struct {
 
1545
                const char *server_name;/* [unique,charset(UTF16)] */
 
1546
                uint32_t count;/* [range(0,32000)] */
 
1547
                struct netr_DsRAddress *addresses;/* [ref,size_is(count)] */
 
1548
        } in;
 
1549
 
 
1550
        struct {
 
1551
                struct netr_DsRAddressToSitenamesWCtr **ctr;/* [ref] */
 
1552
                WERROR result;
 
1553
        } out;
 
1554
 
 
1555
};
 
1556
 
 
1557
 
 
1558
struct netr_DsRGetDCNameEx2 {
 
1559
        struct {
 
1560
                const char *server_unc;/* [unique,charset(UTF16)] */
 
1561
                const char *client_account;/* [unique,charset(UTF16)] */
 
1562
                uint32_t mask;
 
1563
                const char *domain_name;/* [unique,charset(UTF16)] */
 
1564
                struct GUID *domain_guid;/* [unique] */
 
1565
                const char *site_name;/* [unique,charset(UTF16)] */
 
1566
                uint32_t flags;
 
1567
        } in;
 
1568
 
 
1569
        struct {
 
1570
                struct netr_DsRGetDCNameInfo **info;/* [ref] */
 
1571
                WERROR result;
 
1572
        } out;
 
1573
 
 
1574
};
 
1575
 
 
1576
 
 
1577
struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN {
 
1578
        struct {
 
1579
                WERROR result;
 
1580
        } out;
 
1581
 
 
1582
};
 
1583
 
 
1584
 
 
1585
struct netr_NetrEnumerateTrustedDomainsEx {
 
1586
        struct {
 
1587
                const char *server_name;/* [unique,charset(UTF16)] */
 
1588
        } in;
 
1589
 
 
1590
        struct {
 
1591
                struct netr_DomainTrustList *dom_trust_list;/* [ref] */
 
1592
                WERROR result;
 
1593
        } out;
 
1594
 
 
1595
};
 
1596
 
 
1597
 
 
1598
struct netr_DsRAddressToSitenamesExW {
 
1599
        struct {
 
1600
                const char *server_name;/* [unique,charset(UTF16)] */
 
1601
                uint32_t count;/* [range(0,32000)] */
 
1602
                struct netr_DsRAddress *addresses;/* [ref,size_is(count)] */
 
1603
        } in;
 
1604
 
 
1605
        struct {
 
1606
                struct netr_DsRAddressToSitenamesExWCtr **ctr;/* [ref] */
 
1607
                WERROR result;
 
1608
        } out;
 
1609
 
 
1610
};
 
1611
 
 
1612
 
 
1613
struct netr_DsrGetDcSiteCoverageW {
 
1614
        struct {
 
1615
                const char *server_name;/* [unique,charset(UTF16)] */
 
1616
        } in;
 
1617
 
 
1618
        struct {
 
1619
                struct DcSitesCtr **ctr;/* [ref] */
 
1620
                WERROR result;
 
1621
        } out;
 
1622
 
 
1623
};
 
1624
 
 
1625
 
 
1626
struct netr_LogonSamLogonEx {
 
1627
        struct {
 
1628
                const char *server_name;/* [unique,charset(UTF16)] */
 
1629
                const char *computer_name;/* [unique,charset(UTF16)] */
 
1630
                enum netr_LogonInfoClass logon_level;
 
1631
                union netr_LogonLevel *logon;/* [ref,switch_is(logon_level)] */
 
1632
                uint16_t validation_level;
 
1633
                uint32_t *flags;/* [ref] */
 
1634
        } in;
 
1635
 
 
1636
        struct {
 
1637
                union netr_Validation *validation;/* [ref,switch_is(validation_level)] */
 
1638
                uint8_t *authoritative;/* [ref] */
 
1639
                uint32_t *flags;/* [ref] */
 
1640
                NTSTATUS result;
 
1641
        } out;
 
1642
 
 
1643
};
 
1644
 
 
1645
 
 
1646
struct netr_DsrEnumerateDomainTrusts {
 
1647
        struct {
 
1648
                const char *server_name;/* [unique,charset(UTF16)] */
 
1649
                uint32_t trust_flags;
 
1650
        } in;
 
1651
 
 
1652
        struct {
 
1653
                struct netr_DomainTrustList *trusts;/* [ref] */
 
1654
                WERROR result;
 
1655
        } out;
 
1656
 
 
1657
};
 
1658
 
 
1659
 
 
1660
struct netr_DsrDeregisterDNSHostRecords {
 
1661
        struct {
 
1662
                const char *server_name;/* [unique,charset(UTF16)] */
 
1663
                const char *domain;/* [unique,charset(UTF16)] */
 
1664
                struct GUID *domain_guid;/* [unique] */
 
1665
                struct GUID *dsa_guid;/* [unique] */
 
1666
                const char *dns_host;/* [ref,charset(UTF16)] */
 
1667
        } in;
 
1668
 
 
1669
        struct {
 
1670
                WERROR result;
 
1671
        } out;
 
1672
 
 
1673
};
 
1674
 
 
1675
 
 
1676
struct netr_ServerTrustPasswordsGet {
 
1677
        struct {
 
1678
                const char *server_name;/* [unique,charset(UTF16)] */
 
1679
                const char *account_name;/* [charset(UTF16)] */
 
1680
                enum netr_SchannelType secure_channel_type;
 
1681
                const char *computer_name;/* [charset(UTF16)] */
 
1682
                struct netr_Authenticator *credential;/* [ref] */
 
1683
        } in;
 
1684
 
 
1685
        struct {
 
1686
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1687
                struct samr_Password *password;/* [ref] */
 
1688
                struct samr_Password *password2;/* [ref] */
 
1689
                NTSTATUS result;
 
1690
        } out;
 
1691
 
 
1692
};
 
1693
 
 
1694
 
 
1695
struct netr_DsRGetForestTrustInformation {
 
1696
        struct {
 
1697
                const char *server_name;/* [unique,charset(UTF16)] */
 
1698
                const char *trusted_domain_name;/* [unique,charset(UTF16)] */
 
1699
                uint32_t flags;
 
1700
        } in;
 
1701
 
 
1702
        struct {
 
1703
                struct lsa_ForestTrustInformation **forest_trust_info;/* [ref] */
 
1704
                WERROR result;
 
1705
        } out;
 
1706
 
 
1707
};
 
1708
 
 
1709
 
 
1710
struct netr_GetForestTrustInformation {
 
1711
        struct {
 
1712
                const char *server_name;/* [unique,charset(UTF16)] */
 
1713
                const char *trusted_domain_name;/* [ref,charset(UTF16)] */
 
1714
                struct netr_Authenticator *credential;/* [ref] */
 
1715
                uint32_t flags;
 
1716
        } in;
 
1717
 
 
1718
        struct {
 
1719
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1720
                struct lsa_ForestTrustInformation **forest_trust_info;/* [ref] */
 
1721
                WERROR result;
 
1722
        } out;
 
1723
 
 
1724
};
 
1725
 
 
1726
 
 
1727
struct netr_LogonSamLogonWithFlags {
 
1728
        struct {
 
1729
                const char *server_name;/* [unique,charset(UTF16)] */
 
1730
                const char *computer_name;/* [unique,charset(UTF16)] */
 
1731
                struct netr_Authenticator *credential;/* [unique] */
 
1732
                enum netr_LogonInfoClass logon_level;
 
1733
                union netr_LogonLevel *logon;/* [ref,switch_is(logon_level)] */
 
1734
                uint16_t validation_level;
 
1735
                struct netr_Authenticator *return_authenticator;/* [unique] */
 
1736
                uint32_t *flags;/* [ref] */
 
1737
        } in;
 
1738
 
 
1739
        struct {
 
1740
                union netr_Validation *validation;/* [ref,switch_is(validation_level)] */
 
1741
                uint8_t *authoritative;/* [ref] */
 
1742
                struct netr_Authenticator *return_authenticator;/* [unique] */
 
1743
                uint32_t *flags;/* [ref] */
 
1744
                NTSTATUS result;
 
1745
        } out;
 
1746
 
 
1747
};
 
1748
 
 
1749
 
 
1750
struct netr_ServerGetTrustInfo {
 
1751
        struct {
 
1752
                const char *server_name;/* [unique,charset(UTF16)] */
 
1753
                const char *account_name;/* [ref,charset(UTF16)] */
 
1754
                enum netr_SchannelType secure_channel_type;
 
1755
                const char *computer_name;/* [ref,charset(UTF16)] */
 
1756
                struct netr_Authenticator *credential;/* [ref] */
 
1757
        } in;
 
1758
 
 
1759
        struct {
 
1760
                struct netr_Authenticator *return_authenticator;/* [ref] */
 
1761
                struct samr_Password *new_owf_password;/* [ref] */
 
1762
                struct samr_Password *old_owf_password;/* [ref] */
 
1763
                struct netr_TrustInfo **trust_info;/* [ref] */
 
1764
                NTSTATUS result;
 
1765
        } out;
 
1766
 
 
1767
};
 
1768
 
 
1769
#endif /* _HEADER_netlogon */