← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/samba/oneiric-security

« back to all changes in this revision

Viewing changes to .pc/fix-windows7-print-connection.patch/librpc/gen_ndr/netlogon.h

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2011-03-10 10:03:01 UTC
  • mfrom: (0.39.11 sid)
  • Revision ID: james.westby@ubuntu.com-20110310100301-jfjg41wv0iq05zj4
Tags: 2:3.5.8~dfsg-1ubuntu1
https://launchpad.net/bugs/639768
* Merge from debian unstable.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access. 
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/mksmbpasswd.awk:
    - Do not add user with UID less than 1000 to smbpasswd
  + debian/control:
    - Make libwbclient0 replace/conflict with hardy's likewise-open.
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
    - Add cuups breaks to push the package to aslo upgrade cups (LP: #639768)
  + debian/rules:
    - enable "native" PIE hardening.
    - Add BIND_NOW to maximize benefit of RELRO hardening.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
    - Don't ship the /etc/network/if-up.d file.
  + debian/samba.postinst: 
    - Fixed bashism.
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/samba.logrotate: Make it upstart compatible
  + debian/samba-common.dhcp: Fix typo to get a proper parsing in
    /etc/samba/dhcp.
  + Dropped:
    - debian/patches/fix-windows7-print-connection.patch: Merged upstream.
    - debian/patches/security-CVE-2011-0719.patch: Merged upstream. 

Show diffs side-by-side

added added

removed removed

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