← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/ndr_samr.c

  • 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/ndr_samr.c
 
1
/* parser auto-generated by pidl */
 
2
 
 
3
#include "includes.h"
 
4
#include "../librpc/gen_ndr/ndr_samr.h"
 
5
 
 
6
#include "librpc/gen_ndr/ndr_misc.h"
 
7
#include "librpc/gen_ndr/ndr_lsa.h"
 
8
#include "librpc/gen_ndr/ndr_security.h"
 
9
_PUBLIC_ enum ndr_err_code ndr_push_netr_SamDatabaseID(struct ndr_push *ndr, int ndr_flags, enum netr_SamDatabaseID r)
 
10
{
 
11
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
12
        return NDR_ERR_SUCCESS;
 
13
}
 
14
 
 
15
_PUBLIC_ enum ndr_err_code ndr_pull_netr_SamDatabaseID(struct ndr_pull *ndr, int ndr_flags, enum netr_SamDatabaseID *r)
 
16
{
 
17
        uint32_t v;
 
18
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
19
        *r = v;
 
20
        return NDR_ERR_SUCCESS;
 
21
}
 
22
 
 
23
_PUBLIC_ void ndr_print_netr_SamDatabaseID(struct ndr_print *ndr, const char *name, enum netr_SamDatabaseID r)
 
24
{
 
25
        const char *val = NULL;
 
26
 
 
27
        switch (r) {
 
28
                case SAM_DATABASE_DOMAIN: val = "SAM_DATABASE_DOMAIN"; break;
 
29
                case SAM_DATABASE_BUILTIN: val = "SAM_DATABASE_BUILTIN"; break;
 
30
                case SAM_DATABASE_PRIVS: val = "SAM_DATABASE_PRIVS"; break;
 
31
        }
 
32
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
33
}
 
34
 
 
35
_PUBLIC_ enum ndr_err_code ndr_push_samr_RejectReason(struct ndr_push *ndr, int ndr_flags, enum samr_RejectReason r)
 
36
{
 
37
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
38
        return NDR_ERR_SUCCESS;
 
39
}
 
40
 
 
41
_PUBLIC_ enum ndr_err_code ndr_pull_samr_RejectReason(struct ndr_pull *ndr, int ndr_flags, enum samr_RejectReason *r)
 
42
{
 
43
        uint32_t v;
 
44
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
45
        *r = v;
 
46
        return NDR_ERR_SUCCESS;
 
47
}
 
48
 
 
49
_PUBLIC_ void ndr_print_samr_RejectReason(struct ndr_print *ndr, const char *name, enum samr_RejectReason r)
 
50
{
 
51
        const char *val = NULL;
 
52
 
 
53
        switch (r) {
 
54
                case SAMR_REJECT_OTHER: val = "SAMR_REJECT_OTHER"; break;
 
55
                case SAMR_REJECT_TOO_SHORT: val = "SAMR_REJECT_TOO_SHORT"; break;
 
56
                case SAMR_REJECT_IN_HISTORY: val = "SAMR_REJECT_IN_HISTORY"; break;
 
57
                case SAMR_REJECT_COMPLEXITY: val = "SAMR_REJECT_COMPLEXITY"; break;
 
58
        }
 
59
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
60
}
 
61
 
 
62
_PUBLIC_ enum ndr_err_code ndr_push_samr_AcctFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
63
{
 
64
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
65
        return NDR_ERR_SUCCESS;
 
66
}
 
67
 
 
68
_PUBLIC_ enum ndr_err_code ndr_pull_samr_AcctFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
69
{
 
70
        uint32_t v;
 
71
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
72
        *r = v;
 
73
        return NDR_ERR_SUCCESS;
 
74
}
 
75
 
 
76
_PUBLIC_ void ndr_print_samr_AcctFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 
77
{
 
78
        ndr_print_uint32(ndr, name, r);
 
79
        ndr->depth++;
 
80
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DISABLED", ACB_DISABLED, r);
 
81
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_HOMDIRREQ", ACB_HOMDIRREQ, r);
 
82
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PWNOTREQ", ACB_PWNOTREQ, r);
 
83
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TEMPDUP", ACB_TEMPDUP, r);
 
84
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NORMAL", ACB_NORMAL, r);
 
85
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_MNS", ACB_MNS, r);
 
86
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DOMTRUST", ACB_DOMTRUST, r);
 
87
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_WSTRUST", ACB_WSTRUST, r);
 
88
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_SVRTRUST", ACB_SVRTRUST, r);
 
89
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PWNOEXP", ACB_PWNOEXP, r);
 
90
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_AUTOLOCK", ACB_AUTOLOCK, r);
 
91
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_ENC_TXT_PWD_ALLOWED", ACB_ENC_TXT_PWD_ALLOWED, r);
 
92
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_SMARTCARD_REQUIRED", ACB_SMARTCARD_REQUIRED, r);
 
93
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TRUSTED_FOR_DELEGATION", ACB_TRUSTED_FOR_DELEGATION, r);
 
94
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NOT_DELEGATED", ACB_NOT_DELEGATED, r);
 
95
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_USE_DES_KEY_ONLY", ACB_USE_DES_KEY_ONLY, r);
 
96
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DONT_REQUIRE_PREAUTH", ACB_DONT_REQUIRE_PREAUTH, r);
 
97
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PW_EXPIRED", ACB_PW_EXPIRED, r);
 
98
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NO_AUTH_DATA_REQD", ACB_NO_AUTH_DATA_REQD, r);
 
99
        ndr->depth--;
 
100
}
 
101
 
 
102
static enum ndr_err_code ndr_push_samr_ConnectAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
103
{
 
104
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
105
        return NDR_ERR_SUCCESS;
 
106
}
 
107
 
 
108
static enum ndr_err_code ndr_pull_samr_ConnectAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
109
{
 
110
        uint32_t v;
 
111
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
112
        *r = v;
 
113
        return NDR_ERR_SUCCESS;
 
114
}
 
115
 
 
116
_PUBLIC_ void ndr_print_samr_ConnectAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 
117
{
 
118
        ndr_print_uint32(ndr, name, r);
 
119
        ndr->depth++;
 
120
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_CONNECT_TO_SERVER", SAMR_ACCESS_CONNECT_TO_SERVER, r);
 
121
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_SHUTDOWN_SERVER", SAMR_ACCESS_SHUTDOWN_SERVER, r);
 
122
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_INITIALIZE_SERVER", SAMR_ACCESS_INITIALIZE_SERVER, r);
 
123
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_CREATE_DOMAIN", SAMR_ACCESS_CREATE_DOMAIN, r);
 
124
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_ENUM_DOMAINS", SAMR_ACCESS_ENUM_DOMAINS, r);
 
125
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_LOOKUP_DOMAIN", SAMR_ACCESS_LOOKUP_DOMAIN, r);
 
126
        ndr->depth--;
 
127
}
 
128
 
 
129
static enum ndr_err_code ndr_push_samr_UserAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
130
{
 
131
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
132
        return NDR_ERR_SUCCESS;
 
133
}
 
134
 
 
135
static enum ndr_err_code ndr_pull_samr_UserAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
136
{
 
137
        uint32_t v;
 
138
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
139
        *r = v;
 
140
        return NDR_ERR_SUCCESS;
 
141
}
 
142
 
 
143
_PUBLIC_ void ndr_print_samr_UserAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 
144
{
 
145
        ndr_print_uint32(ndr, name, r);
 
146
        ndr->depth++;
 
147
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_NAME_ETC", SAMR_USER_ACCESS_GET_NAME_ETC, r);
 
148
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOCALE", SAMR_USER_ACCESS_GET_LOCALE, r);
 
149
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_LOC_COM", SAMR_USER_ACCESS_SET_LOC_COM, r);
 
150
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOGONINFO", SAMR_USER_ACCESS_GET_LOGONINFO, r);
 
151
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_ATTRIBUTES", SAMR_USER_ACCESS_GET_ATTRIBUTES, r);
 
152
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_ATTRIBUTES", SAMR_USER_ACCESS_SET_ATTRIBUTES, r);
 
153
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_PASSWORD", SAMR_USER_ACCESS_CHANGE_PASSWORD, r);
 
154
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_PASSWORD", SAMR_USER_ACCESS_SET_PASSWORD, r);
 
155
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUPS", SAMR_USER_ACCESS_GET_GROUPS, r);
 
156
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP, r);
 
157
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP, r);
 
158
        ndr->depth--;
 
159
}
 
160
 
 
161
static enum ndr_err_code ndr_push_samr_DomainAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
162
{
 
163
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
164
        return NDR_ERR_SUCCESS;
 
165
}
 
166
 
 
167
static enum ndr_err_code ndr_pull_samr_DomainAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
168
{
 
169
        uint32_t v;
 
170
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
171
        *r = v;
 
172
        return NDR_ERR_SUCCESS;
 
173
}
 
174
 
 
175
_PUBLIC_ void ndr_print_samr_DomainAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 
176
{
 
177
        ndr_print_uint32(ndr, name, r);
 
178
        ndr->depth++;
 
179
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1, r);
 
180
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_1", SAMR_DOMAIN_ACCESS_SET_INFO_1, r);
 
181
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2, r);
 
182
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_2", SAMR_DOMAIN_ACCESS_SET_INFO_2, r);
 
183
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_USER", SAMR_DOMAIN_ACCESS_CREATE_USER, r);
 
184
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_GROUP", SAMR_DOMAIN_ACCESS_CREATE_GROUP, r);
 
185
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_ALIAS", SAMR_DOMAIN_ACCESS_CREATE_ALIAS, r);
 
186
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS", SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS, r);
 
187
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS", SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS, r);
 
188
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT", SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT, r);
 
189
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_3", SAMR_DOMAIN_ACCESS_SET_INFO_3, r);
 
190
        ndr->depth--;
 
191
}
 
192
 
 
193
static enum ndr_err_code ndr_push_samr_GroupAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
194
{
 
195
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
196
        return NDR_ERR_SUCCESS;
 
197
}
 
198
 
 
199
static enum ndr_err_code ndr_pull_samr_GroupAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
200
{
 
201
        uint32_t v;
 
202
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
203
        *r = v;
 
204
        return NDR_ERR_SUCCESS;
 
205
}
 
206
 
 
207
_PUBLIC_ void ndr_print_samr_GroupAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 
208
{
 
209
        ndr_print_uint32(ndr, name, r);
 
210
        ndr->depth++;
 
211
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_LOOKUP_INFO", SAMR_GROUP_ACCESS_LOOKUP_INFO, r);
 
212
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_SET_INFO", SAMR_GROUP_ACCESS_SET_INFO, r);
 
213
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_ADD_MEMBER", SAMR_GROUP_ACCESS_ADD_MEMBER, r);
 
214
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_REMOVE_MEMBER", SAMR_GROUP_ACCESS_REMOVE_MEMBER, r);
 
215
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_GET_MEMBERS", SAMR_GROUP_ACCESS_GET_MEMBERS, r);
 
216
        ndr->depth--;
 
217
}
 
218
 
 
219
static enum ndr_err_code ndr_push_samr_AliasAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
220
{
 
221
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
222
        return NDR_ERR_SUCCESS;
 
223
}
 
224
 
 
225
static enum ndr_err_code ndr_pull_samr_AliasAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
226
{
 
227
        uint32_t v;
 
228
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
229
        *r = v;
 
230
        return NDR_ERR_SUCCESS;
 
231
}
 
232
 
 
233
_PUBLIC_ void ndr_print_samr_AliasAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 
234
{
 
235
        ndr_print_uint32(ndr, name, r);
 
236
        ndr->depth++;
 
237
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_ADD_MEMBER", SAMR_ALIAS_ACCESS_ADD_MEMBER, r);
 
238
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_REMOVE_MEMBER", SAMR_ALIAS_ACCESS_REMOVE_MEMBER, r);
 
239
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_GET_MEMBERS", SAMR_ALIAS_ACCESS_GET_MEMBERS, r);
 
240
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_LOOKUP_INFO", SAMR_ALIAS_ACCESS_LOOKUP_INFO, r);
 
241
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_SET_INFO", SAMR_ALIAS_ACCESS_SET_INFO, r);
 
242
        ndr->depth--;
 
243
}
 
244
 
 
245
static enum ndr_err_code ndr_push_samr_SamEntry(struct ndr_push *ndr, int ndr_flags, const struct samr_SamEntry *r)
 
246
{
 
247
        if (ndr_flags & NDR_SCALARS) {
 
248
                NDR_CHECK(ndr_push_align(ndr, 4));
 
249
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
 
250
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 
251
        }
 
252
        if (ndr_flags & NDR_BUFFERS) {
 
253
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
254
        }
 
255
        return NDR_ERR_SUCCESS;
 
256
}
 
257
 
 
258
static enum ndr_err_code ndr_pull_samr_SamEntry(struct ndr_pull *ndr, int ndr_flags, struct samr_SamEntry *r)
 
259
{
 
260
        if (ndr_flags & NDR_SCALARS) {
 
261
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
262
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
 
263
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 
264
        }
 
265
        if (ndr_flags & NDR_BUFFERS) {
 
266
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
267
        }
 
268
        return NDR_ERR_SUCCESS;
 
269
}
 
270
 
 
271
_PUBLIC_ void ndr_print_samr_SamEntry(struct ndr_print *ndr, const char *name, const struct samr_SamEntry *r)
 
272
{
 
273
        ndr_print_struct(ndr, name, "samr_SamEntry");
 
274
        ndr->depth++;
 
275
        ndr_print_uint32(ndr, "idx", r->idx);
 
276
        ndr_print_lsa_String(ndr, "name", &r->name);
 
277
        ndr->depth--;
 
278
}
 
279
 
 
280
static enum ndr_err_code ndr_push_samr_SamArray(struct ndr_push *ndr, int ndr_flags, const struct samr_SamArray *r)
 
281
{
 
282
        uint32_t cntr_entries_1;
 
283
        if (ndr_flags & NDR_SCALARS) {
 
284
                NDR_CHECK(ndr_push_align(ndr, 4));
 
285
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
286
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
 
287
        }
 
288
        if (ndr_flags & NDR_BUFFERS) {
 
289
                if (r->entries) {
 
290
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
291
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
292
                                NDR_CHECK(ndr_push_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
293
                        }
 
294
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
295
                                NDR_CHECK(ndr_push_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
296
                        }
 
297
                }
 
298
        }
 
299
        return NDR_ERR_SUCCESS;
 
300
}
 
301
 
 
302
static enum ndr_err_code ndr_pull_samr_SamArray(struct ndr_pull *ndr, int ndr_flags, struct samr_SamArray *r)
 
303
{
 
304
        uint32_t _ptr_entries;
 
305
        uint32_t cntr_entries_1;
 
306
        TALLOC_CTX *_mem_save_entries_0;
 
307
        TALLOC_CTX *_mem_save_entries_1;
 
308
        if (ndr_flags & NDR_SCALARS) {
 
309
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
310
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
311
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 
312
                if (_ptr_entries) {
 
313
                        NDR_PULL_ALLOC(ndr, r->entries);
 
314
                } else {
 
315
                        r->entries = NULL;
 
316
                }
 
317
        }
 
318
        if (ndr_flags & NDR_BUFFERS) {
 
319
                if (r->entries) {
 
320
                        _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
321
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
322
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 
323
                        NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
 
324
                        _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
325
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
326
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
327
                                NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
328
                        }
 
329
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
330
                                NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
331
                        }
 
332
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 
333
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 
334
                }
 
335
                if (r->entries) {
 
336
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 
337
                }
 
338
        }
 
339
        return NDR_ERR_SUCCESS;
 
340
}
 
341
 
 
342
_PUBLIC_ void ndr_print_samr_SamArray(struct ndr_print *ndr, const char *name, const struct samr_SamArray *r)
 
343
{
 
344
        uint32_t cntr_entries_1;
 
345
        ndr_print_struct(ndr, name, "samr_SamArray");
 
346
        ndr->depth++;
 
347
        ndr_print_uint32(ndr, "count", r->count);
 
348
        ndr_print_ptr(ndr, "entries", r->entries);
 
349
        ndr->depth++;
 
350
        if (r->entries) {
 
351
                ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 
352
                ndr->depth++;
 
353
                for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 
354
                        char *idx_1=NULL;
 
355
                        if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
 
356
                                ndr_print_samr_SamEntry(ndr, "entries", &r->entries[cntr_entries_1]);
 
357
                                free(idx_1);
 
358
                        }
 
359
                }
 
360
                ndr->depth--;
 
361
        }
 
362
        ndr->depth--;
 
363
        ndr->depth--;
 
364
}
 
365
 
 
366
static enum ndr_err_code ndr_push_samr_Role(struct ndr_push *ndr, int ndr_flags, enum samr_Role r)
 
367
{
 
368
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
369
        return NDR_ERR_SUCCESS;
 
370
}
 
371
 
 
372
static enum ndr_err_code ndr_pull_samr_Role(struct ndr_pull *ndr, int ndr_flags, enum samr_Role *r)
 
373
{
 
374
        uint32_t v;
 
375
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
376
        *r = v;
 
377
        return NDR_ERR_SUCCESS;
 
378
}
 
379
 
 
380
_PUBLIC_ void ndr_print_samr_Role(struct ndr_print *ndr, const char *name, enum samr_Role r)
 
381
{
 
382
        const char *val = NULL;
 
383
 
 
384
        switch (r) {
 
385
                case SAMR_ROLE_STANDALONE: val = "SAMR_ROLE_STANDALONE"; break;
 
386
                case SAMR_ROLE_DOMAIN_MEMBER: val = "SAMR_ROLE_DOMAIN_MEMBER"; break;
 
387
                case SAMR_ROLE_DOMAIN_BDC: val = "SAMR_ROLE_DOMAIN_BDC"; break;
 
388
                case SAMR_ROLE_DOMAIN_PDC: val = "SAMR_ROLE_DOMAIN_PDC"; break;
 
389
        }
 
390
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
391
}
 
392
 
 
393
_PUBLIC_ enum ndr_err_code ndr_push_samr_PasswordProperties(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
394
{
 
395
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
396
        return NDR_ERR_SUCCESS;
 
397
}
 
398
 
 
399
_PUBLIC_ enum ndr_err_code ndr_pull_samr_PasswordProperties(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
400
{
 
401
        uint32_t v;
 
402
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
403
        *r = v;
 
404
        return NDR_ERR_SUCCESS;
 
405
}
 
406
 
 
407
_PUBLIC_ void ndr_print_samr_PasswordProperties(struct ndr_print *ndr, const char *name, uint32_t r)
 
408
{
 
409
        ndr_print_uint32(ndr, name, r);
 
410
        ndr->depth++;
 
411
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_COMPLEX", DOMAIN_PASSWORD_COMPLEX, r);
 
412
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_ANON_CHANGE", DOMAIN_PASSWORD_NO_ANON_CHANGE, r);
 
413
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_CLEAR_CHANGE", DOMAIN_PASSWORD_NO_CLEAR_CHANGE, r);
 
414
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_LOCKOUT_ADMINS", DOMAIN_PASSWORD_LOCKOUT_ADMINS, r);
 
415
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_STORE_CLEARTEXT", DOMAIN_PASSWORD_STORE_CLEARTEXT, r);
 
416
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_REFUSE_PASSWORD_CHANGE", DOMAIN_REFUSE_PASSWORD_CHANGE, r);
 
417
        ndr->depth--;
 
418
}
 
419
 
 
420
static enum ndr_err_code ndr_push_samr_DomainServerState(struct ndr_push *ndr, int ndr_flags, enum samr_DomainServerState r)
 
421
{
 
422
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
423
        return NDR_ERR_SUCCESS;
 
424
}
 
425
 
 
426
static enum ndr_err_code ndr_pull_samr_DomainServerState(struct ndr_pull *ndr, int ndr_flags, enum samr_DomainServerState *r)
 
427
{
 
428
        uint32_t v;
 
429
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
430
        *r = v;
 
431
        return NDR_ERR_SUCCESS;
 
432
}
 
433
 
 
434
_PUBLIC_ void ndr_print_samr_DomainServerState(struct ndr_print *ndr, const char *name, enum samr_DomainServerState r)
 
435
{
 
436
        const char *val = NULL;
 
437
 
 
438
        switch (r) {
 
439
                case DOMAIN_SERVER_ENABLED: val = "DOMAIN_SERVER_ENABLED"; break;
 
440
                case DOMAIN_SERVER_DISABLED: val = "DOMAIN_SERVER_DISABLED"; break;
 
441
        }
 
442
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
443
}
 
444
 
 
445
static enum ndr_err_code ndr_push_samr_DomInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo1 *r)
 
446
{
 
447
        if (ndr_flags & NDR_SCALARS) {
 
448
                NDR_CHECK(ndr_push_align(ndr, 4));
 
449
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
 
450
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->password_history_length));
 
451
                NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
 
452
                NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->max_password_age));
 
453
                NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->min_password_age));
 
454
        }
 
455
        if (ndr_flags & NDR_BUFFERS) {
 
456
        }
 
457
        return NDR_ERR_SUCCESS;
 
458
}
 
459
 
 
460
static enum ndr_err_code ndr_pull_samr_DomInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo1 *r)
 
461
{
 
462
        if (ndr_flags & NDR_SCALARS) {
 
463
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
464
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
 
465
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->password_history_length));
 
466
                NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
 
467
                NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->max_password_age));
 
468
                NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->min_password_age));
 
469
        }
 
470
        if (ndr_flags & NDR_BUFFERS) {
 
471
        }
 
472
        return NDR_ERR_SUCCESS;
 
473
}
 
474
 
 
475
_PUBLIC_ void ndr_print_samr_DomInfo1(struct ndr_print *ndr, const char *name, const struct samr_DomInfo1 *r)
 
476
{
 
477
        ndr_print_struct(ndr, name, "samr_DomInfo1");
 
478
        ndr->depth++;
 
479
        ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
 
480
        ndr_print_uint16(ndr, "password_history_length", r->password_history_length);
 
481
        ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
 
482
        ndr_print_dlong(ndr, "max_password_age", r->max_password_age);
 
483
        ndr_print_dlong(ndr, "min_password_age", r->min_password_age);
 
484
        ndr->depth--;
 
485
}
 
486
 
 
487
static enum ndr_err_code ndr_push_samr_DomGeneralInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation *r)
 
488
{
 
489
        if (ndr_flags & NDR_SCALARS) {
 
490
                NDR_CHECK(ndr_push_align(ndr, 4));
 
491
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 
492
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 
493
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 
494
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 
495
                NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->sequence_num));
 
496
                NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
 
497
                NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 
498
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
 
499
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_users));
 
500
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_groups));
 
501
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_aliases));
 
502
        }
 
503
        if (ndr_flags & NDR_BUFFERS) {
 
504
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 
505
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 
506
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 
507
        }
 
508
        return NDR_ERR_SUCCESS;
 
509
}
 
510
 
 
511
static enum ndr_err_code ndr_pull_samr_DomGeneralInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation *r)
 
512
{
 
513
        if (ndr_flags & NDR_SCALARS) {
 
514
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
515
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 
516
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 
517
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 
518
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 
519
                NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->sequence_num));
 
520
                NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
 
521
                NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 
522
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
 
523
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_users));
 
524
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_groups));
 
525
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_aliases));
 
526
        }
 
527
        if (ndr_flags & NDR_BUFFERS) {
 
528
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 
529
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 
530
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 
531
        }
 
532
        return NDR_ERR_SUCCESS;
 
533
}
 
534
 
 
535
_PUBLIC_ void ndr_print_samr_DomGeneralInformation(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation *r)
 
536
{
 
537
        ndr_print_struct(ndr, name, "samr_DomGeneralInformation");
 
538
        ndr->depth++;
 
539
        ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 
540
        ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 
541
        ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 
542
        ndr_print_lsa_String(ndr, "primary", &r->primary);
 
543
        ndr_print_udlong(ndr, "sequence_num", r->sequence_num);
 
544
        ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);
 
545
        ndr_print_samr_Role(ndr, "role", r->role);
 
546
        ndr_print_uint32(ndr, "unknown3", r->unknown3);
 
547
        ndr_print_uint32(ndr, "num_users", r->num_users);
 
548
        ndr_print_uint32(ndr, "num_groups", r->num_groups);
 
549
        ndr_print_uint32(ndr, "num_aliases", r->num_aliases);
 
550
        ndr->depth--;
 
551
}
 
552
 
 
553
static enum ndr_err_code ndr_push_samr_DomInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo3 *r)
 
554
{
 
555
        if (ndr_flags & NDR_SCALARS) {
 
556
                NDR_CHECK(ndr_push_align(ndr, 4));
 
557
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 
558
        }
 
559
        if (ndr_flags & NDR_BUFFERS) {
 
560
        }
 
561
        return NDR_ERR_SUCCESS;
 
562
}
 
563
 
 
564
static enum ndr_err_code ndr_pull_samr_DomInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo3 *r)
 
565
{
 
566
        if (ndr_flags & NDR_SCALARS) {
 
567
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
568
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 
569
        }
 
570
        if (ndr_flags & NDR_BUFFERS) {
 
571
        }
 
572
        return NDR_ERR_SUCCESS;
 
573
}
 
574
 
 
575
_PUBLIC_ void ndr_print_samr_DomInfo3(struct ndr_print *ndr, const char *name, const struct samr_DomInfo3 *r)
 
576
{
 
577
        ndr_print_struct(ndr, name, "samr_DomInfo3");
 
578
        ndr->depth++;
 
579
        ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 
580
        ndr->depth--;
 
581
}
 
582
 
 
583
static enum ndr_err_code ndr_push_samr_DomOEMInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomOEMInformation *r)
 
584
{
 
585
        if (ndr_flags & NDR_SCALARS) {
 
586
                NDR_CHECK(ndr_push_align(ndr, 4));
 
587
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 
588
        }
 
589
        if (ndr_flags & NDR_BUFFERS) {
 
590
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 
591
        }
 
592
        return NDR_ERR_SUCCESS;
 
593
}
 
594
 
 
595
static enum ndr_err_code ndr_pull_samr_DomOEMInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomOEMInformation *r)
 
596
{
 
597
        if (ndr_flags & NDR_SCALARS) {
 
598
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
599
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 
600
        }
 
601
        if (ndr_flags & NDR_BUFFERS) {
 
602
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 
603
        }
 
604
        return NDR_ERR_SUCCESS;
 
605
}
 
606
 
 
607
_PUBLIC_ void ndr_print_samr_DomOEMInformation(struct ndr_print *ndr, const char *name, const struct samr_DomOEMInformation *r)
 
608
{
 
609
        ndr_print_struct(ndr, name, "samr_DomOEMInformation");
 
610
        ndr->depth++;
 
611
        ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 
612
        ndr->depth--;
 
613
}
 
614
 
 
615
static enum ndr_err_code ndr_push_samr_DomInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo5 *r)
 
616
{
 
617
        if (ndr_flags & NDR_SCALARS) {
 
618
                NDR_CHECK(ndr_push_align(ndr, 4));
 
619
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 
620
        }
 
621
        if (ndr_flags & NDR_BUFFERS) {
 
622
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 
623
        }
 
624
        return NDR_ERR_SUCCESS;
 
625
}
 
626
 
 
627
static enum ndr_err_code ndr_pull_samr_DomInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo5 *r)
 
628
{
 
629
        if (ndr_flags & NDR_SCALARS) {
 
630
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
631
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 
632
        }
 
633
        if (ndr_flags & NDR_BUFFERS) {
 
634
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 
635
        }
 
636
        return NDR_ERR_SUCCESS;
 
637
}
 
638
 
 
639
_PUBLIC_ void ndr_print_samr_DomInfo5(struct ndr_print *ndr, const char *name, const struct samr_DomInfo5 *r)
 
640
{
 
641
        ndr_print_struct(ndr, name, "samr_DomInfo5");
 
642
        ndr->depth++;
 
643
        ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 
644
        ndr->depth--;
 
645
}
 
646
 
 
647
static enum ndr_err_code ndr_push_samr_DomInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo6 *r)
 
648
{
 
649
        if (ndr_flags & NDR_SCALARS) {
 
650
                NDR_CHECK(ndr_push_align(ndr, 4));
 
651
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 
652
        }
 
653
        if (ndr_flags & NDR_BUFFERS) {
 
654
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 
655
        }
 
656
        return NDR_ERR_SUCCESS;
 
657
}
 
658
 
 
659
static enum ndr_err_code ndr_pull_samr_DomInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo6 *r)
 
660
{
 
661
        if (ndr_flags & NDR_SCALARS) {
 
662
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
663
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 
664
        }
 
665
        if (ndr_flags & NDR_BUFFERS) {
 
666
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 
667
        }
 
668
        return NDR_ERR_SUCCESS;
 
669
}
 
670
 
 
671
_PUBLIC_ void ndr_print_samr_DomInfo6(struct ndr_print *ndr, const char *name, const struct samr_DomInfo6 *r)
 
672
{
 
673
        ndr_print_struct(ndr, name, "samr_DomInfo6");
 
674
        ndr->depth++;
 
675
        ndr_print_lsa_String(ndr, "primary", &r->primary);
 
676
        ndr->depth--;
 
677
}
 
678
 
 
679
static enum ndr_err_code ndr_push_samr_DomInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo7 *r)
 
680
{
 
681
        if (ndr_flags & NDR_SCALARS) {
 
682
                NDR_CHECK(ndr_push_align(ndr, 4));
 
683
                NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 
684
        }
 
685
        if (ndr_flags & NDR_BUFFERS) {
 
686
        }
 
687
        return NDR_ERR_SUCCESS;
 
688
}
 
689
 
 
690
static enum ndr_err_code ndr_pull_samr_DomInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo7 *r)
 
691
{
 
692
        if (ndr_flags & NDR_SCALARS) {
 
693
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
694
                NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 
695
        }
 
696
        if (ndr_flags & NDR_BUFFERS) {
 
697
        }
 
698
        return NDR_ERR_SUCCESS;
 
699
}
 
700
 
 
701
_PUBLIC_ void ndr_print_samr_DomInfo7(struct ndr_print *ndr, const char *name, const struct samr_DomInfo7 *r)
 
702
{
 
703
        ndr_print_struct(ndr, name, "samr_DomInfo7");
 
704
        ndr->depth++;
 
705
        ndr_print_samr_Role(ndr, "role", r->role);
 
706
        ndr->depth--;
 
707
}
 
708
 
 
709
static enum ndr_err_code ndr_push_samr_DomInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo8 *r)
 
710
{
 
711
        if (ndr_flags & NDR_SCALARS) {
 
712
                NDR_CHECK(ndr_push_align(ndr, 8));
 
713
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 
714
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 
715
        }
 
716
        if (ndr_flags & NDR_BUFFERS) {
 
717
        }
 
718
        return NDR_ERR_SUCCESS;
 
719
}
 
720
 
 
721
static enum ndr_err_code ndr_pull_samr_DomInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo8 *r)
 
722
{
 
723
        if (ndr_flags & NDR_SCALARS) {
 
724
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
725
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 
726
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 
727
        }
 
728
        if (ndr_flags & NDR_BUFFERS) {
 
729
        }
 
730
        return NDR_ERR_SUCCESS;
 
731
}
 
732
 
 
733
_PUBLIC_ void ndr_print_samr_DomInfo8(struct ndr_print *ndr, const char *name, const struct samr_DomInfo8 *r)
 
734
{
 
735
        ndr_print_struct(ndr, name, "samr_DomInfo8");
 
736
        ndr->depth++;
 
737
        ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 
738
        ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 
739
        ndr->depth--;
 
740
}
 
741
 
 
742
static enum ndr_err_code ndr_push_samr_DomInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo9 *r)
 
743
{
 
744
        if (ndr_flags & NDR_SCALARS) {
 
745
                NDR_CHECK(ndr_push_align(ndr, 4));
 
746
                NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
 
747
        }
 
748
        if (ndr_flags & NDR_BUFFERS) {
 
749
        }
 
750
        return NDR_ERR_SUCCESS;
 
751
}
 
752
 
 
753
static enum ndr_err_code ndr_pull_samr_DomInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo9 *r)
 
754
{
 
755
        if (ndr_flags & NDR_SCALARS) {
 
756
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
757
                NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
 
758
        }
 
759
        if (ndr_flags & NDR_BUFFERS) {
 
760
        }
 
761
        return NDR_ERR_SUCCESS;
 
762
}
 
763
 
 
764
_PUBLIC_ void ndr_print_samr_DomInfo9(struct ndr_print *ndr, const char *name, const struct samr_DomInfo9 *r)
 
765
{
 
766
        ndr_print_struct(ndr, name, "samr_DomInfo9");
 
767
        ndr->depth++;
 
768
        ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);
 
769
        ndr->depth--;
 
770
}
 
771
 
 
772
static enum ndr_err_code ndr_push_samr_DomGeneralInformation2(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation2 *r)
 
773
{
 
774
        if (ndr_flags & NDR_SCALARS) {
 
775
                NDR_CHECK(ndr_push_align(ndr, 8));
 
776
                NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 
777
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 
778
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 
779
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 
780
        }
 
781
        if (ndr_flags & NDR_BUFFERS) {
 
782
                NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 
783
        }
 
784
        return NDR_ERR_SUCCESS;
 
785
}
 
786
 
 
787
static enum ndr_err_code ndr_pull_samr_DomGeneralInformation2(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation2 *r)
 
788
{
 
789
        if (ndr_flags & NDR_SCALARS) {
 
790
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
791
                NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 
792
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 
793
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 
794
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 
795
        }
 
796
        if (ndr_flags & NDR_BUFFERS) {
 
797
                NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 
798
        }
 
799
        return NDR_ERR_SUCCESS;
 
800
}
 
801
 
 
802
_PUBLIC_ void ndr_print_samr_DomGeneralInformation2(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation2 *r)
 
803
{
 
804
        ndr_print_struct(ndr, name, "samr_DomGeneralInformation2");
 
805
        ndr->depth++;
 
806
        ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
 
807
        ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 
808
        ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 
809
        ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 
810
        ndr->depth--;
 
811
}
 
812
 
 
813
static enum ndr_err_code ndr_push_samr_DomInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo12 *r)
 
814
{
 
815
        if (ndr_flags & NDR_SCALARS) {
 
816
                NDR_CHECK(ndr_push_align(ndr, 8));
 
817
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 
818
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 
819
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 
820
        }
 
821
        if (ndr_flags & NDR_BUFFERS) {
 
822
        }
 
823
        return NDR_ERR_SUCCESS;
 
824
}
 
825
 
 
826
static enum ndr_err_code ndr_pull_samr_DomInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo12 *r)
 
827
{
 
828
        if (ndr_flags & NDR_SCALARS) {
 
829
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
830
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 
831
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 
832
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 
833
        }
 
834
        if (ndr_flags & NDR_BUFFERS) {
 
835
        }
 
836
        return NDR_ERR_SUCCESS;
 
837
}
 
838
 
 
839
_PUBLIC_ void ndr_print_samr_DomInfo12(struct ndr_print *ndr, const char *name, const struct samr_DomInfo12 *r)
 
840
{
 
841
        ndr_print_struct(ndr, name, "samr_DomInfo12");
 
842
        ndr->depth++;
 
843
        ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 
844
        ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 
845
        ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 
846
        ndr->depth--;
 
847
}
 
848
 
 
849
static enum ndr_err_code ndr_push_samr_DomInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo13 *r)
 
850
{
 
851
        if (ndr_flags & NDR_SCALARS) {
 
852
                NDR_CHECK(ndr_push_align(ndr, 8));
 
853
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 
854
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 
855
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->modified_count_at_last_promotion));
 
856
        }
 
857
        if (ndr_flags & NDR_BUFFERS) {
 
858
        }
 
859
        return NDR_ERR_SUCCESS;
 
860
}
 
861
 
 
862
static enum ndr_err_code ndr_pull_samr_DomInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo13 *r)
 
863
{
 
864
        if (ndr_flags & NDR_SCALARS) {
 
865
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
866
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 
867
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 
868
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->modified_count_at_last_promotion));
 
869
        }
 
870
        if (ndr_flags & NDR_BUFFERS) {
 
871
        }
 
872
        return NDR_ERR_SUCCESS;
 
873
}
 
874
 
 
875
_PUBLIC_ void ndr_print_samr_DomInfo13(struct ndr_print *ndr, const char *name, const struct samr_DomInfo13 *r)
 
876
{
 
877
        ndr_print_struct(ndr, name, "samr_DomInfo13");
 
878
        ndr->depth++;
 
879
        ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 
880
        ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 
881
        ndr_print_hyper(ndr, "modified_count_at_last_promotion", r->modified_count_at_last_promotion);
 
882
        ndr->depth--;
 
883
}
 
884
 
 
885
static enum ndr_err_code ndr_push_samr_DomainInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DomainInfo *r)
 
886
{
 
887
        if (ndr_flags & NDR_SCALARS) {
 
888
                int level = ndr_push_get_switch_value(ndr, r);
 
889
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 
890
                switch (level) {
 
891
                        case 1: {
 
892
                                NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
 
893
                        break; }
 
894
 
 
895
                        case 2: {
 
896
                                NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 
897
                        break; }
 
898
 
 
899
                        case 3: {
 
900
                                NDR_CHECK(ndr_push_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
 
901
                        break; }
 
902
 
 
903
                        case 4: {
 
904
                                NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
 
905
                        break; }
 
906
 
 
907
                        case 5: {
 
908
                                NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
 
909
                        break; }
 
910
 
 
911
                        case 6: {
 
912
                                NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
 
913
                        break; }
 
914
 
 
915
                        case 7: {
 
916
                                NDR_CHECK(ndr_push_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
 
917
                        break; }
 
918
 
 
919
                        case 8: {
 
920
                                NDR_CHECK(ndr_push_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
 
921
                        break; }
 
922
 
 
923
                        case 9: {
 
924
                                NDR_CHECK(ndr_push_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
 
925
                        break; }
 
926
 
 
927
                        case 11: {
 
928
                                NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
 
929
                        break; }
 
930
 
 
931
                        case 12: {
 
932
                                NDR_CHECK(ndr_push_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
 
933
                        break; }
 
934
 
 
935
                        case 13: {
 
936
                                NDR_CHECK(ndr_push_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
 
937
                        break; }
 
938
 
 
939
                        default:
 
940
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
941
                }
 
942
        }
 
943
        if (ndr_flags & NDR_BUFFERS) {
 
944
                int level = ndr_push_get_switch_value(ndr, r);
 
945
                switch (level) {
 
946
                        case 1:
 
947
                        break;
 
948
 
 
949
                        case 2:
 
950
                                NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 
951
                        break;
 
952
 
 
953
                        case 3:
 
954
                        break;
 
955
 
 
956
                        case 4:
 
957
                                NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
 
958
                        break;
 
959
 
 
960
                        case 5:
 
961
                                NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
 
962
                        break;
 
963
 
 
964
                        case 6:
 
965
                                NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
 
966
                        break;
 
967
 
 
968
                        case 7:
 
969
                        break;
 
970
 
 
971
                        case 8:
 
972
                        break;
 
973
 
 
974
                        case 9:
 
975
                        break;
 
976
 
 
977
                        case 11:
 
978
                                NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
 
979
                        break;
 
980
 
 
981
                        case 12:
 
982
                        break;
 
983
 
 
984
                        case 13:
 
985
                        break;
 
986
 
 
987
                        default:
 
988
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
989
                }
 
990
        }
 
991
        return NDR_ERR_SUCCESS;
 
992
}
 
993
 
 
994
static enum ndr_err_code ndr_pull_samr_DomainInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DomainInfo *r)
 
995
{
 
996
        int level;
 
997
        uint16_t _level;
 
998
        level = ndr_pull_get_switch_value(ndr, r);
 
999
        if (ndr_flags & NDR_SCALARS) {
 
1000
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
1001
                if (_level != level) {
 
1002
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 
1003
                }
 
1004
                switch (level) {
 
1005
                        case 1: {
 
1006
                                NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
 
1007
                        break; }
 
1008
 
 
1009
                        case 2: {
 
1010
                                NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 
1011
                        break; }
 
1012
 
 
1013
                        case 3: {
 
1014
                                NDR_CHECK(ndr_pull_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
 
1015
                        break; }
 
1016
 
 
1017
                        case 4: {
 
1018
                                NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
 
1019
                        break; }
 
1020
 
 
1021
                        case 5: {
 
1022
                                NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
 
1023
                        break; }
 
1024
 
 
1025
                        case 6: {
 
1026
                                NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
 
1027
                        break; }
 
1028
 
 
1029
                        case 7: {
 
1030
                                NDR_CHECK(ndr_pull_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
 
1031
                        break; }
 
1032
 
 
1033
                        case 8: {
 
1034
                                NDR_CHECK(ndr_pull_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
 
1035
                        break; }
 
1036
 
 
1037
                        case 9: {
 
1038
                                NDR_CHECK(ndr_pull_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
 
1039
                        break; }
 
1040
 
 
1041
                        case 11: {
 
1042
                                NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
 
1043
                        break; }
 
1044
 
 
1045
                        case 12: {
 
1046
                                NDR_CHECK(ndr_pull_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
 
1047
                        break; }
 
1048
 
 
1049
                        case 13: {
 
1050
                                NDR_CHECK(ndr_pull_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
 
1051
                        break; }
 
1052
 
 
1053
                        default:
 
1054
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1055
                }
 
1056
        }
 
1057
        if (ndr_flags & NDR_BUFFERS) {
 
1058
                switch (level) {
 
1059
                        case 1:
 
1060
                        break;
 
1061
 
 
1062
                        case 2:
 
1063
                                NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 
1064
                        break;
 
1065
 
 
1066
                        case 3:
 
1067
                        break;
 
1068
 
 
1069
                        case 4:
 
1070
                                NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
 
1071
                        break;
 
1072
 
 
1073
                        case 5:
 
1074
                                NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
 
1075
                        break;
 
1076
 
 
1077
                        case 6:
 
1078
                                NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
 
1079
                        break;
 
1080
 
 
1081
                        case 7:
 
1082
                        break;
 
1083
 
 
1084
                        case 8:
 
1085
                        break;
 
1086
 
 
1087
                        case 9:
 
1088
                        break;
 
1089
 
 
1090
                        case 11:
 
1091
                                NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
 
1092
                        break;
 
1093
 
 
1094
                        case 12:
 
1095
                        break;
 
1096
 
 
1097
                        case 13:
 
1098
                        break;
 
1099
 
 
1100
                        default:
 
1101
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1102
                }
 
1103
        }
 
1104
        return NDR_ERR_SUCCESS;
 
1105
}
 
1106
 
 
1107
_PUBLIC_ void ndr_print_samr_DomainInfo(struct ndr_print *ndr, const char *name, const union samr_DomainInfo *r)
 
1108
{
 
1109
        int level;
 
1110
        level = ndr_print_get_switch_value(ndr, r);
 
1111
        ndr_print_union(ndr, name, level, "samr_DomainInfo");
 
1112
        switch (level) {
 
1113
                case 1:
 
1114
                        ndr_print_samr_DomInfo1(ndr, "info1", &r->info1);
 
1115
                break;
 
1116
 
 
1117
                case 2:
 
1118
                        ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
 
1119
                break;
 
1120
 
 
1121
                case 3:
 
1122
                        ndr_print_samr_DomInfo3(ndr, "info3", &r->info3);
 
1123
                break;
 
1124
 
 
1125
                case 4:
 
1126
                        ndr_print_samr_DomOEMInformation(ndr, "oem", &r->oem);
 
1127
                break;
 
1128
 
 
1129
                case 5:
 
1130
                        ndr_print_samr_DomInfo5(ndr, "info5", &r->info5);
 
1131
                break;
 
1132
 
 
1133
                case 6:
 
1134
                        ndr_print_samr_DomInfo6(ndr, "info6", &r->info6);
 
1135
                break;
 
1136
 
 
1137
                case 7:
 
1138
                        ndr_print_samr_DomInfo7(ndr, "info7", &r->info7);
 
1139
                break;
 
1140
 
 
1141
                case 8:
 
1142
                        ndr_print_samr_DomInfo8(ndr, "info8", &r->info8);
 
1143
                break;
 
1144
 
 
1145
                case 9:
 
1146
                        ndr_print_samr_DomInfo9(ndr, "info9", &r->info9);
 
1147
                break;
 
1148
 
 
1149
                case 11:
 
1150
                        ndr_print_samr_DomGeneralInformation2(ndr, "general2", &r->general2);
 
1151
                break;
 
1152
 
 
1153
                case 12:
 
1154
                        ndr_print_samr_DomInfo12(ndr, "info12", &r->info12);
 
1155
                break;
 
1156
 
 
1157
                case 13:
 
1158
                        ndr_print_samr_DomInfo13(ndr, "info13", &r->info13);
 
1159
                break;
 
1160
 
 
1161
                default:
 
1162
                        ndr_print_bad_level(ndr, name, level);
 
1163
        }
 
1164
}
 
1165
 
 
1166
static enum ndr_err_code ndr_push_samr_Ids(struct ndr_push *ndr, int ndr_flags, const struct samr_Ids *r)
 
1167
{
 
1168
        uint32_t cntr_ids_1;
 
1169
        if (ndr_flags & NDR_SCALARS) {
 
1170
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1171
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
1172
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->ids));
 
1173
        }
 
1174
        if (ndr_flags & NDR_BUFFERS) {
 
1175
                if (r->ids) {
 
1176
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
1177
                        for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {
 
1178
                                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ids[cntr_ids_1]));
 
1179
                        }
 
1180
                }
 
1181
        }
 
1182
        return NDR_ERR_SUCCESS;
 
1183
}
 
1184
 
 
1185
static enum ndr_err_code ndr_pull_samr_Ids(struct ndr_pull *ndr, int ndr_flags, struct samr_Ids *r)
 
1186
{
 
1187
        uint32_t _ptr_ids;
 
1188
        uint32_t cntr_ids_1;
 
1189
        TALLOC_CTX *_mem_save_ids_0;
 
1190
        TALLOC_CTX *_mem_save_ids_1;
 
1191
        if (ndr_flags & NDR_SCALARS) {
 
1192
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1193
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
1194
                if (r->count > 1024) {
 
1195
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
1196
                }
 
1197
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ids));
 
1198
                if (_ptr_ids) {
 
1199
                        NDR_PULL_ALLOC(ndr, r->ids);
 
1200
                } else {
 
1201
                        r->ids = NULL;
 
1202
                }
 
1203
        }
 
1204
        if (ndr_flags & NDR_BUFFERS) {
 
1205
                if (r->ids) {
 
1206
                        _mem_save_ids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1207
                        NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
 
1208
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->ids));
 
1209
                        NDR_PULL_ALLOC_N(ndr, r->ids, ndr_get_array_size(ndr, &r->ids));
 
1210
                        _mem_save_ids_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
1211
                        NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
 
1212
                        for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {
 
1213
                                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ids[cntr_ids_1]));
 
1214
                        }
 
1215
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_1, 0);
 
1216
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_0, 0);
 
1217
                }
 
1218
                if (r->ids) {
 
1219
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->ids, r->count));
 
1220
                }
 
1221
        }
 
1222
        return NDR_ERR_SUCCESS;
 
1223
}
 
1224
 
 
1225
_PUBLIC_ void ndr_print_samr_Ids(struct ndr_print *ndr, const char *name, const struct samr_Ids *r)
 
1226
{
 
1227
        uint32_t cntr_ids_1;
 
1228
        ndr_print_struct(ndr, name, "samr_Ids");
 
1229
        ndr->depth++;
 
1230
        ndr_print_uint32(ndr, "count", r->count);
 
1231
        ndr_print_ptr(ndr, "ids", r->ids);
 
1232
        ndr->depth++;
 
1233
        if (r->ids) {
 
1234
                ndr->print(ndr, "%s: ARRAY(%d)", "ids", (int)r->count);
 
1235
                ndr->depth++;
 
1236
                for (cntr_ids_1=0;cntr_ids_1<r->count;cntr_ids_1++) {
 
1237
                        char *idx_1=NULL;
 
1238
                        if (asprintf(&idx_1, "[%d]", cntr_ids_1) != -1) {
 
1239
                                ndr_print_uint32(ndr, "ids", r->ids[cntr_ids_1]);
 
1240
                                free(idx_1);
 
1241
                        }
 
1242
                }
 
1243
                ndr->depth--;
 
1244
        }
 
1245
        ndr->depth--;
 
1246
        ndr->depth--;
 
1247
}
 
1248
 
 
1249
_PUBLIC_ enum ndr_err_code ndr_push_samr_GroupAttrs(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
1250
{
 
1251
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
1252
        return NDR_ERR_SUCCESS;
 
1253
}
 
1254
 
 
1255
_PUBLIC_ enum ndr_err_code ndr_pull_samr_GroupAttrs(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
1256
{
 
1257
        uint32_t v;
 
1258
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
1259
        *r = v;
 
1260
        return NDR_ERR_SUCCESS;
 
1261
}
 
1262
 
 
1263
_PUBLIC_ void ndr_print_samr_GroupAttrs(struct ndr_print *ndr, const char *name, uint32_t r)
 
1264
{
 
1265
        ndr_print_uint32(ndr, name, r);
 
1266
        ndr->depth++;
 
1267
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_MANDATORY", SE_GROUP_MANDATORY, r);
 
1268
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED_BY_DEFAULT", SE_GROUP_ENABLED_BY_DEFAULT, r);
 
1269
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED", SE_GROUP_ENABLED, r);
 
1270
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_OWNER", SE_GROUP_OWNER, r);
 
1271
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_USE_FOR_DENY_ONLY", SE_GROUP_USE_FOR_DENY_ONLY, r);
 
1272
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_RESOURCE", SE_GROUP_RESOURCE, r);
 
1273
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_LOGON_ID", SE_GROUP_LOGON_ID, r);
 
1274
        ndr->depth--;
 
1275
}
 
1276
 
 
1277
static enum ndr_err_code ndr_push_samr_GroupInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAll *r)
 
1278
{
 
1279
        if (ndr_flags & NDR_SCALARS) {
 
1280
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1281
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1282
                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
 
1283
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
 
1284
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1285
        }
 
1286
        if (ndr_flags & NDR_BUFFERS) {
 
1287
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1288
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1289
        }
 
1290
        return NDR_ERR_SUCCESS;
 
1291
}
 
1292
 
 
1293
static enum ndr_err_code ndr_pull_samr_GroupInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAll *r)
 
1294
{
 
1295
        if (ndr_flags & NDR_SCALARS) {
 
1296
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1297
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1298
                NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
 
1299
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
 
1300
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1301
        }
 
1302
        if (ndr_flags & NDR_BUFFERS) {
 
1303
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1304
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1305
        }
 
1306
        return NDR_ERR_SUCCESS;
 
1307
}
 
1308
 
 
1309
_PUBLIC_ void ndr_print_samr_GroupInfoAll(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAll *r)
 
1310
{
 
1311
        ndr_print_struct(ndr, name, "samr_GroupInfoAll");
 
1312
        ndr->depth++;
 
1313
        ndr_print_lsa_String(ndr, "name", &r->name);
 
1314
        ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
 
1315
        ndr_print_uint32(ndr, "num_members", r->num_members);
 
1316
        ndr_print_lsa_String(ndr, "description", &r->description);
 
1317
        ndr->depth--;
 
1318
}
 
1319
 
 
1320
static enum ndr_err_code ndr_push_samr_GroupInfoAttributes(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAttributes *r)
 
1321
{
 
1322
        if (ndr_flags & NDR_SCALARS) {
 
1323
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1324
                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
 
1325
        }
 
1326
        if (ndr_flags & NDR_BUFFERS) {
 
1327
        }
 
1328
        return NDR_ERR_SUCCESS;
 
1329
}
 
1330
 
 
1331
static enum ndr_err_code ndr_pull_samr_GroupInfoAttributes(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAttributes *r)
 
1332
{
 
1333
        if (ndr_flags & NDR_SCALARS) {
 
1334
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1335
                NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
 
1336
        }
 
1337
        if (ndr_flags & NDR_BUFFERS) {
 
1338
        }
 
1339
        return NDR_ERR_SUCCESS;
 
1340
}
 
1341
 
 
1342
_PUBLIC_ void ndr_print_samr_GroupInfoAttributes(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAttributes *r)
 
1343
{
 
1344
        ndr_print_struct(ndr, name, "samr_GroupInfoAttributes");
 
1345
        ndr->depth++;
 
1346
        ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
 
1347
        ndr->depth--;
 
1348
}
 
1349
 
 
1350
static enum ndr_err_code ndr_push_samr_GroupInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_GroupInfoEnum r)
 
1351
{
 
1352
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
1353
        return NDR_ERR_SUCCESS;
 
1354
}
 
1355
 
 
1356
static enum ndr_err_code ndr_pull_samr_GroupInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_GroupInfoEnum *r)
 
1357
{
 
1358
        uint16_t v;
 
1359
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
1360
        *r = v;
 
1361
        return NDR_ERR_SUCCESS;
 
1362
}
 
1363
 
 
1364
_PUBLIC_ void ndr_print_samr_GroupInfoEnum(struct ndr_print *ndr, const char *name, enum samr_GroupInfoEnum r)
 
1365
{
 
1366
        const char *val = NULL;
 
1367
 
 
1368
        switch (r) {
 
1369
                case GROUPINFOALL: val = "GROUPINFOALL"; break;
 
1370
                case GROUPINFONAME: val = "GROUPINFONAME"; break;
 
1371
                case GROUPINFOATTRIBUTES: val = "GROUPINFOATTRIBUTES"; break;
 
1372
                case GROUPINFODESCRIPTION: val = "GROUPINFODESCRIPTION"; break;
 
1373
                case GROUPINFOALL2: val = "GROUPINFOALL2"; break;
 
1374
        }
 
1375
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
1376
}
 
1377
 
 
1378
static enum ndr_err_code ndr_push_samr_GroupInfo(struct ndr_push *ndr, int ndr_flags, const union samr_GroupInfo *r)
 
1379
{
 
1380
        if (ndr_flags & NDR_SCALARS) {
 
1381
                int level = ndr_push_get_switch_value(ndr, r);
 
1382
                NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, level));
 
1383
                switch (level) {
 
1384
                        case GROUPINFOALL: {
 
1385
                                NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
 
1386
                        break; }
 
1387
 
 
1388
                        case GROUPINFONAME: {
 
1389
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1390
                        break; }
 
1391
 
 
1392
                        case GROUPINFOATTRIBUTES: {
 
1393
                                NDR_CHECK(ndr_push_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
 
1394
                        break; }
 
1395
 
 
1396
                        case GROUPINFODESCRIPTION: {
 
1397
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1398
                        break; }
 
1399
 
 
1400
                        case GROUPINFOALL2: {
 
1401
                                NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
 
1402
                        break; }
 
1403
 
 
1404
                        default:
 
1405
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1406
                }
 
1407
        }
 
1408
        if (ndr_flags & NDR_BUFFERS) {
 
1409
                int level = ndr_push_get_switch_value(ndr, r);
 
1410
                switch (level) {
 
1411
                        case GROUPINFOALL:
 
1412
                                NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
 
1413
                        break;
 
1414
 
 
1415
                        case GROUPINFONAME:
 
1416
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1417
                        break;
 
1418
 
 
1419
                        case GROUPINFOATTRIBUTES:
 
1420
                        break;
 
1421
 
 
1422
                        case GROUPINFODESCRIPTION:
 
1423
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1424
                        break;
 
1425
 
 
1426
                        case GROUPINFOALL2:
 
1427
                                NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
 
1428
                        break;
 
1429
 
 
1430
                        default:
 
1431
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1432
                }
 
1433
        }
 
1434
        return NDR_ERR_SUCCESS;
 
1435
}
 
1436
 
 
1437
static enum ndr_err_code ndr_pull_samr_GroupInfo(struct ndr_pull *ndr, int ndr_flags, union samr_GroupInfo *r)
 
1438
{
 
1439
        int level;
 
1440
        uint16_t _level;
 
1441
        level = ndr_pull_get_switch_value(ndr, r);
 
1442
        if (ndr_flags & NDR_SCALARS) {
 
1443
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
1444
                if (_level != level) {
 
1445
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 
1446
                }
 
1447
                switch (level) {
 
1448
                        case GROUPINFOALL: {
 
1449
                                NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
 
1450
                        break; }
 
1451
 
 
1452
                        case GROUPINFONAME: {
 
1453
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1454
                        break; }
 
1455
 
 
1456
                        case GROUPINFOATTRIBUTES: {
 
1457
                                NDR_CHECK(ndr_pull_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
 
1458
                        break; }
 
1459
 
 
1460
                        case GROUPINFODESCRIPTION: {
 
1461
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1462
                        break; }
 
1463
 
 
1464
                        case GROUPINFOALL2: {
 
1465
                                NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
 
1466
                        break; }
 
1467
 
 
1468
                        default:
 
1469
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1470
                }
 
1471
        }
 
1472
        if (ndr_flags & NDR_BUFFERS) {
 
1473
                switch (level) {
 
1474
                        case GROUPINFOALL:
 
1475
                                NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
 
1476
                        break;
 
1477
 
 
1478
                        case GROUPINFONAME:
 
1479
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1480
                        break;
 
1481
 
 
1482
                        case GROUPINFOATTRIBUTES:
 
1483
                        break;
 
1484
 
 
1485
                        case GROUPINFODESCRIPTION:
 
1486
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1487
                        break;
 
1488
 
 
1489
                        case GROUPINFOALL2:
 
1490
                                NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
 
1491
                        break;
 
1492
 
 
1493
                        default:
 
1494
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1495
                }
 
1496
        }
 
1497
        return NDR_ERR_SUCCESS;
 
1498
}
 
1499
 
 
1500
_PUBLIC_ void ndr_print_samr_GroupInfo(struct ndr_print *ndr, const char *name, const union samr_GroupInfo *r)
 
1501
{
 
1502
        int level;
 
1503
        level = ndr_print_get_switch_value(ndr, r);
 
1504
        ndr_print_union(ndr, name, level, "samr_GroupInfo");
 
1505
        switch (level) {
 
1506
                case GROUPINFOALL:
 
1507
                        ndr_print_samr_GroupInfoAll(ndr, "all", &r->all);
 
1508
                break;
 
1509
 
 
1510
                case GROUPINFONAME:
 
1511
                        ndr_print_lsa_String(ndr, "name", &r->name);
 
1512
                break;
 
1513
 
 
1514
                case GROUPINFOATTRIBUTES:
 
1515
                        ndr_print_samr_GroupInfoAttributes(ndr, "attributes", &r->attributes);
 
1516
                break;
 
1517
 
 
1518
                case GROUPINFODESCRIPTION:
 
1519
                        ndr_print_lsa_String(ndr, "description", &r->description);
 
1520
                break;
 
1521
 
 
1522
                case GROUPINFOALL2:
 
1523
                        ndr_print_samr_GroupInfoAll(ndr, "all2", &r->all2);
 
1524
                break;
 
1525
 
 
1526
                default:
 
1527
                        ndr_print_bad_level(ndr, name, level);
 
1528
        }
 
1529
}
 
1530
 
 
1531
static enum ndr_err_code ndr_push_samr_RidTypeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidTypeArray *r)
 
1532
{
 
1533
        uint32_t cntr_rids_1;
 
1534
        uint32_t cntr_types_1;
 
1535
        if (ndr_flags & NDR_SCALARS) {
 
1536
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1537
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
1538
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
 
1539
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
 
1540
        }
 
1541
        if (ndr_flags & NDR_BUFFERS) {
 
1542
                if (r->rids) {
 
1543
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
1544
                        for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
 
1545
                                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_1]));
 
1546
                        }
 
1547
                }
 
1548
                if (r->types) {
 
1549
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
1550
                        for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
 
1551
                                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->types[cntr_types_1]));
 
1552
                        }
 
1553
                }
 
1554
        }
 
1555
        return NDR_ERR_SUCCESS;
 
1556
}
 
1557
 
 
1558
static enum ndr_err_code ndr_pull_samr_RidTypeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidTypeArray *r)
 
1559
{
 
1560
        uint32_t _ptr_rids;
 
1561
        uint32_t cntr_rids_1;
 
1562
        TALLOC_CTX *_mem_save_rids_0;
 
1563
        TALLOC_CTX *_mem_save_rids_1;
 
1564
        uint32_t _ptr_types;
 
1565
        uint32_t cntr_types_1;
 
1566
        TALLOC_CTX *_mem_save_types_0;
 
1567
        TALLOC_CTX *_mem_save_types_1;
 
1568
        if (ndr_flags & NDR_SCALARS) {
 
1569
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1570
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
1571
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
 
1572
                if (_ptr_rids) {
 
1573
                        NDR_PULL_ALLOC(ndr, r->rids);
 
1574
                } else {
 
1575
                        r->rids = NULL;
 
1576
                }
 
1577
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
 
1578
                if (_ptr_types) {
 
1579
                        NDR_PULL_ALLOC(ndr, r->types);
 
1580
                } else {
 
1581
                        r->types = NULL;
 
1582
                }
 
1583
        }
 
1584
        if (ndr_flags & NDR_BUFFERS) {
 
1585
                if (r->rids) {
 
1586
                        _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1587
                        NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
 
1588
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
 
1589
                        NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));
 
1590
                        _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
1591
                        NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
 
1592
                        for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
 
1593
                                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
 
1594
                        }
 
1595
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
 
1596
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
 
1597
                }
 
1598
                if (r->types) {
 
1599
                        _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1600
                        NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
 
1601
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
 
1602
                        NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
 
1603
                        _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
1604
                        NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
 
1605
                        for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
 
1606
                                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
 
1607
                        }
 
1608
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
 
1609
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
 
1610
                }
 
1611
                if (r->rids) {
 
1612
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
 
1613
                }
 
1614
                if (r->types) {
 
1615
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
 
1616
                }
 
1617
        }
 
1618
        return NDR_ERR_SUCCESS;
 
1619
}
 
1620
 
 
1621
_PUBLIC_ void ndr_print_samr_RidTypeArray(struct ndr_print *ndr, const char *name, const struct samr_RidTypeArray *r)
 
1622
{
 
1623
        uint32_t cntr_rids_1;
 
1624
        uint32_t cntr_types_1;
 
1625
        ndr_print_struct(ndr, name, "samr_RidTypeArray");
 
1626
        ndr->depth++;
 
1627
        ndr_print_uint32(ndr, "count", r->count);
 
1628
        ndr_print_ptr(ndr, "rids", r->rids);
 
1629
        ndr->depth++;
 
1630
        if (r->rids) {
 
1631
                ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
 
1632
                ndr->depth++;
 
1633
                for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
 
1634
                        char *idx_1=NULL;
 
1635
                        if (asprintf(&idx_1, "[%d]", cntr_rids_1) != -1) {
 
1636
                                ndr_print_uint32(ndr, "rids", r->rids[cntr_rids_1]);
 
1637
                                free(idx_1);
 
1638
                        }
 
1639
                }
 
1640
                ndr->depth--;
 
1641
        }
 
1642
        ndr->depth--;
 
1643
        ndr_print_ptr(ndr, "types", r->types);
 
1644
        ndr->depth++;
 
1645
        if (r->types) {
 
1646
                ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
 
1647
                ndr->depth++;
 
1648
                for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
 
1649
                        char *idx_1=NULL;
 
1650
                        if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
 
1651
                                ndr_print_uint32(ndr, "types", r->types[cntr_types_1]);
 
1652
                                free(idx_1);
 
1653
                        }
 
1654
                }
 
1655
                ndr->depth--;
 
1656
        }
 
1657
        ndr->depth--;
 
1658
        ndr->depth--;
 
1659
}
 
1660
 
 
1661
static enum ndr_err_code ndr_push_samr_AliasInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_AliasInfoAll *r)
 
1662
{
 
1663
        if (ndr_flags & NDR_SCALARS) {
 
1664
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1665
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1666
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
 
1667
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1668
        }
 
1669
        if (ndr_flags & NDR_BUFFERS) {
 
1670
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1671
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1672
        }
 
1673
        return NDR_ERR_SUCCESS;
 
1674
}
 
1675
 
 
1676
static enum ndr_err_code ndr_pull_samr_AliasInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_AliasInfoAll *r)
 
1677
{
 
1678
        if (ndr_flags & NDR_SCALARS) {
 
1679
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1680
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1681
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
 
1682
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1683
        }
 
1684
        if (ndr_flags & NDR_BUFFERS) {
 
1685
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1686
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1687
        }
 
1688
        return NDR_ERR_SUCCESS;
 
1689
}
 
1690
 
 
1691
_PUBLIC_ void ndr_print_samr_AliasInfoAll(struct ndr_print *ndr, const char *name, const struct samr_AliasInfoAll *r)
 
1692
{
 
1693
        ndr_print_struct(ndr, name, "samr_AliasInfoAll");
 
1694
        ndr->depth++;
 
1695
        ndr_print_lsa_String(ndr, "name", &r->name);
 
1696
        ndr_print_uint32(ndr, "num_members", r->num_members);
 
1697
        ndr_print_lsa_String(ndr, "description", &r->description);
 
1698
        ndr->depth--;
 
1699
}
 
1700
 
 
1701
static enum ndr_err_code ndr_push_samr_AliasInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_AliasInfoEnum r)
 
1702
{
 
1703
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
1704
        return NDR_ERR_SUCCESS;
 
1705
}
 
1706
 
 
1707
static enum ndr_err_code ndr_pull_samr_AliasInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_AliasInfoEnum *r)
 
1708
{
 
1709
        uint16_t v;
 
1710
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
1711
        *r = v;
 
1712
        return NDR_ERR_SUCCESS;
 
1713
}
 
1714
 
 
1715
_PUBLIC_ void ndr_print_samr_AliasInfoEnum(struct ndr_print *ndr, const char *name, enum samr_AliasInfoEnum r)
 
1716
{
 
1717
        const char *val = NULL;
 
1718
 
 
1719
        switch (r) {
 
1720
                case ALIASINFOALL: val = "ALIASINFOALL"; break;
 
1721
                case ALIASINFONAME: val = "ALIASINFONAME"; break;
 
1722
                case ALIASINFODESCRIPTION: val = "ALIASINFODESCRIPTION"; break;
 
1723
        }
 
1724
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
1725
}
 
1726
 
 
1727
static enum ndr_err_code ndr_push_samr_AliasInfo(struct ndr_push *ndr, int ndr_flags, const union samr_AliasInfo *r)
 
1728
{
 
1729
        if (ndr_flags & NDR_SCALARS) {
 
1730
                int level = ndr_push_get_switch_value(ndr, r);
 
1731
                NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, level));
 
1732
                switch (level) {
 
1733
                        case ALIASINFOALL: {
 
1734
                                NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
 
1735
                        break; }
 
1736
 
 
1737
                        case ALIASINFONAME: {
 
1738
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1739
                        break; }
 
1740
 
 
1741
                        case ALIASINFODESCRIPTION: {
 
1742
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1743
                        break; }
 
1744
 
 
1745
                        default:
 
1746
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1747
                }
 
1748
        }
 
1749
        if (ndr_flags & NDR_BUFFERS) {
 
1750
                int level = ndr_push_get_switch_value(ndr, r);
 
1751
                switch (level) {
 
1752
                        case ALIASINFOALL:
 
1753
                                NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
 
1754
                        break;
 
1755
 
 
1756
                        case ALIASINFONAME:
 
1757
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1758
                        break;
 
1759
 
 
1760
                        case ALIASINFODESCRIPTION:
 
1761
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1762
                        break;
 
1763
 
 
1764
                        default:
 
1765
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1766
                }
 
1767
        }
 
1768
        return NDR_ERR_SUCCESS;
 
1769
}
 
1770
 
 
1771
static enum ndr_err_code ndr_pull_samr_AliasInfo(struct ndr_pull *ndr, int ndr_flags, union samr_AliasInfo *r)
 
1772
{
 
1773
        int level;
 
1774
        uint16_t _level;
 
1775
        level = ndr_pull_get_switch_value(ndr, r);
 
1776
        if (ndr_flags & NDR_SCALARS) {
 
1777
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
1778
                if (_level != level) {
 
1779
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 
1780
                }
 
1781
                switch (level) {
 
1782
                        case ALIASINFOALL: {
 
1783
                                NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
 
1784
                        break; }
 
1785
 
 
1786
                        case ALIASINFONAME: {
 
1787
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1788
                        break; }
 
1789
 
 
1790
                        case ALIASINFODESCRIPTION: {
 
1791
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1792
                        break; }
 
1793
 
 
1794
                        default:
 
1795
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1796
                }
 
1797
        }
 
1798
        if (ndr_flags & NDR_BUFFERS) {
 
1799
                switch (level) {
 
1800
                        case ALIASINFOALL:
 
1801
                                NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
 
1802
                        break;
 
1803
 
 
1804
                        case ALIASINFONAME:
 
1805
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1806
                        break;
 
1807
 
 
1808
                        case ALIASINFODESCRIPTION:
 
1809
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1810
                        break;
 
1811
 
 
1812
                        default:
 
1813
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1814
                }
 
1815
        }
 
1816
        return NDR_ERR_SUCCESS;
 
1817
}
 
1818
 
 
1819
_PUBLIC_ void ndr_print_samr_AliasInfo(struct ndr_print *ndr, const char *name, const union samr_AliasInfo *r)
 
1820
{
 
1821
        int level;
 
1822
        level = ndr_print_get_switch_value(ndr, r);
 
1823
        ndr_print_union(ndr, name, level, "samr_AliasInfo");
 
1824
        switch (level) {
 
1825
                case ALIASINFOALL:
 
1826
                        ndr_print_samr_AliasInfoAll(ndr, "all", &r->all);
 
1827
                break;
 
1828
 
 
1829
                case ALIASINFONAME:
 
1830
                        ndr_print_lsa_String(ndr, "name", &r->name);
 
1831
                break;
 
1832
 
 
1833
                case ALIASINFODESCRIPTION:
 
1834
                        ndr_print_lsa_String(ndr, "description", &r->description);
 
1835
                break;
 
1836
 
 
1837
                default:
 
1838
                        ndr_print_bad_level(ndr, name, level);
 
1839
        }
 
1840
}
 
1841
 
 
1842
static enum ndr_err_code ndr_push_samr_UserInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo1 *r)
 
1843
{
 
1844
        if (ndr_flags & NDR_SCALARS) {
 
1845
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1846
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
1847
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
1848
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
 
1849
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1850
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
 
1851
        }
 
1852
        if (ndr_flags & NDR_BUFFERS) {
 
1853
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
1854
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
1855
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1856
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
 
1857
        }
 
1858
        return NDR_ERR_SUCCESS;
 
1859
}
 
1860
 
 
1861
static enum ndr_err_code ndr_pull_samr_UserInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo1 *r)
 
1862
{
 
1863
        if (ndr_flags & NDR_SCALARS) {
 
1864
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1865
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
1866
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
1867
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
 
1868
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1869
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
 
1870
        }
 
1871
        if (ndr_flags & NDR_BUFFERS) {
 
1872
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
1873
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
1874
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1875
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
 
1876
        }
 
1877
        return NDR_ERR_SUCCESS;
 
1878
}
 
1879
 
 
1880
_PUBLIC_ void ndr_print_samr_UserInfo1(struct ndr_print *ndr, const char *name, const struct samr_UserInfo1 *r)
 
1881
{
 
1882
        ndr_print_struct(ndr, name, "samr_UserInfo1");
 
1883
        ndr->depth++;
 
1884
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
1885
        ndr_print_lsa_String(ndr, "full_name", &r->full_name);
 
1886
        ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
 
1887
        ndr_print_lsa_String(ndr, "description", &r->description);
 
1888
        ndr_print_lsa_String(ndr, "comment", &r->comment);
 
1889
        ndr->depth--;
 
1890
}
 
1891
 
 
1892
static enum ndr_err_code ndr_push_samr_UserInfo2(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo2 *r)
 
1893
{
 
1894
        if (ndr_flags & NDR_SCALARS) {
 
1895
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1896
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
 
1897
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown));
 
1898
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
 
1899
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
 
1900
        }
 
1901
        if (ndr_flags & NDR_BUFFERS) {
 
1902
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
 
1903
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->unknown));
 
1904
        }
 
1905
        return NDR_ERR_SUCCESS;
 
1906
}
 
1907
 
 
1908
static enum ndr_err_code ndr_pull_samr_UserInfo2(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo2 *r)
 
1909
{
 
1910
        if (ndr_flags & NDR_SCALARS) {
 
1911
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1912
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
 
1913
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown));
 
1914
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
 
1915
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
 
1916
        }
 
1917
        if (ndr_flags & NDR_BUFFERS) {
 
1918
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
 
1919
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->unknown));
 
1920
        }
 
1921
        return NDR_ERR_SUCCESS;
 
1922
}
 
1923
 
 
1924
_PUBLIC_ void ndr_print_samr_UserInfo2(struct ndr_print *ndr, const char *name, const struct samr_UserInfo2 *r)
 
1925
{
 
1926
        ndr_print_struct(ndr, name, "samr_UserInfo2");
 
1927
        ndr->depth++;
 
1928
        ndr_print_lsa_String(ndr, "comment", &r->comment);
 
1929
        ndr_print_lsa_String(ndr, "unknown", &r->unknown);
 
1930
        ndr_print_uint16(ndr, "country_code", r->country_code);
 
1931
        ndr_print_uint16(ndr, "code_page", r->code_page);
 
1932
        ndr->depth--;
 
1933
}
 
1934
 
 
1935
_PUBLIC_ enum ndr_err_code ndr_push_samr_LogonHours(struct ndr_push *ndr, int ndr_flags, const struct samr_LogonHours *r)
 
1936
{
 
1937
        {
 
1938
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1939
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
1940
                if (ndr_flags & NDR_SCALARS) {
 
1941
                        NDR_CHECK(ndr_push_align(ndr, 4));
 
1942
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->units_per_week));
 
1943
                        NDR_CHECK(ndr_push_unique_ptr(ndr, r->bits));
 
1944
                }
 
1945
                if (ndr_flags & NDR_BUFFERS) {
 
1946
                        if (r->bits) {
 
1947
                                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1260));
 
1948
                                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 
1949
                                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->units_per_week / 8));
 
1950
                                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->bits, r->units_per_week / 8));
 
1951
                        }
 
1952
                }
 
1953
                ndr->flags = _flags_save_STRUCT;
 
1954
        }
 
1955
        return NDR_ERR_SUCCESS;
 
1956
}
 
1957
 
 
1958
_PUBLIC_ enum ndr_err_code ndr_pull_samr_LogonHours(struct ndr_pull *ndr, int ndr_flags, struct samr_LogonHours *r)
 
1959
{
 
1960
        uint32_t _ptr_bits;
 
1961
        TALLOC_CTX *_mem_save_bits_0;
 
1962
        {
 
1963
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1964
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
1965
                if (ndr_flags & NDR_SCALARS) {
 
1966
                        NDR_CHECK(ndr_pull_align(ndr, 4));
 
1967
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->units_per_week));
 
1968
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bits));
 
1969
                        if (_ptr_bits) {
 
1970
                                NDR_PULL_ALLOC(ndr, r->bits);
 
1971
                        } else {
 
1972
                                r->bits = NULL;
 
1973
                        }
 
1974
                }
 
1975
                if (ndr_flags & NDR_BUFFERS) {
 
1976
                        if (r->bits) {
 
1977
                                _mem_save_bits_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1978
                                NDR_PULL_SET_MEM_CTX(ndr, r->bits, 0);
 
1979
                                NDR_CHECK(ndr_pull_array_size(ndr, &r->bits));
 
1980
                                NDR_CHECK(ndr_pull_array_length(ndr, &r->bits));
 
1981
                                if (ndr_get_array_length(ndr, &r->bits) > ndr_get_array_size(ndr, &r->bits)) {
 
1982
                                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->bits), ndr_get_array_length(ndr, &r->bits));
 
1983
                                }
 
1984
                                NDR_PULL_ALLOC_N(ndr, r->bits, ndr_get_array_size(ndr, &r->bits));
 
1985
                                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->bits, ndr_get_array_length(ndr, &r->bits)));
 
1986
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bits_0, 0);
 
1987
                        }
 
1988
                        if (r->bits) {
 
1989
                                NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->bits, 1260));
 
1990
                        }
 
1991
                        if (r->bits) {
 
1992
                                NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->bits, r->units_per_week / 8));
 
1993
                        }
 
1994
                }
 
1995
                ndr->flags = _flags_save_STRUCT;
 
1996
        }
 
1997
        return NDR_ERR_SUCCESS;
 
1998
}
 
1999
 
 
2000
_PUBLIC_ void ndr_print_samr_LogonHours(struct ndr_print *ndr, const char *name, const struct samr_LogonHours *r)
 
2001
{
 
2002
        ndr_print_struct(ndr, name, "samr_LogonHours");
 
2003
        {
 
2004
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2005
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
2006
                ndr->depth++;
 
2007
                ndr_print_uint16(ndr, "units_per_week", r->units_per_week);
 
2008
                ndr_print_ptr(ndr, "bits", r->bits);
 
2009
                ndr->depth++;
 
2010
                if (r->bits) {
 
2011
                        ndr_print_array_uint8(ndr, "bits", r->bits, r->units_per_week / 8);
 
2012
                }
 
2013
                ndr->depth--;
 
2014
                ndr->depth--;
 
2015
                ndr->flags = _flags_save_STRUCT;
 
2016
        }
 
2017
}
 
2018
 
 
2019
static enum ndr_err_code ndr_push_samr_UserInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo3 *r)
 
2020
{
 
2021
        if (ndr_flags & NDR_SCALARS) {
 
2022
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2023
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2024
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2025
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
 
2026
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
 
2027
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2028
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2029
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2030
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2031
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2032
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
 
2033
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
 
2034
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
 
2035
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
 
2036
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
 
2037
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2038
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
 
2039
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
 
2040
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
 
2041
        }
 
2042
        if (ndr_flags & NDR_BUFFERS) {
 
2043
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2044
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2045
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2046
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2047
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2048
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2049
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2050
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
2051
        }
 
2052
        return NDR_ERR_SUCCESS;
 
2053
}
 
2054
 
 
2055
static enum ndr_err_code ndr_pull_samr_UserInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo3 *r)
 
2056
{
 
2057
        if (ndr_flags & NDR_SCALARS) {
 
2058
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2059
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2060
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2061
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
 
2062
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
 
2063
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2064
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2065
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2066
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2067
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2068
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
 
2069
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
 
2070
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
 
2071
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
 
2072
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
 
2073
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2074
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
 
2075
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
 
2076
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
 
2077
        }
 
2078
        if (ndr_flags & NDR_BUFFERS) {
 
2079
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2080
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2081
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2082
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2083
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2084
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2085
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2086
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
2087
        }
 
2088
        return NDR_ERR_SUCCESS;
 
2089
}
 
2090
 
 
2091
_PUBLIC_ void ndr_print_samr_UserInfo3(struct ndr_print *ndr, const char *name, const struct samr_UserInfo3 *r)
 
2092
{
 
2093
        ndr_print_struct(ndr, name, "samr_UserInfo3");
 
2094
        ndr->depth++;
 
2095
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
2096
        ndr_print_lsa_String(ndr, "full_name", &r->full_name);
 
2097
        ndr_print_uint32(ndr, "rid", r->rid);
 
2098
        ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
 
2099
        ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
 
2100
        ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
 
2101
        ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
 
2102
        ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
 
2103
        ndr_print_lsa_String(ndr, "workstations", &r->workstations);
 
2104
        ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
 
2105
        ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
 
2106
        ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
 
2107
        ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
 
2108
        ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
 
2109
        ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
 
2110
        ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
 
2111
        ndr_print_uint16(ndr, "logon_count", r->logon_count);
 
2112
        ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
 
2113
        ndr->depth--;
 
2114
}
 
2115
 
 
2116
static enum ndr_err_code ndr_push_samr_UserInfo4(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo4 *r)
 
2117
{
 
2118
        if (ndr_flags & NDR_SCALARS) {
 
2119
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2120
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2121
        }
 
2122
        if (ndr_flags & NDR_BUFFERS) {
 
2123
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
2124
        }
 
2125
        return NDR_ERR_SUCCESS;
 
2126
}
 
2127
 
 
2128
static enum ndr_err_code ndr_pull_samr_UserInfo4(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo4 *r)
 
2129
{
 
2130
        if (ndr_flags & NDR_SCALARS) {
 
2131
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2132
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2133
        }
 
2134
        if (ndr_flags & NDR_BUFFERS) {
 
2135
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
2136
        }
 
2137
        return NDR_ERR_SUCCESS;
 
2138
}
 
2139
 
 
2140
_PUBLIC_ void ndr_print_samr_UserInfo4(struct ndr_print *ndr, const char *name, const struct samr_UserInfo4 *r)
 
2141
{
 
2142
        ndr_print_struct(ndr, name, "samr_UserInfo4");
 
2143
        ndr->depth++;
 
2144
        ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
 
2145
        ndr->depth--;
 
2146
}
 
2147
 
 
2148
static enum ndr_err_code ndr_push_samr_UserInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo5 *r)
 
2149
{
 
2150
        if (ndr_flags & NDR_SCALARS) {
 
2151
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2152
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2153
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2154
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
 
2155
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
 
2156
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2157
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2158
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2159
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2160
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
2161
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2162
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
 
2163
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
 
2164
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2165
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
 
2166
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
 
2167
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
 
2168
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
 
2169
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
 
2170
        }
 
2171
        if (ndr_flags & NDR_BUFFERS) {
 
2172
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2173
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2174
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2175
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2176
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2177
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2178
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
2179
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2180
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
2181
        }
 
2182
        return NDR_ERR_SUCCESS;
 
2183
}
 
2184
 
 
2185
static enum ndr_err_code ndr_pull_samr_UserInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo5 *r)
 
2186
{
 
2187
        if (ndr_flags & NDR_SCALARS) {
 
2188
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2189
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2190
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2191
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
 
2192
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
 
2193
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2194
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2195
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2196
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2197
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
2198
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2199
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
 
2200
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
 
2201
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2202
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
 
2203
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
 
2204
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
 
2205
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
 
2206
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
 
2207
        }
 
2208
        if (ndr_flags & NDR_BUFFERS) {
 
2209
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2210
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2211
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2212
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2213
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2214
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2215
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
2216
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2217
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
2218
        }
 
2219
        return NDR_ERR_SUCCESS;
 
2220
}
 
2221
 
 
2222
_PUBLIC_ void ndr_print_samr_UserInfo5(struct ndr_print *ndr, const char *name, const struct samr_UserInfo5 *r)
 
2223
{
 
2224
        ndr_print_struct(ndr, name, "samr_UserInfo5");
 
2225
        ndr->depth++;
 
2226
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
2227
        ndr_print_lsa_String(ndr, "full_name", &r->full_name);
 
2228
        ndr_print_uint32(ndr, "rid", r->rid);
 
2229
        ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
 
2230
        ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
 
2231
        ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
 
2232
        ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
 
2233
        ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
 
2234
        ndr_print_lsa_String(ndr, "description", &r->description);
 
2235
        ndr_print_lsa_String(ndr, "workstations", &r->workstations);
 
2236
        ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
 
2237
        ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
 
2238
        ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
 
2239
        ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
 
2240
        ndr_print_uint16(ndr, "logon_count", r->logon_count);
 
2241
        ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
 
2242
        ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
 
2243
        ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
 
2244
        ndr->depth--;
 
2245
}
 
2246
 
 
2247
static enum ndr_err_code ndr_push_samr_UserInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo6 *r)
 
2248
{
 
2249
        if (ndr_flags & NDR_SCALARS) {
 
2250
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2251
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2252
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2253
        }
 
2254
        if (ndr_flags & NDR_BUFFERS) {
 
2255
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2256
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2257
        }
 
2258
        return NDR_ERR_SUCCESS;
 
2259
}
 
2260
 
 
2261
static enum ndr_err_code ndr_pull_samr_UserInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo6 *r)
 
2262
{
 
2263
        if (ndr_flags & NDR_SCALARS) {
 
2264
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2265
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2266
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2267
        }
 
2268
        if (ndr_flags & NDR_BUFFERS) {
 
2269
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2270
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2271
        }
 
2272
        return NDR_ERR_SUCCESS;
 
2273
}
 
2274
 
 
2275
_PUBLIC_ void ndr_print_samr_UserInfo6(struct ndr_print *ndr, const char *name, const struct samr_UserInfo6 *r)
 
2276
{
 
2277
        ndr_print_struct(ndr, name, "samr_UserInfo6");
 
2278
        ndr->depth++;
 
2279
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
2280
        ndr_print_lsa_String(ndr, "full_name", &r->full_name);
 
2281
        ndr->depth--;
 
2282
}
 
2283
 
 
2284
static enum ndr_err_code ndr_push_samr_UserInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo7 *r)
 
2285
{
 
2286
        if (ndr_flags & NDR_SCALARS) {
 
2287
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2288
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2289
        }
 
2290
        if (ndr_flags & NDR_BUFFERS) {
 
2291
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2292
        }
 
2293
        return NDR_ERR_SUCCESS;
 
2294
}
 
2295
 
 
2296
static enum ndr_err_code ndr_pull_samr_UserInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo7 *r)
 
2297
{
 
2298
        if (ndr_flags & NDR_SCALARS) {
 
2299
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2300
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2301
        }
 
2302
        if (ndr_flags & NDR_BUFFERS) {
 
2303
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2304
        }
 
2305
        return NDR_ERR_SUCCESS;
 
2306
}
 
2307
 
 
2308
_PUBLIC_ void ndr_print_samr_UserInfo7(struct ndr_print *ndr, const char *name, const struct samr_UserInfo7 *r)
 
2309
{
 
2310
        ndr_print_struct(ndr, name, "samr_UserInfo7");
 
2311
        ndr->depth++;
 
2312
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
2313
        ndr->depth--;
 
2314
}
 
2315
 
 
2316
static enum ndr_err_code ndr_push_samr_UserInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo8 *r)
 
2317
{
 
2318
        if (ndr_flags & NDR_SCALARS) {
 
2319
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2320
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2321
        }
 
2322
        if (ndr_flags & NDR_BUFFERS) {
 
2323
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2324
        }
 
2325
        return NDR_ERR_SUCCESS;
 
2326
}
 
2327
 
 
2328
static enum ndr_err_code ndr_pull_samr_UserInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo8 *r)
 
2329
{
 
2330
        if (ndr_flags & NDR_SCALARS) {
 
2331
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2332
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2333
        }
 
2334
        if (ndr_flags & NDR_BUFFERS) {
 
2335
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2336
        }
 
2337
        return NDR_ERR_SUCCESS;
 
2338
}
 
2339
 
 
2340
_PUBLIC_ void ndr_print_samr_UserInfo8(struct ndr_print *ndr, const char *name, const struct samr_UserInfo8 *r)
 
2341
{
 
2342
        ndr_print_struct(ndr, name, "samr_UserInfo8");
 
2343
        ndr->depth++;
 
2344
        ndr_print_lsa_String(ndr, "full_name", &r->full_name);
 
2345
        ndr->depth--;
 
2346
}
 
2347
 
 
2348
static enum ndr_err_code ndr_push_samr_UserInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo9 *r)
 
2349
{
 
2350
        if (ndr_flags & NDR_SCALARS) {
 
2351
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2352
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
 
2353
        }
 
2354
        if (ndr_flags & NDR_BUFFERS) {
 
2355
        }
 
2356
        return NDR_ERR_SUCCESS;
 
2357
}
 
2358
 
 
2359
static enum ndr_err_code ndr_pull_samr_UserInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo9 *r)
 
2360
{
 
2361
        if (ndr_flags & NDR_SCALARS) {
 
2362
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2363
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
 
2364
        }
 
2365
        if (ndr_flags & NDR_BUFFERS) {
 
2366
        }
 
2367
        return NDR_ERR_SUCCESS;
 
2368
}
 
2369
 
 
2370
_PUBLIC_ void ndr_print_samr_UserInfo9(struct ndr_print *ndr, const char *name, const struct samr_UserInfo9 *r)
 
2371
{
 
2372
        ndr_print_struct(ndr, name, "samr_UserInfo9");
 
2373
        ndr->depth++;
 
2374
        ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
 
2375
        ndr->depth--;
 
2376
}
 
2377
 
 
2378
static enum ndr_err_code ndr_push_samr_UserInfo10(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo10 *r)
 
2379
{
 
2380
        if (ndr_flags & NDR_SCALARS) {
 
2381
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2382
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2383
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2384
        }
 
2385
        if (ndr_flags & NDR_BUFFERS) {
 
2386
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2387
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2388
        }
 
2389
        return NDR_ERR_SUCCESS;
 
2390
}
 
2391
 
 
2392
static enum ndr_err_code ndr_pull_samr_UserInfo10(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo10 *r)
 
2393
{
 
2394
        if (ndr_flags & NDR_SCALARS) {
 
2395
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2396
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2397
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2398
        }
 
2399
        if (ndr_flags & NDR_BUFFERS) {
 
2400
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2401
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2402
        }
 
2403
        return NDR_ERR_SUCCESS;
 
2404
}
 
2405
 
 
2406
_PUBLIC_ void ndr_print_samr_UserInfo10(struct ndr_print *ndr, const char *name, const struct samr_UserInfo10 *r)
 
2407
{
 
2408
        ndr_print_struct(ndr, name, "samr_UserInfo10");
 
2409
        ndr->depth++;
 
2410
        ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
 
2411
        ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
 
2412
        ndr->depth--;
 
2413
}
 
2414
 
 
2415
static enum ndr_err_code ndr_push_samr_UserInfo11(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo11 *r)
 
2416
{
 
2417
        if (ndr_flags & NDR_SCALARS) {
 
2418
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2419
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2420
        }
 
2421
        if (ndr_flags & NDR_BUFFERS) {
 
2422
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2423
        }
 
2424
        return NDR_ERR_SUCCESS;
 
2425
}
 
2426
 
 
2427
static enum ndr_err_code ndr_pull_samr_UserInfo11(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo11 *r)
 
2428
{
 
2429
        if (ndr_flags & NDR_SCALARS) {
 
2430
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2431
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2432
        }
 
2433
        if (ndr_flags & NDR_BUFFERS) {
 
2434
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2435
        }
 
2436
        return NDR_ERR_SUCCESS;
 
2437
}
 
2438
 
 
2439
_PUBLIC_ void ndr_print_samr_UserInfo11(struct ndr_print *ndr, const char *name, const struct samr_UserInfo11 *r)
 
2440
{
 
2441
        ndr_print_struct(ndr, name, "samr_UserInfo11");
 
2442
        ndr->depth++;
 
2443
        ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
 
2444
        ndr->depth--;
 
2445
}
 
2446
 
 
2447
static enum ndr_err_code ndr_push_samr_UserInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo12 *r)
 
2448
{
 
2449
        if (ndr_flags & NDR_SCALARS) {
 
2450
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2451
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2452
        }
 
2453
        if (ndr_flags & NDR_BUFFERS) {
 
2454
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2455
        }
 
2456
        return NDR_ERR_SUCCESS;
 
2457
}
 
2458
 
 
2459
static enum ndr_err_code ndr_pull_samr_UserInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo12 *r)
 
2460
{
 
2461
        if (ndr_flags & NDR_SCALARS) {
 
2462
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2463
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2464
        }
 
2465
        if (ndr_flags & NDR_BUFFERS) {
 
2466
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2467
        }
 
2468
        return NDR_ERR_SUCCESS;
 
2469
}
 
2470
 
 
2471
_PUBLIC_ void ndr_print_samr_UserInfo12(struct ndr_print *ndr, const char *name, const struct samr_UserInfo12 *r)
 
2472
{
 
2473
        ndr_print_struct(ndr, name, "samr_UserInfo12");
 
2474
        ndr->depth++;
 
2475
        ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
 
2476
        ndr->depth--;
 
2477
}
 
2478
 
 
2479
static enum ndr_err_code ndr_push_samr_UserInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo13 *r)
 
2480
{
 
2481
        if (ndr_flags & NDR_SCALARS) {
 
2482
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2483
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
2484
        }
 
2485
        if (ndr_flags & NDR_BUFFERS) {
 
2486
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
2487
        }
 
2488
        return NDR_ERR_SUCCESS;
 
2489
}
 
2490
 
 
2491
static enum ndr_err_code ndr_pull_samr_UserInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo13 *r)
 
2492
{
 
2493
        if (ndr_flags & NDR_SCALARS) {
 
2494
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2495
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
2496
        }
 
2497
        if (ndr_flags & NDR_BUFFERS) {
 
2498
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
2499
        }
 
2500
        return NDR_ERR_SUCCESS;
 
2501
}
 
2502
 
 
2503
_PUBLIC_ void ndr_print_samr_UserInfo13(struct ndr_print *ndr, const char *name, const struct samr_UserInfo13 *r)
 
2504
{
 
2505
        ndr_print_struct(ndr, name, "samr_UserInfo13");
 
2506
        ndr->depth++;
 
2507
        ndr_print_lsa_String(ndr, "description", &r->description);
 
2508
        ndr->depth--;
 
2509
}
 
2510
 
 
2511
static enum ndr_err_code ndr_push_samr_UserInfo14(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo14 *r)
 
2512
{
 
2513
        if (ndr_flags & NDR_SCALARS) {
 
2514
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2515
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2516
        }
 
2517
        if (ndr_flags & NDR_BUFFERS) {
 
2518
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2519
        }
 
2520
        return NDR_ERR_SUCCESS;
 
2521
}
 
2522
 
 
2523
static enum ndr_err_code ndr_pull_samr_UserInfo14(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo14 *r)
 
2524
{
 
2525
        if (ndr_flags & NDR_SCALARS) {
 
2526
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2527
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2528
        }
 
2529
        if (ndr_flags & NDR_BUFFERS) {
 
2530
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2531
        }
 
2532
        return NDR_ERR_SUCCESS;
 
2533
}
 
2534
 
 
2535
_PUBLIC_ void ndr_print_samr_UserInfo14(struct ndr_print *ndr, const char *name, const struct samr_UserInfo14 *r)
 
2536
{
 
2537
        ndr_print_struct(ndr, name, "samr_UserInfo14");
 
2538
        ndr->depth++;
 
2539
        ndr_print_lsa_String(ndr, "workstations", &r->workstations);
 
2540
        ndr->depth--;
 
2541
}
 
2542
 
 
2543
static enum ndr_err_code ndr_push_samr_UserInfo16(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo16 *r)
 
2544
{
 
2545
        if (ndr_flags & NDR_SCALARS) {
 
2546
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2547
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
 
2548
        }
 
2549
        if (ndr_flags & NDR_BUFFERS) {
 
2550
        }
 
2551
        return NDR_ERR_SUCCESS;
 
2552
}
 
2553
 
 
2554
static enum ndr_err_code ndr_pull_samr_UserInfo16(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo16 *r)
 
2555
{
 
2556
        if (ndr_flags & NDR_SCALARS) {
 
2557
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2558
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
 
2559
        }
 
2560
        if (ndr_flags & NDR_BUFFERS) {
 
2561
        }
 
2562
        return NDR_ERR_SUCCESS;
 
2563
}
 
2564
 
 
2565
_PUBLIC_ void ndr_print_samr_UserInfo16(struct ndr_print *ndr, const char *name, const struct samr_UserInfo16 *r)
 
2566
{
 
2567
        ndr_print_struct(ndr, name, "samr_UserInfo16");
 
2568
        ndr->depth++;
 
2569
        ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
 
2570
        ndr->depth--;
 
2571
}
 
2572
 
 
2573
static enum ndr_err_code ndr_push_samr_UserInfo17(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo17 *r)
 
2574
{
 
2575
        if (ndr_flags & NDR_SCALARS) {
 
2576
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2577
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
 
2578
        }
 
2579
        if (ndr_flags & NDR_BUFFERS) {
 
2580
        }
 
2581
        return NDR_ERR_SUCCESS;
 
2582
}
 
2583
 
 
2584
static enum ndr_err_code ndr_pull_samr_UserInfo17(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo17 *r)
 
2585
{
 
2586
        if (ndr_flags & NDR_SCALARS) {
 
2587
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2588
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
 
2589
        }
 
2590
        if (ndr_flags & NDR_BUFFERS) {
 
2591
        }
 
2592
        return NDR_ERR_SUCCESS;
 
2593
}
 
2594
 
 
2595
_PUBLIC_ void ndr_print_samr_UserInfo17(struct ndr_print *ndr, const char *name, const struct samr_UserInfo17 *r)
 
2596
{
 
2597
        ndr_print_struct(ndr, name, "samr_UserInfo17");
 
2598
        ndr->depth++;
 
2599
        ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
 
2600
        ndr->depth--;
 
2601
}
 
2602
 
 
2603
_PUBLIC_ enum ndr_err_code ndr_push_samr_Password(struct ndr_push *ndr, int ndr_flags, const struct samr_Password *r)
 
2604
{
 
2605
        {
 
2606
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2607
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
2608
                if (ndr_flags & NDR_SCALARS) {
 
2609
                        NDR_CHECK(ndr_push_align(ndr, 1));
 
2610
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
 
2611
                }
 
2612
                if (ndr_flags & NDR_BUFFERS) {
 
2613
                }
 
2614
                ndr->flags = _flags_save_STRUCT;
 
2615
        }
 
2616
        return NDR_ERR_SUCCESS;
 
2617
}
 
2618
 
 
2619
_PUBLIC_ enum ndr_err_code ndr_pull_samr_Password(struct ndr_pull *ndr, int ndr_flags, struct samr_Password *r)
 
2620
{
 
2621
        {
 
2622
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2623
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
2624
                if (ndr_flags & NDR_SCALARS) {
 
2625
                        NDR_CHECK(ndr_pull_align(ndr, 1));
 
2626
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
 
2627
                }
 
2628
                if (ndr_flags & NDR_BUFFERS) {
 
2629
                }
 
2630
                ndr->flags = _flags_save_STRUCT;
 
2631
        }
 
2632
        return NDR_ERR_SUCCESS;
 
2633
}
 
2634
 
 
2635
_PUBLIC_ void ndr_print_samr_Password(struct ndr_print *ndr, const char *name, const struct samr_Password *r)
 
2636
{
 
2637
        ndr_print_struct(ndr, name, "samr_Password");
 
2638
        {
 
2639
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2640
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
2641
                ndr->depth++;
 
2642
                ndr_print_array_uint8(ndr, "hash", r->hash, 16);
 
2643
                ndr->depth--;
 
2644
                ndr->flags = _flags_save_STRUCT;
 
2645
        }
 
2646
}
 
2647
 
 
2648
static enum ndr_err_code ndr_push_samr_UserInfo18(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo18 *r)
 
2649
{
 
2650
        if (ndr_flags & NDR_SCALARS) {
 
2651
                NDR_CHECK(ndr_push_align(ndr, 1));
 
2652
                NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
 
2653
                NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
 
2654
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_pwd_active));
 
2655
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_pwd_active));
 
2656
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
 
2657
        }
 
2658
        if (ndr_flags & NDR_BUFFERS) {
 
2659
        }
 
2660
        return NDR_ERR_SUCCESS;
 
2661
}
 
2662
 
 
2663
static enum ndr_err_code ndr_pull_samr_UserInfo18(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo18 *r)
 
2664
{
 
2665
        if (ndr_flags & NDR_SCALARS) {
 
2666
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
2667
                NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
 
2668
                NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
 
2669
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_pwd_active));
 
2670
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_pwd_active));
 
2671
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
 
2672
        }
 
2673
        if (ndr_flags & NDR_BUFFERS) {
 
2674
        }
 
2675
        return NDR_ERR_SUCCESS;
 
2676
}
 
2677
 
 
2678
_PUBLIC_ void ndr_print_samr_UserInfo18(struct ndr_print *ndr, const char *name, const struct samr_UserInfo18 *r)
 
2679
{
 
2680
        ndr_print_struct(ndr, name, "samr_UserInfo18");
 
2681
        ndr->depth++;
 
2682
        ndr_print_samr_Password(ndr, "nt_pwd", &r->nt_pwd);
 
2683
        ndr_print_samr_Password(ndr, "lm_pwd", &r->lm_pwd);
 
2684
        ndr_print_uint8(ndr, "nt_pwd_active", r->nt_pwd_active);
 
2685
        ndr_print_uint8(ndr, "lm_pwd_active", r->lm_pwd_active);
 
2686
        ndr_print_uint8(ndr, "password_expired", r->password_expired);
 
2687
        ndr->depth--;
 
2688
}
 
2689
 
 
2690
static enum ndr_err_code ndr_push_samr_UserInfo20(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo20 *r)
 
2691
{
 
2692
        if (ndr_flags & NDR_SCALARS) {
 
2693
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2694
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
 
2695
        }
 
2696
        if (ndr_flags & NDR_BUFFERS) {
 
2697
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
 
2698
        }
 
2699
        return NDR_ERR_SUCCESS;
 
2700
}
 
2701
 
 
2702
static enum ndr_err_code ndr_pull_samr_UserInfo20(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo20 *r)
 
2703
{
 
2704
        if (ndr_flags & NDR_SCALARS) {
 
2705
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2706
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
 
2707
        }
 
2708
        if (ndr_flags & NDR_BUFFERS) {
 
2709
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
 
2710
        }
 
2711
        return NDR_ERR_SUCCESS;
 
2712
}
 
2713
 
 
2714
_PUBLIC_ void ndr_print_samr_UserInfo20(struct ndr_print *ndr, const char *name, const struct samr_UserInfo20 *r)
 
2715
{
 
2716
        ndr_print_struct(ndr, name, "samr_UserInfo20");
 
2717
        ndr->depth++;
 
2718
        ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
 
2719
        ndr->depth--;
 
2720
}
 
2721
 
 
2722
static enum ndr_err_code ndr_push_samr_FieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
2723
{
 
2724
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
2725
        return NDR_ERR_SUCCESS;
 
2726
}
 
2727
 
 
2728
static enum ndr_err_code ndr_pull_samr_FieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
2729
{
 
2730
        uint32_t v;
 
2731
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
2732
        *r = v;
 
2733
        return NDR_ERR_SUCCESS;
 
2734
}
 
2735
 
 
2736
_PUBLIC_ void ndr_print_samr_FieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
 
2737
{
 
2738
        ndr_print_uint32(ndr, name, r);
 
2739
        ndr->depth++;
 
2740
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCOUNT_NAME", SAMR_FIELD_ACCOUNT_NAME, r);
 
2741
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FULL_NAME", SAMR_FIELD_FULL_NAME, r);
 
2742
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_RID", SAMR_FIELD_RID, r);
 
2743
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIMARY_GID", SAMR_FIELD_PRIMARY_GID, r);
 
2744
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_DESCRIPTION", SAMR_FIELD_DESCRIPTION, r);
 
2745
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COMMENT", SAMR_FIELD_COMMENT, r);
 
2746
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DIRECTORY", SAMR_FIELD_HOME_DIRECTORY, r);
 
2747
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DRIVE", SAMR_FIELD_HOME_DRIVE, r);
 
2748
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_SCRIPT", SAMR_FIELD_LOGON_SCRIPT, r);
 
2749
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PROFILE_PATH", SAMR_FIELD_PROFILE_PATH, r);
 
2750
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_WORKSTATIONS", SAMR_FIELD_WORKSTATIONS, r);
 
2751
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGON", SAMR_FIELD_LAST_LOGON, r);
 
2752
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGOFF", SAMR_FIELD_LAST_LOGOFF, r);
 
2753
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_HOURS", SAMR_FIELD_LOGON_HOURS, r);
 
2754
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_BAD_PWD_COUNT", SAMR_FIELD_BAD_PWD_COUNT, r);
 
2755
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NUM_LOGONS", SAMR_FIELD_NUM_LOGONS, r);
 
2756
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ALLOW_PWD_CHANGE", SAMR_FIELD_ALLOW_PWD_CHANGE, r);
 
2757
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FORCE_PWD_CHANGE", SAMR_FIELD_FORCE_PWD_CHANGE, r);
 
2758
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_PWD_CHANGE", SAMR_FIELD_LAST_PWD_CHANGE, r);
 
2759
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_EXPIRY", SAMR_FIELD_ACCT_EXPIRY, r);
 
2760
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_FLAGS", SAMR_FIELD_ACCT_FLAGS, r);
 
2761
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PARAMETERS", SAMR_FIELD_PARAMETERS, r);
 
2762
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COUNTRY_CODE", SAMR_FIELD_COUNTRY_CODE, r);
 
2763
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_CODE_PAGE", SAMR_FIELD_CODE_PAGE, r);
 
2764
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NT_PASSWORD_PRESENT", SAMR_FIELD_NT_PASSWORD_PRESENT, r);
 
2765
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LM_PASSWORD_PRESENT", SAMR_FIELD_LM_PASSWORD_PRESENT, r);
 
2766
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIVATE_DATA", SAMR_FIELD_PRIVATE_DATA, r);
 
2767
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_EXPIRED_FLAG", SAMR_FIELD_EXPIRED_FLAG, r);
 
2768
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_SEC_DESC", SAMR_FIELD_SEC_DESC, r);
 
2769
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_OWF_PWD", SAMR_FIELD_OWF_PWD, r);
 
2770
        ndr->depth--;
 
2771
}
 
2772
 
 
2773
static enum ndr_err_code ndr_push_samr_UserInfo21(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo21 *r)
 
2774
{
 
2775
        if (ndr_flags & NDR_SCALARS) {
 
2776
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2777
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
 
2778
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
 
2779
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
 
2780
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
 
2781
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
 
2782
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
 
2783
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2784
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2785
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2786
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2787
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2788
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2789
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
2790
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2791
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
 
2792
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
 
2793
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));
 
2794
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));
 
2795
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown3));
 
2796
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_count));
 
2797
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->buffer));
 
2798
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
 
2799
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
 
2800
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
 
2801
                NDR_CHECK(ndr_push_samr_FieldsPresent(ndr, NDR_SCALARS, r->fields_present));
 
2802
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2803
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
 
2804
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
 
2805
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
 
2806
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
 
2807
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_password_set));
 
2808
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_password_set));
 
2809
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
 
2810
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->unknown4));
 
2811
        }
 
2812
        if (ndr_flags & NDR_BUFFERS) {
 
2813
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2814
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2815
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2816
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2817
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2818
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2819
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
2820
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2821
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
 
2822
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
 
2823
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));
 
2824
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));
 
2825
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->unknown3));
 
2826
                if (r->buffer) {
 
2827
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_count));
 
2828
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->buffer, r->buf_count));
 
2829
                }
 
2830
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
2831
        }
 
2832
        return NDR_ERR_SUCCESS;
 
2833
}
 
2834
 
 
2835
static enum ndr_err_code ndr_pull_samr_UserInfo21(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo21 *r)
 
2836
{
 
2837
        uint32_t _ptr_buffer;
 
2838
        TALLOC_CTX *_mem_save_buffer_0;
 
2839
        if (ndr_flags & NDR_SCALARS) {
 
2840
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2841
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
 
2842
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
 
2843
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
 
2844
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
 
2845
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
 
2846
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
 
2847
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2848
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2849
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2850
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2851
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2852
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2853
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
2854
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2855
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
 
2856
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
 
2857
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));
 
2858
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));
 
2859
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown3));
 
2860
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_count));
 
2861
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
 
2862
                if (_ptr_buffer) {
 
2863
                        NDR_PULL_ALLOC(ndr, r->buffer);
 
2864
                } else {
 
2865
                        r->buffer = NULL;
 
2866
                }
 
2867
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
 
2868
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
 
2869
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
 
2870
                NDR_CHECK(ndr_pull_samr_FieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
 
2871
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2872
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
 
2873
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
 
2874
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
 
2875
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
 
2876
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_password_set));
 
2877
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_password_set));
 
2878
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
 
2879
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown4));
 
2880
        }
 
2881
        if (ndr_flags & NDR_BUFFERS) {
 
2882
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2883
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2884
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2885
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2886
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2887
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2888
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
2889
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2890
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
 
2891
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
 
2892
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));
 
2893
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));
 
2894
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->unknown3));
 
2895
                if (r->buffer) {
 
2896
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
2897
                        NDR_PULL_SET_MEM_CTX(ndr, r->buffer, 0);
 
2898
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->buffer));
 
2899
                        NDR_PULL_ALLOC_N(ndr, r->buffer, ndr_get_array_size(ndr, &r->buffer));
 
2900
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->buffer, ndr_get_array_size(ndr, &r->buffer)));
 
2901
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
 
2902
                }
 
2903
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
2904
                if (r->buffer) {
 
2905
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->buffer, r->buf_count));
 
2906
                }
 
2907
        }
 
2908
        return NDR_ERR_SUCCESS;
 
2909
}
 
2910
 
 
2911
_PUBLIC_ void ndr_print_samr_UserInfo21(struct ndr_print *ndr, const char *name, const struct samr_UserInfo21 *r)
 
2912
{
 
2913
        ndr_print_struct(ndr, name, "samr_UserInfo21");
 
2914
        ndr->depth++;
 
2915
        ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
 
2916
        ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
 
2917
        ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
 
2918
        ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
 
2919
        ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
 
2920
        ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
 
2921
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
2922
        ndr_print_lsa_String(ndr, "full_name", &r->full_name);
 
2923
        ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
 
2924
        ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
 
2925
        ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
 
2926
        ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
 
2927
        ndr_print_lsa_String(ndr, "description", &r->description);
 
2928
        ndr_print_lsa_String(ndr, "workstations", &r->workstations);
 
2929
        ndr_print_lsa_String(ndr, "comment", &r->comment);
 
2930
        ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
 
2931
        ndr_print_lsa_BinaryString(ndr, "lm_owf_password", &r->lm_owf_password);
 
2932
        ndr_print_lsa_BinaryString(ndr, "nt_owf_password", &r->nt_owf_password);
 
2933
        ndr_print_lsa_String(ndr, "unknown3", &r->unknown3);
 
2934
        ndr_print_uint32(ndr, "buf_count", r->buf_count);
 
2935
        ndr_print_ptr(ndr, "buffer", r->buffer);
 
2936
        ndr->depth++;
 
2937
        if (r->buffer) {
 
2938
                ndr_print_array_uint8(ndr, "buffer", r->buffer, r->buf_count);
 
2939
        }
 
2940
        ndr->depth--;
 
2941
        ndr_print_uint32(ndr, "rid", r->rid);
 
2942
        ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
 
2943
        ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
 
2944
        ndr_print_samr_FieldsPresent(ndr, "fields_present", r->fields_present);
 
2945
        ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
 
2946
        ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
 
2947
        ndr_print_uint16(ndr, "logon_count", r->logon_count);
 
2948
        ndr_print_uint16(ndr, "country_code", r->country_code);
 
2949
        ndr_print_uint16(ndr, "code_page", r->code_page);
 
2950
        ndr_print_uint8(ndr, "lm_password_set", r->lm_password_set);
 
2951
        ndr_print_uint8(ndr, "nt_password_set", r->nt_password_set);
 
2952
        ndr_print_uint8(ndr, "password_expired", r->password_expired);
 
2953
        ndr_print_uint8(ndr, "unknown4", r->unknown4);
 
2954
        ndr->depth--;
 
2955
}
 
2956
 
 
2957
_PUBLIC_ enum ndr_err_code ndr_push_samr_CryptPassword(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPassword *r)
 
2958
{
 
2959
        {
 
2960
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2961
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
2962
                if (ndr_flags & NDR_SCALARS) {
 
2963
                        NDR_CHECK(ndr_push_align(ndr, 1));
 
2964
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 516));
 
2965
                }
 
2966
                if (ndr_flags & NDR_BUFFERS) {
 
2967
                }
 
2968
                ndr->flags = _flags_save_STRUCT;
 
2969
        }
 
2970
        return NDR_ERR_SUCCESS;
 
2971
}
 
2972
 
 
2973
_PUBLIC_ enum ndr_err_code ndr_pull_samr_CryptPassword(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPassword *r)
 
2974
{
 
2975
        {
 
2976
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2977
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
2978
                if (ndr_flags & NDR_SCALARS) {
 
2979
                        NDR_CHECK(ndr_pull_align(ndr, 1));
 
2980
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 516));
 
2981
                }
 
2982
                if (ndr_flags & NDR_BUFFERS) {
 
2983
                }
 
2984
                ndr->flags = _flags_save_STRUCT;
 
2985
        }
 
2986
        return NDR_ERR_SUCCESS;
 
2987
}
 
2988
 
 
2989
_PUBLIC_ void ndr_print_samr_CryptPassword(struct ndr_print *ndr, const char *name, const struct samr_CryptPassword *r)
 
2990
{
 
2991
        ndr_print_struct(ndr, name, "samr_CryptPassword");
 
2992
        {
 
2993
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2994
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
2995
                ndr->depth++;
 
2996
                ndr_print_array_uint8(ndr, "data", r->data, 516);
 
2997
                ndr->depth--;
 
2998
                ndr->flags = _flags_save_STRUCT;
 
2999
        }
 
3000
}
 
3001
 
 
3002
static enum ndr_err_code ndr_push_samr_UserInfo23(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo23 *r)
 
3003
{
 
3004
        if (ndr_flags & NDR_SCALARS) {
 
3005
                NDR_CHECK(ndr_push_align(ndr, 4));
 
3006
                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
 
3007
                NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
 
3008
        }
 
3009
        if (ndr_flags & NDR_BUFFERS) {
 
3010
                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
 
3011
        }
 
3012
        return NDR_ERR_SUCCESS;
 
3013
}
 
3014
 
 
3015
static enum ndr_err_code ndr_pull_samr_UserInfo23(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo23 *r)
 
3016
{
 
3017
        if (ndr_flags & NDR_SCALARS) {
 
3018
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
3019
                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
 
3020
                NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
 
3021
        }
 
3022
        if (ndr_flags & NDR_BUFFERS) {
 
3023
                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
 
3024
        }
 
3025
        return NDR_ERR_SUCCESS;
 
3026
}
 
3027
 
 
3028
_PUBLIC_ void ndr_print_samr_UserInfo23(struct ndr_print *ndr, const char *name, const struct samr_UserInfo23 *r)
 
3029
{
 
3030
        ndr_print_struct(ndr, name, "samr_UserInfo23");
 
3031
        ndr->depth++;
 
3032
        ndr_print_samr_UserInfo21(ndr, "info", &r->info);
 
3033
        ndr_print_samr_CryptPassword(ndr, "password", &r->password);
 
3034
        ndr->depth--;
 
3035
}
 
3036
 
 
3037
static enum ndr_err_code ndr_push_samr_UserInfo24(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo24 *r)
 
3038
{
 
3039
        if (ndr_flags & NDR_SCALARS) {
 
3040
                NDR_CHECK(ndr_push_align(ndr, 1));
 
3041
                NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
 
3042
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
 
3043
        }
 
3044
        if (ndr_flags & NDR_BUFFERS) {
 
3045
        }
 
3046
        return NDR_ERR_SUCCESS;
 
3047
}
 
3048
 
 
3049
static enum ndr_err_code ndr_pull_samr_UserInfo24(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo24 *r)
 
3050
{
 
3051
        if (ndr_flags & NDR_SCALARS) {
 
3052
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
3053
                NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
 
3054
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
 
3055
        }
 
3056
        if (ndr_flags & NDR_BUFFERS) {
 
3057
        }
 
3058
        return NDR_ERR_SUCCESS;
 
3059
}
 
3060
 
 
3061
_PUBLIC_ void ndr_print_samr_UserInfo24(struct ndr_print *ndr, const char *name, const struct samr_UserInfo24 *r)
 
3062
{
 
3063
        ndr_print_struct(ndr, name, "samr_UserInfo24");
 
3064
        ndr->depth++;
 
3065
        ndr_print_samr_CryptPassword(ndr, "password", &r->password);
 
3066
        ndr_print_uint8(ndr, "password_expired", r->password_expired);
 
3067
        ndr->depth--;
 
3068
}
 
3069
 
 
3070
static enum ndr_err_code ndr_push_samr_CryptPasswordEx(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPasswordEx *r)
 
3071
{
 
3072
        {
 
3073
                uint32_t _flags_save_STRUCT = ndr->flags;
 
3074
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
3075
                if (ndr_flags & NDR_SCALARS) {
 
3076
                        NDR_CHECK(ndr_push_align(ndr, 1));
 
3077
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 532));
 
3078
                }
 
3079
                if (ndr_flags & NDR_BUFFERS) {
 
3080
                }
 
3081
                ndr->flags = _flags_save_STRUCT;
 
3082
        }
 
3083
        return NDR_ERR_SUCCESS;
 
3084
}
 
3085
 
 
3086
static enum ndr_err_code ndr_pull_samr_CryptPasswordEx(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPasswordEx *r)
 
3087
{
 
3088
        {
 
3089
                uint32_t _flags_save_STRUCT = ndr->flags;
 
3090
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
3091
                if (ndr_flags & NDR_SCALARS) {
 
3092
                        NDR_CHECK(ndr_pull_align(ndr, 1));
 
3093
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 532));
 
3094
                }
 
3095
                if (ndr_flags & NDR_BUFFERS) {
 
3096
                }
 
3097
                ndr->flags = _flags_save_STRUCT;
 
3098
        }
 
3099
        return NDR_ERR_SUCCESS;
 
3100
}
 
3101
 
 
3102
_PUBLIC_ void ndr_print_samr_CryptPasswordEx(struct ndr_print *ndr, const char *name, const struct samr_CryptPasswordEx *r)
 
3103
{
 
3104
        ndr_print_struct(ndr, name, "samr_CryptPasswordEx");
 
3105
        {
 
3106
                uint32_t _flags_save_STRUCT = ndr->flags;
 
3107
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
3108
                ndr->depth++;
 
3109
                ndr_print_array_uint8(ndr, "data", r->data, 532);
 
3110
                ndr->depth--;
 
3111
                ndr->flags = _flags_save_STRUCT;
 
3112
        }
 
3113
}
 
3114
 
 
3115
static enum ndr_err_code ndr_push_samr_UserInfo25(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo25 *r)
 
3116
{
 
3117
        if (ndr_flags & NDR_SCALARS) {
 
3118
                NDR_CHECK(ndr_push_align(ndr, 4));
 
3119
                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
 
3120
                NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
 
3121
        }
 
3122
        if (ndr_flags & NDR_BUFFERS) {
 
3123
                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
 
3124
        }
 
3125
        return NDR_ERR_SUCCESS;
 
3126
}
 
3127
 
 
3128
static enum ndr_err_code ndr_pull_samr_UserInfo25(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo25 *r)
 
3129
{
 
3130
        if (ndr_flags & NDR_SCALARS) {
 
3131
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
3132
                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
 
3133
                NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
 
3134
        }
 
3135
        if (ndr_flags & NDR_BUFFERS) {
 
3136
                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
 
3137
        }
 
3138
        return NDR_ERR_SUCCESS;
 
3139
}
 
3140
 
 
3141
_PUBLIC_ void ndr_print_samr_UserInfo25(struct ndr_print *ndr, const char *name, const struct samr_UserInfo25 *r)
 
3142
{
 
3143
        ndr_print_struct(ndr, name, "samr_UserInfo25");
 
3144
        ndr->depth++;
 
3145
        ndr_print_samr_UserInfo21(ndr, "info", &r->info);
 
3146
        ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
 
3147
        ndr->depth--;
 
3148
}
 
3149
 
 
3150
static enum ndr_err_code ndr_push_samr_UserInfo26(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo26 *r)
 
3151
{
 
3152
        if (ndr_flags & NDR_SCALARS) {
 
3153
                NDR_CHECK(ndr_push_align(ndr, 1));
 
3154
                NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
 
3155
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
 
3156
        }
 
3157
        if (ndr_flags & NDR_BUFFERS) {
 
3158
        }
 
3159
        return NDR_ERR_SUCCESS;
 
3160
}
 
3161
 
 
3162
static enum ndr_err_code ndr_pull_samr_UserInfo26(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo26 *r)
 
3163
{
 
3164
        if (ndr_flags & NDR_SCALARS) {
 
3165
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
3166
                NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
 
3167
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
 
3168
        }
 
3169
        if (ndr_flags & NDR_BUFFERS) {
 
3170
        }
 
3171
        return NDR_ERR_SUCCESS;
 
3172
}
 
3173
 
 
3174
_PUBLIC_ void ndr_print_samr_UserInfo26(struct ndr_print *ndr, const char *name, const struct samr_UserInfo26 *r)
 
3175
{
 
3176
        ndr_print_struct(ndr, name, "samr_UserInfo26");
 
3177
        ndr->depth++;
 
3178
        ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
 
3179
        ndr_print_uint8(ndr, "password_expired", r->password_expired);
 
3180
        ndr->depth--;
 
3181
}
 
3182
 
 
3183
static enum ndr_err_code ndr_push_samr_UserInfo(struct ndr_push *ndr, int ndr_flags, const union samr_UserInfo *r)
 
3184
{
 
3185
        if (ndr_flags & NDR_SCALARS) {
 
3186
                int level = ndr_push_get_switch_value(ndr, r);
 
3187
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 
3188
                switch (level) {
 
3189
                        case 1: {
 
3190
                                NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
 
3191
                        break; }
 
3192
 
 
3193
                        case 2: {
 
3194
                                NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
 
3195
                        break; }
 
3196
 
 
3197
                        case 3: {
 
3198
                                NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
 
3199
                        break; }
 
3200
 
 
3201
                        case 4: {
 
3202
                                NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
 
3203
                        break; }
 
3204
 
 
3205
                        case 5: {
 
3206
                                NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
 
3207
                        break; }
 
3208
 
 
3209
                        case 6: {
 
3210
                                NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
 
3211
                        break; }
 
3212
 
 
3213
                        case 7: {
 
3214
                                NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
 
3215
                        break; }
 
3216
 
 
3217
                        case 8: {
 
3218
                                NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
 
3219
                        break; }
 
3220
 
 
3221
                        case 9: {
 
3222
                                NDR_CHECK(ndr_push_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
 
3223
                        break; }
 
3224
 
 
3225
                        case 10: {
 
3226
                                NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
 
3227
                        break; }
 
3228
 
 
3229
                        case 11: {
 
3230
                                NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
 
3231
                        break; }
 
3232
 
 
3233
                        case 12: {
 
3234
                                NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
 
3235
                        break; }
 
3236
 
 
3237
                        case 13: {
 
3238
                                NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
 
3239
                        break; }
 
3240
 
 
3241
                        case 14: {
 
3242
                                NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
 
3243
                        break; }
 
3244
 
 
3245
                        case 16: {
 
3246
                                NDR_CHECK(ndr_push_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
 
3247
                        break; }
 
3248
 
 
3249
                        case 17: {
 
3250
                                NDR_CHECK(ndr_push_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
 
3251
                        break; }
 
3252
 
 
3253
                        case 18: {
 
3254
                                NDR_CHECK(ndr_push_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
 
3255
                        break; }
 
3256
 
 
3257
                        case 20: {
 
3258
                                NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
 
3259
                        break; }
 
3260
 
 
3261
                        case 21: {
 
3262
                                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
 
3263
                        break; }
 
3264
 
 
3265
                        case 23: {
 
3266
                                NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
 
3267
                        break; }
 
3268
 
 
3269
                        case 24: {
 
3270
                                NDR_CHECK(ndr_push_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
 
3271
                        break; }
 
3272
 
 
3273
                        case 25: {
 
3274
                                NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
 
3275
                        break; }
 
3276
 
 
3277
                        case 26: {
 
3278
                                NDR_CHECK(ndr_push_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
 
3279
                        break; }
 
3280
 
 
3281
                        default:
 
3282
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
3283
                }
 
3284
        }
 
3285
        if (ndr_flags & NDR_BUFFERS) {
 
3286
                int level = ndr_push_get_switch_value(ndr, r);
 
3287
                switch (level) {
 
3288
                        case 1:
 
3289
                                NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
 
3290
                        break;
 
3291
 
 
3292
                        case 2:
 
3293
                                NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
 
3294
                        break;
 
3295
 
 
3296
                        case 3:
 
3297
                                NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
 
3298
                        break;
 
3299
 
 
3300
                        case 4:
 
3301
                                NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
 
3302
                        break;
 
3303
 
 
3304
                        case 5:
 
3305
                                NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
 
3306
                        break;
 
3307
 
 
3308
                        case 6:
 
3309
                                NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
 
3310
                        break;
 
3311
 
 
3312
                        case 7:
 
3313
                                NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
 
3314
                        break;
 
3315
 
 
3316
                        case 8:
 
3317
                                NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
 
3318
                        break;
 
3319
 
 
3320
                        case 9:
 
3321
                        break;
 
3322
 
 
3323
                        case 10:
 
3324
                                NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
 
3325
                        break;
 
3326
 
 
3327
                        case 11:
 
3328
                                NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
 
3329
                        break;
 
3330
 
 
3331
                        case 12:
 
3332
                                NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
 
3333
                        break;
 
3334
 
 
3335
                        case 13:
 
3336
                                NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
 
3337
                        break;
 
3338
 
 
3339
                        case 14:
 
3340
                                NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
 
3341
                        break;
 
3342
 
 
3343
                        case 16:
 
3344
                        break;
 
3345
 
 
3346
                        case 17:
 
3347
                        break;
 
3348
 
 
3349
                        case 18:
 
3350
                        break;
 
3351
 
 
3352
                        case 20:
 
3353
                                NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
 
3354
                        break;
 
3355
 
 
3356
                        case 21:
 
3357
                                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
 
3358
                        break;
 
3359
 
 
3360
                        case 23:
 
3361
                                NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
 
3362
                        break;
 
3363
 
 
3364
                        case 24:
 
3365
                        break;
 
3366
 
 
3367
                        case 25:
 
3368
                                NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
 
3369
                        break;
 
3370
 
 
3371
                        case 26:
 
3372
                        break;
 
3373
 
 
3374
                        default:
 
3375
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
3376
                }
 
3377
        }
 
3378
        return NDR_ERR_SUCCESS;
 
3379
}
 
3380
 
 
3381
static enum ndr_err_code ndr_pull_samr_UserInfo(struct ndr_pull *ndr, int ndr_flags, union samr_UserInfo *r)
 
3382
{
 
3383
        int level;
 
3384
        uint16_t _level;
 
3385
        level = ndr_pull_get_switch_value(ndr, r);
 
3386
        if (ndr_flags & NDR_SCALARS) {
 
3387
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
3388
                if (_level != level) {
 
3389
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 
3390
                }
 
3391
                switch (level) {
 
3392
                        case 1: {
 
3393
                                NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
 
3394
                        break; }
 
3395
 
 
3396
                        case 2: {
 
3397
                                NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
 
3398
                        break; }
 
3399
 
 
3400
                        case 3: {
 
3401
                                NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
 
3402
                        break; }
 
3403
 
 
3404
                        case 4: {
 
3405
                                NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
 
3406
                        break; }
 
3407
 
 
3408
                        case 5: {
 
3409
                                NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
 
3410
                        break; }
 
3411
 
 
3412
                        case 6: {
 
3413
                                NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
 
3414
                        break; }
 
3415
 
 
3416
                        case 7: {
 
3417
                                NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
 
3418
                        break; }
 
3419
 
 
3420
                        case 8: {
 
3421
                                NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
 
3422
                        break; }
 
3423
 
 
3424
                        case 9: {
 
3425
                                NDR_CHECK(ndr_pull_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
 
3426
                        break; }
 
3427
 
 
3428
                        case 10: {
 
3429
                                NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
 
3430
                        break; }
 
3431
 
 
3432
                        case 11: {
 
3433
                                NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
 
3434
                        break; }
 
3435
 
 
3436
                        case 12: {
 
3437
                                NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
 
3438
                        break; }
 
3439
 
 
3440
                        case 13: {
 
3441
                                NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
 
3442
                        break; }
 
3443
 
 
3444
                        case 14: {
 
3445
                                NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
 
3446
                        break; }
 
3447
 
 
3448
                        case 16: {
 
3449
                                NDR_CHECK(ndr_pull_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
 
3450
                        break; }
 
3451
 
 
3452
                        case 17: {
 
3453
                                NDR_CHECK(ndr_pull_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
 
3454
                        break; }
 
3455
 
 
3456
                        case 18: {
 
3457
                                NDR_CHECK(ndr_pull_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
 
3458
                        break; }
 
3459
 
 
3460
                        case 20: {
 
3461
                                NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
 
3462
                        break; }
 
3463
 
 
3464
                        case 21: {
 
3465
                                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
 
3466
                        break; }
 
3467
 
 
3468
                        case 23: {
 
3469
                                NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
 
3470
                        break; }
 
3471
 
 
3472
                        case 24: {
 
3473
                                NDR_CHECK(ndr_pull_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
 
3474
                        break; }
 
3475
 
 
3476
                        case 25: {
 
3477
                                NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
 
3478
                        break; }
 
3479
 
 
3480
                        case 26: {
 
3481
                                NDR_CHECK(ndr_pull_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
 
3482
                        break; }
 
3483
 
 
3484
                        default:
 
3485
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
3486
                }
 
3487
        }
 
3488
        if (ndr_flags & NDR_BUFFERS) {
 
3489
                switch (level) {
 
3490
                        case 1:
 
3491
                                NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
 
3492
                        break;
 
3493
 
 
3494
                        case 2:
 
3495
                                NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
 
3496
                        break;
 
3497
 
 
3498
                        case 3:
 
3499
                                NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
 
3500
                        break;
 
3501
 
 
3502
                        case 4:
 
3503
                                NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
 
3504
                        break;
 
3505
 
 
3506
                        case 5:
 
3507
                                NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
 
3508
                        break;
 
3509
 
 
3510
                        case 6:
 
3511
                                NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
 
3512
                        break;
 
3513
 
 
3514
                        case 7:
 
3515
                                NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
 
3516
                        break;
 
3517
 
 
3518
                        case 8:
 
3519
                                NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
 
3520
                        break;
 
3521
 
 
3522
                        case 9:
 
3523
                        break;
 
3524
 
 
3525
                        case 10:
 
3526
                                NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
 
3527
                        break;
 
3528
 
 
3529
                        case 11:
 
3530
                                NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
 
3531
                        break;
 
3532
 
 
3533
                        case 12:
 
3534
                                NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
 
3535
                        break;
 
3536
 
 
3537
                        case 13:
 
3538
                                NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
 
3539
                        break;
 
3540
 
 
3541
                        case 14:
 
3542
                                NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
 
3543
                        break;
 
3544
 
 
3545
                        case 16:
 
3546
                        break;
 
3547
 
 
3548
                        case 17:
 
3549
                        break;
 
3550
 
 
3551
                        case 18:
 
3552
                        break;
 
3553
 
 
3554
                        case 20:
 
3555
                                NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
 
3556
                        break;
 
3557
 
 
3558
                        case 21:
 
3559
                                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
 
3560
                        break;
 
3561
 
 
3562
                        case 23:
 
3563
                                NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
 
3564
                        break;
 
3565
 
 
3566
                        case 24:
 
3567
                        break;
 
3568
 
 
3569
                        case 25:
 
3570
                                NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
 
3571
                        break;
 
3572
 
 
3573
                        case 26:
 
3574
                        break;
 
3575
 
 
3576
                        default:
 
3577
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
3578
                }
 
3579
        }
 
3580
        return NDR_ERR_SUCCESS;
 
3581
}
 
3582
 
 
3583
_PUBLIC_ void ndr_print_samr_UserInfo(struct ndr_print *ndr, const char *name, const union samr_UserInfo *r)
 
3584
{
 
3585
        int level;
 
3586
        level = ndr_print_get_switch_value(ndr, r);
 
3587
        ndr_print_union(ndr, name, level, "samr_UserInfo");
 
3588
        switch (level) {
 
3589
                case 1:
 
3590
                        ndr_print_samr_UserInfo1(ndr, "info1", &r->info1);
 
3591
                break;
 
3592
 
 
3593
                case 2:
 
3594
                        ndr_print_samr_UserInfo2(ndr, "info2", &r->info2);
 
3595
                break;
 
3596
 
 
3597
                case 3:
 
3598
                        ndr_print_samr_UserInfo3(ndr, "info3", &r->info3);
 
3599
                break;
 
3600
 
 
3601
                case 4:
 
3602
                        ndr_print_samr_UserInfo4(ndr, "info4", &r->info4);
 
3603
                break;
 
3604
 
 
3605
                case 5:
 
3606
                        ndr_print_samr_UserInfo5(ndr, "info5", &r->info5);
 
3607
                break;
 
3608
 
 
3609
                case 6:
 
3610
                        ndr_print_samr_UserInfo6(ndr, "info6", &r->info6);
 
3611
                break;
 
3612
 
 
3613
                case 7:
 
3614
                        ndr_print_samr_UserInfo7(ndr, "info7", &r->info7);
 
3615
                break;
 
3616
 
 
3617
                case 8:
 
3618
                        ndr_print_samr_UserInfo8(ndr, "info8", &r->info8);
 
3619
                break;
 
3620
 
 
3621
                case 9:
 
3622
                        ndr_print_samr_UserInfo9(ndr, "info9", &r->info9);
 
3623
                break;
 
3624
 
 
3625
                case 10:
 
3626
                        ndr_print_samr_UserInfo10(ndr, "info10", &r->info10);
 
3627
                break;
 
3628
 
 
3629
                case 11:
 
3630
                        ndr_print_samr_UserInfo11(ndr, "info11", &r->info11);
 
3631
                break;
 
3632
 
 
3633
                case 12:
 
3634
                        ndr_print_samr_UserInfo12(ndr, "info12", &r->info12);
 
3635
                break;
 
3636
 
 
3637
                case 13:
 
3638
                        ndr_print_samr_UserInfo13(ndr, "info13", &r->info13);
 
3639
                break;
 
3640
 
 
3641
                case 14:
 
3642
                        ndr_print_samr_UserInfo14(ndr, "info14", &r->info14);
 
3643
                break;
 
3644
 
 
3645
                case 16:
 
3646
                        ndr_print_samr_UserInfo16(ndr, "info16", &r->info16);
 
3647
                break;
 
3648
 
 
3649
                case 17:
 
3650
                        ndr_print_samr_UserInfo17(ndr, "info17", &r->info17);
 
3651
                break;
 
3652
 
 
3653
                case 18:
 
3654
                        ndr_print_samr_UserInfo18(ndr, "info18", &r->info18);
 
3655
                break;
 
3656
 
 
3657
                case 20:
 
3658
                        ndr_print_samr_UserInfo20(ndr, "info20", &r->info20);
 
3659
                break;
 
3660
 
 
3661
                case 21:
 
3662
                        ndr_print_samr_UserInfo21(ndr, "info21", &r->info21);
 
3663
                break;
 
3664
 
 
3665
                case 23:
 
3666
                        ndr_print_samr_UserInfo23(ndr, "info23", &r->info23);
 
3667
                break;
 
3668
 
 
3669
                case 24:
 
3670
                        ndr_print_samr_UserInfo24(ndr, "info24", &r->info24);
 
3671
                break;
 
3672
 
 
3673
                case 25:
 
3674
                        ndr_print_samr_UserInfo25(ndr, "info25", &r->info25);
 
3675
                break;
 
3676
 
 
3677
                case 26:
 
3678
                        ndr_print_samr_UserInfo26(ndr, "info26", &r->info26);
 
3679
                break;
 
3680
 
 
3681
                default:
 
3682
                        ndr_print_bad_level(ndr, name, level);
 
3683
        }
 
3684
}
 
3685
 
 
3686
_PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttribute(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttribute *r)
 
3687
{
 
3688
        if (ndr_flags & NDR_SCALARS) {
 
3689
                NDR_CHECK(ndr_push_align(ndr, 4));
 
3690
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
 
3691
                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
 
3692
        }
 
3693
        if (ndr_flags & NDR_BUFFERS) {
 
3694
        }
 
3695
        return NDR_ERR_SUCCESS;
 
3696
}
 
3697
 
 
3698
_PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttribute(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttribute *r)
 
3699
{
 
3700
        if (ndr_flags & NDR_SCALARS) {
 
3701
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
3702
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
 
3703
                NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
 
3704
        }
 
3705
        if (ndr_flags & NDR_BUFFERS) {
 
3706
        }
 
3707
        return NDR_ERR_SUCCESS;
 
3708
}
 
3709
 
 
3710
_PUBLIC_ void ndr_print_samr_RidWithAttribute(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttribute *r)
 
3711
{
 
3712
        ndr_print_struct(ndr, name, "samr_RidWithAttribute");
 
3713
        ndr->depth++;
 
3714
        ndr_print_uint32(ndr, "rid", r->rid);
 
3715
        ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
 
3716
        ndr->depth--;
 
3717
}
 
3718
 
 
3719
_PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttributeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttributeArray *r)
 
3720
{
 
3721
        uint32_t cntr_rids_1;
 
3722
        if (ndr_flags & NDR_SCALARS) {
 
3723
                NDR_CHECK(ndr_push_align(ndr, 4));
 
3724
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
3725
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
 
3726
        }
 
3727
        if (ndr_flags & NDR_BUFFERS) {
 
3728
                if (r->rids) {
 
3729
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
3730
                        for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
 
3731
                                NDR_CHECK(ndr_push_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
 
3732
                        }
 
3733
                }
 
3734
        }
 
3735
        return NDR_ERR_SUCCESS;
 
3736
}
 
3737
 
 
3738
_PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttributeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttributeArray *r)
 
3739
{
 
3740
        uint32_t _ptr_rids;
 
3741
        uint32_t cntr_rids_1;
 
3742
        TALLOC_CTX *_mem_save_rids_0;
 
3743
        TALLOC_CTX *_mem_save_rids_1;
 
3744
        if (ndr_flags & NDR_SCALARS) {
 
3745
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
3746
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
3747
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
 
3748
                if (_ptr_rids) {
 
3749
                        NDR_PULL_ALLOC(ndr, r->rids);
 
3750
                } else {
 
3751
                        r->rids = NULL;
 
3752
                }
 
3753
        }
 
3754
        if (ndr_flags & NDR_BUFFERS) {
 
3755
                if (r->rids) {
 
3756
                        _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
3757
                        NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
 
3758
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
 
3759
                        NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));
 
3760
                        _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
3761
                        NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
 
3762
                        for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
 
3763
                                NDR_CHECK(ndr_pull_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
 
3764
                        }
 
3765
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
 
3766
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
 
3767
                }
 
3768
                if (r->rids) {
 
3769
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
 
3770
                }
 
3771
        }
 
3772
        return NDR_ERR_SUCCESS;
 
3773
}
 
3774
 
 
3775
_PUBLIC_ void ndr_print_samr_RidWithAttributeArray(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttributeArray *r)
 
3776
{
 
3777
        uint32_t cntr_rids_1;
 
3778
        ndr_print_struct(ndr, name, "samr_RidWithAttributeArray");
 
3779
        ndr->depth++;
 
3780
        ndr_print_uint32(ndr, "count", r->count);
 
3781
        ndr_print_ptr(ndr, "rids", r->rids);
 
3782
        ndr->depth++;
 
3783
        if (r->rids) {
 
3784
                ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
 
3785
                ndr->depth++;
 
3786
                for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
 
3787
                        char *idx_1=NULL;
 
3788
                        if (asprintf(&idx_1, "[%d]", cntr_rids_1) != -1) {
 
3789
                                ndr_print_samr_RidWithAttribute(ndr, "rids", &r->rids[cntr_rids_1]);
 
3790
                                free(idx_1);
 
3791
                        }
 
3792
                }
 
3793
                ndr->depth--;
 
3794
        }
 
3795
        ndr->depth--;
 
3796
        ndr->depth--;
 
3797
}
 
3798
 
 
3799
static enum ndr_err_code ndr_push_samr_DispEntryGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryGeneral *r)
 
3800
{
 
3801
        if (ndr_flags & NDR_SCALARS) {
 
3802
                NDR_CHECK(ndr_push_align(ndr, 4));
 
3803
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
 
3804
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
 
3805
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
 
3806
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
3807
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
3808
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
3809
        }
 
3810
        if (ndr_flags & NDR_BUFFERS) {
 
3811
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
3812
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
3813
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
3814
        }
 
3815
        return NDR_ERR_SUCCESS;
 
3816
}
 
3817
 
 
3818
static enum ndr_err_code ndr_pull_samr_DispEntryGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryGeneral *r)
 
3819
{
 
3820
        if (ndr_flags & NDR_SCALARS) {
 
3821
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
3822
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
 
3823
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
 
3824
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
 
3825
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
3826
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
3827
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
3828
        }
 
3829
        if (ndr_flags & NDR_BUFFERS) {
 
3830
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
3831
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
3832
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
3833
        }
 
3834
        return NDR_ERR_SUCCESS;
 
3835
}
 
3836
 
 
3837
_PUBLIC_ void ndr_print_samr_DispEntryGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispEntryGeneral *r)
 
3838
{
 
3839
        ndr_print_struct(ndr, name, "samr_DispEntryGeneral");
 
3840
        ndr->depth++;
 
3841
        ndr_print_uint32(ndr, "idx", r->idx);
 
3842
        ndr_print_uint32(ndr, "rid", r->rid);
 
3843
        ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
 
3844
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
3845
        ndr_print_lsa_String(ndr, "description", &r->description);
 
3846
        ndr_print_lsa_String(ndr, "full_name", &r->full_name);
 
3847
        ndr->depth--;
 
3848
}
 
3849
 
 
3850
static enum ndr_err_code ndr_push_samr_DispInfoGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoGeneral *r)
 
3851
{
 
3852
        uint32_t cntr_entries_1;
 
3853
        if (ndr_flags & NDR_SCALARS) {
 
3854
                NDR_CHECK(ndr_push_align(ndr, 4));
 
3855
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
3856
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
 
3857
        }
 
3858
        if (ndr_flags & NDR_BUFFERS) {
 
3859
                if (r->entries) {
 
3860
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
3861
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
3862
                                NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
3863
                        }
 
3864
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
3865
                                NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
3866
                        }
 
3867
                }
 
3868
        }
 
3869
        return NDR_ERR_SUCCESS;
 
3870
}
 
3871
 
 
3872
static enum ndr_err_code ndr_pull_samr_DispInfoGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoGeneral *r)
 
3873
{
 
3874
        uint32_t _ptr_entries;
 
3875
        uint32_t cntr_entries_1;
 
3876
        TALLOC_CTX *_mem_save_entries_0;
 
3877
        TALLOC_CTX *_mem_save_entries_1;
 
3878
        if (ndr_flags & NDR_SCALARS) {
 
3879
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
3880
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
3881
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 
3882
                if (_ptr_entries) {
 
3883
                        NDR_PULL_ALLOC(ndr, r->entries);
 
3884
                } else {
 
3885
                        r->entries = NULL;
 
3886
                }
 
3887
        }
 
3888
        if (ndr_flags & NDR_BUFFERS) {
 
3889
                if (r->entries) {
 
3890
                        _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
3891
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
3892
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 
3893
                        NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
 
3894
                        _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
3895
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
3896
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
3897
                                NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
3898
                        }
 
3899
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
3900
                                NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
3901
                        }
 
3902
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 
3903
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 
3904
                }
 
3905
                if (r->entries) {
 
3906
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 
3907
                }
 
3908
        }
 
3909
        return NDR_ERR_SUCCESS;
 
3910
}
 
3911
 
 
3912
_PUBLIC_ void ndr_print_samr_DispInfoGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispInfoGeneral *r)
 
3913
{
 
3914
        uint32_t cntr_entries_1;
 
3915
        ndr_print_struct(ndr, name, "samr_DispInfoGeneral");
 
3916
        ndr->depth++;
 
3917
        ndr_print_uint32(ndr, "count", r->count);
 
3918
        ndr_print_ptr(ndr, "entries", r->entries);
 
3919
        ndr->depth++;
 
3920
        if (r->entries) {
 
3921
                ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 
3922
                ndr->depth++;
 
3923
                for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 
3924
                        char *idx_1=NULL;
 
3925
                        if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
 
3926
                                ndr_print_samr_DispEntryGeneral(ndr, "entries", &r->entries[cntr_entries_1]);
 
3927
                                free(idx_1);
 
3928
                        }
 
3929
                }
 
3930
                ndr->depth--;
 
3931
        }
 
3932
        ndr->depth--;
 
3933
        ndr->depth--;
 
3934
}
 
3935
 
 
3936
static enum ndr_err_code ndr_push_samr_DispEntryFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFull *r)
 
3937
{
 
3938
        if (ndr_flags & NDR_SCALARS) {
 
3939
                NDR_CHECK(ndr_push_align(ndr, 4));
 
3940
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
 
3941
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
 
3942
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
 
3943
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
3944
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
3945
        }
 
3946
        if (ndr_flags & NDR_BUFFERS) {
 
3947
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
3948
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
3949
        }
 
3950
        return NDR_ERR_SUCCESS;
 
3951
}
 
3952
 
 
3953
static enum ndr_err_code ndr_pull_samr_DispEntryFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFull *r)
 
3954
{
 
3955
        if (ndr_flags & NDR_SCALARS) {
 
3956
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
3957
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
 
3958
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
 
3959
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
 
3960
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
3961
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
3962
        }
 
3963
        if (ndr_flags & NDR_BUFFERS) {
 
3964
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
3965
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
3966
        }
 
3967
        return NDR_ERR_SUCCESS;
 
3968
}
 
3969
 
 
3970
_PUBLIC_ void ndr_print_samr_DispEntryFull(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFull *r)
 
3971
{
 
3972
        ndr_print_struct(ndr, name, "samr_DispEntryFull");
 
3973
        ndr->depth++;
 
3974
        ndr_print_uint32(ndr, "idx", r->idx);
 
3975
        ndr_print_uint32(ndr, "rid", r->rid);
 
3976
        ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
 
3977
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
3978
        ndr_print_lsa_String(ndr, "description", &r->description);
 
3979
        ndr->depth--;
 
3980
}
 
3981
 
 
3982
static enum ndr_err_code ndr_push_samr_DispInfoFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFull *r)
 
3983
{
 
3984
        uint32_t cntr_entries_1;
 
3985
        if (ndr_flags & NDR_SCALARS) {
 
3986
                NDR_CHECK(ndr_push_align(ndr, 4));
 
3987
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
3988
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
 
3989
        }
 
3990
        if (ndr_flags & NDR_BUFFERS) {
 
3991
                if (r->entries) {
 
3992
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
3993
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
3994
                                NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
3995
                        }
 
3996
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
3997
                                NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
3998
                        }
 
3999
                }
 
4000
        }
 
4001
        return NDR_ERR_SUCCESS;
 
4002
}
 
4003
 
 
4004
static enum ndr_err_code ndr_pull_samr_DispInfoFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFull *r)
 
4005
{
 
4006
        uint32_t _ptr_entries;
 
4007
        uint32_t cntr_entries_1;
 
4008
        TALLOC_CTX *_mem_save_entries_0;
 
4009
        TALLOC_CTX *_mem_save_entries_1;
 
4010
        if (ndr_flags & NDR_SCALARS) {
 
4011
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
4012
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
4013
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 
4014
                if (_ptr_entries) {
 
4015
                        NDR_PULL_ALLOC(ndr, r->entries);
 
4016
                } else {
 
4017
                        r->entries = NULL;
 
4018
                }
 
4019
        }
 
4020
        if (ndr_flags & NDR_BUFFERS) {
 
4021
                if (r->entries) {
 
4022
                        _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
4023
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
4024
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 
4025
                        NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
 
4026
                        _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
4027
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
4028
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4029
                                NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
4030
                        }
 
4031
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4032
                                NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
4033
                        }
 
4034
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 
4035
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 
4036
                }
 
4037
                if (r->entries) {
 
4038
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 
4039
                }
 
4040
        }
 
4041
        return NDR_ERR_SUCCESS;
 
4042
}
 
4043
 
 
4044
_PUBLIC_ void ndr_print_samr_DispInfoFull(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFull *r)
 
4045
{
 
4046
        uint32_t cntr_entries_1;
 
4047
        ndr_print_struct(ndr, name, "samr_DispInfoFull");
 
4048
        ndr->depth++;
 
4049
        ndr_print_uint32(ndr, "count", r->count);
 
4050
        ndr_print_ptr(ndr, "entries", r->entries);
 
4051
        ndr->depth++;
 
4052
        if (r->entries) {
 
4053
                ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 
4054
                ndr->depth++;
 
4055
                for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 
4056
                        char *idx_1=NULL;
 
4057
                        if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
 
4058
                                ndr_print_samr_DispEntryFull(ndr, "entries", &r->entries[cntr_entries_1]);
 
4059
                                free(idx_1);
 
4060
                        }
 
4061
                }
 
4062
                ndr->depth--;
 
4063
        }
 
4064
        ndr->depth--;
 
4065
        ndr->depth--;
 
4066
}
 
4067
 
 
4068
static enum ndr_err_code ndr_push_samr_DispEntryFullGroup(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFullGroup *r)
 
4069
{
 
4070
        if (ndr_flags & NDR_SCALARS) {
 
4071
                NDR_CHECK(ndr_push_align(ndr, 4));
 
4072
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
 
4073
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
 
4074
                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->acct_flags));
 
4075
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
4076
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
4077
        }
 
4078
        if (ndr_flags & NDR_BUFFERS) {
 
4079
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
4080
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
4081
        }
 
4082
        return NDR_ERR_SUCCESS;
 
4083
}
 
4084
 
 
4085
static enum ndr_err_code ndr_pull_samr_DispEntryFullGroup(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFullGroup *r)
 
4086
{
 
4087
        if (ndr_flags & NDR_SCALARS) {
 
4088
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
4089
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
 
4090
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
 
4091
                NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->acct_flags));
 
4092
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
4093
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
4094
        }
 
4095
        if (ndr_flags & NDR_BUFFERS) {
 
4096
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
4097
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
4098
        }
 
4099
        return NDR_ERR_SUCCESS;
 
4100
}
 
4101
 
 
4102
_PUBLIC_ void ndr_print_samr_DispEntryFullGroup(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFullGroup *r)
 
4103
{
 
4104
        ndr_print_struct(ndr, name, "samr_DispEntryFullGroup");
 
4105
        ndr->depth++;
 
4106
        ndr_print_uint32(ndr, "idx", r->idx);
 
4107
        ndr_print_uint32(ndr, "rid", r->rid);
 
4108
        ndr_print_samr_GroupAttrs(ndr, "acct_flags", r->acct_flags);
 
4109
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
4110
        ndr_print_lsa_String(ndr, "description", &r->description);
 
4111
        ndr->depth--;
 
4112
}
 
4113
 
 
4114
static enum ndr_err_code ndr_push_samr_DispInfoFullGroups(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFullGroups *r)
 
4115
{
 
4116
        uint32_t cntr_entries_1;
 
4117
        if (ndr_flags & NDR_SCALARS) {
 
4118
                NDR_CHECK(ndr_push_align(ndr, 4));
 
4119
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
4120
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
 
4121
        }
 
4122
        if (ndr_flags & NDR_BUFFERS) {
 
4123
                if (r->entries) {
 
4124
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
4125
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4126
                                NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
4127
                        }
 
4128
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4129
                                NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
4130
                        }
 
4131
                }
 
4132
        }
 
4133
        return NDR_ERR_SUCCESS;
 
4134
}
 
4135
 
 
4136
static enum ndr_err_code ndr_pull_samr_DispInfoFullGroups(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFullGroups *r)
 
4137
{
 
4138
        uint32_t _ptr_entries;
 
4139
        uint32_t cntr_entries_1;
 
4140
        TALLOC_CTX *_mem_save_entries_0;
 
4141
        TALLOC_CTX *_mem_save_entries_1;
 
4142
        if (ndr_flags & NDR_SCALARS) {
 
4143
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
4144
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
4145
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 
4146
                if (_ptr_entries) {
 
4147
                        NDR_PULL_ALLOC(ndr, r->entries);
 
4148
                } else {
 
4149
                        r->entries = NULL;
 
4150
                }
 
4151
        }
 
4152
        if (ndr_flags & NDR_BUFFERS) {
 
4153
                if (r->entries) {
 
4154
                        _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
4155
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
4156
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 
4157
                        NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
 
4158
                        _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
4159
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
4160
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4161
                                NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
4162
                        }
 
4163
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4164
                                NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
4165
                        }
 
4166
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 
4167
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 
4168
                }
 
4169
                if (r->entries) {
 
4170
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 
4171
                }
 
4172
        }
 
4173
        return NDR_ERR_SUCCESS;
 
4174
}
 
4175
 
 
4176
_PUBLIC_ void ndr_print_samr_DispInfoFullGroups(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFullGroups *r)
 
4177
{
 
4178
        uint32_t cntr_entries_1;
 
4179
        ndr_print_struct(ndr, name, "samr_DispInfoFullGroups");
 
4180
        ndr->depth++;
 
4181
        ndr_print_uint32(ndr, "count", r->count);
 
4182
        ndr_print_ptr(ndr, "entries", r->entries);
 
4183
        ndr->depth++;
 
4184
        if (r->entries) {
 
4185
                ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 
4186
                ndr->depth++;
 
4187
                for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 
4188
                        char *idx_1=NULL;
 
4189
                        if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
 
4190
                                ndr_print_samr_DispEntryFullGroup(ndr, "entries", &r->entries[cntr_entries_1]);
 
4191
                                free(idx_1);
 
4192
                        }
 
4193
                }
 
4194
                ndr->depth--;
 
4195
        }
 
4196
        ndr->depth--;
 
4197
        ndr->depth--;
 
4198
}
 
4199
 
 
4200
static enum ndr_err_code ndr_push_samr_DispEntryAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryAscii *r)
 
4201
{
 
4202
        if (ndr_flags & NDR_SCALARS) {
 
4203
                NDR_CHECK(ndr_push_align(ndr, 4));
 
4204
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
 
4205
                NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
 
4206
        }
 
4207
        if (ndr_flags & NDR_BUFFERS) {
 
4208
                NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
 
4209
        }
 
4210
        return NDR_ERR_SUCCESS;
 
4211
}
 
4212
 
 
4213
static enum ndr_err_code ndr_pull_samr_DispEntryAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryAscii *r)
 
4214
{
 
4215
        if (ndr_flags & NDR_SCALARS) {
 
4216
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
4217
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
 
4218
                NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
 
4219
        }
 
4220
        if (ndr_flags & NDR_BUFFERS) {
 
4221
                NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
 
4222
        }
 
4223
        return NDR_ERR_SUCCESS;
 
4224
}
 
4225
 
 
4226
_PUBLIC_ void ndr_print_samr_DispEntryAscii(struct ndr_print *ndr, const char *name, const struct samr_DispEntryAscii *r)
 
4227
{
 
4228
        ndr_print_struct(ndr, name, "samr_DispEntryAscii");
 
4229
        ndr->depth++;
 
4230
        ndr_print_uint32(ndr, "idx", r->idx);
 
4231
        ndr_print_lsa_AsciiStringLarge(ndr, "account_name", &r->account_name);
 
4232
        ndr->depth--;
 
4233
}
 
4234
 
 
4235
static enum ndr_err_code ndr_push_samr_DispInfoAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoAscii *r)
 
4236
{
 
4237
        uint32_t cntr_entries_1;
 
4238
        if (ndr_flags & NDR_SCALARS) {
 
4239
                NDR_CHECK(ndr_push_align(ndr, 4));
 
4240
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
4241
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
 
4242
        }
 
4243
        if (ndr_flags & NDR_BUFFERS) {
 
4244
                if (r->entries) {
 
4245
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
4246
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4247
                                NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
4248
                        }
 
4249
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4250
                                NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
4251
                        }
 
4252
                }
 
4253
        }
 
4254
        return NDR_ERR_SUCCESS;
 
4255
}
 
4256
 
 
4257
static enum ndr_err_code ndr_pull_samr_DispInfoAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoAscii *r)
 
4258
{
 
4259
        uint32_t _ptr_entries;
 
4260
        uint32_t cntr_entries_1;
 
4261
        TALLOC_CTX *_mem_save_entries_0;
 
4262
        TALLOC_CTX *_mem_save_entries_1;
 
4263
        if (ndr_flags & NDR_SCALARS) {
 
4264
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
4265
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
4266
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 
4267
                if (_ptr_entries) {
 
4268
                        NDR_PULL_ALLOC(ndr, r->entries);
 
4269
                } else {
 
4270
                        r->entries = NULL;
 
4271
                }
 
4272
        }
 
4273
        if (ndr_flags & NDR_BUFFERS) {
 
4274
                if (r->entries) {
 
4275
                        _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
4276
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
4277
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 
4278
                        NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
 
4279
                        _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
4280
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
4281
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4282
                                NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
4283
                        }
 
4284
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4285
                                NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
4286
                        }
 
4287
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 
4288
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 
4289
                }
 
4290
                if (r->entries) {
 
4291
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 
4292
                }
 
4293
        }
 
4294
        return NDR_ERR_SUCCESS;
 
4295
}
 
4296
 
 
4297
_PUBLIC_ void ndr_print_samr_DispInfoAscii(struct ndr_print *ndr, const char *name, const struct samr_DispInfoAscii *r)
 
4298
{
 
4299
        uint32_t cntr_entries_1;
 
4300
        ndr_print_struct(ndr, name, "samr_DispInfoAscii");
 
4301
        ndr->depth++;
 
4302
        ndr_print_uint32(ndr, "count", r->count);
 
4303
        ndr_print_ptr(ndr, "entries", r->entries);
 
4304
        ndr->depth++;
 
4305
        if (r->entries) {
 
4306
                ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 
4307
                ndr->depth++;
 
4308
                for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 
4309
                        char *idx_1=NULL;
 
4310
                        if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
 
4311
                                ndr_print_samr_DispEntryAscii(ndr, "entries", &r->entries[cntr_entries_1]);
 
4312
                                free(idx_1);
 
4313
                        }
 
4314
                }
 
4315
                ndr->depth--;
 
4316
        }
 
4317
        ndr->depth--;
 
4318
        ndr->depth--;
 
4319
}
 
4320
 
 
4321
static enum ndr_err_code ndr_push_samr_DispInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DispInfo *r)
 
4322
{
 
4323
        if (ndr_flags & NDR_SCALARS) {
 
4324
                int level = ndr_push_get_switch_value(ndr, r);
 
4325
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 
4326
                switch (level) {
 
4327
                        case 1: {
 
4328
                                NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
 
4329
                        break; }
 
4330
 
 
4331
                        case 2: {
 
4332
                                NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
 
4333
                        break; }
 
4334
 
 
4335
                        case 3: {
 
4336
                                NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
 
4337
                        break; }
 
4338
 
 
4339
                        case 4: {
 
4340
                                NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
 
4341
                        break; }
 
4342
 
 
4343
                        case 5: {
 
4344
                                NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
 
4345
                        break; }
 
4346
 
 
4347
                        default:
 
4348
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
4349
                }
 
4350
        }
 
4351
        if (ndr_flags & NDR_BUFFERS) {
 
4352
                int level = ndr_push_get_switch_value(ndr, r);
 
4353
                switch (level) {
 
4354
                        case 1:
 
4355
                                NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
 
4356
                        break;
 
4357
 
 
4358
                        case 2:
 
4359
                                NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
 
4360
                        break;
 
4361
 
 
4362
                        case 3:
 
4363
                                NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
 
4364
                        break;
 
4365
 
 
4366
                        case 4:
 
4367
                                NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
 
4368
                        break;
 
4369
 
 
4370
                        case 5:
 
4371
                                NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
 
4372
                        break;
 
4373
 
 
4374
                        default:
 
4375
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
4376
                }
 
4377
        }
 
4378
        return NDR_ERR_SUCCESS;
 
4379
}
 
4380
 
 
4381
static enum ndr_err_code ndr_pull_samr_DispInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DispInfo *r)
 
4382
{
 
4383
        int level;
 
4384
        uint16_t _level;
 
4385
        level = ndr_pull_get_switch_value(ndr, r);
 
4386
        if (ndr_flags & NDR_SCALARS) {
 
4387
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
4388
                if (_level != level) {
 
4389
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 
4390
                }
 
4391
                switch (level) {
 
4392
                        case 1: {
 
4393
                                NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
 
4394
                        break; }
 
4395
 
 
4396
                        case 2: {
 
4397
                                NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
 
4398
                        break; }
 
4399
 
 
4400
                        case 3: {
 
4401
                                NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
 
4402
                        break; }
 
4403
 
 
4404
                        case 4: {
 
4405
                                NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
 
4406
                        break; }
 
4407
 
 
4408
                        case 5: {
 
4409
                                NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
 
4410
                        break; }
 
4411
 
 
4412
                        default:
 
4413
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
4414
                }
 
4415
        }
 
4416
        if (ndr_flags & NDR_BUFFERS) {
 
4417
                switch (level) {
 
4418
                        case 1:
 
4419
                                NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
 
4420
                        break;
 
4421
 
 
4422
                        case 2:
 
4423
                                NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
 
4424
                        break;
 
4425
 
 
4426
                        case 3:
 
4427
                                NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
 
4428
                        break;
 
4429
 
 
4430
                        case 4:
 
4431
                                NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
 
4432
                        break;
 
4433
 
 
4434
                        case 5:
 
4435
                                NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
 
4436
                        break;
 
4437
 
 
4438
                        default:
 
4439
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
4440
                }
 
4441
        }
 
4442
        return NDR_ERR_SUCCESS;
 
4443
}
 
4444
 
 
4445
_PUBLIC_ void ndr_print_samr_DispInfo(struct ndr_print *ndr, const char *name, const union samr_DispInfo *r)
 
4446
{
 
4447
        int level;
 
4448
        level = ndr_print_get_switch_value(ndr, r);
 
4449
        ndr_print_union(ndr, name, level, "samr_DispInfo");
 
4450
        switch (level) {
 
4451
                case 1:
 
4452
                        ndr_print_samr_DispInfoGeneral(ndr, "info1", &r->info1);
 
4453
                break;
 
4454
 
 
4455
                case 2:
 
4456
                        ndr_print_samr_DispInfoFull(ndr, "info2", &r->info2);
 
4457
                break;
 
4458
 
 
4459
                case 3:
 
4460
                        ndr_print_samr_DispInfoFullGroups(ndr, "info3", &r->info3);
 
4461
                break;
 
4462
 
 
4463
                case 4:
 
4464
                        ndr_print_samr_DispInfoAscii(ndr, "info4", &r->info4);
 
4465
                break;
 
4466
 
 
4467
                case 5:
 
4468
                        ndr_print_samr_DispInfoAscii(ndr, "info5", &r->info5);
 
4469
                break;
 
4470
 
 
4471
                default:
 
4472
                        ndr_print_bad_level(ndr, name, level);
 
4473
        }
 
4474
}
 
4475
 
 
4476
static enum ndr_err_code ndr_push_samr_PwInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_PwInfo *r)
 
4477
{
 
4478
        if (ndr_flags & NDR_SCALARS) {
 
4479
                NDR_CHECK(ndr_push_align(ndr, 4));
 
4480
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
 
4481
                NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
 
4482
        }
 
4483
        if (ndr_flags & NDR_BUFFERS) {
 
4484
        }
 
4485
        return NDR_ERR_SUCCESS;
 
4486
}
 
4487
 
 
4488
static enum ndr_err_code ndr_pull_samr_PwInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_PwInfo *r)
 
4489
{
 
4490
        if (ndr_flags & NDR_SCALARS) {
 
4491
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
4492
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
 
4493
                NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
 
4494
        }
 
4495
        if (ndr_flags & NDR_BUFFERS) {
 
4496
        }
 
4497
        return NDR_ERR_SUCCESS;
 
4498
}
 
4499
 
 
4500
_PUBLIC_ void ndr_print_samr_PwInfo(struct ndr_print *ndr, const char *name, const struct samr_PwInfo *r)
 
4501
{
 
4502
        ndr_print_struct(ndr, name, "samr_PwInfo");
 
4503
        ndr->depth++;
 
4504
        ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
 
4505
        ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
 
4506
        ndr->depth--;
 
4507
}
 
4508
 
 
4509
static enum ndr_err_code ndr_push_samr_ConnectVersion(struct ndr_push *ndr, int ndr_flags, enum samr_ConnectVersion r)
 
4510
{
 
4511
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
4512
        return NDR_ERR_SUCCESS;
 
4513
}
 
4514
 
 
4515
static enum ndr_err_code ndr_pull_samr_ConnectVersion(struct ndr_pull *ndr, int ndr_flags, enum samr_ConnectVersion *r)
 
4516
{
 
4517
        uint32_t v;
 
4518
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
4519
        *r = v;
 
4520
        return NDR_ERR_SUCCESS;
 
4521
}
 
4522
 
 
4523
_PUBLIC_ void ndr_print_samr_ConnectVersion(struct ndr_print *ndr, const char *name, enum samr_ConnectVersion r)
 
4524
{
 
4525
        const char *val = NULL;
 
4526
 
 
4527
        switch (r) {
 
4528
                case SAMR_CONNECT_PRE_W2K: val = "SAMR_CONNECT_PRE_W2K"; break;
 
4529
                case SAMR_CONNECT_W2K: val = "SAMR_CONNECT_W2K"; break;
 
4530
                case SAMR_CONNECT_AFTER_W2K: val = "SAMR_CONNECT_AFTER_W2K"; break;
 
4531
        }
 
4532
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
4533
}
 
4534
 
 
4535
static enum ndr_err_code ndr_push_samr_ChangeReject(struct ndr_push *ndr, int ndr_flags, const struct samr_ChangeReject *r)
 
4536
{
 
4537
        if (ndr_flags & NDR_SCALARS) {
 
4538
                NDR_CHECK(ndr_push_align(ndr, 4));
 
4539
                NDR_CHECK(ndr_push_samr_RejectReason(ndr, NDR_SCALARS, r->reason));
 
4540
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
 
4541
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
 
4542
        }
 
4543
        if (ndr_flags & NDR_BUFFERS) {
 
4544
        }
 
4545
        return NDR_ERR_SUCCESS;
 
4546
}
 
4547
 
 
4548
static enum ndr_err_code ndr_pull_samr_ChangeReject(struct ndr_pull *ndr, int ndr_flags, struct samr_ChangeReject *r)
 
4549
{
 
4550
        if (ndr_flags & NDR_SCALARS) {
 
4551
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
4552
                NDR_CHECK(ndr_pull_samr_RejectReason(ndr, NDR_SCALARS, &r->reason));
 
4553
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
 
4554
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
 
4555
        }
 
4556
        if (ndr_flags & NDR_BUFFERS) {
 
4557
        }
 
4558
        return NDR_ERR_SUCCESS;
 
4559
}
 
4560
 
 
4561
_PUBLIC_ void ndr_print_samr_ChangeReject(struct ndr_print *ndr, const char *name, const struct samr_ChangeReject *r)
 
4562
{
 
4563
        ndr_print_struct(ndr, name, "samr_ChangeReject");
 
4564
        ndr->depth++;
 
4565
        ndr_print_samr_RejectReason(ndr, "reason", r->reason);
 
4566
        ndr_print_uint32(ndr, "unknown1", r->unknown1);
 
4567
        ndr_print_uint32(ndr, "unknown2", r->unknown2);
 
4568
        ndr->depth--;
 
4569
}
 
4570
 
 
4571
static enum ndr_err_code ndr_push_samr_ConnectInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_ConnectInfo1 *r)
 
4572
{
 
4573
        if (ndr_flags & NDR_SCALARS) {
 
4574
                NDR_CHECK(ndr_push_align(ndr, 4));
 
4575
                NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->client_version));
 
4576
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
 
4577
        }
 
4578
        if (ndr_flags & NDR_BUFFERS) {
 
4579
        }
 
4580
        return NDR_ERR_SUCCESS;
 
4581
}
 
4582
 
 
4583
static enum ndr_err_code ndr_pull_samr_ConnectInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_ConnectInfo1 *r)
 
4584
{
 
4585
        if (ndr_flags & NDR_SCALARS) {
 
4586
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
4587
                NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->client_version));
 
4588
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
 
4589
        }
 
4590
        if (ndr_flags & NDR_BUFFERS) {
 
4591
        }
 
4592
        return NDR_ERR_SUCCESS;
 
4593
}
 
4594
 
 
4595
_PUBLIC_ void ndr_print_samr_ConnectInfo1(struct ndr_print *ndr, const char *name, const struct samr_ConnectInfo1 *r)
 
4596
{
 
4597
        ndr_print_struct(ndr, name, "samr_ConnectInfo1");
 
4598
        ndr->depth++;
 
4599
        ndr_print_samr_ConnectVersion(ndr, "client_version", r->client_version);
 
4600
        ndr_print_uint32(ndr, "unknown2", r->unknown2);
 
4601
        ndr->depth--;
 
4602
}
 
4603
 
 
4604
static enum ndr_err_code ndr_push_samr_ConnectInfo(struct ndr_push *ndr, int ndr_flags, const union samr_ConnectInfo *r)
 
4605
{
 
4606
        if (ndr_flags & NDR_SCALARS) {
 
4607
                int level = ndr_push_get_switch_value(ndr, r);
 
4608
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
 
4609
                switch (level) {
 
4610
                        case 1: {
 
4611
                                NDR_CHECK(ndr_push_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
 
4612
                        break; }
 
4613
 
 
4614
                        default:
 
4615
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
4616
                }
 
4617
        }
 
4618
        if (ndr_flags & NDR_BUFFERS) {
 
4619
                int level = ndr_push_get_switch_value(ndr, r);
 
4620
                switch (level) {
 
4621
                        case 1:
 
4622
                        break;
 
4623
 
 
4624
                        default:
 
4625
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
4626
                }
 
4627
        }
 
4628
        return NDR_ERR_SUCCESS;
 
4629
}
 
4630
 
 
4631
static enum ndr_err_code ndr_pull_samr_ConnectInfo(struct ndr_pull *ndr, int ndr_flags, union samr_ConnectInfo *r)
 
4632
{
 
4633
        int level;
 
4634
        uint32_t _level;
 
4635
        level = ndr_pull_get_switch_value(ndr, r);
 
4636
        if (ndr_flags & NDR_SCALARS) {
 
4637
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 
4638
                if (_level != level) {
 
4639
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 
4640
                }
 
4641
                switch (level) {
 
4642
                        case 1: {
 
4643
                                NDR_CHECK(ndr_pull_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
 
4644
                        break; }
 
4645
 
 
4646
                        default:
 
4647
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
4648
                }
 
4649
        }
 
4650
        if (ndr_flags & NDR_BUFFERS) {
 
4651
                switch (level) {
 
4652
                        case 1:
 
4653
                        break;
 
4654
 
 
4655
                        default:
 
4656
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
4657
                }
 
4658
        }
 
4659
        return NDR_ERR_SUCCESS;
 
4660
}
 
4661
 
 
4662
_PUBLIC_ void ndr_print_samr_ConnectInfo(struct ndr_print *ndr, const char *name, const union samr_ConnectInfo *r)
 
4663
{
 
4664
        int level;
 
4665
        level = ndr_print_get_switch_value(ndr, r);
 
4666
        ndr_print_union(ndr, name, level, "samr_ConnectInfo");
 
4667
        switch (level) {
 
4668
                case 1:
 
4669
                        ndr_print_samr_ConnectInfo1(ndr, "info1", &r->info1);
 
4670
                break;
 
4671
 
 
4672
                default:
 
4673
                        ndr_print_bad_level(ndr, name, level);
 
4674
        }
 
4675
}
 
4676
 
 
4677
static enum ndr_err_code ndr_push_samr_ValidateFieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
4678
{
 
4679
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
4680
        return NDR_ERR_SUCCESS;
 
4681
}
 
4682
 
 
4683
static enum ndr_err_code ndr_pull_samr_ValidateFieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
4684
{
 
4685
        uint32_t v;
 
4686
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
4687
        *r = v;
 
4688
        return NDR_ERR_SUCCESS;
 
4689
}
 
4690
 
 
4691
_PUBLIC_ void ndr_print_samr_ValidateFieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
 
4692
{
 
4693
        ndr_print_uint32(ndr, name, r);
 
4694
        ndr->depth++;
 
4695
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET", SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET, r);
 
4696
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME", SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME, r);
 
4697
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_LOCKOUT_TIME", SAMR_VALIDATE_FIELD_LOCKOUT_TIME, r);
 
4698
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT", SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT, r);
 
4699
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH, r);
 
4700
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY, r);
 
4701
        ndr->depth--;
 
4702
}
 
4703
 
 
4704
static enum ndr_err_code ndr_push_samr_ValidatePasswordLevel(struct ndr_push *ndr, int ndr_flags, enum samr_ValidatePasswordLevel r)
 
4705
{
 
4706
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
4707
        return NDR_ERR_SUCCESS;
 
4708
}
 
4709
 
 
4710
static enum ndr_err_code ndr_pull_samr_ValidatePasswordLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidatePasswordLevel *r)
 
4711
{
 
4712
        uint16_t v;
 
4713
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
4714
        *r = v;
 
4715
        return NDR_ERR_SUCCESS;
 
4716
}
 
4717
 
 
4718
_PUBLIC_ void ndr_print_samr_ValidatePasswordLevel(struct ndr_print *ndr, const char *name, enum samr_ValidatePasswordLevel r)
 
4719
{
 
4720
        const char *val = NULL;
 
4721
 
 
4722
        switch (r) {
 
4723
                case NetValidateAuthentication: val = "NetValidateAuthentication"; break;
 
4724
                case NetValidatePasswordChange: val = "NetValidatePasswordChange"; break;
 
4725
                case NetValidatePasswordReset: val = "NetValidatePasswordReset"; break;
 
4726
        }
 
4727
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
4728
}
 
4729
 
 
4730
static enum ndr_err_code ndr_push_samr_ValidationStatus(struct ndr_push *ndr, int ndr_flags, enum samr_ValidationStatus r)
 
4731
{
 
4732
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
4733
        return NDR_ERR_SUCCESS;
 
4734
}
 
4735
 
 
4736
static enum ndr_err_code ndr_pull_samr_ValidationStatus(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidationStatus *r)
 
4737
{
 
4738
        uint16_t v;
 
4739
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
4740
        *r = v;
 
4741
        return NDR_ERR_SUCCESS;
 
4742
}
 
4743
 
 
4744
_PUBLIC_ void ndr_print_samr_ValidationStatus(struct ndr_print *ndr, const char *name, enum samr_ValidationStatus r)
 
4745
{
 
4746
        const char *val = NULL;
 
4747
 
 
4748
        switch (r) {
 
4749
                case SAMR_VALIDATION_STATUS_SUCCESS: val = "SAMR_VALIDATION_STATUS_SUCCESS"; break;
 
4750
                case SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE: val = "SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE"; break;
 
4751
                case SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT: val = "SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT"; break;
 
4752
                case SAMR_VALIDATION_STATUS_BAD_PASSWORD: val = "SAMR_VALIDATION_STATUS_BAD_PASSWORD"; break;
 
4753
                case SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT: val = "SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT"; break;
 
4754
                case SAMR_VALIDATION_STATUS_PWD_TOO_SHORT: val = "SAMR_VALIDATION_STATUS_PWD_TOO_SHORT"; break;
 
4755
                case SAMR_VALIDATION_STATUS_PWD_TOO_LONG: val = "SAMR_VALIDATION_STATUS_PWD_TOO_LONG"; break;
 
4756
                case SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH: val = "SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH"; break;
 
4757
                case SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT: val = "SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT"; break;
 
4758
        }
 
4759
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
4760
}
 
4761
 
 
4762
static enum ndr_err_code ndr_push_samr_ValidationBlob(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidationBlob *r)
 
4763
{
 
4764
        if (ndr_flags & NDR_SCALARS) {
 
4765
                NDR_CHECK(ndr_push_align(ndr, 4));
 
4766
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
 
4767
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
 
4768
        }
 
4769
        if (ndr_flags & NDR_BUFFERS) {
 
4770
                if (r->data) {
 
4771
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
 
4772
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
 
4773
                }
 
4774
        }
 
4775
        return NDR_ERR_SUCCESS;
 
4776
}
 
4777
 
 
4778
static enum ndr_err_code ndr_pull_samr_ValidationBlob(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidationBlob *r)
 
4779
{
 
4780
        uint32_t _ptr_data;
 
4781
        TALLOC_CTX *_mem_save_data_0;
 
4782
        if (ndr_flags & NDR_SCALARS) {
 
4783
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
4784
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 
4785
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
 
4786
                if (_ptr_data) {
 
4787
                        NDR_PULL_ALLOC(ndr, r->data);
 
4788
                } else {
 
4789
                        r->data = NULL;
 
4790
                }
 
4791
        }
 
4792
        if (ndr_flags & NDR_BUFFERS) {
 
4793
                if (r->data) {
 
4794
                        _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
4795
                        NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
 
4796
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
 
4797
                        NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
 
4798
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
 
4799
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
 
4800
                }
 
4801
                if (r->data) {
 
4802
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
 
4803
                }
 
4804
        }
 
4805
        return NDR_ERR_SUCCESS;
 
4806
}
 
4807
 
 
4808
_PUBLIC_ void ndr_print_samr_ValidationBlob(struct ndr_print *ndr, const char *name, const struct samr_ValidationBlob *r)
 
4809
{
 
4810
        ndr_print_struct(ndr, name, "samr_ValidationBlob");
 
4811
        ndr->depth++;
 
4812
        ndr_print_uint32(ndr, "length", r->length);
 
4813
        ndr_print_ptr(ndr, "data", r->data);
 
4814
        ndr->depth++;
 
4815
        if (r->data) {
 
4816
                ndr_print_array_uint8(ndr, "data", r->data, r->length);
 
4817
        }
 
4818
        ndr->depth--;
 
4819
        ndr->depth--;
 
4820
}
 
4821
 
 
4822
static enum ndr_err_code ndr_push_samr_ValidatePasswordInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordInfo *r)
 
4823
{
 
4824
        uint32_t cntr_pwd_history_1;
 
4825
        if (ndr_flags & NDR_SCALARS) {
 
4826
                NDR_CHECK(ndr_push_align(ndr, 8));
 
4827
                NDR_CHECK(ndr_push_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, r->fields_present));
 
4828
                NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->last_password_change));
 
4829
                NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->bad_password_time));
 
4830
                NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->lockout_time));
 
4831
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bad_pwd_count));
 
4832
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwd_history_len));
 
4833
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->pwd_history));
 
4834
        }
 
4835
        if (ndr_flags & NDR_BUFFERS) {
 
4836
                if (r->pwd_history) {
 
4837
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwd_history_len));
 
4838
                        for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
 
4839
                                NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
 
4840
                        }
 
4841
                        for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
 
4842
                                NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
 
4843
                        }
 
4844
                }
 
4845
        }
 
4846
        return NDR_ERR_SUCCESS;
 
4847
}
 
4848
 
 
4849
static enum ndr_err_code ndr_pull_samr_ValidatePasswordInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordInfo *r)
 
4850
{
 
4851
        uint32_t _ptr_pwd_history;
 
4852
        uint32_t cntr_pwd_history_1;
 
4853
        TALLOC_CTX *_mem_save_pwd_history_0;
 
4854
        TALLOC_CTX *_mem_save_pwd_history_1;
 
4855
        if (ndr_flags & NDR_SCALARS) {
 
4856
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
4857
                NDR_CHECK(ndr_pull_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
 
4858
                NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->last_password_change));
 
4859
                NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->bad_password_time));
 
4860
                NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->lockout_time));
 
4861
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bad_pwd_count));
 
4862
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pwd_history_len));
 
4863
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pwd_history));
 
4864
                if (_ptr_pwd_history) {
 
4865
                        NDR_PULL_ALLOC(ndr, r->pwd_history);
 
4866
                } else {
 
4867
                        r->pwd_history = NULL;
 
4868
                }
 
4869
        }
 
4870
        if (ndr_flags & NDR_BUFFERS) {
 
4871
                if (r->pwd_history) {
 
4872
                        _mem_save_pwd_history_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
4873
                        NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
 
4874
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->pwd_history));
 
4875
                        NDR_PULL_ALLOC_N(ndr, r->pwd_history, ndr_get_array_size(ndr, &r->pwd_history));
 
4876
                        _mem_save_pwd_history_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
4877
                        NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
 
4878
                        for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
 
4879
                                NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
 
4880
                        }
 
4881
                        for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
 
4882
                                NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
 
4883
                        }
 
4884
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_1, 0);
 
4885
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_0, 0);
 
4886
                }
 
4887
                if (r->pwd_history) {
 
4888
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pwd_history, r->pwd_history_len));
 
4889
                }
 
4890
        }
 
4891
        return NDR_ERR_SUCCESS;
 
4892
}
 
4893
 
 
4894
_PUBLIC_ void ndr_print_samr_ValidatePasswordInfo(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordInfo *r)
 
4895
{
 
4896
        uint32_t cntr_pwd_history_1;
 
4897
        ndr_print_struct(ndr, name, "samr_ValidatePasswordInfo");
 
4898
        ndr->depth++;
 
4899
        ndr_print_samr_ValidateFieldsPresent(ndr, "fields_present", r->fields_present);
 
4900
        ndr_print_NTTIME_hyper(ndr, "last_password_change", r->last_password_change);
 
4901
        ndr_print_NTTIME_hyper(ndr, "bad_password_time", r->bad_password_time);
 
4902
        ndr_print_NTTIME_hyper(ndr, "lockout_time", r->lockout_time);
 
4903
        ndr_print_uint32(ndr, "bad_pwd_count", r->bad_pwd_count);
 
4904
        ndr_print_uint32(ndr, "pwd_history_len", r->pwd_history_len);
 
4905
        ndr_print_ptr(ndr, "pwd_history", r->pwd_history);
 
4906
        ndr->depth++;
 
4907
        if (r->pwd_history) {
 
4908
                ndr->print(ndr, "%s: ARRAY(%d)", "pwd_history", (int)r->pwd_history_len);
 
4909
                ndr->depth++;
 
4910
                for (cntr_pwd_history_1=0;cntr_pwd_history_1<r->pwd_history_len;cntr_pwd_history_1++) {
 
4911
                        char *idx_1=NULL;
 
4912
                        if (asprintf(&idx_1, "[%d]", cntr_pwd_history_1) != -1) {
 
4913
                                ndr_print_samr_ValidationBlob(ndr, "pwd_history", &r->pwd_history[cntr_pwd_history_1]);
 
4914
                                free(idx_1);
 
4915
                        }
 
4916
                }
 
4917
                ndr->depth--;
 
4918
        }
 
4919
        ndr->depth--;
 
4920
        ndr->depth--;
 
4921
}
 
4922
 
 
4923
static enum ndr_err_code ndr_push_samr_ValidatePasswordRepCtr(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordRepCtr *r)
 
4924
{
 
4925
        if (ndr_flags & NDR_SCALARS) {
 
4926
                NDR_CHECK(ndr_push_align(ndr, 8));
 
4927
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
4928
                NDR_CHECK(ndr_push_samr_ValidationStatus(ndr, NDR_SCALARS, r->status));
 
4929
        }
 
4930
        if (ndr_flags & NDR_BUFFERS) {
 
4931
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
4932
        }
 
4933
        return NDR_ERR_SUCCESS;
 
4934
}
 
4935
 
 
4936
static enum ndr_err_code ndr_pull_samr_ValidatePasswordRepCtr(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordRepCtr *r)
 
4937
{
 
4938
        if (ndr_flags & NDR_SCALARS) {
 
4939
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
4940
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
4941
                NDR_CHECK(ndr_pull_samr_ValidationStatus(ndr, NDR_SCALARS, &r->status));
 
4942
        }
 
4943
        if (ndr_flags & NDR_BUFFERS) {
 
4944
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
4945
        }
 
4946
        return NDR_ERR_SUCCESS;
 
4947
}
 
4948
 
 
4949
_PUBLIC_ void ndr_print_samr_ValidatePasswordRepCtr(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordRepCtr *r)
 
4950
{
 
4951
        ndr_print_struct(ndr, name, "samr_ValidatePasswordRepCtr");
 
4952
        ndr->depth++;
 
4953
        ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
 
4954
        ndr_print_samr_ValidationStatus(ndr, "status", r->status);
 
4955
        ndr->depth--;
 
4956
}
 
4957
 
 
4958
static enum ndr_err_code ndr_push_samr_ValidatePasswordRep(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordRep *r)
 
4959
{
 
4960
        if (ndr_flags & NDR_SCALARS) {
 
4961
                int level = ndr_push_get_switch_value(ndr, r);
 
4962
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 
4963
                switch (level) {
 
4964
                        case 1: {
 
4965
                                NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
 
4966
                        break; }
 
4967
 
 
4968
                        case 2: {
 
4969
                                NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
 
4970
                        break; }
 
4971
 
 
4972
                        case 3: {
 
4973
                                NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
 
4974
                        break; }
 
4975
 
 
4976
                        default:
 
4977
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
4978
                }
 
4979
        }
 
4980
        if (ndr_flags & NDR_BUFFERS) {
 
4981
                int level = ndr_push_get_switch_value(ndr, r);
 
4982
                switch (level) {
 
4983
                        case 1:
 
4984
                                NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
 
4985
                        break;
 
4986
 
 
4987
                        case 2:
 
4988
                                NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
 
4989
                        break;
 
4990
 
 
4991
                        case 3:
 
4992
                                NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
 
4993
                        break;
 
4994
 
 
4995
                        default:
 
4996
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
4997
                }
 
4998
        }
 
4999
        return NDR_ERR_SUCCESS;
 
5000
}
 
5001
 
 
5002
static enum ndr_err_code ndr_pull_samr_ValidatePasswordRep(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordRep *r)
 
5003
{
 
5004
        int level;
 
5005
        uint16_t _level;
 
5006
        level = ndr_pull_get_switch_value(ndr, r);
 
5007
        if (ndr_flags & NDR_SCALARS) {
 
5008
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
5009
                if (_level != level) {
 
5010
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 
5011
                }
 
5012
                switch (level) {
 
5013
                        case 1: {
 
5014
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
 
5015
                        break; }
 
5016
 
 
5017
                        case 2: {
 
5018
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
 
5019
                        break; }
 
5020
 
 
5021
                        case 3: {
 
5022
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
 
5023
                        break; }
 
5024
 
 
5025
                        default:
 
5026
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
5027
                }
 
5028
        }
 
5029
        if (ndr_flags & NDR_BUFFERS) {
 
5030
                switch (level) {
 
5031
                        case 1:
 
5032
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
 
5033
                        break;
 
5034
 
 
5035
                        case 2:
 
5036
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
 
5037
                        break;
 
5038
 
 
5039
                        case 3:
 
5040
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
 
5041
                        break;
 
5042
 
 
5043
                        default:
 
5044
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
5045
                }
 
5046
        }
 
5047
        return NDR_ERR_SUCCESS;
 
5048
}
 
5049
 
 
5050
_PUBLIC_ void ndr_print_samr_ValidatePasswordRep(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordRep *r)
 
5051
{
 
5052
        int level;
 
5053
        level = ndr_print_get_switch_value(ndr, r);
 
5054
        ndr_print_union(ndr, name, level, "samr_ValidatePasswordRep");
 
5055
        switch (level) {
 
5056
                case 1:
 
5057
                        ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr1", &r->ctr1);
 
5058
                break;
 
5059
 
 
5060
                case 2:
 
5061
                        ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr2", &r->ctr2);
 
5062
                break;
 
5063
 
 
5064
                case 3:
 
5065
                        ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr3", &r->ctr3);
 
5066
                break;
 
5067
 
 
5068
                default:
 
5069
                        ndr_print_bad_level(ndr, name, level);
 
5070
        }
 
5071
}
 
5072
 
 
5073
static enum ndr_err_code ndr_push_samr_ValidatePasswordReq3(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq3 *r)
 
5074
{
 
5075
        if (ndr_flags & NDR_SCALARS) {
 
5076
                NDR_CHECK(ndr_push_align(ndr, 8));
 
5077
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
5078
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
 
5079
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
 
5080
                NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
 
5081
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pwd_must_change_at_next_logon));
 
5082
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->clear_lockout));
 
5083
        }
 
5084
        if (ndr_flags & NDR_BUFFERS) {
 
5085
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
5086
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
 
5087
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
 
5088
                NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
 
5089
        }
 
5090
        return NDR_ERR_SUCCESS;
 
5091
}
 
5092
 
 
5093
static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq3(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq3 *r)
 
5094
{
 
5095
        if (ndr_flags & NDR_SCALARS) {
 
5096
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
5097
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
5098
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
 
5099
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
 
5100
                NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
 
5101
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pwd_must_change_at_next_logon));
 
5102
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->clear_lockout));
 
5103
        }
 
5104
        if (ndr_flags & NDR_BUFFERS) {
 
5105
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
5106
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
 
5107
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
 
5108
                NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
 
5109
        }
 
5110
        return NDR_ERR_SUCCESS;
 
5111
}
 
5112
 
 
5113
_PUBLIC_ void ndr_print_samr_ValidatePasswordReq3(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq3 *r)
 
5114
{
 
5115
        ndr_print_struct(ndr, name, "samr_ValidatePasswordReq3");
 
5116
        ndr->depth++;
 
5117
        ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
 
5118
        ndr_print_lsa_StringLarge(ndr, "password", &r->password);
 
5119
        ndr_print_lsa_StringLarge(ndr, "account", &r->account);
 
5120
        ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
 
5121
        ndr_print_uint8(ndr, "pwd_must_change_at_next_logon", r->pwd_must_change_at_next_logon);
 
5122
        ndr_print_uint8(ndr, "clear_lockout", r->clear_lockout);
 
5123
        ndr->depth--;
 
5124
}
 
5125
 
 
5126
static enum ndr_err_code ndr_push_samr_ValidatePasswordReq2(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq2 *r)
 
5127
{
 
5128
        if (ndr_flags & NDR_SCALARS) {
 
5129
                NDR_CHECK(ndr_push_align(ndr, 8));
 
5130
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
5131
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
 
5132
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
 
5133
                NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
 
5134
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
 
5135
        }
 
5136
        if (ndr_flags & NDR_BUFFERS) {
 
5137
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
5138
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
 
5139
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
 
5140
                NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
 
5141
        }
 
5142
        return NDR_ERR_SUCCESS;
 
5143
}
 
5144
 
 
5145
static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq2(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq2 *r)
 
5146
{
 
5147
        if (ndr_flags & NDR_SCALARS) {
 
5148
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
5149
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
5150
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
 
5151
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
 
5152
                NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
 
5153
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
 
5154
        }
 
5155
        if (ndr_flags & NDR_BUFFERS) {
 
5156
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
5157
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
 
5158
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
 
5159
                NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
 
5160
        }
 
5161
        return NDR_ERR_SUCCESS;
 
5162
}
 
5163
 
 
5164
_PUBLIC_ void ndr_print_samr_ValidatePasswordReq2(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq2 *r)
 
5165
{
 
5166
        ndr_print_struct(ndr, name, "samr_ValidatePasswordReq2");
 
5167
        ndr->depth++;
 
5168
        ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
 
5169
        ndr_print_lsa_StringLarge(ndr, "password", &r->password);
 
5170
        ndr_print_lsa_StringLarge(ndr, "account", &r->account);
 
5171
        ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
 
5172
        ndr_print_uint8(ndr, "password_matched", r->password_matched);
 
5173
        ndr->depth--;
 
5174
}
 
5175
 
 
5176
static enum ndr_err_code ndr_push_samr_ValidatePasswordReq1(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq1 *r)
 
5177
{
 
5178
        if (ndr_flags & NDR_SCALARS) {
 
5179
                NDR_CHECK(ndr_push_align(ndr, 8));
 
5180
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
5181
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
 
5182
        }
 
5183
        if (ndr_flags & NDR_BUFFERS) {
 
5184
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
5185
        }
 
5186
        return NDR_ERR_SUCCESS;
 
5187
}
 
5188
 
 
5189
static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq1(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq1 *r)
 
5190
{
 
5191
        if (ndr_flags & NDR_SCALARS) {
 
5192
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
5193
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
5194
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
 
5195
        }
 
5196
        if (ndr_flags & NDR_BUFFERS) {
 
5197
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
5198
        }
 
5199
        return NDR_ERR_SUCCESS;
 
5200
}
 
5201
 
 
5202
_PUBLIC_ void ndr_print_samr_ValidatePasswordReq1(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq1 *r)
 
5203
{
 
5204
        ndr_print_struct(ndr, name, "samr_ValidatePasswordReq1");
 
5205
        ndr->depth++;
 
5206
        ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
 
5207
        ndr_print_uint8(ndr, "password_matched", r->password_matched);
 
5208
        ndr->depth--;
 
5209
}
 
5210
 
 
5211
static enum ndr_err_code ndr_push_samr_ValidatePasswordReq(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordReq *r)
 
5212
{
 
5213
        if (ndr_flags & NDR_SCALARS) {
 
5214
                int level = ndr_push_get_switch_value(ndr, r);
 
5215
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 
5216
                switch (level) {
 
5217
                        case 1: {
 
5218
                                NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
 
5219
                        break; }
 
5220
 
 
5221
                        case 2: {
 
5222
                                NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
 
5223
                        break; }
 
5224
 
 
5225
                        case 3: {
 
5226
                                NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
 
5227
                        break; }
 
5228
 
 
5229
                        default:
 
5230
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
5231
                }
 
5232
        }
 
5233
        if (ndr_flags & NDR_BUFFERS) {
 
5234
                int level = ndr_push_get_switch_value(ndr, r);
 
5235
                switch (level) {
 
5236
                        case 1:
 
5237
                                NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
 
5238
                        break;
 
5239
 
 
5240
                        case 2:
 
5241
                                NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
 
5242
                        break;
 
5243
 
 
5244
                        case 3:
 
5245
                                NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
 
5246
                        break;
 
5247
 
 
5248
                        default:
 
5249
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
5250
                }
 
5251
        }
 
5252
        return NDR_ERR_SUCCESS;
 
5253
}
 
5254
 
 
5255
static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordReq *r)
 
5256
{
 
5257
        int level;
 
5258
        uint16_t _level;
 
5259
        level = ndr_pull_get_switch_value(ndr, r);
 
5260
        if (ndr_flags & NDR_SCALARS) {
 
5261
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
5262
                if (_level != level) {
 
5263
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 
5264
                }
 
5265
                switch (level) {
 
5266
                        case 1: {
 
5267
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
 
5268
                        break; }
 
5269
 
 
5270
                        case 2: {
 
5271
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
 
5272
                        break; }
 
5273
 
 
5274
                        case 3: {
 
5275
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
 
5276
                        break; }
 
5277
 
 
5278
                        default:
 
5279
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
5280
                }
 
5281
        }
 
5282
        if (ndr_flags & NDR_BUFFERS) {
 
5283
                switch (level) {
 
5284
                        case 1:
 
5285
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
 
5286
                        break;
 
5287
 
 
5288
                        case 2:
 
5289
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
 
5290
                        break;
 
5291
 
 
5292
                        case 3:
 
5293
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
 
5294
                        break;
 
5295
 
 
5296
                        default:
 
5297
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
5298
                }
 
5299
        }
 
5300
        return NDR_ERR_SUCCESS;
 
5301
}
 
5302
 
 
5303
_PUBLIC_ void ndr_print_samr_ValidatePasswordReq(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordReq *r)
 
5304
{
 
5305
        int level;
 
5306
        level = ndr_print_get_switch_value(ndr, r);
 
5307
        ndr_print_union(ndr, name, level, "samr_ValidatePasswordReq");
 
5308
        switch (level) {
 
5309
                case 1:
 
5310
                        ndr_print_samr_ValidatePasswordReq1(ndr, "req1", &r->req1);
 
5311
                break;
 
5312
 
 
5313
                case 2:
 
5314
                        ndr_print_samr_ValidatePasswordReq2(ndr, "req2", &r->req2);
 
5315
                break;
 
5316
 
 
5317
                case 3:
 
5318
                        ndr_print_samr_ValidatePasswordReq3(ndr, "req3", &r->req3);
 
5319
                break;
 
5320
 
 
5321
                default:
 
5322
                        ndr_print_bad_level(ndr, name, level);
 
5323
        }
 
5324
}
 
5325
 
 
5326
static enum ndr_err_code ndr_push_samr_Connect(struct ndr_push *ndr, int flags, const struct samr_Connect *r)
 
5327
{
 
5328
        if (flags & NDR_IN) {
 
5329
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 
5330
                if (r->in.system_name) {
 
5331
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
 
5332
                }
 
5333
                NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
5334
        }
 
5335
        if (flags & NDR_OUT) {
 
5336
                if (r->out.connect_handle == NULL) {
 
5337
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5338
                }
 
5339
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
5340
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
5341
        }
 
5342
        return NDR_ERR_SUCCESS;
 
5343
}
 
5344
 
 
5345
static enum ndr_err_code ndr_pull_samr_Connect(struct ndr_pull *ndr, int flags, struct samr_Connect *r)
 
5346
{
 
5347
        uint32_t _ptr_system_name;
 
5348
        TALLOC_CTX *_mem_save_system_name_0;
 
5349
        TALLOC_CTX *_mem_save_connect_handle_0;
 
5350
        if (flags & NDR_IN) {
 
5351
                ZERO_STRUCT(r->out);
 
5352
 
 
5353
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 
5354
                if (_ptr_system_name) {
 
5355
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
 
5356
                } else {
 
5357
                        r->in.system_name = NULL;
 
5358
                }
 
5359
                if (r->in.system_name) {
 
5360
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5361
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 
5362
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
 
5363
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 
5364
                }
 
5365
                NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
5366
                NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
5367
                ZERO_STRUCTP(r->out.connect_handle);
 
5368
        }
 
5369
        if (flags & NDR_OUT) {
 
5370
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5371
                        NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
5372
                }
 
5373
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5374
                NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
5375
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
5376
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5377
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
5378
        }
 
5379
        return NDR_ERR_SUCCESS;
 
5380
}
 
5381
 
 
5382
_PUBLIC_ void ndr_print_samr_Connect(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect *r)
 
5383
{
 
5384
        ndr_print_struct(ndr, name, "samr_Connect");
 
5385
        ndr->depth++;
 
5386
        if (flags & NDR_SET_VALUES) {
 
5387
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
5388
        }
 
5389
        if (flags & NDR_IN) {
 
5390
                ndr_print_struct(ndr, "in", "samr_Connect");
 
5391
                ndr->depth++;
 
5392
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
 
5393
                ndr->depth++;
 
5394
                if (r->in.system_name) {
 
5395
                        ndr_print_uint16(ndr, "system_name", *r->in.system_name);
 
5396
                }
 
5397
                ndr->depth--;
 
5398
                ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
 
5399
                ndr->depth--;
 
5400
        }
 
5401
        if (flags & NDR_OUT) {
 
5402
                ndr_print_struct(ndr, "out", "samr_Connect");
 
5403
                ndr->depth++;
 
5404
                ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
 
5405
                ndr->depth++;
 
5406
                ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
 
5407
                ndr->depth--;
 
5408
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
5409
                ndr->depth--;
 
5410
        }
 
5411
        ndr->depth--;
 
5412
}
 
5413
 
 
5414
_PUBLIC_ enum ndr_err_code ndr_push_samr_Close(struct ndr_push *ndr, int flags, const struct samr_Close *r)
 
5415
{
 
5416
        if (flags & NDR_IN) {
 
5417
                if (r->in.handle == NULL) {
 
5418
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5419
                }
 
5420
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 
5421
        }
 
5422
        if (flags & NDR_OUT) {
 
5423
                if (r->out.handle == NULL) {
 
5424
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5425
                }
 
5426
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
 
5427
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
5428
        }
 
5429
        return NDR_ERR_SUCCESS;
 
5430
}
 
5431
 
 
5432
_PUBLIC_ enum ndr_err_code ndr_pull_samr_Close(struct ndr_pull *ndr, int flags, struct samr_Close *r)
 
5433
{
 
5434
        TALLOC_CTX *_mem_save_handle_0;
 
5435
        if (flags & NDR_IN) {
 
5436
                ZERO_STRUCT(r->out);
 
5437
 
 
5438
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5439
                        NDR_PULL_ALLOC(ndr, r->in.handle);
 
5440
                }
 
5441
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5442
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 
5443
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 
5444
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5445
                NDR_PULL_ALLOC(ndr, r->out.handle);
 
5446
                *r->out.handle = *r->in.handle;
 
5447
        }
 
5448
        if (flags & NDR_OUT) {
 
5449
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5450
                        NDR_PULL_ALLOC(ndr, r->out.handle);
 
5451
                }
 
5452
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5453
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
 
5454
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
 
5455
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5456
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
5457
        }
 
5458
        return NDR_ERR_SUCCESS;
 
5459
}
 
5460
 
 
5461
_PUBLIC_ void ndr_print_samr_Close(struct ndr_print *ndr, const char *name, int flags, const struct samr_Close *r)
 
5462
{
 
5463
        ndr_print_struct(ndr, name, "samr_Close");
 
5464
        ndr->depth++;
 
5465
        if (flags & NDR_SET_VALUES) {
 
5466
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
5467
        }
 
5468
        if (flags & NDR_IN) {
 
5469
                ndr_print_struct(ndr, "in", "samr_Close");
 
5470
                ndr->depth++;
 
5471
                ndr_print_ptr(ndr, "handle", r->in.handle);
 
5472
                ndr->depth++;
 
5473
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
 
5474
                ndr->depth--;
 
5475
                ndr->depth--;
 
5476
        }
 
5477
        if (flags & NDR_OUT) {
 
5478
                ndr_print_struct(ndr, "out", "samr_Close");
 
5479
                ndr->depth++;
 
5480
                ndr_print_ptr(ndr, "handle", r->out.handle);
 
5481
                ndr->depth++;
 
5482
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
 
5483
                ndr->depth--;
 
5484
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
5485
                ndr->depth--;
 
5486
        }
 
5487
        ndr->depth--;
 
5488
}
 
5489
 
 
5490
static enum ndr_err_code ndr_push_samr_SetSecurity(struct ndr_push *ndr, int flags, const struct samr_SetSecurity *r)
 
5491
{
 
5492
        if (flags & NDR_IN) {
 
5493
                if (r->in.handle == NULL) {
 
5494
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5495
                }
 
5496
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 
5497
                NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
 
5498
                if (r->in.sdbuf == NULL) {
 
5499
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5500
                }
 
5501
                NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
 
5502
        }
 
5503
        if (flags & NDR_OUT) {
 
5504
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
5505
        }
 
5506
        return NDR_ERR_SUCCESS;
 
5507
}
 
5508
 
 
5509
static enum ndr_err_code ndr_pull_samr_SetSecurity(struct ndr_pull *ndr, int flags, struct samr_SetSecurity *r)
 
5510
{
 
5511
        TALLOC_CTX *_mem_save_handle_0;
 
5512
        TALLOC_CTX *_mem_save_sdbuf_0;
 
5513
        if (flags & NDR_IN) {
 
5514
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5515
                        NDR_PULL_ALLOC(ndr, r->in.handle);
 
5516
                }
 
5517
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5518
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 
5519
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 
5520
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5521
                NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
 
5522
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5523
                        NDR_PULL_ALLOC(ndr, r->in.sdbuf);
 
5524
                }
 
5525
                _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5526
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sdbuf, LIBNDR_FLAG_REF_ALLOC);
 
5527
                NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
 
5528
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
 
5529
        }
 
5530
        if (flags & NDR_OUT) {
 
5531
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
5532
        }
 
5533
        return NDR_ERR_SUCCESS;
 
5534
}
 
5535
 
 
5536
_PUBLIC_ void ndr_print_samr_SetSecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetSecurity *r)
 
5537
{
 
5538
        ndr_print_struct(ndr, name, "samr_SetSecurity");
 
5539
        ndr->depth++;
 
5540
        if (flags & NDR_SET_VALUES) {
 
5541
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
5542
        }
 
5543
        if (flags & NDR_IN) {
 
5544
                ndr_print_struct(ndr, "in", "samr_SetSecurity");
 
5545
                ndr->depth++;
 
5546
                ndr_print_ptr(ndr, "handle", r->in.handle);
 
5547
                ndr->depth++;
 
5548
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
 
5549
                ndr->depth--;
 
5550
                ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
 
5551
                ndr_print_ptr(ndr, "sdbuf", r->in.sdbuf);
 
5552
                ndr->depth++;
 
5553
                ndr_print_sec_desc_buf(ndr, "sdbuf", r->in.sdbuf);
 
5554
                ndr->depth--;
 
5555
                ndr->depth--;
 
5556
        }
 
5557
        if (flags & NDR_OUT) {
 
5558
                ndr_print_struct(ndr, "out", "samr_SetSecurity");
 
5559
                ndr->depth++;
 
5560
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
5561
                ndr->depth--;
 
5562
        }
 
5563
        ndr->depth--;
 
5564
}
 
5565
 
 
5566
static enum ndr_err_code ndr_push_samr_QuerySecurity(struct ndr_push *ndr, int flags, const struct samr_QuerySecurity *r)
 
5567
{
 
5568
        if (flags & NDR_IN) {
 
5569
                if (r->in.handle == NULL) {
 
5570
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5571
                }
 
5572
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 
5573
                NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
 
5574
        }
 
5575
        if (flags & NDR_OUT) {
 
5576
                if (r->out.sdbuf == NULL) {
 
5577
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5578
                }
 
5579
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sdbuf));
 
5580
                if (*r->out.sdbuf) {
 
5581
                        NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
 
5582
                }
 
5583
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
5584
        }
 
5585
        return NDR_ERR_SUCCESS;
 
5586
}
 
5587
 
 
5588
static enum ndr_err_code ndr_pull_samr_QuerySecurity(struct ndr_pull *ndr, int flags, struct samr_QuerySecurity *r)
 
5589
{
 
5590
        uint32_t _ptr_sdbuf;
 
5591
        TALLOC_CTX *_mem_save_handle_0;
 
5592
        TALLOC_CTX *_mem_save_sdbuf_0;
 
5593
        TALLOC_CTX *_mem_save_sdbuf_1;
 
5594
        if (flags & NDR_IN) {
 
5595
                ZERO_STRUCT(r->out);
 
5596
 
 
5597
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5598
                        NDR_PULL_ALLOC(ndr, r->in.handle);
 
5599
                }
 
5600
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5601
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 
5602
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 
5603
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5604
                NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
 
5605
                NDR_PULL_ALLOC(ndr, r->out.sdbuf);
 
5606
                ZERO_STRUCTP(r->out.sdbuf);
 
5607
        }
 
5608
        if (flags & NDR_OUT) {
 
5609
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5610
                        NDR_PULL_ALLOC(ndr, r->out.sdbuf);
 
5611
                }
 
5612
                _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5613
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sdbuf, LIBNDR_FLAG_REF_ALLOC);
 
5614
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sdbuf));
 
5615
                if (_ptr_sdbuf) {
 
5616
                        NDR_PULL_ALLOC(ndr, *r->out.sdbuf);
 
5617
                } else {
 
5618
                        *r->out.sdbuf = NULL;
 
5619
                }
 
5620
                if (*r->out.sdbuf) {
 
5621
                        _mem_save_sdbuf_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
5622
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.sdbuf, 0);
 
5623
                        NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
 
5624
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_1, 0);
 
5625
                }
 
5626
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
 
5627
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
5628
        }
 
5629
        return NDR_ERR_SUCCESS;
 
5630
}
 
5631
 
 
5632
_PUBLIC_ void ndr_print_samr_QuerySecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_QuerySecurity *r)
 
5633
{
 
5634
        ndr_print_struct(ndr, name, "samr_QuerySecurity");
 
5635
        ndr->depth++;
 
5636
        if (flags & NDR_SET_VALUES) {
 
5637
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
5638
        }
 
5639
        if (flags & NDR_IN) {
 
5640
                ndr_print_struct(ndr, "in", "samr_QuerySecurity");
 
5641
                ndr->depth++;
 
5642
                ndr_print_ptr(ndr, "handle", r->in.handle);
 
5643
                ndr->depth++;
 
5644
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
 
5645
                ndr->depth--;
 
5646
                ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
 
5647
                ndr->depth--;
 
5648
        }
 
5649
        if (flags & NDR_OUT) {
 
5650
                ndr_print_struct(ndr, "out", "samr_QuerySecurity");
 
5651
                ndr->depth++;
 
5652
                ndr_print_ptr(ndr, "sdbuf", r->out.sdbuf);
 
5653
                ndr->depth++;
 
5654
                ndr_print_ptr(ndr, "sdbuf", *r->out.sdbuf);
 
5655
                ndr->depth++;
 
5656
                if (*r->out.sdbuf) {
 
5657
                        ndr_print_sec_desc_buf(ndr, "sdbuf", *r->out.sdbuf);
 
5658
                }
 
5659
                ndr->depth--;
 
5660
                ndr->depth--;
 
5661
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
5662
                ndr->depth--;
 
5663
        }
 
5664
        ndr->depth--;
 
5665
}
 
5666
 
 
5667
static enum ndr_err_code ndr_push_samr_Shutdown(struct ndr_push *ndr, int flags, const struct samr_Shutdown *r)
 
5668
{
 
5669
        if (flags & NDR_IN) {
 
5670
                if (r->in.connect_handle == NULL) {
 
5671
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5672
                }
 
5673
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
5674
        }
 
5675
        if (flags & NDR_OUT) {
 
5676
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
5677
        }
 
5678
        return NDR_ERR_SUCCESS;
 
5679
}
 
5680
 
 
5681
static enum ndr_err_code ndr_pull_samr_Shutdown(struct ndr_pull *ndr, int flags, struct samr_Shutdown *r)
 
5682
{
 
5683
        TALLOC_CTX *_mem_save_connect_handle_0;
 
5684
        if (flags & NDR_IN) {
 
5685
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5686
                        NDR_PULL_ALLOC(ndr, r->in.connect_handle);
 
5687
                }
 
5688
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5689
                NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
5690
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
5691
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5692
        }
 
5693
        if (flags & NDR_OUT) {
 
5694
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
5695
        }
 
5696
        return NDR_ERR_SUCCESS;
 
5697
}
 
5698
 
 
5699
_PUBLIC_ void ndr_print_samr_Shutdown(struct ndr_print *ndr, const char *name, int flags, const struct samr_Shutdown *r)
 
5700
{
 
5701
        ndr_print_struct(ndr, name, "samr_Shutdown");
 
5702
        ndr->depth++;
 
5703
        if (flags & NDR_SET_VALUES) {
 
5704
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
5705
        }
 
5706
        if (flags & NDR_IN) {
 
5707
                ndr_print_struct(ndr, "in", "samr_Shutdown");
 
5708
                ndr->depth++;
 
5709
                ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
 
5710
                ndr->depth++;
 
5711
                ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
 
5712
                ndr->depth--;
 
5713
                ndr->depth--;
 
5714
        }
 
5715
        if (flags & NDR_OUT) {
 
5716
                ndr_print_struct(ndr, "out", "samr_Shutdown");
 
5717
                ndr->depth++;
 
5718
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
5719
                ndr->depth--;
 
5720
        }
 
5721
        ndr->depth--;
 
5722
}
 
5723
 
 
5724
static enum ndr_err_code ndr_push_samr_LookupDomain(struct ndr_push *ndr, int flags, const struct samr_LookupDomain *r)
 
5725
{
 
5726
        if (flags & NDR_IN) {
 
5727
                if (r->in.connect_handle == NULL) {
 
5728
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5729
                }
 
5730
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
5731
                if (r->in.domain_name == NULL) {
 
5732
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5733
                }
 
5734
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
 
5735
        }
 
5736
        if (flags & NDR_OUT) {
 
5737
                if (r->out.sid == NULL) {
 
5738
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5739
                }
 
5740
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
 
5741
                if (*r->out.sid) {
 
5742
                        NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
 
5743
                }
 
5744
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
5745
        }
 
5746
        return NDR_ERR_SUCCESS;
 
5747
}
 
5748
 
 
5749
static enum ndr_err_code ndr_pull_samr_LookupDomain(struct ndr_pull *ndr, int flags, struct samr_LookupDomain *r)
 
5750
{
 
5751
        uint32_t _ptr_sid;
 
5752
        TALLOC_CTX *_mem_save_connect_handle_0;
 
5753
        TALLOC_CTX *_mem_save_domain_name_0;
 
5754
        TALLOC_CTX *_mem_save_sid_0;
 
5755
        TALLOC_CTX *_mem_save_sid_1;
 
5756
        if (flags & NDR_IN) {
 
5757
                ZERO_STRUCT(r->out);
 
5758
 
 
5759
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5760
                        NDR_PULL_ALLOC(ndr, r->in.connect_handle);
 
5761
                }
 
5762
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5763
                NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
5764
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
5765
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5766
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5767
                        NDR_PULL_ALLOC(ndr, r->in.domain_name);
 
5768
                }
 
5769
                _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5770
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, LIBNDR_FLAG_REF_ALLOC);
 
5771
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
 
5772
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, LIBNDR_FLAG_REF_ALLOC);
 
5773
                NDR_PULL_ALLOC(ndr, r->out.sid);
 
5774
                ZERO_STRUCTP(r->out.sid);
 
5775
        }
 
5776
        if (flags & NDR_OUT) {
 
5777
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5778
                        NDR_PULL_ALLOC(ndr, r->out.sid);
 
5779
                }
 
5780
                _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5781
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
 
5782
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
 
5783
                if (_ptr_sid) {
 
5784
                        NDR_PULL_ALLOC(ndr, *r->out.sid);
 
5785
                } else {
 
5786
                        *r->out.sid = NULL;
 
5787
                }
 
5788
                if (*r->out.sid) {
 
5789
                        _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
5790
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
 
5791
                        NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
 
5792
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
 
5793
                }
 
5794
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 
5795
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
5796
        }
 
5797
        return NDR_ERR_SUCCESS;
 
5798
}
 
5799
 
 
5800
_PUBLIC_ void ndr_print_samr_LookupDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupDomain *r)
 
5801
{
 
5802
        ndr_print_struct(ndr, name, "samr_LookupDomain");
 
5803
        ndr->depth++;
 
5804
        if (flags & NDR_SET_VALUES) {
 
5805
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
5806
        }
 
5807
        if (flags & NDR_IN) {
 
5808
                ndr_print_struct(ndr, "in", "samr_LookupDomain");
 
5809
                ndr->depth++;
 
5810
                ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
 
5811
                ndr->depth++;
 
5812
                ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
 
5813
                ndr->depth--;
 
5814
                ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
 
5815
                ndr->depth++;
 
5816
                ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
 
5817
                ndr->depth--;
 
5818
                ndr->depth--;
 
5819
        }
 
5820
        if (flags & NDR_OUT) {
 
5821
                ndr_print_struct(ndr, "out", "samr_LookupDomain");
 
5822
                ndr->depth++;
 
5823
                ndr_print_ptr(ndr, "sid", r->out.sid);
 
5824
                ndr->depth++;
 
5825
                ndr_print_ptr(ndr, "sid", *r->out.sid);
 
5826
                ndr->depth++;
 
5827
                if (*r->out.sid) {
 
5828
                        ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
 
5829
                }
 
5830
                ndr->depth--;
 
5831
                ndr->depth--;
 
5832
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
5833
                ndr->depth--;
 
5834
        }
 
5835
        ndr->depth--;
 
5836
}
 
5837
 
 
5838
static enum ndr_err_code ndr_push_samr_EnumDomains(struct ndr_push *ndr, int flags, const struct samr_EnumDomains *r)
 
5839
{
 
5840
        if (flags & NDR_IN) {
 
5841
                if (r->in.connect_handle == NULL) {
 
5842
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5843
                }
 
5844
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
5845
                if (r->in.resume_handle == NULL) {
 
5846
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5847
                }
 
5848
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
 
5849
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
 
5850
        }
 
5851
        if (flags & NDR_OUT) {
 
5852
                if (r->out.resume_handle == NULL) {
 
5853
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5854
                }
 
5855
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
 
5856
                if (r->out.sam == NULL) {
 
5857
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5858
                }
 
5859
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
 
5860
                if (*r->out.sam) {
 
5861
                        NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
5862
                }
 
5863
                if (r->out.num_entries == NULL) {
 
5864
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5865
                }
 
5866
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
 
5867
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
5868
        }
 
5869
        return NDR_ERR_SUCCESS;
 
5870
}
 
5871
 
 
5872
static enum ndr_err_code ndr_pull_samr_EnumDomains(struct ndr_pull *ndr, int flags, struct samr_EnumDomains *r)
 
5873
{
 
5874
        uint32_t _ptr_sam;
 
5875
        TALLOC_CTX *_mem_save_connect_handle_0;
 
5876
        TALLOC_CTX *_mem_save_resume_handle_0;
 
5877
        TALLOC_CTX *_mem_save_sam_0;
 
5878
        TALLOC_CTX *_mem_save_sam_1;
 
5879
        TALLOC_CTX *_mem_save_num_entries_0;
 
5880
        if (flags & NDR_IN) {
 
5881
                ZERO_STRUCT(r->out);
 
5882
 
 
5883
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5884
                        NDR_PULL_ALLOC(ndr, r->in.connect_handle);
 
5885
                }
 
5886
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5887
                NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
5888
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
5889
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5890
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5891
                        NDR_PULL_ALLOC(ndr, r->in.resume_handle);
 
5892
                }
 
5893
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5894
                NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
5895
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
 
5896
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5897
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
 
5898
                NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
5899
                *r->out.resume_handle = *r->in.resume_handle;
 
5900
                NDR_PULL_ALLOC(ndr, r->out.sam);
 
5901
                ZERO_STRUCTP(r->out.sam);
 
5902
                NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
5903
                ZERO_STRUCTP(r->out.num_entries);
 
5904
        }
 
5905
        if (flags & NDR_OUT) {
 
5906
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5907
                        NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
5908
                }
 
5909
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5910
                NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
5911
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
 
5912
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5913
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5914
                        NDR_PULL_ALLOC(ndr, r->out.sam);
 
5915
                }
 
5916
                _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5917
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
 
5918
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
 
5919
                if (_ptr_sam) {
 
5920
                        NDR_PULL_ALLOC(ndr, *r->out.sam);
 
5921
                } else {
 
5922
                        *r->out.sam = NULL;
 
5923
                }
 
5924
                if (*r->out.sam) {
 
5925
                        _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
5926
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
 
5927
                        NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
5928
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
 
5929
                }
 
5930
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
 
5931
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5932
                        NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
5933
                }
 
5934
                _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5935
                NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
 
5936
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
 
5937
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
 
5938
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
5939
        }
 
5940
        return NDR_ERR_SUCCESS;
 
5941
}
 
5942
 
 
5943
_PUBLIC_ void ndr_print_samr_EnumDomains(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomains *r)
 
5944
{
 
5945
        ndr_print_struct(ndr, name, "samr_EnumDomains");
 
5946
        ndr->depth++;
 
5947
        if (flags & NDR_SET_VALUES) {
 
5948
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
5949
        }
 
5950
        if (flags & NDR_IN) {
 
5951
                ndr_print_struct(ndr, "in", "samr_EnumDomains");
 
5952
                ndr->depth++;
 
5953
                ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
 
5954
                ndr->depth++;
 
5955
                ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
 
5956
                ndr->depth--;
 
5957
                ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
 
5958
                ndr->depth++;
 
5959
                ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
 
5960
                ndr->depth--;
 
5961
                ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
 
5962
                ndr->depth--;
 
5963
        }
 
5964
        if (flags & NDR_OUT) {
 
5965
                ndr_print_struct(ndr, "out", "samr_EnumDomains");
 
5966
                ndr->depth++;
 
5967
                ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
 
5968
                ndr->depth++;
 
5969
                ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
 
5970
                ndr->depth--;
 
5971
                ndr_print_ptr(ndr, "sam", r->out.sam);
 
5972
                ndr->depth++;
 
5973
                ndr_print_ptr(ndr, "sam", *r->out.sam);
 
5974
                ndr->depth++;
 
5975
                if (*r->out.sam) {
 
5976
                        ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
 
5977
                }
 
5978
                ndr->depth--;
 
5979
                ndr->depth--;
 
5980
                ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
 
5981
                ndr->depth++;
 
5982
                ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
 
5983
                ndr->depth--;
 
5984
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
5985
                ndr->depth--;
 
5986
        }
 
5987
        ndr->depth--;
 
5988
}
 
5989
 
 
5990
_PUBLIC_ enum ndr_err_code ndr_push_samr_OpenDomain(struct ndr_push *ndr, int flags, const struct samr_OpenDomain *r)
 
5991
{
 
5992
        if (flags & NDR_IN) {
 
5993
                if (r->in.connect_handle == NULL) {
 
5994
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5995
                }
 
5996
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
5997
                NDR_CHECK(ndr_push_samr_DomainAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
5998
                if (r->in.sid == NULL) {
 
5999
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6000
                }
 
6001
                NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
6002
        }
 
6003
        if (flags & NDR_OUT) {
 
6004
                if (r->out.domain_handle == NULL) {
 
6005
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6006
                }
 
6007
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
 
6008
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6009
        }
 
6010
        return NDR_ERR_SUCCESS;
 
6011
}
 
6012
 
 
6013
_PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenDomain(struct ndr_pull *ndr, int flags, struct samr_OpenDomain *r)
 
6014
{
 
6015
        TALLOC_CTX *_mem_save_connect_handle_0;
 
6016
        TALLOC_CTX *_mem_save_sid_0;
 
6017
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6018
        if (flags & NDR_IN) {
 
6019
                ZERO_STRUCT(r->out);
 
6020
 
 
6021
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6022
                        NDR_PULL_ALLOC(ndr, r->in.connect_handle);
 
6023
                }
 
6024
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6025
                NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
6026
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
6027
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6028
                NDR_CHECK(ndr_pull_samr_DomainAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
6029
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6030
                        NDR_PULL_ALLOC(ndr, r->in.sid);
 
6031
                }
 
6032
                _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6033
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
 
6034
                NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
6035
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 
6036
                NDR_PULL_ALLOC(ndr, r->out.domain_handle);
 
6037
                ZERO_STRUCTP(r->out.domain_handle);
 
6038
        }
 
6039
        if (flags & NDR_OUT) {
 
6040
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6041
                        NDR_PULL_ALLOC(ndr, r->out.domain_handle);
 
6042
                }
 
6043
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6044
                NDR_PULL_SET_MEM_CTX(ndr, r->out.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6045
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
 
6046
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6047
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6048
        }
 
6049
        return NDR_ERR_SUCCESS;
 
6050
}
 
6051
 
 
6052
_PUBLIC_ void ndr_print_samr_OpenDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenDomain *r)
 
6053
{
 
6054
        ndr_print_struct(ndr, name, "samr_OpenDomain");
 
6055
        ndr->depth++;
 
6056
        if (flags & NDR_SET_VALUES) {
 
6057
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6058
        }
 
6059
        if (flags & NDR_IN) {
 
6060
                ndr_print_struct(ndr, "in", "samr_OpenDomain");
 
6061
                ndr->depth++;
 
6062
                ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
 
6063
                ndr->depth++;
 
6064
                ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
 
6065
                ndr->depth--;
 
6066
                ndr_print_samr_DomainAccessMask(ndr, "access_mask", r->in.access_mask);
 
6067
                ndr_print_ptr(ndr, "sid", r->in.sid);
 
6068
                ndr->depth++;
 
6069
                ndr_print_dom_sid2(ndr, "sid", r->in.sid);
 
6070
                ndr->depth--;
 
6071
                ndr->depth--;
 
6072
        }
 
6073
        if (flags & NDR_OUT) {
 
6074
                ndr_print_struct(ndr, "out", "samr_OpenDomain");
 
6075
                ndr->depth++;
 
6076
                ndr_print_ptr(ndr, "domain_handle", r->out.domain_handle);
 
6077
                ndr->depth++;
 
6078
                ndr_print_policy_handle(ndr, "domain_handle", r->out.domain_handle);
 
6079
                ndr->depth--;
 
6080
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6081
                ndr->depth--;
 
6082
        }
 
6083
        ndr->depth--;
 
6084
}
 
6085
 
 
6086
static enum ndr_err_code ndr_push_samr_QueryDomainInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo *r)
 
6087
{
 
6088
        if (flags & NDR_IN) {
 
6089
                if (r->in.domain_handle == NULL) {
 
6090
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6091
                }
 
6092
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6093
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
6094
        }
 
6095
        if (flags & NDR_OUT) {
 
6096
                if (r->out.info == NULL) {
 
6097
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6098
                }
 
6099
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
 
6100
                if (*r->out.info) {
 
6101
                        NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
 
6102
                        NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
6103
                }
 
6104
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6105
        }
 
6106
        return NDR_ERR_SUCCESS;
 
6107
}
 
6108
 
 
6109
static enum ndr_err_code ndr_pull_samr_QueryDomainInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo *r)
 
6110
{
 
6111
        uint32_t _ptr_info;
 
6112
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6113
        TALLOC_CTX *_mem_save_info_0;
 
6114
        TALLOC_CTX *_mem_save_info_1;
 
6115
        if (flags & NDR_IN) {
 
6116
                ZERO_STRUCT(r->out);
 
6117
 
 
6118
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6119
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
6120
                }
 
6121
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6122
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6123
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6124
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6125
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
6126
                NDR_PULL_ALLOC(ndr, r->out.info);
 
6127
                ZERO_STRUCTP(r->out.info);
 
6128
        }
 
6129
        if (flags & NDR_OUT) {
 
6130
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6131
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
6132
                }
 
6133
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6134
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
6135
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 
6136
                if (_ptr_info) {
 
6137
                        NDR_PULL_ALLOC(ndr, *r->out.info);
 
6138
                } else {
 
6139
                        *r->out.info = NULL;
 
6140
                }
 
6141
                if (*r->out.info) {
 
6142
                        _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
6143
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
 
6144
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
 
6145
                        NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
6146
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
 
6147
                }
 
6148
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
6149
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6150
        }
 
6151
        return NDR_ERR_SUCCESS;
 
6152
}
 
6153
 
 
6154
_PUBLIC_ void ndr_print_samr_QueryDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo *r)
 
6155
{
 
6156
        ndr_print_struct(ndr, name, "samr_QueryDomainInfo");
 
6157
        ndr->depth++;
 
6158
        if (flags & NDR_SET_VALUES) {
 
6159
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6160
        }
 
6161
        if (flags & NDR_IN) {
 
6162
                ndr_print_struct(ndr, "in", "samr_QueryDomainInfo");
 
6163
                ndr->depth++;
 
6164
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
6165
                ndr->depth++;
 
6166
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
6167
                ndr->depth--;
 
6168
                ndr_print_uint16(ndr, "level", r->in.level);
 
6169
                ndr->depth--;
 
6170
        }
 
6171
        if (flags & NDR_OUT) {
 
6172
                ndr_print_struct(ndr, "out", "samr_QueryDomainInfo");
 
6173
                ndr->depth++;
 
6174
                ndr_print_ptr(ndr, "info", r->out.info);
 
6175
                ndr->depth++;
 
6176
                ndr_print_ptr(ndr, "info", *r->out.info);
 
6177
                ndr->depth++;
 
6178
                if (*r->out.info) {
 
6179
                        ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
 
6180
                        ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
 
6181
                }
 
6182
                ndr->depth--;
 
6183
                ndr->depth--;
 
6184
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6185
                ndr->depth--;
 
6186
        }
 
6187
        ndr->depth--;
 
6188
}
 
6189
 
 
6190
static enum ndr_err_code ndr_push_samr_SetDomainInfo(struct ndr_push *ndr, int flags, const struct samr_SetDomainInfo *r)
 
6191
{
 
6192
        if (flags & NDR_IN) {
 
6193
                if (r->in.domain_handle == NULL) {
 
6194
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6195
                }
 
6196
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6197
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
6198
                if (r->in.info == NULL) {
 
6199
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6200
                }
 
6201
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
 
6202
                NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
6203
        }
 
6204
        if (flags & NDR_OUT) {
 
6205
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6206
        }
 
6207
        return NDR_ERR_SUCCESS;
 
6208
}
 
6209
 
 
6210
static enum ndr_err_code ndr_pull_samr_SetDomainInfo(struct ndr_pull *ndr, int flags, struct samr_SetDomainInfo *r)
 
6211
{
 
6212
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6213
        TALLOC_CTX *_mem_save_info_0;
 
6214
        if (flags & NDR_IN) {
 
6215
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6216
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
6217
                }
 
6218
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6219
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6220
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6221
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6222
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
6223
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6224
                        NDR_PULL_ALLOC(ndr, r->in.info);
 
6225
                }
 
6226
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6227
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
 
6228
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
 
6229
                NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
6230
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
6231
        }
 
6232
        if (flags & NDR_OUT) {
 
6233
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6234
        }
 
6235
        return NDR_ERR_SUCCESS;
 
6236
}
 
6237
 
 
6238
_PUBLIC_ void ndr_print_samr_SetDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDomainInfo *r)
 
6239
{
 
6240
        ndr_print_struct(ndr, name, "samr_SetDomainInfo");
 
6241
        ndr->depth++;
 
6242
        if (flags & NDR_SET_VALUES) {
 
6243
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6244
        }
 
6245
        if (flags & NDR_IN) {
 
6246
                ndr_print_struct(ndr, "in", "samr_SetDomainInfo");
 
6247
                ndr->depth++;
 
6248
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
6249
                ndr->depth++;
 
6250
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
6251
                ndr->depth--;
 
6252
                ndr_print_uint16(ndr, "level", r->in.level);
 
6253
                ndr_print_ptr(ndr, "info", r->in.info);
 
6254
                ndr->depth++;
 
6255
                ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
 
6256
                ndr_print_samr_DomainInfo(ndr, "info", r->in.info);
 
6257
                ndr->depth--;
 
6258
                ndr->depth--;
 
6259
        }
 
6260
        if (flags & NDR_OUT) {
 
6261
                ndr_print_struct(ndr, "out", "samr_SetDomainInfo");
 
6262
                ndr->depth++;
 
6263
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6264
                ndr->depth--;
 
6265
        }
 
6266
        ndr->depth--;
 
6267
}
 
6268
 
 
6269
static enum ndr_err_code ndr_push_samr_CreateDomainGroup(struct ndr_push *ndr, int flags, const struct samr_CreateDomainGroup *r)
 
6270
{
 
6271
        if (flags & NDR_IN) {
 
6272
                if (r->in.domain_handle == NULL) {
 
6273
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6274
                }
 
6275
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6276
                if (r->in.name == NULL) {
 
6277
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6278
                }
 
6279
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
6280
                NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
6281
        }
 
6282
        if (flags & NDR_OUT) {
 
6283
                if (r->out.group_handle == NULL) {
 
6284
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6285
                }
 
6286
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
 
6287
                if (r->out.rid == NULL) {
 
6288
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6289
                }
 
6290
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
 
6291
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6292
        }
 
6293
        return NDR_ERR_SUCCESS;
 
6294
}
 
6295
 
 
6296
static enum ndr_err_code ndr_pull_samr_CreateDomainGroup(struct ndr_pull *ndr, int flags, struct samr_CreateDomainGroup *r)
 
6297
{
 
6298
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6299
        TALLOC_CTX *_mem_save_name_0;
 
6300
        TALLOC_CTX *_mem_save_group_handle_0;
 
6301
        TALLOC_CTX *_mem_save_rid_0;
 
6302
        if (flags & NDR_IN) {
 
6303
                ZERO_STRUCT(r->out);
 
6304
 
 
6305
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6306
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
6307
                }
 
6308
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6309
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6310
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6311
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6312
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6313
                        NDR_PULL_ALLOC(ndr, r->in.name);
 
6314
                }
 
6315
                _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6316
                NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
 
6317
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
6318
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
 
6319
                NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
6320
                NDR_PULL_ALLOC(ndr, r->out.group_handle);
 
6321
                ZERO_STRUCTP(r->out.group_handle);
 
6322
                NDR_PULL_ALLOC(ndr, r->out.rid);
 
6323
                ZERO_STRUCTP(r->out.rid);
 
6324
        }
 
6325
        if (flags & NDR_OUT) {
 
6326
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6327
                        NDR_PULL_ALLOC(ndr, r->out.group_handle);
 
6328
                }
 
6329
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6330
                NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
6331
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
 
6332
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6333
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6334
                        NDR_PULL_ALLOC(ndr, r->out.rid);
 
6335
                }
 
6336
                _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6337
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
 
6338
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
 
6339
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
 
6340
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6341
        }
 
6342
        return NDR_ERR_SUCCESS;
 
6343
}
 
6344
 
 
6345
_PUBLIC_ void ndr_print_samr_CreateDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomainGroup *r)
 
6346
{
 
6347
        ndr_print_struct(ndr, name, "samr_CreateDomainGroup");
 
6348
        ndr->depth++;
 
6349
        if (flags & NDR_SET_VALUES) {
 
6350
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6351
        }
 
6352
        if (flags & NDR_IN) {
 
6353
                ndr_print_struct(ndr, "in", "samr_CreateDomainGroup");
 
6354
                ndr->depth++;
 
6355
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
6356
                ndr->depth++;
 
6357
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
6358
                ndr->depth--;
 
6359
                ndr_print_ptr(ndr, "name", r->in.name);
 
6360
                ndr->depth++;
 
6361
                ndr_print_lsa_String(ndr, "name", r->in.name);
 
6362
                ndr->depth--;
 
6363
                ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
 
6364
                ndr->depth--;
 
6365
        }
 
6366
        if (flags & NDR_OUT) {
 
6367
                ndr_print_struct(ndr, "out", "samr_CreateDomainGroup");
 
6368
                ndr->depth++;
 
6369
                ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
 
6370
                ndr->depth++;
 
6371
                ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
 
6372
                ndr->depth--;
 
6373
                ndr_print_ptr(ndr, "rid", r->out.rid);
 
6374
                ndr->depth++;
 
6375
                ndr_print_uint32(ndr, "rid", *r->out.rid);
 
6376
                ndr->depth--;
 
6377
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6378
                ndr->depth--;
 
6379
        }
 
6380
        ndr->depth--;
 
6381
}
 
6382
 
 
6383
static enum ndr_err_code ndr_push_samr_EnumDomainGroups(struct ndr_push *ndr, int flags, const struct samr_EnumDomainGroups *r)
 
6384
{
 
6385
        if (flags & NDR_IN) {
 
6386
                if (r->in.domain_handle == NULL) {
 
6387
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6388
                }
 
6389
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6390
                if (r->in.resume_handle == NULL) {
 
6391
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6392
                }
 
6393
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
 
6394
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
 
6395
        }
 
6396
        if (flags & NDR_OUT) {
 
6397
                if (r->out.resume_handle == NULL) {
 
6398
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6399
                }
 
6400
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
 
6401
                if (r->out.sam == NULL) {
 
6402
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6403
                }
 
6404
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
 
6405
                if (*r->out.sam) {
 
6406
                        NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
6407
                }
 
6408
                if (r->out.num_entries == NULL) {
 
6409
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6410
                }
 
6411
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
 
6412
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6413
        }
 
6414
        return NDR_ERR_SUCCESS;
 
6415
}
 
6416
 
 
6417
static enum ndr_err_code ndr_pull_samr_EnumDomainGroups(struct ndr_pull *ndr, int flags, struct samr_EnumDomainGroups *r)
 
6418
{
 
6419
        uint32_t _ptr_sam;
 
6420
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6421
        TALLOC_CTX *_mem_save_resume_handle_0;
 
6422
        TALLOC_CTX *_mem_save_sam_0;
 
6423
        TALLOC_CTX *_mem_save_sam_1;
 
6424
        TALLOC_CTX *_mem_save_num_entries_0;
 
6425
        if (flags & NDR_IN) {
 
6426
                ZERO_STRUCT(r->out);
 
6427
 
 
6428
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6429
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
6430
                }
 
6431
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6432
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6433
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6434
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6435
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6436
                        NDR_PULL_ALLOC(ndr, r->in.resume_handle);
 
6437
                }
 
6438
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6439
                NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
6440
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
 
6441
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6442
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
 
6443
                NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
6444
                *r->out.resume_handle = *r->in.resume_handle;
 
6445
                NDR_PULL_ALLOC(ndr, r->out.sam);
 
6446
                ZERO_STRUCTP(r->out.sam);
 
6447
                NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
6448
                ZERO_STRUCTP(r->out.num_entries);
 
6449
        }
 
6450
        if (flags & NDR_OUT) {
 
6451
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6452
                        NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
6453
                }
 
6454
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6455
                NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
6456
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
 
6457
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6458
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6459
                        NDR_PULL_ALLOC(ndr, r->out.sam);
 
6460
                }
 
6461
                _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6462
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
 
6463
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
 
6464
                if (_ptr_sam) {
 
6465
                        NDR_PULL_ALLOC(ndr, *r->out.sam);
 
6466
                } else {
 
6467
                        *r->out.sam = NULL;
 
6468
                }
 
6469
                if (*r->out.sam) {
 
6470
                        _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
6471
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
 
6472
                        NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
6473
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
 
6474
                }
 
6475
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
 
6476
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6477
                        NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
6478
                }
 
6479
                _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6480
                NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
 
6481
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
 
6482
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
 
6483
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6484
        }
 
6485
        return NDR_ERR_SUCCESS;
 
6486
}
 
6487
 
 
6488
_PUBLIC_ void ndr_print_samr_EnumDomainGroups(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainGroups *r)
 
6489
{
 
6490
        ndr_print_struct(ndr, name, "samr_EnumDomainGroups");
 
6491
        ndr->depth++;
 
6492
        if (flags & NDR_SET_VALUES) {
 
6493
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6494
        }
 
6495
        if (flags & NDR_IN) {
 
6496
                ndr_print_struct(ndr, "in", "samr_EnumDomainGroups");
 
6497
                ndr->depth++;
 
6498
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
6499
                ndr->depth++;
 
6500
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
6501
                ndr->depth--;
 
6502
                ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
 
6503
                ndr->depth++;
 
6504
                ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
 
6505
                ndr->depth--;
 
6506
                ndr_print_uint32(ndr, "max_size", r->in.max_size);
 
6507
                ndr->depth--;
 
6508
        }
 
6509
        if (flags & NDR_OUT) {
 
6510
                ndr_print_struct(ndr, "out", "samr_EnumDomainGroups");
 
6511
                ndr->depth++;
 
6512
                ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
 
6513
                ndr->depth++;
 
6514
                ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
 
6515
                ndr->depth--;
 
6516
                ndr_print_ptr(ndr, "sam", r->out.sam);
 
6517
                ndr->depth++;
 
6518
                ndr_print_ptr(ndr, "sam", *r->out.sam);
 
6519
                ndr->depth++;
 
6520
                if (*r->out.sam) {
 
6521
                        ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
 
6522
                }
 
6523
                ndr->depth--;
 
6524
                ndr->depth--;
 
6525
                ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
 
6526
                ndr->depth++;
 
6527
                ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
 
6528
                ndr->depth--;
 
6529
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6530
                ndr->depth--;
 
6531
        }
 
6532
        ndr->depth--;
 
6533
}
 
6534
 
 
6535
static enum ndr_err_code ndr_push_samr_CreateUser(struct ndr_push *ndr, int flags, const struct samr_CreateUser *r)
 
6536
{
 
6537
        if (flags & NDR_IN) {
 
6538
                if (r->in.domain_handle == NULL) {
 
6539
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6540
                }
 
6541
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6542
                if (r->in.account_name == NULL) {
 
6543
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6544
                }
 
6545
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
 
6546
                NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
6547
        }
 
6548
        if (flags & NDR_OUT) {
 
6549
                if (r->out.user_handle == NULL) {
 
6550
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6551
                }
 
6552
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
6553
                if (r->out.rid == NULL) {
 
6554
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6555
                }
 
6556
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
 
6557
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6558
        }
 
6559
        return NDR_ERR_SUCCESS;
 
6560
}
 
6561
 
 
6562
static enum ndr_err_code ndr_pull_samr_CreateUser(struct ndr_pull *ndr, int flags, struct samr_CreateUser *r)
 
6563
{
 
6564
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6565
        TALLOC_CTX *_mem_save_account_name_0;
 
6566
        TALLOC_CTX *_mem_save_user_handle_0;
 
6567
        TALLOC_CTX *_mem_save_rid_0;
 
6568
        if (flags & NDR_IN) {
 
6569
                ZERO_STRUCT(r->out);
 
6570
 
 
6571
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6572
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
6573
                }
 
6574
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6575
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6576
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6577
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6578
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6579
                        NDR_PULL_ALLOC(ndr, r->in.account_name);
 
6580
                }
 
6581
                _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6582
                NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
 
6583
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
 
6584
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
 
6585
                NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
6586
                NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
6587
                ZERO_STRUCTP(r->out.user_handle);
 
6588
                NDR_PULL_ALLOC(ndr, r->out.rid);
 
6589
                ZERO_STRUCTP(r->out.rid);
 
6590
        }
 
6591
        if (flags & NDR_OUT) {
 
6592
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6593
                        NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
6594
                }
 
6595
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6596
                NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
6597
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
6598
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6599
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6600
                        NDR_PULL_ALLOC(ndr, r->out.rid);
 
6601
                }
 
6602
                _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6603
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
 
6604
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
 
6605
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
 
6606
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6607
        }
 
6608
        return NDR_ERR_SUCCESS;
 
6609
}
 
6610
 
 
6611
_PUBLIC_ void ndr_print_samr_CreateUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser *r)
 
6612
{
 
6613
        ndr_print_struct(ndr, name, "samr_CreateUser");
 
6614
        ndr->depth++;
 
6615
        if (flags & NDR_SET_VALUES) {
 
6616
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6617
        }
 
6618
        if (flags & NDR_IN) {
 
6619
                ndr_print_struct(ndr, "in", "samr_CreateUser");
 
6620
                ndr->depth++;
 
6621
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
6622
                ndr->depth++;
 
6623
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
6624
                ndr->depth--;
 
6625
                ndr_print_ptr(ndr, "account_name", r->in.account_name);
 
6626
                ndr->depth++;
 
6627
                ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
 
6628
                ndr->depth--;
 
6629
                ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
 
6630
                ndr->depth--;
 
6631
        }
 
6632
        if (flags & NDR_OUT) {
 
6633
                ndr_print_struct(ndr, "out", "samr_CreateUser");
 
6634
                ndr->depth++;
 
6635
                ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
 
6636
                ndr->depth++;
 
6637
                ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
 
6638
                ndr->depth--;
 
6639
                ndr_print_ptr(ndr, "rid", r->out.rid);
 
6640
                ndr->depth++;
 
6641
                ndr_print_uint32(ndr, "rid", *r->out.rid);
 
6642
                ndr->depth--;
 
6643
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6644
                ndr->depth--;
 
6645
        }
 
6646
        ndr->depth--;
 
6647
}
 
6648
 
 
6649
static enum ndr_err_code ndr_push_samr_EnumDomainUsers(struct ndr_push *ndr, int flags, const struct samr_EnumDomainUsers *r)
 
6650
{
 
6651
        if (flags & NDR_IN) {
 
6652
                if (r->in.domain_handle == NULL) {
 
6653
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6654
                }
 
6655
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6656
                if (r->in.resume_handle == NULL) {
 
6657
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6658
                }
 
6659
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
 
6660
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
 
6661
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
 
6662
        }
 
6663
        if (flags & NDR_OUT) {
 
6664
                if (r->out.resume_handle == NULL) {
 
6665
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6666
                }
 
6667
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
 
6668
                if (r->out.sam == NULL) {
 
6669
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6670
                }
 
6671
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
 
6672
                if (*r->out.sam) {
 
6673
                        NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
6674
                }
 
6675
                if (r->out.num_entries == NULL) {
 
6676
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6677
                }
 
6678
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
 
6679
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6680
        }
 
6681
        return NDR_ERR_SUCCESS;
 
6682
}
 
6683
 
 
6684
static enum ndr_err_code ndr_pull_samr_EnumDomainUsers(struct ndr_pull *ndr, int flags, struct samr_EnumDomainUsers *r)
 
6685
{
 
6686
        uint32_t _ptr_sam;
 
6687
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6688
        TALLOC_CTX *_mem_save_resume_handle_0;
 
6689
        TALLOC_CTX *_mem_save_sam_0;
 
6690
        TALLOC_CTX *_mem_save_sam_1;
 
6691
        TALLOC_CTX *_mem_save_num_entries_0;
 
6692
        if (flags & NDR_IN) {
 
6693
                ZERO_STRUCT(r->out);
 
6694
 
 
6695
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6696
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
6697
                }
 
6698
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6699
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6700
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6701
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6702
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6703
                        NDR_PULL_ALLOC(ndr, r->in.resume_handle);
 
6704
                }
 
6705
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6706
                NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
6707
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
 
6708
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6709
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
 
6710
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
 
6711
                NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
6712
                *r->out.resume_handle = *r->in.resume_handle;
 
6713
                NDR_PULL_ALLOC(ndr, r->out.sam);
 
6714
                ZERO_STRUCTP(r->out.sam);
 
6715
                NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
6716
                ZERO_STRUCTP(r->out.num_entries);
 
6717
        }
 
6718
        if (flags & NDR_OUT) {
 
6719
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6720
                        NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
6721
                }
 
6722
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6723
                NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
6724
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
 
6725
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6726
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6727
                        NDR_PULL_ALLOC(ndr, r->out.sam);
 
6728
                }
 
6729
                _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6730
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
 
6731
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
 
6732
                if (_ptr_sam) {
 
6733
                        NDR_PULL_ALLOC(ndr, *r->out.sam);
 
6734
                } else {
 
6735
                        *r->out.sam = NULL;
 
6736
                }
 
6737
                if (*r->out.sam) {
 
6738
                        _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
6739
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
 
6740
                        NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
6741
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
 
6742
                }
 
6743
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
 
6744
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6745
                        NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
6746
                }
 
6747
                _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6748
                NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
 
6749
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
 
6750
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
 
6751
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6752
        }
 
6753
        return NDR_ERR_SUCCESS;
 
6754
}
 
6755
 
 
6756
_PUBLIC_ void ndr_print_samr_EnumDomainUsers(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainUsers *r)
 
6757
{
 
6758
        ndr_print_struct(ndr, name, "samr_EnumDomainUsers");
 
6759
        ndr->depth++;
 
6760
        if (flags & NDR_SET_VALUES) {
 
6761
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6762
        }
 
6763
        if (flags & NDR_IN) {
 
6764
                ndr_print_struct(ndr, "in", "samr_EnumDomainUsers");
 
6765
                ndr->depth++;
 
6766
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
6767
                ndr->depth++;
 
6768
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
6769
                ndr->depth--;
 
6770
                ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
 
6771
                ndr->depth++;
 
6772
                ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
 
6773
                ndr->depth--;
 
6774
                ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
 
6775
                ndr_print_uint32(ndr, "max_size", r->in.max_size);
 
6776
                ndr->depth--;
 
6777
        }
 
6778
        if (flags & NDR_OUT) {
 
6779
                ndr_print_struct(ndr, "out", "samr_EnumDomainUsers");
 
6780
                ndr->depth++;
 
6781
                ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
 
6782
                ndr->depth++;
 
6783
                ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
 
6784
                ndr->depth--;
 
6785
                ndr_print_ptr(ndr, "sam", r->out.sam);
 
6786
                ndr->depth++;
 
6787
                ndr_print_ptr(ndr, "sam", *r->out.sam);
 
6788
                ndr->depth++;
 
6789
                if (*r->out.sam) {
 
6790
                        ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
 
6791
                }
 
6792
                ndr->depth--;
 
6793
                ndr->depth--;
 
6794
                ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
 
6795
                ndr->depth++;
 
6796
                ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
 
6797
                ndr->depth--;
 
6798
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6799
                ndr->depth--;
 
6800
        }
 
6801
        ndr->depth--;
 
6802
}
 
6803
 
 
6804
static enum ndr_err_code ndr_push_samr_CreateDomAlias(struct ndr_push *ndr, int flags, const struct samr_CreateDomAlias *r)
 
6805
{
 
6806
        if (flags & NDR_IN) {
 
6807
                if (r->in.domain_handle == NULL) {
 
6808
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6809
                }
 
6810
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6811
                if (r->in.alias_name == NULL) {
 
6812
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6813
                }
 
6814
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
 
6815
                NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
6816
        }
 
6817
        if (flags & NDR_OUT) {
 
6818
                if (r->out.alias_handle == NULL) {
 
6819
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6820
                }
 
6821
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
 
6822
                if (r->out.rid == NULL) {
 
6823
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6824
                }
 
6825
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
 
6826
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6827
        }
 
6828
        return NDR_ERR_SUCCESS;
 
6829
}
 
6830
 
 
6831
static enum ndr_err_code ndr_pull_samr_CreateDomAlias(struct ndr_pull *ndr, int flags, struct samr_CreateDomAlias *r)
 
6832
{
 
6833
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6834
        TALLOC_CTX *_mem_save_alias_name_0;
 
6835
        TALLOC_CTX *_mem_save_alias_handle_0;
 
6836
        TALLOC_CTX *_mem_save_rid_0;
 
6837
        if (flags & NDR_IN) {
 
6838
                ZERO_STRUCT(r->out);
 
6839
 
 
6840
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6841
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
6842
                }
 
6843
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6844
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6845
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6846
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6847
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6848
                        NDR_PULL_ALLOC(ndr, r->in.alias_name);
 
6849
                }
 
6850
                _mem_save_alias_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6851
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_name, LIBNDR_FLAG_REF_ALLOC);
 
6852
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
 
6853
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_name_0, LIBNDR_FLAG_REF_ALLOC);
 
6854
                NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
6855
                NDR_PULL_ALLOC(ndr, r->out.alias_handle);
 
6856
                ZERO_STRUCTP(r->out.alias_handle);
 
6857
                NDR_PULL_ALLOC(ndr, r->out.rid);
 
6858
                ZERO_STRUCTP(r->out.rid);
 
6859
        }
 
6860
        if (flags & NDR_OUT) {
 
6861
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6862
                        NDR_PULL_ALLOC(ndr, r->out.alias_handle);
 
6863
                }
 
6864
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6865
                NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
6866
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
 
6867
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6868
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6869
                        NDR_PULL_ALLOC(ndr, r->out.rid);
 
6870
                }
 
6871
                _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6872
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
 
6873
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
 
6874
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
 
6875
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6876
        }
 
6877
        return NDR_ERR_SUCCESS;
 
6878
}
 
6879
 
 
6880
_PUBLIC_ void ndr_print_samr_CreateDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomAlias *r)
 
6881
{
 
6882
        ndr_print_struct(ndr, name, "samr_CreateDomAlias");
 
6883
        ndr->depth++;
 
6884
        if (flags & NDR_SET_VALUES) {
 
6885
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6886
        }
 
6887
        if (flags & NDR_IN) {
 
6888
                ndr_print_struct(ndr, "in", "samr_CreateDomAlias");
 
6889
                ndr->depth++;
 
6890
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
6891
                ndr->depth++;
 
6892
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
6893
                ndr->depth--;
 
6894
                ndr_print_ptr(ndr, "alias_name", r->in.alias_name);
 
6895
                ndr->depth++;
 
6896
                ndr_print_lsa_String(ndr, "alias_name", r->in.alias_name);
 
6897
                ndr->depth--;
 
6898
                ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
 
6899
                ndr->depth--;
 
6900
        }
 
6901
        if (flags & NDR_OUT) {
 
6902
                ndr_print_struct(ndr, "out", "samr_CreateDomAlias");
 
6903
                ndr->depth++;
 
6904
                ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
 
6905
                ndr->depth++;
 
6906
                ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
 
6907
                ndr->depth--;
 
6908
                ndr_print_ptr(ndr, "rid", r->out.rid);
 
6909
                ndr->depth++;
 
6910
                ndr_print_uint32(ndr, "rid", *r->out.rid);
 
6911
                ndr->depth--;
 
6912
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6913
                ndr->depth--;
 
6914
        }
 
6915
        ndr->depth--;
 
6916
}
 
6917
 
 
6918
static enum ndr_err_code ndr_push_samr_EnumDomainAliases(struct ndr_push *ndr, int flags, const struct samr_EnumDomainAliases *r)
 
6919
{
 
6920
        if (flags & NDR_IN) {
 
6921
                if (r->in.domain_handle == NULL) {
 
6922
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6923
                }
 
6924
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6925
                if (r->in.resume_handle == NULL) {
 
6926
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6927
                }
 
6928
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
 
6929
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
 
6930
        }
 
6931
        if (flags & NDR_OUT) {
 
6932
                if (r->out.resume_handle == NULL) {
 
6933
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6934
                }
 
6935
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
 
6936
                if (r->out.sam == NULL) {
 
6937
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6938
                }
 
6939
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
 
6940
                if (*r->out.sam) {
 
6941
                        NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
6942
                }
 
6943
                if (r->out.num_entries == NULL) {
 
6944
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6945
                }
 
6946
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
 
6947
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6948
        }
 
6949
        return NDR_ERR_SUCCESS;
 
6950
}
 
6951
 
 
6952
static enum ndr_err_code ndr_pull_samr_EnumDomainAliases(struct ndr_pull *ndr, int flags, struct samr_EnumDomainAliases *r)
 
6953
{
 
6954
        uint32_t _ptr_sam;
 
6955
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6956
        TALLOC_CTX *_mem_save_resume_handle_0;
 
6957
        TALLOC_CTX *_mem_save_sam_0;
 
6958
        TALLOC_CTX *_mem_save_sam_1;
 
6959
        TALLOC_CTX *_mem_save_num_entries_0;
 
6960
        if (flags & NDR_IN) {
 
6961
                ZERO_STRUCT(r->out);
 
6962
 
 
6963
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6964
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
6965
                }
 
6966
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6967
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6968
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6969
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6970
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6971
                        NDR_PULL_ALLOC(ndr, r->in.resume_handle);
 
6972
                }
 
6973
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6974
                NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
6975
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
 
6976
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6977
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
 
6978
                NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
6979
                *r->out.resume_handle = *r->in.resume_handle;
 
6980
                NDR_PULL_ALLOC(ndr, r->out.sam);
 
6981
                ZERO_STRUCTP(r->out.sam);
 
6982
                NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
6983
                ZERO_STRUCTP(r->out.num_entries);
 
6984
        }
 
6985
        if (flags & NDR_OUT) {
 
6986
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6987
                        NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
6988
                }
 
6989
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6990
                NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
6991
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
 
6992
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6993
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6994
                        NDR_PULL_ALLOC(ndr, r->out.sam);
 
6995
                }
 
6996
                _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6997
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
 
6998
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
 
6999
                if (_ptr_sam) {
 
7000
                        NDR_PULL_ALLOC(ndr, *r->out.sam);
 
7001
                } else {
 
7002
                        *r->out.sam = NULL;
 
7003
                }
 
7004
                if (*r->out.sam) {
 
7005
                        _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
7006
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
 
7007
                        NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
7008
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
 
7009
                }
 
7010
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
 
7011
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7012
                        NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
7013
                }
 
7014
                _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7015
                NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
 
7016
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
 
7017
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
 
7018
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7019
        }
 
7020
        return NDR_ERR_SUCCESS;
 
7021
}
 
7022
 
 
7023
_PUBLIC_ void ndr_print_samr_EnumDomainAliases(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainAliases *r)
 
7024
{
 
7025
        ndr_print_struct(ndr, name, "samr_EnumDomainAliases");
 
7026
        ndr->depth++;
 
7027
        if (flags & NDR_SET_VALUES) {
 
7028
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7029
        }
 
7030
        if (flags & NDR_IN) {
 
7031
                ndr_print_struct(ndr, "in", "samr_EnumDomainAliases");
 
7032
                ndr->depth++;
 
7033
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
7034
                ndr->depth++;
 
7035
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
7036
                ndr->depth--;
 
7037
                ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
 
7038
                ndr->depth++;
 
7039
                ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
 
7040
                ndr->depth--;
 
7041
                ndr_print_uint32(ndr, "max_size", r->in.max_size);
 
7042
                ndr->depth--;
 
7043
        }
 
7044
        if (flags & NDR_OUT) {
 
7045
                ndr_print_struct(ndr, "out", "samr_EnumDomainAliases");
 
7046
                ndr->depth++;
 
7047
                ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
 
7048
                ndr->depth++;
 
7049
                ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
 
7050
                ndr->depth--;
 
7051
                ndr_print_ptr(ndr, "sam", r->out.sam);
 
7052
                ndr->depth++;
 
7053
                ndr_print_ptr(ndr, "sam", *r->out.sam);
 
7054
                ndr->depth++;
 
7055
                if (*r->out.sam) {
 
7056
                        ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
 
7057
                }
 
7058
                ndr->depth--;
 
7059
                ndr->depth--;
 
7060
                ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
 
7061
                ndr->depth++;
 
7062
                ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
 
7063
                ndr->depth--;
 
7064
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7065
                ndr->depth--;
 
7066
        }
 
7067
        ndr->depth--;
 
7068
}
 
7069
 
 
7070
static enum ndr_err_code ndr_push_samr_GetAliasMembership(struct ndr_push *ndr, int flags, const struct samr_GetAliasMembership *r)
 
7071
{
 
7072
        if (flags & NDR_IN) {
 
7073
                if (r->in.domain_handle == NULL) {
 
7074
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7075
                }
 
7076
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7077
                if (r->in.sids == NULL) {
 
7078
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7079
                }
 
7080
                NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
 
7081
        }
 
7082
        if (flags & NDR_OUT) {
 
7083
                if (r->out.rids == NULL) {
 
7084
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7085
                }
 
7086
                NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
 
7087
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7088
        }
 
7089
        return NDR_ERR_SUCCESS;
 
7090
}
 
7091
 
 
7092
static enum ndr_err_code ndr_pull_samr_GetAliasMembership(struct ndr_pull *ndr, int flags, struct samr_GetAliasMembership *r)
 
7093
{
 
7094
        TALLOC_CTX *_mem_save_domain_handle_0;
 
7095
        TALLOC_CTX *_mem_save_sids_0;
 
7096
        TALLOC_CTX *_mem_save_rids_0;
 
7097
        if (flags & NDR_IN) {
 
7098
                ZERO_STRUCT(r->out);
 
7099
 
 
7100
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7101
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
7102
                }
 
7103
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7104
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
7105
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7106
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7107
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7108
                        NDR_PULL_ALLOC(ndr, r->in.sids);
 
7109
                }
 
7110
                _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7111
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
 
7112
                NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
 
7113
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
 
7114
                NDR_PULL_ALLOC(ndr, r->out.rids);
 
7115
                ZERO_STRUCTP(r->out.rids);
 
7116
        }
 
7117
        if (flags & NDR_OUT) {
 
7118
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7119
                        NDR_PULL_ALLOC(ndr, r->out.rids);
 
7120
                }
 
7121
                _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7122
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
 
7123
                NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
 
7124
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
 
7125
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7126
        }
 
7127
        return NDR_ERR_SUCCESS;
 
7128
}
 
7129
 
 
7130
_PUBLIC_ void ndr_print_samr_GetAliasMembership(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetAliasMembership *r)
 
7131
{
 
7132
        ndr_print_struct(ndr, name, "samr_GetAliasMembership");
 
7133
        ndr->depth++;
 
7134
        if (flags & NDR_SET_VALUES) {
 
7135
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7136
        }
 
7137
        if (flags & NDR_IN) {
 
7138
                ndr_print_struct(ndr, "in", "samr_GetAliasMembership");
 
7139
                ndr->depth++;
 
7140
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
7141
                ndr->depth++;
 
7142
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
7143
                ndr->depth--;
 
7144
                ndr_print_ptr(ndr, "sids", r->in.sids);
 
7145
                ndr->depth++;
 
7146
                ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
 
7147
                ndr->depth--;
 
7148
                ndr->depth--;
 
7149
        }
 
7150
        if (flags & NDR_OUT) {
 
7151
                ndr_print_struct(ndr, "out", "samr_GetAliasMembership");
 
7152
                ndr->depth++;
 
7153
                ndr_print_ptr(ndr, "rids", r->out.rids);
 
7154
                ndr->depth++;
 
7155
                ndr_print_samr_Ids(ndr, "rids", r->out.rids);
 
7156
                ndr->depth--;
 
7157
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7158
                ndr->depth--;
 
7159
        }
 
7160
        ndr->depth--;
 
7161
}
 
7162
 
 
7163
_PUBLIC_ enum ndr_err_code ndr_push_samr_LookupNames(struct ndr_push *ndr, int flags, const struct samr_LookupNames *r)
 
7164
{
 
7165
        uint32_t cntr_names_0;
 
7166
        if (flags & NDR_IN) {
 
7167
                if (r->in.domain_handle == NULL) {
 
7168
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7169
                }
 
7170
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7171
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
 
7172
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1000));
 
7173
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 
7174
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
 
7175
                for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
 
7176
                        NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
 
7177
                }
 
7178
                for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
 
7179
                        NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
 
7180
                }
 
7181
        }
 
7182
        if (flags & NDR_OUT) {
 
7183
                if (r->out.rids == NULL) {
 
7184
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7185
                }
 
7186
                NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
 
7187
                if (r->out.types == NULL) {
 
7188
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7189
                }
 
7190
                NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
 
7191
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7192
        }
 
7193
        return NDR_ERR_SUCCESS;
 
7194
}
 
7195
 
 
7196
_PUBLIC_ enum ndr_err_code ndr_pull_samr_LookupNames(struct ndr_pull *ndr, int flags, struct samr_LookupNames *r)
 
7197
{
 
7198
        uint32_t cntr_names_0;
 
7199
        TALLOC_CTX *_mem_save_domain_handle_0;
 
7200
        TALLOC_CTX *_mem_save_names_0;
 
7201
        TALLOC_CTX *_mem_save_rids_0;
 
7202
        TALLOC_CTX *_mem_save_types_0;
 
7203
        if (flags & NDR_IN) {
 
7204
                ZERO_STRUCT(r->out);
 
7205
 
 
7206
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7207
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
7208
                }
 
7209
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7210
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
7211
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7212
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7213
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
 
7214
                if (r->in.num_names > 1000) {
 
7215
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
7216
                }
 
7217
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
 
7218
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.names));
 
7219
                if (ndr_get_array_length(ndr, &r->in.names) > ndr_get_array_size(ndr, &r->in.names)) {
 
7220
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.names), ndr_get_array_length(ndr, &r->in.names));
 
7221
                }
 
7222
                NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
 
7223
                _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7224
                NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
 
7225
                for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
 
7226
                        NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
 
7227
                }
 
7228
                for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
 
7229
                        NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
 
7230
                }
 
7231
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
 
7232
                NDR_PULL_ALLOC(ndr, r->out.rids);
 
7233
                ZERO_STRUCTP(r->out.rids);
 
7234
                NDR_PULL_ALLOC(ndr, r->out.types);
 
7235
                ZERO_STRUCTP(r->out.types);
 
7236
                if (r->in.names) {
 
7237
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, 1000));
 
7238
                }
 
7239
                if (r->in.names) {
 
7240
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.names, r->in.num_names));
 
7241
                }
 
7242
        }
 
7243
        if (flags & NDR_OUT) {
 
7244
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7245
                        NDR_PULL_ALLOC(ndr, r->out.rids);
 
7246
                }
 
7247
                _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7248
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
 
7249
                NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
 
7250
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
 
7251
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7252
                        NDR_PULL_ALLOC(ndr, r->out.types);
 
7253
                }
 
7254
                _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7255
                NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
 
7256
                NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
 
7257
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
 
7258
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7259
        }
 
7260
        return NDR_ERR_SUCCESS;
 
7261
}
 
7262
 
 
7263
_PUBLIC_ void ndr_print_samr_LookupNames(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupNames *r)
 
7264
{
 
7265
        uint32_t cntr_names_0;
 
7266
        ndr_print_struct(ndr, name, "samr_LookupNames");
 
7267
        ndr->depth++;
 
7268
        if (flags & NDR_SET_VALUES) {
 
7269
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7270
        }
 
7271
        if (flags & NDR_IN) {
 
7272
                ndr_print_struct(ndr, "in", "samr_LookupNames");
 
7273
                ndr->depth++;
 
7274
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
7275
                ndr->depth++;
 
7276
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
7277
                ndr->depth--;
 
7278
                ndr_print_uint32(ndr, "num_names", r->in.num_names);
 
7279
                ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
 
7280
                ndr->depth++;
 
7281
                for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
 
7282
                        char *idx_0=NULL;
 
7283
                        if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
 
7284
                                ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
 
7285
                                free(idx_0);
 
7286
                        }
 
7287
                }
 
7288
                ndr->depth--;
 
7289
                ndr->depth--;
 
7290
        }
 
7291
        if (flags & NDR_OUT) {
 
7292
                ndr_print_struct(ndr, "out", "samr_LookupNames");
 
7293
                ndr->depth++;
 
7294
                ndr_print_ptr(ndr, "rids", r->out.rids);
 
7295
                ndr->depth++;
 
7296
                ndr_print_samr_Ids(ndr, "rids", r->out.rids);
 
7297
                ndr->depth--;
 
7298
                ndr_print_ptr(ndr, "types", r->out.types);
 
7299
                ndr->depth++;
 
7300
                ndr_print_samr_Ids(ndr, "types", r->out.types);
 
7301
                ndr->depth--;
 
7302
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7303
                ndr->depth--;
 
7304
        }
 
7305
        ndr->depth--;
 
7306
}
 
7307
 
 
7308
static enum ndr_err_code ndr_push_samr_LookupRids(struct ndr_push *ndr, int flags, const struct samr_LookupRids *r)
 
7309
{
 
7310
        uint32_t cntr_rids_0;
 
7311
        if (flags & NDR_IN) {
 
7312
                if (r->in.domain_handle == NULL) {
 
7313
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7314
                }
 
7315
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7316
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_rids));
 
7317
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1000));
 
7318
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 
7319
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_rids));
 
7320
                for (cntr_rids_0 = 0; cntr_rids_0 < r->in.num_rids; cntr_rids_0++) {
 
7321
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rids[cntr_rids_0]));
 
7322
                }
 
7323
        }
 
7324
        if (flags & NDR_OUT) {
 
7325
                if (r->out.names == NULL) {
 
7326
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7327
                }
 
7328
                NDR_CHECK(ndr_push_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
 
7329
                if (r->out.types == NULL) {
 
7330
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7331
                }
 
7332
                NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
 
7333
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7334
        }
 
7335
        return NDR_ERR_SUCCESS;
 
7336
}
 
7337
 
 
7338
static enum ndr_err_code ndr_pull_samr_LookupRids(struct ndr_pull *ndr, int flags, struct samr_LookupRids *r)
 
7339
{
 
7340
        uint32_t cntr_rids_0;
 
7341
        TALLOC_CTX *_mem_save_domain_handle_0;
 
7342
        TALLOC_CTX *_mem_save_rids_0;
 
7343
        TALLOC_CTX *_mem_save_names_0;
 
7344
        TALLOC_CTX *_mem_save_types_0;
 
7345
        if (flags & NDR_IN) {
 
7346
                ZERO_STRUCT(r->out);
 
7347
 
 
7348
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7349
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
7350
                }
 
7351
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7352
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
7353
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7354
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7355
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_rids));
 
7356
                if (r->in.num_rids > 1000) {
 
7357
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
7358
                }
 
7359
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rids));
 
7360
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rids));
 
7361
                if (ndr_get_array_length(ndr, &r->in.rids) > ndr_get_array_size(ndr, &r->in.rids)) {
 
7362
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.rids), ndr_get_array_length(ndr, &r->in.rids));
 
7363
                }
 
7364
                NDR_PULL_ALLOC_N(ndr, r->in.rids, ndr_get_array_size(ndr, &r->in.rids));
 
7365
                _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7366
                NDR_PULL_SET_MEM_CTX(ndr, r->in.rids, 0);
 
7367
                for (cntr_rids_0 = 0; cntr_rids_0 < r->in.num_rids; cntr_rids_0++) {
 
7368
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rids[cntr_rids_0]));
 
7369
                }
 
7370
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
 
7371
                NDR_PULL_ALLOC(ndr, r->out.names);
 
7372
                ZERO_STRUCTP(r->out.names);
 
7373
                NDR_PULL_ALLOC(ndr, r->out.types);
 
7374
                ZERO_STRUCTP(r->out.types);
 
7375
                if (r->in.rids) {
 
7376
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.rids, 1000));
 
7377
                }
 
7378
                if (r->in.rids) {
 
7379
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.rids, r->in.num_rids));
 
7380
                }
 
7381
        }
 
7382
        if (flags & NDR_OUT) {
 
7383
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7384
                        NDR_PULL_ALLOC(ndr, r->out.names);
 
7385
                }
 
7386
                _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7387
                NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
 
7388
                NDR_CHECK(ndr_pull_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
 
7389
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
 
7390
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7391
                        NDR_PULL_ALLOC(ndr, r->out.types);
 
7392
                }
 
7393
                _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7394
                NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
 
7395
                NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
 
7396
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
 
7397
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7398
        }
 
7399
        return NDR_ERR_SUCCESS;
 
7400
}
 
7401
 
 
7402
_PUBLIC_ void ndr_print_samr_LookupRids(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupRids *r)
 
7403
{
 
7404
        uint32_t cntr_rids_0;
 
7405
        ndr_print_struct(ndr, name, "samr_LookupRids");
 
7406
        ndr->depth++;
 
7407
        if (flags & NDR_SET_VALUES) {
 
7408
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7409
        }
 
7410
        if (flags & NDR_IN) {
 
7411
                ndr_print_struct(ndr, "in", "samr_LookupRids");
 
7412
                ndr->depth++;
 
7413
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
7414
                ndr->depth++;
 
7415
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
7416
                ndr->depth--;
 
7417
                ndr_print_uint32(ndr, "num_rids", r->in.num_rids);
 
7418
                ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->in.num_rids);
 
7419
                ndr->depth++;
 
7420
                for (cntr_rids_0=0;cntr_rids_0<r->in.num_rids;cntr_rids_0++) {
 
7421
                        char *idx_0=NULL;
 
7422
                        if (asprintf(&idx_0, "[%d]", cntr_rids_0) != -1) {
 
7423
                                ndr_print_uint32(ndr, "rids", r->in.rids[cntr_rids_0]);
 
7424
                                free(idx_0);
 
7425
                        }
 
7426
                }
 
7427
                ndr->depth--;
 
7428
                ndr->depth--;
 
7429
        }
 
7430
        if (flags & NDR_OUT) {
 
7431
                ndr_print_struct(ndr, "out", "samr_LookupRids");
 
7432
                ndr->depth++;
 
7433
                ndr_print_ptr(ndr, "names", r->out.names);
 
7434
                ndr->depth++;
 
7435
                ndr_print_lsa_Strings(ndr, "names", r->out.names);
 
7436
                ndr->depth--;
 
7437
                ndr_print_ptr(ndr, "types", r->out.types);
 
7438
                ndr->depth++;
 
7439
                ndr_print_samr_Ids(ndr, "types", r->out.types);
 
7440
                ndr->depth--;
 
7441
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7442
                ndr->depth--;
 
7443
        }
 
7444
        ndr->depth--;
 
7445
}
 
7446
 
 
7447
static enum ndr_err_code ndr_push_samr_OpenGroup(struct ndr_push *ndr, int flags, const struct samr_OpenGroup *r)
 
7448
{
 
7449
        if (flags & NDR_IN) {
 
7450
                if (r->in.domain_handle == NULL) {
 
7451
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7452
                }
 
7453
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7454
                NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
7455
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
 
7456
        }
 
7457
        if (flags & NDR_OUT) {
 
7458
                if (r->out.group_handle == NULL) {
 
7459
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7460
                }
 
7461
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
 
7462
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7463
        }
 
7464
        return NDR_ERR_SUCCESS;
 
7465
}
 
7466
 
 
7467
static enum ndr_err_code ndr_pull_samr_OpenGroup(struct ndr_pull *ndr, int flags, struct samr_OpenGroup *r)
 
7468
{
 
7469
        TALLOC_CTX *_mem_save_domain_handle_0;
 
7470
        TALLOC_CTX *_mem_save_group_handle_0;
 
7471
        if (flags & NDR_IN) {
 
7472
                ZERO_STRUCT(r->out);
 
7473
 
 
7474
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7475
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
7476
                }
 
7477
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7478
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
7479
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7480
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7481
                NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
7482
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
 
7483
                NDR_PULL_ALLOC(ndr, r->out.group_handle);
 
7484
                ZERO_STRUCTP(r->out.group_handle);
 
7485
        }
 
7486
        if (flags & NDR_OUT) {
 
7487
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7488
                        NDR_PULL_ALLOC(ndr, r->out.group_handle);
 
7489
                }
 
7490
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7491
                NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
7492
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
 
7493
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7494
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7495
        }
 
7496
        return NDR_ERR_SUCCESS;
 
7497
}
 
7498
 
 
7499
_PUBLIC_ void ndr_print_samr_OpenGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenGroup *r)
 
7500
{
 
7501
        ndr_print_struct(ndr, name, "samr_OpenGroup");
 
7502
        ndr->depth++;
 
7503
        if (flags & NDR_SET_VALUES) {
 
7504
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7505
        }
 
7506
        if (flags & NDR_IN) {
 
7507
                ndr_print_struct(ndr, "in", "samr_OpenGroup");
 
7508
                ndr->depth++;
 
7509
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
7510
                ndr->depth++;
 
7511
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
7512
                ndr->depth--;
 
7513
                ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
 
7514
                ndr_print_uint32(ndr, "rid", r->in.rid);
 
7515
                ndr->depth--;
 
7516
        }
 
7517
        if (flags & NDR_OUT) {
 
7518
                ndr_print_struct(ndr, "out", "samr_OpenGroup");
 
7519
                ndr->depth++;
 
7520
                ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
 
7521
                ndr->depth++;
 
7522
                ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
 
7523
                ndr->depth--;
 
7524
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7525
                ndr->depth--;
 
7526
        }
 
7527
        ndr->depth--;
 
7528
}
 
7529
 
 
7530
static enum ndr_err_code ndr_push_samr_QueryGroupInfo(struct ndr_push *ndr, int flags, const struct samr_QueryGroupInfo *r)
 
7531
{
 
7532
        if (flags & NDR_IN) {
 
7533
                if (r->in.group_handle == NULL) {
 
7534
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7535
                }
 
7536
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7537
                NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
 
7538
        }
 
7539
        if (flags & NDR_OUT) {
 
7540
                if (r->out.info == NULL) {
 
7541
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7542
                }
 
7543
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
 
7544
                if (*r->out.info) {
 
7545
                        NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
 
7546
                        NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
7547
                }
 
7548
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7549
        }
 
7550
        return NDR_ERR_SUCCESS;
 
7551
}
 
7552
 
 
7553
static enum ndr_err_code ndr_pull_samr_QueryGroupInfo(struct ndr_pull *ndr, int flags, struct samr_QueryGroupInfo *r)
 
7554
{
 
7555
        uint32_t _ptr_info;
 
7556
        TALLOC_CTX *_mem_save_group_handle_0;
 
7557
        TALLOC_CTX *_mem_save_info_0;
 
7558
        TALLOC_CTX *_mem_save_info_1;
 
7559
        if (flags & NDR_IN) {
 
7560
                ZERO_STRUCT(r->out);
 
7561
 
 
7562
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7563
                        NDR_PULL_ALLOC(ndr, r->in.group_handle);
 
7564
                }
 
7565
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7566
                NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
7567
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7568
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7569
                NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
 
7570
                NDR_PULL_ALLOC(ndr, r->out.info);
 
7571
                ZERO_STRUCTP(r->out.info);
 
7572
        }
 
7573
        if (flags & NDR_OUT) {
 
7574
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7575
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
7576
                }
 
7577
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7578
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
7579
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 
7580
                if (_ptr_info) {
 
7581
                        NDR_PULL_ALLOC(ndr, *r->out.info);
 
7582
                } else {
 
7583
                        *r->out.info = NULL;
 
7584
                }
 
7585
                if (*r->out.info) {
 
7586
                        _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
7587
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
 
7588
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
 
7589
                        NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
7590
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
 
7591
                }
 
7592
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
7593
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7594
        }
 
7595
        return NDR_ERR_SUCCESS;
 
7596
}
 
7597
 
 
7598
_PUBLIC_ void ndr_print_samr_QueryGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupInfo *r)
 
7599
{
 
7600
        ndr_print_struct(ndr, name, "samr_QueryGroupInfo");
 
7601
        ndr->depth++;
 
7602
        if (flags & NDR_SET_VALUES) {
 
7603
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7604
        }
 
7605
        if (flags & NDR_IN) {
 
7606
                ndr_print_struct(ndr, "in", "samr_QueryGroupInfo");
 
7607
                ndr->depth++;
 
7608
                ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
 
7609
                ndr->depth++;
 
7610
                ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
 
7611
                ndr->depth--;
 
7612
                ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
 
7613
                ndr->depth--;
 
7614
        }
 
7615
        if (flags & NDR_OUT) {
 
7616
                ndr_print_struct(ndr, "out", "samr_QueryGroupInfo");
 
7617
                ndr->depth++;
 
7618
                ndr_print_ptr(ndr, "info", r->out.info);
 
7619
                ndr->depth++;
 
7620
                ndr_print_ptr(ndr, "info", *r->out.info);
 
7621
                ndr->depth++;
 
7622
                if (*r->out.info) {
 
7623
                        ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
 
7624
                        ndr_print_samr_GroupInfo(ndr, "info", *r->out.info);
 
7625
                }
 
7626
                ndr->depth--;
 
7627
                ndr->depth--;
 
7628
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7629
                ndr->depth--;
 
7630
        }
 
7631
        ndr->depth--;
 
7632
}
 
7633
 
 
7634
static enum ndr_err_code ndr_push_samr_SetGroupInfo(struct ndr_push *ndr, int flags, const struct samr_SetGroupInfo *r)
 
7635
{
 
7636
        if (flags & NDR_IN) {
 
7637
                if (r->in.group_handle == NULL) {
 
7638
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7639
                }
 
7640
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7641
                NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
 
7642
                if (r->in.info == NULL) {
 
7643
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7644
                }
 
7645
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
 
7646
                NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
7647
        }
 
7648
        if (flags & NDR_OUT) {
 
7649
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7650
        }
 
7651
        return NDR_ERR_SUCCESS;
 
7652
}
 
7653
 
 
7654
static enum ndr_err_code ndr_pull_samr_SetGroupInfo(struct ndr_pull *ndr, int flags, struct samr_SetGroupInfo *r)
 
7655
{
 
7656
        TALLOC_CTX *_mem_save_group_handle_0;
 
7657
        TALLOC_CTX *_mem_save_info_0;
 
7658
        if (flags & NDR_IN) {
 
7659
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7660
                        NDR_PULL_ALLOC(ndr, r->in.group_handle);
 
7661
                }
 
7662
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7663
                NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
7664
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7665
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7666
                NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
 
7667
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7668
                        NDR_PULL_ALLOC(ndr, r->in.info);
 
7669
                }
 
7670
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7671
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
 
7672
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
 
7673
                NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
7674
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
7675
        }
 
7676
        if (flags & NDR_OUT) {
 
7677
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7678
        }
 
7679
        return NDR_ERR_SUCCESS;
 
7680
}
 
7681
 
 
7682
_PUBLIC_ void ndr_print_samr_SetGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetGroupInfo *r)
 
7683
{
 
7684
        ndr_print_struct(ndr, name, "samr_SetGroupInfo");
 
7685
        ndr->depth++;
 
7686
        if (flags & NDR_SET_VALUES) {
 
7687
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7688
        }
 
7689
        if (flags & NDR_IN) {
 
7690
                ndr_print_struct(ndr, "in", "samr_SetGroupInfo");
 
7691
                ndr->depth++;
 
7692
                ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
 
7693
                ndr->depth++;
 
7694
                ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
 
7695
                ndr->depth--;
 
7696
                ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
 
7697
                ndr_print_ptr(ndr, "info", r->in.info);
 
7698
                ndr->depth++;
 
7699
                ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
 
7700
                ndr_print_samr_GroupInfo(ndr, "info", r->in.info);
 
7701
                ndr->depth--;
 
7702
                ndr->depth--;
 
7703
        }
 
7704
        if (flags & NDR_OUT) {
 
7705
                ndr_print_struct(ndr, "out", "samr_SetGroupInfo");
 
7706
                ndr->depth++;
 
7707
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7708
                ndr->depth--;
 
7709
        }
 
7710
        ndr->depth--;
 
7711
}
 
7712
 
 
7713
static enum ndr_err_code ndr_push_samr_AddGroupMember(struct ndr_push *ndr, int flags, const struct samr_AddGroupMember *r)
 
7714
{
 
7715
        if (flags & NDR_IN) {
 
7716
                if (r->in.group_handle == NULL) {
 
7717
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7718
                }
 
7719
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7720
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
 
7721
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
 
7722
        }
 
7723
        if (flags & NDR_OUT) {
 
7724
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7725
        }
 
7726
        return NDR_ERR_SUCCESS;
 
7727
}
 
7728
 
 
7729
static enum ndr_err_code ndr_pull_samr_AddGroupMember(struct ndr_pull *ndr, int flags, struct samr_AddGroupMember *r)
 
7730
{
 
7731
        TALLOC_CTX *_mem_save_group_handle_0;
 
7732
        if (flags & NDR_IN) {
 
7733
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7734
                        NDR_PULL_ALLOC(ndr, r->in.group_handle);
 
7735
                }
 
7736
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7737
                NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
7738
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7739
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7740
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
 
7741
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
 
7742
        }
 
7743
        if (flags & NDR_OUT) {
 
7744
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7745
        }
 
7746
        return NDR_ERR_SUCCESS;
 
7747
}
 
7748
 
 
7749
_PUBLIC_ void ndr_print_samr_AddGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddGroupMember *r)
 
7750
{
 
7751
        ndr_print_struct(ndr, name, "samr_AddGroupMember");
 
7752
        ndr->depth++;
 
7753
        if (flags & NDR_SET_VALUES) {
 
7754
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7755
        }
 
7756
        if (flags & NDR_IN) {
 
7757
                ndr_print_struct(ndr, "in", "samr_AddGroupMember");
 
7758
                ndr->depth++;
 
7759
                ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
 
7760
                ndr->depth++;
 
7761
                ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
 
7762
                ndr->depth--;
 
7763
                ndr_print_uint32(ndr, "rid", r->in.rid);
 
7764
                ndr_print_uint32(ndr, "flags", r->in.flags);
 
7765
                ndr->depth--;
 
7766
        }
 
7767
        if (flags & NDR_OUT) {
 
7768
                ndr_print_struct(ndr, "out", "samr_AddGroupMember");
 
7769
                ndr->depth++;
 
7770
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7771
                ndr->depth--;
 
7772
        }
 
7773
        ndr->depth--;
 
7774
}
 
7775
 
 
7776
static enum ndr_err_code ndr_push_samr_DeleteDomainGroup(struct ndr_push *ndr, int flags, const struct samr_DeleteDomainGroup *r)
 
7777
{
 
7778
        if (flags & NDR_IN) {
 
7779
                if (r->in.group_handle == NULL) {
 
7780
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7781
                }
 
7782
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7783
        }
 
7784
        if (flags & NDR_OUT) {
 
7785
                if (r->out.group_handle == NULL) {
 
7786
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7787
                }
 
7788
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
 
7789
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7790
        }
 
7791
        return NDR_ERR_SUCCESS;
 
7792
}
 
7793
 
 
7794
static enum ndr_err_code ndr_pull_samr_DeleteDomainGroup(struct ndr_pull *ndr, int flags, struct samr_DeleteDomainGroup *r)
 
7795
{
 
7796
        TALLOC_CTX *_mem_save_group_handle_0;
 
7797
        if (flags & NDR_IN) {
 
7798
                ZERO_STRUCT(r->out);
 
7799
 
 
7800
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7801
                        NDR_PULL_ALLOC(ndr, r->in.group_handle);
 
7802
                }
 
7803
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7804
                NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
7805
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7806
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7807
                NDR_PULL_ALLOC(ndr, r->out.group_handle);
 
7808
                *r->out.group_handle = *r->in.group_handle;
 
7809
        }
 
7810
        if (flags & NDR_OUT) {
 
7811
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7812
                        NDR_PULL_ALLOC(ndr, r->out.group_handle);
 
7813
                }
 
7814
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7815
                NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
7816
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
 
7817
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7818
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7819
        }
 
7820
        return NDR_ERR_SUCCESS;
 
7821
}
 
7822
 
 
7823
_PUBLIC_ void ndr_print_samr_DeleteDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomainGroup *r)
 
7824
{
 
7825
        ndr_print_struct(ndr, name, "samr_DeleteDomainGroup");
 
7826
        ndr->depth++;
 
7827
        if (flags & NDR_SET_VALUES) {
 
7828
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7829
        }
 
7830
        if (flags & NDR_IN) {
 
7831
                ndr_print_struct(ndr, "in", "samr_DeleteDomainGroup");
 
7832
                ndr->depth++;
 
7833
                ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
 
7834
                ndr->depth++;
 
7835
                ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
 
7836
                ndr->depth--;
 
7837
                ndr->depth--;
 
7838
        }
 
7839
        if (flags & NDR_OUT) {
 
7840
                ndr_print_struct(ndr, "out", "samr_DeleteDomainGroup");
 
7841
                ndr->depth++;
 
7842
                ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
 
7843
                ndr->depth++;
 
7844
                ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
 
7845
                ndr->depth--;
 
7846
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7847
                ndr->depth--;
 
7848
        }
 
7849
        ndr->depth--;
 
7850
}
 
7851
 
 
7852
static enum ndr_err_code ndr_push_samr_DeleteGroupMember(struct ndr_push *ndr, int flags, const struct samr_DeleteGroupMember *r)
 
7853
{
 
7854
        if (flags & NDR_IN) {
 
7855
                if (r->in.group_handle == NULL) {
 
7856
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7857
                }
 
7858
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7859
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
 
7860
        }
 
7861
        if (flags & NDR_OUT) {
 
7862
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7863
        }
 
7864
        return NDR_ERR_SUCCESS;
 
7865
}
 
7866
 
 
7867
static enum ndr_err_code ndr_pull_samr_DeleteGroupMember(struct ndr_pull *ndr, int flags, struct samr_DeleteGroupMember *r)
 
7868
{
 
7869
        TALLOC_CTX *_mem_save_group_handle_0;
 
7870
        if (flags & NDR_IN) {
 
7871
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7872
                        NDR_PULL_ALLOC(ndr, r->in.group_handle);
 
7873
                }
 
7874
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7875
                NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
7876
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7877
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7878
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
 
7879
        }
 
7880
        if (flags & NDR_OUT) {
 
7881
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7882
        }
 
7883
        return NDR_ERR_SUCCESS;
 
7884
}
 
7885
 
 
7886
_PUBLIC_ void ndr_print_samr_DeleteGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteGroupMember *r)
 
7887
{
 
7888
        ndr_print_struct(ndr, name, "samr_DeleteGroupMember");
 
7889
        ndr->depth++;
 
7890
        if (flags & NDR_SET_VALUES) {
 
7891
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7892
        }
 
7893
        if (flags & NDR_IN) {
 
7894
                ndr_print_struct(ndr, "in", "samr_DeleteGroupMember");
 
7895
                ndr->depth++;
 
7896
                ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
 
7897
                ndr->depth++;
 
7898
                ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
 
7899
                ndr->depth--;
 
7900
                ndr_print_uint32(ndr, "rid", r->in.rid);
 
7901
                ndr->depth--;
 
7902
        }
 
7903
        if (flags & NDR_OUT) {
 
7904
                ndr_print_struct(ndr, "out", "samr_DeleteGroupMember");
 
7905
                ndr->depth++;
 
7906
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7907
                ndr->depth--;
 
7908
        }
 
7909
        ndr->depth--;
 
7910
}
 
7911
 
 
7912
static enum ndr_err_code ndr_push_samr_QueryGroupMember(struct ndr_push *ndr, int flags, const struct samr_QueryGroupMember *r)
 
7913
{
 
7914
        if (flags & NDR_IN) {
 
7915
                if (r->in.group_handle == NULL) {
 
7916
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7917
                }
 
7918
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7919
        }
 
7920
        if (flags & NDR_OUT) {
 
7921
                if (r->out.rids == NULL) {
 
7922
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7923
                }
 
7924
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
 
7925
                if (*r->out.rids) {
 
7926
                        NDR_CHECK(ndr_push_samr_RidTypeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
 
7927
                }
 
7928
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7929
        }
 
7930
        return NDR_ERR_SUCCESS;
 
7931
}
 
7932
 
 
7933
static enum ndr_err_code ndr_pull_samr_QueryGroupMember(struct ndr_pull *ndr, int flags, struct samr_QueryGroupMember *r)
 
7934
{
 
7935
        uint32_t _ptr_rids;
 
7936
        TALLOC_CTX *_mem_save_group_handle_0;
 
7937
        TALLOC_CTX *_mem_save_rids_0;
 
7938
        TALLOC_CTX *_mem_save_rids_1;
 
7939
        if (flags & NDR_IN) {
 
7940
                ZERO_STRUCT(r->out);
 
7941
 
 
7942
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7943
                        NDR_PULL_ALLOC(ndr, r->in.group_handle);
 
7944
                }
 
7945
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7946
                NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
7947
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7948
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7949
                NDR_PULL_ALLOC(ndr, r->out.rids);
 
7950
                ZERO_STRUCTP(r->out.rids);
 
7951
        }
 
7952
        if (flags & NDR_OUT) {
 
7953
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7954
                        NDR_PULL_ALLOC(ndr, r->out.rids);
 
7955
                }
 
7956
                _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7957
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
 
7958
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
 
7959
                if (_ptr_rids) {
 
7960
                        NDR_PULL_ALLOC(ndr, *r->out.rids);
 
7961
                } else {
 
7962
                        *r->out.rids = NULL;
 
7963
                }
 
7964
                if (*r->out.rids) {
 
7965
                        _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
7966
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
 
7967
                        NDR_CHECK(ndr_pull_samr_RidTypeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
 
7968
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
 
7969
                }
 
7970
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
 
7971
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7972
        }
 
7973
        return NDR_ERR_SUCCESS;
 
7974
}
 
7975
 
 
7976
_PUBLIC_ void ndr_print_samr_QueryGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupMember *r)
 
7977
{
 
7978
        ndr_print_struct(ndr, name, "samr_QueryGroupMember");
 
7979
        ndr->depth++;
 
7980
        if (flags & NDR_SET_VALUES) {
 
7981
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7982
        }
 
7983
        if (flags & NDR_IN) {
 
7984
                ndr_print_struct(ndr, "in", "samr_QueryGroupMember");
 
7985
                ndr->depth++;
 
7986
                ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
 
7987
                ndr->depth++;
 
7988
                ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
 
7989
                ndr->depth--;
 
7990
                ndr->depth--;
 
7991
        }
 
7992
        if (flags & NDR_OUT) {
 
7993
                ndr_print_struct(ndr, "out", "samr_QueryGroupMember");
 
7994
                ndr->depth++;
 
7995
                ndr_print_ptr(ndr, "rids", r->out.rids);
 
7996
                ndr->depth++;
 
7997
                ndr_print_ptr(ndr, "rids", *r->out.rids);
 
7998
                ndr->depth++;
 
7999
                if (*r->out.rids) {
 
8000
                        ndr_print_samr_RidTypeArray(ndr, "rids", *r->out.rids);
 
8001
                }
 
8002
                ndr->depth--;
 
8003
                ndr->depth--;
 
8004
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8005
                ndr->depth--;
 
8006
        }
 
8007
        ndr->depth--;
 
8008
}
 
8009
 
 
8010
static enum ndr_err_code ndr_push_samr_SetMemberAttributesOfGroup(struct ndr_push *ndr, int flags, const struct samr_SetMemberAttributesOfGroup *r)
 
8011
{
 
8012
        if (flags & NDR_IN) {
 
8013
                if (r->in.group_handle == NULL) {
 
8014
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8015
                }
 
8016
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
8017
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
 
8018
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
 
8019
        }
 
8020
        if (flags & NDR_OUT) {
 
8021
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8022
        }
 
8023
        return NDR_ERR_SUCCESS;
 
8024
}
 
8025
 
 
8026
static enum ndr_err_code ndr_pull_samr_SetMemberAttributesOfGroup(struct ndr_pull *ndr, int flags, struct samr_SetMemberAttributesOfGroup *r)
 
8027
{
 
8028
        TALLOC_CTX *_mem_save_group_handle_0;
 
8029
        if (flags & NDR_IN) {
 
8030
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8031
                        NDR_PULL_ALLOC(ndr, r->in.group_handle);
 
8032
                }
 
8033
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8034
                NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
8035
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
8036
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8037
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
 
8038
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
 
8039
        }
 
8040
        if (flags & NDR_OUT) {
 
8041
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8042
        }
 
8043
        return NDR_ERR_SUCCESS;
 
8044
}
 
8045
 
 
8046
_PUBLIC_ void ndr_print_samr_SetMemberAttributesOfGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetMemberAttributesOfGroup *r)
 
8047
{
 
8048
        ndr_print_struct(ndr, name, "samr_SetMemberAttributesOfGroup");
 
8049
        ndr->depth++;
 
8050
        if (flags & NDR_SET_VALUES) {
 
8051
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8052
        }
 
8053
        if (flags & NDR_IN) {
 
8054
                ndr_print_struct(ndr, "in", "samr_SetMemberAttributesOfGroup");
 
8055
                ndr->depth++;
 
8056
                ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
 
8057
                ndr->depth++;
 
8058
                ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
 
8059
                ndr->depth--;
 
8060
                ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
 
8061
                ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
 
8062
                ndr->depth--;
 
8063
        }
 
8064
        if (flags & NDR_OUT) {
 
8065
                ndr_print_struct(ndr, "out", "samr_SetMemberAttributesOfGroup");
 
8066
                ndr->depth++;
 
8067
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8068
                ndr->depth--;
 
8069
        }
 
8070
        ndr->depth--;
 
8071
}
 
8072
 
 
8073
static enum ndr_err_code ndr_push_samr_OpenAlias(struct ndr_push *ndr, int flags, const struct samr_OpenAlias *r)
 
8074
{
 
8075
        if (flags & NDR_IN) {
 
8076
                if (r->in.domain_handle == NULL) {
 
8077
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8078
                }
 
8079
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
8080
                NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
8081
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
 
8082
        }
 
8083
        if (flags & NDR_OUT) {
 
8084
                if (r->out.alias_handle == NULL) {
 
8085
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8086
                }
 
8087
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
 
8088
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8089
        }
 
8090
        return NDR_ERR_SUCCESS;
 
8091
}
 
8092
 
 
8093
static enum ndr_err_code ndr_pull_samr_OpenAlias(struct ndr_pull *ndr, int flags, struct samr_OpenAlias *r)
 
8094
{
 
8095
        TALLOC_CTX *_mem_save_domain_handle_0;
 
8096
        TALLOC_CTX *_mem_save_alias_handle_0;
 
8097
        if (flags & NDR_IN) {
 
8098
                ZERO_STRUCT(r->out);
 
8099
 
 
8100
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8101
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
8102
                }
 
8103
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8104
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
8105
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
8106
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8107
                NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
8108
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
 
8109
                NDR_PULL_ALLOC(ndr, r->out.alias_handle);
 
8110
                ZERO_STRUCTP(r->out.alias_handle);
 
8111
        }
 
8112
        if (flags & NDR_OUT) {
 
8113
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8114
                        NDR_PULL_ALLOC(ndr, r->out.alias_handle);
 
8115
                }
 
8116
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8117
                NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8118
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
 
8119
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8120
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8121
        }
 
8122
        return NDR_ERR_SUCCESS;
 
8123
}
 
8124
 
 
8125
_PUBLIC_ void ndr_print_samr_OpenAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenAlias *r)
 
8126
{
 
8127
        ndr_print_struct(ndr, name, "samr_OpenAlias");
 
8128
        ndr->depth++;
 
8129
        if (flags & NDR_SET_VALUES) {
 
8130
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8131
        }
 
8132
        if (flags & NDR_IN) {
 
8133
                ndr_print_struct(ndr, "in", "samr_OpenAlias");
 
8134
                ndr->depth++;
 
8135
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
8136
                ndr->depth++;
 
8137
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
8138
                ndr->depth--;
 
8139
                ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
 
8140
                ndr_print_uint32(ndr, "rid", r->in.rid);
 
8141
                ndr->depth--;
 
8142
        }
 
8143
        if (flags & NDR_OUT) {
 
8144
                ndr_print_struct(ndr, "out", "samr_OpenAlias");
 
8145
                ndr->depth++;
 
8146
                ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
 
8147
                ndr->depth++;
 
8148
                ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
 
8149
                ndr->depth--;
 
8150
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8151
                ndr->depth--;
 
8152
        }
 
8153
        ndr->depth--;
 
8154
}
 
8155
 
 
8156
static enum ndr_err_code ndr_push_samr_QueryAliasInfo(struct ndr_push *ndr, int flags, const struct samr_QueryAliasInfo *r)
 
8157
{
 
8158
        if (flags & NDR_IN) {
 
8159
                if (r->in.alias_handle == NULL) {
 
8160
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8161
                }
 
8162
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8163
                NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
 
8164
        }
 
8165
        if (flags & NDR_OUT) {
 
8166
                if (r->out.info == NULL) {
 
8167
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8168
                }
 
8169
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
 
8170
                if (*r->out.info) {
 
8171
                        NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
 
8172
                        NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
8173
                }
 
8174
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8175
        }
 
8176
        return NDR_ERR_SUCCESS;
 
8177
}
 
8178
 
 
8179
static enum ndr_err_code ndr_pull_samr_QueryAliasInfo(struct ndr_pull *ndr, int flags, struct samr_QueryAliasInfo *r)
 
8180
{
 
8181
        uint32_t _ptr_info;
 
8182
        TALLOC_CTX *_mem_save_alias_handle_0;
 
8183
        TALLOC_CTX *_mem_save_info_0;
 
8184
        TALLOC_CTX *_mem_save_info_1;
 
8185
        if (flags & NDR_IN) {
 
8186
                ZERO_STRUCT(r->out);
 
8187
 
 
8188
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8189
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
8190
                }
 
8191
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8192
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8193
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8194
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8195
                NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
 
8196
                NDR_PULL_ALLOC(ndr, r->out.info);
 
8197
                ZERO_STRUCTP(r->out.info);
 
8198
        }
 
8199
        if (flags & NDR_OUT) {
 
8200
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8201
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
8202
                }
 
8203
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8204
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
8205
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 
8206
                if (_ptr_info) {
 
8207
                        NDR_PULL_ALLOC(ndr, *r->out.info);
 
8208
                } else {
 
8209
                        *r->out.info = NULL;
 
8210
                }
 
8211
                if (*r->out.info) {
 
8212
                        _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
8213
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
 
8214
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
 
8215
                        NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
8216
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
 
8217
                }
 
8218
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
8219
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8220
        }
 
8221
        return NDR_ERR_SUCCESS;
 
8222
}
 
8223
 
 
8224
_PUBLIC_ void ndr_print_samr_QueryAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryAliasInfo *r)
 
8225
{
 
8226
        ndr_print_struct(ndr, name, "samr_QueryAliasInfo");
 
8227
        ndr->depth++;
 
8228
        if (flags & NDR_SET_VALUES) {
 
8229
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8230
        }
 
8231
        if (flags & NDR_IN) {
 
8232
                ndr_print_struct(ndr, "in", "samr_QueryAliasInfo");
 
8233
                ndr->depth++;
 
8234
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
8235
                ndr->depth++;
 
8236
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
8237
                ndr->depth--;
 
8238
                ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
 
8239
                ndr->depth--;
 
8240
        }
 
8241
        if (flags & NDR_OUT) {
 
8242
                ndr_print_struct(ndr, "out", "samr_QueryAliasInfo");
 
8243
                ndr->depth++;
 
8244
                ndr_print_ptr(ndr, "info", r->out.info);
 
8245
                ndr->depth++;
 
8246
                ndr_print_ptr(ndr, "info", *r->out.info);
 
8247
                ndr->depth++;
 
8248
                if (*r->out.info) {
 
8249
                        ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
 
8250
                        ndr_print_samr_AliasInfo(ndr, "info", *r->out.info);
 
8251
                }
 
8252
                ndr->depth--;
 
8253
                ndr->depth--;
 
8254
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8255
                ndr->depth--;
 
8256
        }
 
8257
        ndr->depth--;
 
8258
}
 
8259
 
 
8260
static enum ndr_err_code ndr_push_samr_SetAliasInfo(struct ndr_push *ndr, int flags, const struct samr_SetAliasInfo *r)
 
8261
{
 
8262
        if (flags & NDR_IN) {
 
8263
                if (r->in.alias_handle == NULL) {
 
8264
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8265
                }
 
8266
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8267
                NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
 
8268
                if (r->in.info == NULL) {
 
8269
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8270
                }
 
8271
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
 
8272
                NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
8273
        }
 
8274
        if (flags & NDR_OUT) {
 
8275
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8276
        }
 
8277
        return NDR_ERR_SUCCESS;
 
8278
}
 
8279
 
 
8280
static enum ndr_err_code ndr_pull_samr_SetAliasInfo(struct ndr_pull *ndr, int flags, struct samr_SetAliasInfo *r)
 
8281
{
 
8282
        TALLOC_CTX *_mem_save_alias_handle_0;
 
8283
        TALLOC_CTX *_mem_save_info_0;
 
8284
        if (flags & NDR_IN) {
 
8285
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8286
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
8287
                }
 
8288
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8289
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8290
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8291
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8292
                NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
 
8293
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8294
                        NDR_PULL_ALLOC(ndr, r->in.info);
 
8295
                }
 
8296
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8297
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
 
8298
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
 
8299
                NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
8300
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
8301
        }
 
8302
        if (flags & NDR_OUT) {
 
8303
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8304
        }
 
8305
        return NDR_ERR_SUCCESS;
 
8306
}
 
8307
 
 
8308
_PUBLIC_ void ndr_print_samr_SetAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetAliasInfo *r)
 
8309
{
 
8310
        ndr_print_struct(ndr, name, "samr_SetAliasInfo");
 
8311
        ndr->depth++;
 
8312
        if (flags & NDR_SET_VALUES) {
 
8313
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8314
        }
 
8315
        if (flags & NDR_IN) {
 
8316
                ndr_print_struct(ndr, "in", "samr_SetAliasInfo");
 
8317
                ndr->depth++;
 
8318
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
8319
                ndr->depth++;
 
8320
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
8321
                ndr->depth--;
 
8322
                ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
 
8323
                ndr_print_ptr(ndr, "info", r->in.info);
 
8324
                ndr->depth++;
 
8325
                ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
 
8326
                ndr_print_samr_AliasInfo(ndr, "info", r->in.info);
 
8327
                ndr->depth--;
 
8328
                ndr->depth--;
 
8329
        }
 
8330
        if (flags & NDR_OUT) {
 
8331
                ndr_print_struct(ndr, "out", "samr_SetAliasInfo");
 
8332
                ndr->depth++;
 
8333
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8334
                ndr->depth--;
 
8335
        }
 
8336
        ndr->depth--;
 
8337
}
 
8338
 
 
8339
static enum ndr_err_code ndr_push_samr_DeleteDomAlias(struct ndr_push *ndr, int flags, const struct samr_DeleteDomAlias *r)
 
8340
{
 
8341
        if (flags & NDR_IN) {
 
8342
                if (r->in.alias_handle == NULL) {
 
8343
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8344
                }
 
8345
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8346
        }
 
8347
        if (flags & NDR_OUT) {
 
8348
                if (r->out.alias_handle == NULL) {
 
8349
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8350
                }
 
8351
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
 
8352
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8353
        }
 
8354
        return NDR_ERR_SUCCESS;
 
8355
}
 
8356
 
 
8357
static enum ndr_err_code ndr_pull_samr_DeleteDomAlias(struct ndr_pull *ndr, int flags, struct samr_DeleteDomAlias *r)
 
8358
{
 
8359
        TALLOC_CTX *_mem_save_alias_handle_0;
 
8360
        if (flags & NDR_IN) {
 
8361
                ZERO_STRUCT(r->out);
 
8362
 
 
8363
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8364
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
8365
                }
 
8366
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8367
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8368
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8369
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8370
                NDR_PULL_ALLOC(ndr, r->out.alias_handle);
 
8371
                *r->out.alias_handle = *r->in.alias_handle;
 
8372
        }
 
8373
        if (flags & NDR_OUT) {
 
8374
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8375
                        NDR_PULL_ALLOC(ndr, r->out.alias_handle);
 
8376
                }
 
8377
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8378
                NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8379
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
 
8380
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8381
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8382
        }
 
8383
        return NDR_ERR_SUCCESS;
 
8384
}
 
8385
 
 
8386
_PUBLIC_ void ndr_print_samr_DeleteDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomAlias *r)
 
8387
{
 
8388
        ndr_print_struct(ndr, name, "samr_DeleteDomAlias");
 
8389
        ndr->depth++;
 
8390
        if (flags & NDR_SET_VALUES) {
 
8391
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8392
        }
 
8393
        if (flags & NDR_IN) {
 
8394
                ndr_print_struct(ndr, "in", "samr_DeleteDomAlias");
 
8395
                ndr->depth++;
 
8396
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
8397
                ndr->depth++;
 
8398
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
8399
                ndr->depth--;
 
8400
                ndr->depth--;
 
8401
        }
 
8402
        if (flags & NDR_OUT) {
 
8403
                ndr_print_struct(ndr, "out", "samr_DeleteDomAlias");
 
8404
                ndr->depth++;
 
8405
                ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
 
8406
                ndr->depth++;
 
8407
                ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
 
8408
                ndr->depth--;
 
8409
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8410
                ndr->depth--;
 
8411
        }
 
8412
        ndr->depth--;
 
8413
}
 
8414
 
 
8415
static enum ndr_err_code ndr_push_samr_AddAliasMember(struct ndr_push *ndr, int flags, const struct samr_AddAliasMember *r)
 
8416
{
 
8417
        if (flags & NDR_IN) {
 
8418
                if (r->in.alias_handle == NULL) {
 
8419
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8420
                }
 
8421
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8422
                if (r->in.sid == NULL) {
 
8423
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8424
                }
 
8425
                NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
8426
        }
 
8427
        if (flags & NDR_OUT) {
 
8428
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8429
        }
 
8430
        return NDR_ERR_SUCCESS;
 
8431
}
 
8432
 
 
8433
static enum ndr_err_code ndr_pull_samr_AddAliasMember(struct ndr_pull *ndr, int flags, struct samr_AddAliasMember *r)
 
8434
{
 
8435
        TALLOC_CTX *_mem_save_alias_handle_0;
 
8436
        TALLOC_CTX *_mem_save_sid_0;
 
8437
        if (flags & NDR_IN) {
 
8438
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8439
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
8440
                }
 
8441
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8442
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8443
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8444
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8445
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8446
                        NDR_PULL_ALLOC(ndr, r->in.sid);
 
8447
                }
 
8448
                _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8449
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
 
8450
                NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
8451
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 
8452
        }
 
8453
        if (flags & NDR_OUT) {
 
8454
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8455
        }
 
8456
        return NDR_ERR_SUCCESS;
 
8457
}
 
8458
 
 
8459
_PUBLIC_ void ndr_print_samr_AddAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddAliasMember *r)
 
8460
{
 
8461
        ndr_print_struct(ndr, name, "samr_AddAliasMember");
 
8462
        ndr->depth++;
 
8463
        if (flags & NDR_SET_VALUES) {
 
8464
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8465
        }
 
8466
        if (flags & NDR_IN) {
 
8467
                ndr_print_struct(ndr, "in", "samr_AddAliasMember");
 
8468
                ndr->depth++;
 
8469
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
8470
                ndr->depth++;
 
8471
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
8472
                ndr->depth--;
 
8473
                ndr_print_ptr(ndr, "sid", r->in.sid);
 
8474
                ndr->depth++;
 
8475
                ndr_print_dom_sid2(ndr, "sid", r->in.sid);
 
8476
                ndr->depth--;
 
8477
                ndr->depth--;
 
8478
        }
 
8479
        if (flags & NDR_OUT) {
 
8480
                ndr_print_struct(ndr, "out", "samr_AddAliasMember");
 
8481
                ndr->depth++;
 
8482
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8483
                ndr->depth--;
 
8484
        }
 
8485
        ndr->depth--;
 
8486
}
 
8487
 
 
8488
static enum ndr_err_code ndr_push_samr_DeleteAliasMember(struct ndr_push *ndr, int flags, const struct samr_DeleteAliasMember *r)
 
8489
{
 
8490
        if (flags & NDR_IN) {
 
8491
                if (r->in.alias_handle == NULL) {
 
8492
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8493
                }
 
8494
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8495
                if (r->in.sid == NULL) {
 
8496
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8497
                }
 
8498
                NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
8499
        }
 
8500
        if (flags & NDR_OUT) {
 
8501
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8502
        }
 
8503
        return NDR_ERR_SUCCESS;
 
8504
}
 
8505
 
 
8506
static enum ndr_err_code ndr_pull_samr_DeleteAliasMember(struct ndr_pull *ndr, int flags, struct samr_DeleteAliasMember *r)
 
8507
{
 
8508
        TALLOC_CTX *_mem_save_alias_handle_0;
 
8509
        TALLOC_CTX *_mem_save_sid_0;
 
8510
        if (flags & NDR_IN) {
 
8511
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8512
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
8513
                }
 
8514
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8515
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8516
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8517
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8518
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8519
                        NDR_PULL_ALLOC(ndr, r->in.sid);
 
8520
                }
 
8521
                _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8522
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
 
8523
                NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
8524
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 
8525
        }
 
8526
        if (flags & NDR_OUT) {
 
8527
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8528
        }
 
8529
        return NDR_ERR_SUCCESS;
 
8530
}
 
8531
 
 
8532
_PUBLIC_ void ndr_print_samr_DeleteAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteAliasMember *r)
 
8533
{
 
8534
        ndr_print_struct(ndr, name, "samr_DeleteAliasMember");
 
8535
        ndr->depth++;
 
8536
        if (flags & NDR_SET_VALUES) {
 
8537
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8538
        }
 
8539
        if (flags & NDR_IN) {
 
8540
                ndr_print_struct(ndr, "in", "samr_DeleteAliasMember");
 
8541
                ndr->depth++;
 
8542
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
8543
                ndr->depth++;
 
8544
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
8545
                ndr->depth--;
 
8546
                ndr_print_ptr(ndr, "sid", r->in.sid);
 
8547
                ndr->depth++;
 
8548
                ndr_print_dom_sid2(ndr, "sid", r->in.sid);
 
8549
                ndr->depth--;
 
8550
                ndr->depth--;
 
8551
        }
 
8552
        if (flags & NDR_OUT) {
 
8553
                ndr_print_struct(ndr, "out", "samr_DeleteAliasMember");
 
8554
                ndr->depth++;
 
8555
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8556
                ndr->depth--;
 
8557
        }
 
8558
        ndr->depth--;
 
8559
}
 
8560
 
 
8561
static enum ndr_err_code ndr_push_samr_GetMembersInAlias(struct ndr_push *ndr, int flags, const struct samr_GetMembersInAlias *r)
 
8562
{
 
8563
        if (flags & NDR_IN) {
 
8564
                if (r->in.alias_handle == NULL) {
 
8565
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8566
                }
 
8567
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8568
        }
 
8569
        if (flags & NDR_OUT) {
 
8570
                if (r->out.sids == NULL) {
 
8571
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8572
                }
 
8573
                NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
 
8574
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8575
        }
 
8576
        return NDR_ERR_SUCCESS;
 
8577
}
 
8578
 
 
8579
static enum ndr_err_code ndr_pull_samr_GetMembersInAlias(struct ndr_pull *ndr, int flags, struct samr_GetMembersInAlias *r)
 
8580
{
 
8581
        TALLOC_CTX *_mem_save_alias_handle_0;
 
8582
        TALLOC_CTX *_mem_save_sids_0;
 
8583
        if (flags & NDR_IN) {
 
8584
                ZERO_STRUCT(r->out);
 
8585
 
 
8586
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8587
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
8588
                }
 
8589
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8590
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8591
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8592
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8593
                NDR_PULL_ALLOC(ndr, r->out.sids);
 
8594
                ZERO_STRUCTP(r->out.sids);
 
8595
        }
 
8596
        if (flags & NDR_OUT) {
 
8597
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8598
                        NDR_PULL_ALLOC(ndr, r->out.sids);
 
8599
                }
 
8600
                _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8601
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
 
8602
                NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
 
8603
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
 
8604
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8605
        }
 
8606
        return NDR_ERR_SUCCESS;
 
8607
}
 
8608
 
 
8609
_PUBLIC_ void ndr_print_samr_GetMembersInAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetMembersInAlias *r)
 
8610
{
 
8611
        ndr_print_struct(ndr, name, "samr_GetMembersInAlias");
 
8612
        ndr->depth++;
 
8613
        if (flags & NDR_SET_VALUES) {
 
8614
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8615
        }
 
8616
        if (flags & NDR_IN) {
 
8617
                ndr_print_struct(ndr, "in", "samr_GetMembersInAlias");
 
8618
                ndr->depth++;
 
8619
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
8620
                ndr->depth++;
 
8621
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
8622
                ndr->depth--;
 
8623
                ndr->depth--;
 
8624
        }
 
8625
        if (flags & NDR_OUT) {
 
8626
                ndr_print_struct(ndr, "out", "samr_GetMembersInAlias");
 
8627
                ndr->depth++;
 
8628
                ndr_print_ptr(ndr, "sids", r->out.sids);
 
8629
                ndr->depth++;
 
8630
                ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
 
8631
                ndr->depth--;
 
8632
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8633
                ndr->depth--;
 
8634
        }
 
8635
        ndr->depth--;
 
8636
}
 
8637
 
 
8638
_PUBLIC_ enum ndr_err_code ndr_push_samr_OpenUser(struct ndr_push *ndr, int flags, const struct samr_OpenUser *r)
 
8639
{
 
8640
        if (flags & NDR_IN) {
 
8641
                if (r->in.domain_handle == NULL) {
 
8642
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8643
                }
 
8644
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
8645
                NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
8646
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
 
8647
        }
 
8648
        if (flags & NDR_OUT) {
 
8649
                if (r->out.user_handle == NULL) {
 
8650
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8651
                }
 
8652
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
8653
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8654
        }
 
8655
        return NDR_ERR_SUCCESS;
 
8656
}
 
8657
 
 
8658
_PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenUser(struct ndr_pull *ndr, int flags, struct samr_OpenUser *r)
 
8659
{
 
8660
        TALLOC_CTX *_mem_save_domain_handle_0;
 
8661
        TALLOC_CTX *_mem_save_user_handle_0;
 
8662
        if (flags & NDR_IN) {
 
8663
                ZERO_STRUCT(r->out);
 
8664
 
 
8665
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8666
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
8667
                }
 
8668
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8669
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
8670
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
8671
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8672
                NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
8673
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
 
8674
                NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
8675
                ZERO_STRUCTP(r->out.user_handle);
 
8676
        }
 
8677
        if (flags & NDR_OUT) {
 
8678
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8679
                        NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
8680
                }
 
8681
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8682
                NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
8683
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
8684
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8685
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8686
        }
 
8687
        return NDR_ERR_SUCCESS;
 
8688
}
 
8689
 
 
8690
_PUBLIC_ void ndr_print_samr_OpenUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenUser *r)
 
8691
{
 
8692
        ndr_print_struct(ndr, name, "samr_OpenUser");
 
8693
        ndr->depth++;
 
8694
        if (flags & NDR_SET_VALUES) {
 
8695
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8696
        }
 
8697
        if (flags & NDR_IN) {
 
8698
                ndr_print_struct(ndr, "in", "samr_OpenUser");
 
8699
                ndr->depth++;
 
8700
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
8701
                ndr->depth++;
 
8702
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
8703
                ndr->depth--;
 
8704
                ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
 
8705
                ndr_print_uint32(ndr, "rid", r->in.rid);
 
8706
                ndr->depth--;
 
8707
        }
 
8708
        if (flags & NDR_OUT) {
 
8709
                ndr_print_struct(ndr, "out", "samr_OpenUser");
 
8710
                ndr->depth++;
 
8711
                ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
 
8712
                ndr->depth++;
 
8713
                ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
 
8714
                ndr->depth--;
 
8715
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8716
                ndr->depth--;
 
8717
        }
 
8718
        ndr->depth--;
 
8719
}
 
8720
 
 
8721
static enum ndr_err_code ndr_push_samr_DeleteUser(struct ndr_push *ndr, int flags, const struct samr_DeleteUser *r)
 
8722
{
 
8723
        if (flags & NDR_IN) {
 
8724
                if (r->in.user_handle == NULL) {
 
8725
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8726
                }
 
8727
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
8728
        }
 
8729
        if (flags & NDR_OUT) {
 
8730
                if (r->out.user_handle == NULL) {
 
8731
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8732
                }
 
8733
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
8734
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8735
        }
 
8736
        return NDR_ERR_SUCCESS;
 
8737
}
 
8738
 
 
8739
static enum ndr_err_code ndr_pull_samr_DeleteUser(struct ndr_pull *ndr, int flags, struct samr_DeleteUser *r)
 
8740
{
 
8741
        TALLOC_CTX *_mem_save_user_handle_0;
 
8742
        if (flags & NDR_IN) {
 
8743
                ZERO_STRUCT(r->out);
 
8744
 
 
8745
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8746
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
8747
                }
 
8748
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8749
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
8750
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
8751
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8752
                NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
8753
                *r->out.user_handle = *r->in.user_handle;
 
8754
        }
 
8755
        if (flags & NDR_OUT) {
 
8756
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8757
                        NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
8758
                }
 
8759
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8760
                NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
8761
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
8762
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8763
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8764
        }
 
8765
        return NDR_ERR_SUCCESS;
 
8766
}
 
8767
 
 
8768
_PUBLIC_ void ndr_print_samr_DeleteUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteUser *r)
 
8769
{
 
8770
        ndr_print_struct(ndr, name, "samr_DeleteUser");
 
8771
        ndr->depth++;
 
8772
        if (flags & NDR_SET_VALUES) {
 
8773
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8774
        }
 
8775
        if (flags & NDR_IN) {
 
8776
                ndr_print_struct(ndr, "in", "samr_DeleteUser");
 
8777
                ndr->depth++;
 
8778
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
8779
                ndr->depth++;
 
8780
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
8781
                ndr->depth--;
 
8782
                ndr->depth--;
 
8783
        }
 
8784
        if (flags & NDR_OUT) {
 
8785
                ndr_print_struct(ndr, "out", "samr_DeleteUser");
 
8786
                ndr->depth++;
 
8787
                ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
 
8788
                ndr->depth++;
 
8789
                ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
 
8790
                ndr->depth--;
 
8791
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8792
                ndr->depth--;
 
8793
        }
 
8794
        ndr->depth--;
 
8795
}
 
8796
 
 
8797
_PUBLIC_ enum ndr_err_code ndr_push_samr_QueryUserInfo(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo *r)
 
8798
{
 
8799
        if (flags & NDR_IN) {
 
8800
                if (r->in.user_handle == NULL) {
 
8801
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8802
                }
 
8803
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
8804
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
8805
        }
 
8806
        if (flags & NDR_OUT) {
 
8807
                if (r->out.info == NULL) {
 
8808
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8809
                }
 
8810
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
 
8811
                if (*r->out.info) {
 
8812
                        NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
 
8813
                        NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
8814
                }
 
8815
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8816
        }
 
8817
        return NDR_ERR_SUCCESS;
 
8818
}
 
8819
 
 
8820
_PUBLIC_ enum ndr_err_code ndr_pull_samr_QueryUserInfo(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo *r)
 
8821
{
 
8822
        uint32_t _ptr_info;
 
8823
        TALLOC_CTX *_mem_save_user_handle_0;
 
8824
        TALLOC_CTX *_mem_save_info_0;
 
8825
        TALLOC_CTX *_mem_save_info_1;
 
8826
        if (flags & NDR_IN) {
 
8827
                ZERO_STRUCT(r->out);
 
8828
 
 
8829
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8830
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
8831
                }
 
8832
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8833
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
8834
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
8835
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8836
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
8837
                NDR_PULL_ALLOC(ndr, r->out.info);
 
8838
                ZERO_STRUCTP(r->out.info);
 
8839
        }
 
8840
        if (flags & NDR_OUT) {
 
8841
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8842
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
8843
                }
 
8844
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8845
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
8846
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 
8847
                if (_ptr_info) {
 
8848
                        NDR_PULL_ALLOC(ndr, *r->out.info);
 
8849
                } else {
 
8850
                        *r->out.info = NULL;
 
8851
                }
 
8852
                if (*r->out.info) {
 
8853
                        _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
8854
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
 
8855
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
 
8856
                        NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
8857
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
 
8858
                }
 
8859
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
8860
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8861
        }
 
8862
        return NDR_ERR_SUCCESS;
 
8863
}
 
8864
 
 
8865
_PUBLIC_ void ndr_print_samr_QueryUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo *r)
 
8866
{
 
8867
        ndr_print_struct(ndr, name, "samr_QueryUserInfo");
 
8868
        ndr->depth++;
 
8869
        if (flags & NDR_SET_VALUES) {
 
8870
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8871
        }
 
8872
        if (flags & NDR_IN) {
 
8873
                ndr_print_struct(ndr, "in", "samr_QueryUserInfo");
 
8874
                ndr->depth++;
 
8875
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
8876
                ndr->depth++;
 
8877
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
8878
                ndr->depth--;
 
8879
                ndr_print_uint16(ndr, "level", r->in.level);
 
8880
                ndr->depth--;
 
8881
        }
 
8882
        if (flags & NDR_OUT) {
 
8883
                ndr_print_struct(ndr, "out", "samr_QueryUserInfo");
 
8884
                ndr->depth++;
 
8885
                ndr_print_ptr(ndr, "info", r->out.info);
 
8886
                ndr->depth++;
 
8887
                ndr_print_ptr(ndr, "info", *r->out.info);
 
8888
                ndr->depth++;
 
8889
                if (*r->out.info) {
 
8890
                        ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
 
8891
                        ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
 
8892
                }
 
8893
                ndr->depth--;
 
8894
                ndr->depth--;
 
8895
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8896
                ndr->depth--;
 
8897
        }
 
8898
        ndr->depth--;
 
8899
}
 
8900
 
 
8901
_PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo *r)
 
8902
{
 
8903
        if (flags & NDR_IN) {
 
8904
                if (r->in.user_handle == NULL) {
 
8905
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8906
                }
 
8907
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
8908
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
8909
                if (r->in.info == NULL) {
 
8910
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8911
                }
 
8912
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
 
8913
                NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
8914
        }
 
8915
        if (flags & NDR_OUT) {
 
8916
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8917
        }
 
8918
        return NDR_ERR_SUCCESS;
 
8919
}
 
8920
 
 
8921
_PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo *r)
 
8922
{
 
8923
        TALLOC_CTX *_mem_save_user_handle_0;
 
8924
        TALLOC_CTX *_mem_save_info_0;
 
8925
        if (flags & NDR_IN) {
 
8926
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8927
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
8928
                }
 
8929
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8930
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
8931
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
8932
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8933
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
8934
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8935
                        NDR_PULL_ALLOC(ndr, r->in.info);
 
8936
                }
 
8937
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8938
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
 
8939
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
 
8940
                NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
8941
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
8942
        }
 
8943
        if (flags & NDR_OUT) {
 
8944
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8945
        }
 
8946
        return NDR_ERR_SUCCESS;
 
8947
}
 
8948
 
 
8949
_PUBLIC_ void ndr_print_samr_SetUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo *r)
 
8950
{
 
8951
        ndr_print_struct(ndr, name, "samr_SetUserInfo");
 
8952
        ndr->depth++;
 
8953
        if (flags & NDR_SET_VALUES) {
 
8954
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8955
        }
 
8956
        if (flags & NDR_IN) {
 
8957
                ndr_print_struct(ndr, "in", "samr_SetUserInfo");
 
8958
                ndr->depth++;
 
8959
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
8960
                ndr->depth++;
 
8961
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
8962
                ndr->depth--;
 
8963
                ndr_print_uint16(ndr, "level", r->in.level);
 
8964
                ndr_print_ptr(ndr, "info", r->in.info);
 
8965
                ndr->depth++;
 
8966
                ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
 
8967
                ndr_print_samr_UserInfo(ndr, "info", r->in.info);
 
8968
                ndr->depth--;
 
8969
                ndr->depth--;
 
8970
        }
 
8971
        if (flags & NDR_OUT) {
 
8972
                ndr_print_struct(ndr, "out", "samr_SetUserInfo");
 
8973
                ndr->depth++;
 
8974
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8975
                ndr->depth--;
 
8976
        }
 
8977
        ndr->depth--;
 
8978
}
 
8979
 
 
8980
static enum ndr_err_code ndr_push_samr_ChangePasswordUser(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser *r)
 
8981
{
 
8982
        if (flags & NDR_IN) {
 
8983
                if (r->in.user_handle == NULL) {
 
8984
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8985
                }
 
8986
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
8987
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_present));
 
8988
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_lm_crypted));
 
8989
                if (r->in.old_lm_crypted) {
 
8990
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
 
8991
                }
 
8992
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_lm_crypted));
 
8993
                if (r->in.new_lm_crypted) {
 
8994
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
 
8995
                }
 
8996
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.nt_present));
 
8997
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_nt_crypted));
 
8998
                if (r->in.old_nt_crypted) {
 
8999
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
 
9000
                }
 
9001
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_nt_crypted));
 
9002
                if (r->in.new_nt_crypted) {
 
9003
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
 
9004
                }
 
9005
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross1_present));
 
9006
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_cross));
 
9007
                if (r->in.nt_cross) {
 
9008
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
 
9009
                }
 
9010
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross2_present));
 
9011
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_cross));
 
9012
                if (r->in.lm_cross) {
 
9013
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
 
9014
                }
 
9015
        }
 
9016
        if (flags & NDR_OUT) {
 
9017
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9018
        }
 
9019
        return NDR_ERR_SUCCESS;
 
9020
}
 
9021
 
 
9022
static enum ndr_err_code ndr_pull_samr_ChangePasswordUser(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser *r)
 
9023
{
 
9024
        uint32_t _ptr_old_lm_crypted;
 
9025
        uint32_t _ptr_new_lm_crypted;
 
9026
        uint32_t _ptr_old_nt_crypted;
 
9027
        uint32_t _ptr_new_nt_crypted;
 
9028
        uint32_t _ptr_nt_cross;
 
9029
        uint32_t _ptr_lm_cross;
 
9030
        TALLOC_CTX *_mem_save_user_handle_0;
 
9031
        TALLOC_CTX *_mem_save_old_lm_crypted_0;
 
9032
        TALLOC_CTX *_mem_save_new_lm_crypted_0;
 
9033
        TALLOC_CTX *_mem_save_old_nt_crypted_0;
 
9034
        TALLOC_CTX *_mem_save_new_nt_crypted_0;
 
9035
        TALLOC_CTX *_mem_save_nt_cross_0;
 
9036
        TALLOC_CTX *_mem_save_lm_cross_0;
 
9037
        if (flags & NDR_IN) {
 
9038
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9039
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
9040
                }
 
9041
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9042
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
9043
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9044
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9045
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_present));
 
9046
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_lm_crypted));
 
9047
                if (_ptr_old_lm_crypted) {
 
9048
                        NDR_PULL_ALLOC(ndr, r->in.old_lm_crypted);
 
9049
                } else {
 
9050
                        r->in.old_lm_crypted = NULL;
 
9051
                }
 
9052
                if (r->in.old_lm_crypted) {
 
9053
                        _mem_save_old_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9054
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.old_lm_crypted, 0);
 
9055
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
 
9056
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_lm_crypted_0, 0);
 
9057
                }
 
9058
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_lm_crypted));
 
9059
                if (_ptr_new_lm_crypted) {
 
9060
                        NDR_PULL_ALLOC(ndr, r->in.new_lm_crypted);
 
9061
                } else {
 
9062
                        r->in.new_lm_crypted = NULL;
 
9063
                }
 
9064
                if (r->in.new_lm_crypted) {
 
9065
                        _mem_save_new_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9066
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.new_lm_crypted, 0);
 
9067
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
 
9068
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_lm_crypted_0, 0);
 
9069
                }
 
9070
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.nt_present));
 
9071
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_nt_crypted));
 
9072
                if (_ptr_old_nt_crypted) {
 
9073
                        NDR_PULL_ALLOC(ndr, r->in.old_nt_crypted);
 
9074
                } else {
 
9075
                        r->in.old_nt_crypted = NULL;
 
9076
                }
 
9077
                if (r->in.old_nt_crypted) {
 
9078
                        _mem_save_old_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9079
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.old_nt_crypted, 0);
 
9080
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
 
9081
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_nt_crypted_0, 0);
 
9082
                }
 
9083
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_nt_crypted));
 
9084
                if (_ptr_new_nt_crypted) {
 
9085
                        NDR_PULL_ALLOC(ndr, r->in.new_nt_crypted);
 
9086
                } else {
 
9087
                        r->in.new_nt_crypted = NULL;
 
9088
                }
 
9089
                if (r->in.new_nt_crypted) {
 
9090
                        _mem_save_new_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9091
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.new_nt_crypted, 0);
 
9092
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
 
9093
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_nt_crypted_0, 0);
 
9094
                }
 
9095
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross1_present));
 
9096
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_cross));
 
9097
                if (_ptr_nt_cross) {
 
9098
                        NDR_PULL_ALLOC(ndr, r->in.nt_cross);
 
9099
                } else {
 
9100
                        r->in.nt_cross = NULL;
 
9101
                }
 
9102
                if (r->in.nt_cross) {
 
9103
                        _mem_save_nt_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9104
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_cross, 0);
 
9105
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
 
9106
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_cross_0, 0);
 
9107
                }
 
9108
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross2_present));
 
9109
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_cross));
 
9110
                if (_ptr_lm_cross) {
 
9111
                        NDR_PULL_ALLOC(ndr, r->in.lm_cross);
 
9112
                } else {
 
9113
                        r->in.lm_cross = NULL;
 
9114
                }
 
9115
                if (r->in.lm_cross) {
 
9116
                        _mem_save_lm_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9117
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_cross, 0);
 
9118
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
 
9119
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_cross_0, 0);
 
9120
                }
 
9121
        }
 
9122
        if (flags & NDR_OUT) {
 
9123
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9124
        }
 
9125
        return NDR_ERR_SUCCESS;
 
9126
}
 
9127
 
 
9128
_PUBLIC_ void ndr_print_samr_ChangePasswordUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser *r)
 
9129
{
 
9130
        ndr_print_struct(ndr, name, "samr_ChangePasswordUser");
 
9131
        ndr->depth++;
 
9132
        if (flags & NDR_SET_VALUES) {
 
9133
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9134
        }
 
9135
        if (flags & NDR_IN) {
 
9136
                ndr_print_struct(ndr, "in", "samr_ChangePasswordUser");
 
9137
                ndr->depth++;
 
9138
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
9139
                ndr->depth++;
 
9140
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
9141
                ndr->depth--;
 
9142
                ndr_print_uint8(ndr, "lm_present", r->in.lm_present);
 
9143
                ndr_print_ptr(ndr, "old_lm_crypted", r->in.old_lm_crypted);
 
9144
                ndr->depth++;
 
9145
                if (r->in.old_lm_crypted) {
 
9146
                        ndr_print_samr_Password(ndr, "old_lm_crypted", r->in.old_lm_crypted);
 
9147
                }
 
9148
                ndr->depth--;
 
9149
                ndr_print_ptr(ndr, "new_lm_crypted", r->in.new_lm_crypted);
 
9150
                ndr->depth++;
 
9151
                if (r->in.new_lm_crypted) {
 
9152
                        ndr_print_samr_Password(ndr, "new_lm_crypted", r->in.new_lm_crypted);
 
9153
                }
 
9154
                ndr->depth--;
 
9155
                ndr_print_uint8(ndr, "nt_present", r->in.nt_present);
 
9156
                ndr_print_ptr(ndr, "old_nt_crypted", r->in.old_nt_crypted);
 
9157
                ndr->depth++;
 
9158
                if (r->in.old_nt_crypted) {
 
9159
                        ndr_print_samr_Password(ndr, "old_nt_crypted", r->in.old_nt_crypted);
 
9160
                }
 
9161
                ndr->depth--;
 
9162
                ndr_print_ptr(ndr, "new_nt_crypted", r->in.new_nt_crypted);
 
9163
                ndr->depth++;
 
9164
                if (r->in.new_nt_crypted) {
 
9165
                        ndr_print_samr_Password(ndr, "new_nt_crypted", r->in.new_nt_crypted);
 
9166
                }
 
9167
                ndr->depth--;
 
9168
                ndr_print_uint8(ndr, "cross1_present", r->in.cross1_present);
 
9169
                ndr_print_ptr(ndr, "nt_cross", r->in.nt_cross);
 
9170
                ndr->depth++;
 
9171
                if (r->in.nt_cross) {
 
9172
                        ndr_print_samr_Password(ndr, "nt_cross", r->in.nt_cross);
 
9173
                }
 
9174
                ndr->depth--;
 
9175
                ndr_print_uint8(ndr, "cross2_present", r->in.cross2_present);
 
9176
                ndr_print_ptr(ndr, "lm_cross", r->in.lm_cross);
 
9177
                ndr->depth++;
 
9178
                if (r->in.lm_cross) {
 
9179
                        ndr_print_samr_Password(ndr, "lm_cross", r->in.lm_cross);
 
9180
                }
 
9181
                ndr->depth--;
 
9182
                ndr->depth--;
 
9183
        }
 
9184
        if (flags & NDR_OUT) {
 
9185
                ndr_print_struct(ndr, "out", "samr_ChangePasswordUser");
 
9186
                ndr->depth++;
 
9187
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9188
                ndr->depth--;
 
9189
        }
 
9190
        ndr->depth--;
 
9191
}
 
9192
 
 
9193
static enum ndr_err_code ndr_push_samr_GetGroupsForUser(struct ndr_push *ndr, int flags, const struct samr_GetGroupsForUser *r)
 
9194
{
 
9195
        if (flags & NDR_IN) {
 
9196
                if (r->in.user_handle == NULL) {
 
9197
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9198
                }
 
9199
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9200
        }
 
9201
        if (flags & NDR_OUT) {
 
9202
                if (r->out.rids == NULL) {
 
9203
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9204
                }
 
9205
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
 
9206
                if (*r->out.rids) {
 
9207
                        NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
 
9208
                }
 
9209
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9210
        }
 
9211
        return NDR_ERR_SUCCESS;
 
9212
}
 
9213
 
 
9214
static enum ndr_err_code ndr_pull_samr_GetGroupsForUser(struct ndr_pull *ndr, int flags, struct samr_GetGroupsForUser *r)
 
9215
{
 
9216
        uint32_t _ptr_rids;
 
9217
        TALLOC_CTX *_mem_save_user_handle_0;
 
9218
        TALLOC_CTX *_mem_save_rids_0;
 
9219
        TALLOC_CTX *_mem_save_rids_1;
 
9220
        if (flags & NDR_IN) {
 
9221
                ZERO_STRUCT(r->out);
 
9222
 
 
9223
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9224
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
9225
                }
 
9226
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9227
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
9228
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9229
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9230
                NDR_PULL_ALLOC(ndr, r->out.rids);
 
9231
                ZERO_STRUCTP(r->out.rids);
 
9232
        }
 
9233
        if (flags & NDR_OUT) {
 
9234
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9235
                        NDR_PULL_ALLOC(ndr, r->out.rids);
 
9236
                }
 
9237
                _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9238
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
 
9239
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
 
9240
                if (_ptr_rids) {
 
9241
                        NDR_PULL_ALLOC(ndr, *r->out.rids);
 
9242
                } else {
 
9243
                        *r->out.rids = NULL;
 
9244
                }
 
9245
                if (*r->out.rids) {
 
9246
                        _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
9247
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
 
9248
                        NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
 
9249
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
 
9250
                }
 
9251
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
 
9252
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9253
        }
 
9254
        return NDR_ERR_SUCCESS;
 
9255
}
 
9256
 
 
9257
_PUBLIC_ void ndr_print_samr_GetGroupsForUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetGroupsForUser *r)
 
9258
{
 
9259
        ndr_print_struct(ndr, name, "samr_GetGroupsForUser");
 
9260
        ndr->depth++;
 
9261
        if (flags & NDR_SET_VALUES) {
 
9262
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9263
        }
 
9264
        if (flags & NDR_IN) {
 
9265
                ndr_print_struct(ndr, "in", "samr_GetGroupsForUser");
 
9266
                ndr->depth++;
 
9267
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
9268
                ndr->depth++;
 
9269
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
9270
                ndr->depth--;
 
9271
                ndr->depth--;
 
9272
        }
 
9273
        if (flags & NDR_OUT) {
 
9274
                ndr_print_struct(ndr, "out", "samr_GetGroupsForUser");
 
9275
                ndr->depth++;
 
9276
                ndr_print_ptr(ndr, "rids", r->out.rids);
 
9277
                ndr->depth++;
 
9278
                ndr_print_ptr(ndr, "rids", *r->out.rids);
 
9279
                ndr->depth++;
 
9280
                if (*r->out.rids) {
 
9281
                        ndr_print_samr_RidWithAttributeArray(ndr, "rids", *r->out.rids);
 
9282
                }
 
9283
                ndr->depth--;
 
9284
                ndr->depth--;
 
9285
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9286
                ndr->depth--;
 
9287
        }
 
9288
        ndr->depth--;
 
9289
}
 
9290
 
 
9291
static enum ndr_err_code ndr_push_samr_QueryDisplayInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo *r)
 
9292
{
 
9293
        if (flags & NDR_IN) {
 
9294
                if (r->in.domain_handle == NULL) {
 
9295
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9296
                }
 
9297
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9298
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
9299
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
 
9300
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
 
9301
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
 
9302
        }
 
9303
        if (flags & NDR_OUT) {
 
9304
                if (r->out.total_size == NULL) {
 
9305
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9306
                }
 
9307
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
 
9308
                if (r->out.returned_size == NULL) {
 
9309
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9310
                }
 
9311
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
 
9312
                if (r->out.info == NULL) {
 
9313
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9314
                }
 
9315
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
 
9316
                NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 
9317
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9318
        }
 
9319
        return NDR_ERR_SUCCESS;
 
9320
}
 
9321
 
 
9322
static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo *r)
 
9323
{
 
9324
        TALLOC_CTX *_mem_save_domain_handle_0;
 
9325
        TALLOC_CTX *_mem_save_total_size_0;
 
9326
        TALLOC_CTX *_mem_save_returned_size_0;
 
9327
        TALLOC_CTX *_mem_save_info_0;
 
9328
        if (flags & NDR_IN) {
 
9329
                ZERO_STRUCT(r->out);
 
9330
 
 
9331
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9332
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
9333
                }
 
9334
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9335
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
9336
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9337
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9338
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
9339
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
 
9340
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
 
9341
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
 
9342
                NDR_PULL_ALLOC(ndr, r->out.total_size);
 
9343
                ZERO_STRUCTP(r->out.total_size);
 
9344
                NDR_PULL_ALLOC(ndr, r->out.returned_size);
 
9345
                ZERO_STRUCTP(r->out.returned_size);
 
9346
                NDR_PULL_ALLOC(ndr, r->out.info);
 
9347
                ZERO_STRUCTP(r->out.info);
 
9348
        }
 
9349
        if (flags & NDR_OUT) {
 
9350
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9351
                        NDR_PULL_ALLOC(ndr, r->out.total_size);
 
9352
                }
 
9353
                _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9354
                NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
 
9355
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
 
9356
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
 
9357
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9358
                        NDR_PULL_ALLOC(ndr, r->out.returned_size);
 
9359
                }
 
9360
                _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9361
                NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
 
9362
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
 
9363
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
 
9364
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9365
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
9366
                }
 
9367
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9368
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
9369
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
 
9370
                NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 
9371
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
9372
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9373
        }
 
9374
        return NDR_ERR_SUCCESS;
 
9375
}
 
9376
 
 
9377
_PUBLIC_ void ndr_print_samr_QueryDisplayInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo *r)
 
9378
{
 
9379
        ndr_print_struct(ndr, name, "samr_QueryDisplayInfo");
 
9380
        ndr->depth++;
 
9381
        if (flags & NDR_SET_VALUES) {
 
9382
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9383
        }
 
9384
        if (flags & NDR_IN) {
 
9385
                ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo");
 
9386
                ndr->depth++;
 
9387
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
9388
                ndr->depth++;
 
9389
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
9390
                ndr->depth--;
 
9391
                ndr_print_uint16(ndr, "level", r->in.level);
 
9392
                ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
 
9393
                ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
 
9394
                ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
 
9395
                ndr->depth--;
 
9396
        }
 
9397
        if (flags & NDR_OUT) {
 
9398
                ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo");
 
9399
                ndr->depth++;
 
9400
                ndr_print_ptr(ndr, "total_size", r->out.total_size);
 
9401
                ndr->depth++;
 
9402
                ndr_print_uint32(ndr, "total_size", *r->out.total_size);
 
9403
                ndr->depth--;
 
9404
                ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
 
9405
                ndr->depth++;
 
9406
                ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
 
9407
                ndr->depth--;
 
9408
                ndr_print_ptr(ndr, "info", r->out.info);
 
9409
                ndr->depth++;
 
9410
                ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
 
9411
                ndr_print_samr_DispInfo(ndr, "info", r->out.info);
 
9412
                ndr->depth--;
 
9413
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9414
                ndr->depth--;
 
9415
        }
 
9416
        ndr->depth--;
 
9417
}
 
9418
 
 
9419
static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex *r)
 
9420
{
 
9421
        if (flags & NDR_IN) {
 
9422
                if (r->in.domain_handle == NULL) {
 
9423
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9424
                }
 
9425
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9426
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
9427
                if (r->in.name == NULL) {
 
9428
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9429
                }
 
9430
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
9431
        }
 
9432
        if (flags & NDR_OUT) {
 
9433
                if (r->out.idx == NULL) {
 
9434
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9435
                }
 
9436
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
 
9437
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9438
        }
 
9439
        return NDR_ERR_SUCCESS;
 
9440
}
 
9441
 
 
9442
static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex *r)
 
9443
{
 
9444
        TALLOC_CTX *_mem_save_domain_handle_0;
 
9445
        TALLOC_CTX *_mem_save_name_0;
 
9446
        TALLOC_CTX *_mem_save_idx_0;
 
9447
        if (flags & NDR_IN) {
 
9448
                ZERO_STRUCT(r->out);
 
9449
 
 
9450
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9451
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
9452
                }
 
9453
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9454
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
9455
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9456
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9457
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
9458
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9459
                        NDR_PULL_ALLOC(ndr, r->in.name);
 
9460
                }
 
9461
                _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9462
                NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
 
9463
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
9464
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
 
9465
                NDR_PULL_ALLOC(ndr, r->out.idx);
 
9466
                ZERO_STRUCTP(r->out.idx);
 
9467
        }
 
9468
        if (flags & NDR_OUT) {
 
9469
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9470
                        NDR_PULL_ALLOC(ndr, r->out.idx);
 
9471
                }
 
9472
                _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9473
                NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
 
9474
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
 
9475
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
 
9476
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9477
        }
 
9478
        return NDR_ERR_SUCCESS;
 
9479
}
 
9480
 
 
9481
_PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex *r)
 
9482
{
 
9483
        ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex");
 
9484
        ndr->depth++;
 
9485
        if (flags & NDR_SET_VALUES) {
 
9486
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9487
        }
 
9488
        if (flags & NDR_IN) {
 
9489
                ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex");
 
9490
                ndr->depth++;
 
9491
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
9492
                ndr->depth++;
 
9493
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
9494
                ndr->depth--;
 
9495
                ndr_print_uint16(ndr, "level", r->in.level);
 
9496
                ndr_print_ptr(ndr, "name", r->in.name);
 
9497
                ndr->depth++;
 
9498
                ndr_print_lsa_String(ndr, "name", r->in.name);
 
9499
                ndr->depth--;
 
9500
                ndr->depth--;
 
9501
        }
 
9502
        if (flags & NDR_OUT) {
 
9503
                ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex");
 
9504
                ndr->depth++;
 
9505
                ndr_print_ptr(ndr, "idx", r->out.idx);
 
9506
                ndr->depth++;
 
9507
                ndr_print_uint32(ndr, "idx", *r->out.idx);
 
9508
                ndr->depth--;
 
9509
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9510
                ndr->depth--;
 
9511
        }
 
9512
        ndr->depth--;
 
9513
}
 
9514
 
 
9515
static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsDomain(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsDomain *r)
 
9516
{
 
9517
        if (flags & NDR_IN) {
 
9518
                if (r->in.domain_handle == NULL) {
 
9519
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9520
                }
 
9521
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9522
        }
 
9523
        if (flags & NDR_OUT) {
 
9524
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9525
        }
 
9526
        return NDR_ERR_SUCCESS;
 
9527
}
 
9528
 
 
9529
static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsDomain(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsDomain *r)
 
9530
{
 
9531
        TALLOC_CTX *_mem_save_domain_handle_0;
 
9532
        if (flags & NDR_IN) {
 
9533
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9534
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
9535
                }
 
9536
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9537
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
9538
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9539
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9540
        }
 
9541
        if (flags & NDR_OUT) {
 
9542
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9543
        }
 
9544
        return NDR_ERR_SUCCESS;
 
9545
}
 
9546
 
 
9547
_PUBLIC_ void ndr_print_samr_TestPrivateFunctionsDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsDomain *r)
 
9548
{
 
9549
        ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsDomain");
 
9550
        ndr->depth++;
 
9551
        if (flags & NDR_SET_VALUES) {
 
9552
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9553
        }
 
9554
        if (flags & NDR_IN) {
 
9555
                ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsDomain");
 
9556
                ndr->depth++;
 
9557
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
9558
                ndr->depth++;
 
9559
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
9560
                ndr->depth--;
 
9561
                ndr->depth--;
 
9562
        }
 
9563
        if (flags & NDR_OUT) {
 
9564
                ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsDomain");
 
9565
                ndr->depth++;
 
9566
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9567
                ndr->depth--;
 
9568
        }
 
9569
        ndr->depth--;
 
9570
}
 
9571
 
 
9572
static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsUser(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsUser *r)
 
9573
{
 
9574
        if (flags & NDR_IN) {
 
9575
                if (r->in.user_handle == NULL) {
 
9576
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9577
                }
 
9578
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9579
        }
 
9580
        if (flags & NDR_OUT) {
 
9581
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9582
        }
 
9583
        return NDR_ERR_SUCCESS;
 
9584
}
 
9585
 
 
9586
static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsUser(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsUser *r)
 
9587
{
 
9588
        TALLOC_CTX *_mem_save_user_handle_0;
 
9589
        if (flags & NDR_IN) {
 
9590
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9591
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
9592
                }
 
9593
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9594
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
9595
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9596
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9597
        }
 
9598
        if (flags & NDR_OUT) {
 
9599
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9600
        }
 
9601
        return NDR_ERR_SUCCESS;
 
9602
}
 
9603
 
 
9604
_PUBLIC_ void ndr_print_samr_TestPrivateFunctionsUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsUser *r)
 
9605
{
 
9606
        ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsUser");
 
9607
        ndr->depth++;
 
9608
        if (flags & NDR_SET_VALUES) {
 
9609
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9610
        }
 
9611
        if (flags & NDR_IN) {
 
9612
                ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsUser");
 
9613
                ndr->depth++;
 
9614
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
9615
                ndr->depth++;
 
9616
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
9617
                ndr->depth--;
 
9618
                ndr->depth--;
 
9619
        }
 
9620
        if (flags & NDR_OUT) {
 
9621
                ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsUser");
 
9622
                ndr->depth++;
 
9623
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9624
                ndr->depth--;
 
9625
        }
 
9626
        ndr->depth--;
 
9627
}
 
9628
 
 
9629
_PUBLIC_ enum ndr_err_code ndr_push_samr_GetUserPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetUserPwInfo *r)
 
9630
{
 
9631
        if (flags & NDR_IN) {
 
9632
                if (r->in.user_handle == NULL) {
 
9633
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9634
                }
 
9635
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9636
        }
 
9637
        if (flags & NDR_OUT) {
 
9638
                if (r->out.info == NULL) {
 
9639
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9640
                }
 
9641
                NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
 
9642
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9643
        }
 
9644
        return NDR_ERR_SUCCESS;
 
9645
}
 
9646
 
 
9647
_PUBLIC_ enum ndr_err_code ndr_pull_samr_GetUserPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetUserPwInfo *r)
 
9648
{
 
9649
        TALLOC_CTX *_mem_save_user_handle_0;
 
9650
        TALLOC_CTX *_mem_save_info_0;
 
9651
        if (flags & NDR_IN) {
 
9652
                ZERO_STRUCT(r->out);
 
9653
 
 
9654
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9655
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
9656
                }
 
9657
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9658
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
9659
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9660
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9661
                NDR_PULL_ALLOC(ndr, r->out.info);
 
9662
                ZERO_STRUCTP(r->out.info);
 
9663
        }
 
9664
        if (flags & NDR_OUT) {
 
9665
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9666
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
9667
                }
 
9668
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9669
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
9670
                NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
 
9671
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
9672
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9673
        }
 
9674
        return NDR_ERR_SUCCESS;
 
9675
}
 
9676
 
 
9677
_PUBLIC_ void ndr_print_samr_GetUserPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetUserPwInfo *r)
 
9678
{
 
9679
        ndr_print_struct(ndr, name, "samr_GetUserPwInfo");
 
9680
        ndr->depth++;
 
9681
        if (flags & NDR_SET_VALUES) {
 
9682
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9683
        }
 
9684
        if (flags & NDR_IN) {
 
9685
                ndr_print_struct(ndr, "in", "samr_GetUserPwInfo");
 
9686
                ndr->depth++;
 
9687
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
9688
                ndr->depth++;
 
9689
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
9690
                ndr->depth--;
 
9691
                ndr->depth--;
 
9692
        }
 
9693
        if (flags & NDR_OUT) {
 
9694
                ndr_print_struct(ndr, "out", "samr_GetUserPwInfo");
 
9695
                ndr->depth++;
 
9696
                ndr_print_ptr(ndr, "info", r->out.info);
 
9697
                ndr->depth++;
 
9698
                ndr_print_samr_PwInfo(ndr, "info", r->out.info);
 
9699
                ndr->depth--;
 
9700
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9701
                ndr->depth--;
 
9702
        }
 
9703
        ndr->depth--;
 
9704
}
 
9705
 
 
9706
static enum ndr_err_code ndr_push_samr_RemoveMemberFromForeignDomain(struct ndr_push *ndr, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
 
9707
{
 
9708
        if (flags & NDR_IN) {
 
9709
                if (r->in.domain_handle == NULL) {
 
9710
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9711
                }
 
9712
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9713
                if (r->in.sid == NULL) {
 
9714
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9715
                }
 
9716
                NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
9717
        }
 
9718
        if (flags & NDR_OUT) {
 
9719
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9720
        }
 
9721
        return NDR_ERR_SUCCESS;
 
9722
}
 
9723
 
 
9724
static enum ndr_err_code ndr_pull_samr_RemoveMemberFromForeignDomain(struct ndr_pull *ndr, int flags, struct samr_RemoveMemberFromForeignDomain *r)
 
9725
{
 
9726
        TALLOC_CTX *_mem_save_domain_handle_0;
 
9727
        TALLOC_CTX *_mem_save_sid_0;
 
9728
        if (flags & NDR_IN) {
 
9729
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9730
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
9731
                }
 
9732
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9733
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
9734
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9735
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9736
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9737
                        NDR_PULL_ALLOC(ndr, r->in.sid);
 
9738
                }
 
9739
                _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9740
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
 
9741
                NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
9742
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 
9743
        }
 
9744
        if (flags & NDR_OUT) {
 
9745
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9746
        }
 
9747
        return NDR_ERR_SUCCESS;
 
9748
}
 
9749
 
 
9750
_PUBLIC_ void ndr_print_samr_RemoveMemberFromForeignDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
 
9751
{
 
9752
        ndr_print_struct(ndr, name, "samr_RemoveMemberFromForeignDomain");
 
9753
        ndr->depth++;
 
9754
        if (flags & NDR_SET_VALUES) {
 
9755
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9756
        }
 
9757
        if (flags & NDR_IN) {
 
9758
                ndr_print_struct(ndr, "in", "samr_RemoveMemberFromForeignDomain");
 
9759
                ndr->depth++;
 
9760
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
9761
                ndr->depth++;
 
9762
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
9763
                ndr->depth--;
 
9764
                ndr_print_ptr(ndr, "sid", r->in.sid);
 
9765
                ndr->depth++;
 
9766
                ndr_print_dom_sid2(ndr, "sid", r->in.sid);
 
9767
                ndr->depth--;
 
9768
                ndr->depth--;
 
9769
        }
 
9770
        if (flags & NDR_OUT) {
 
9771
                ndr_print_struct(ndr, "out", "samr_RemoveMemberFromForeignDomain");
 
9772
                ndr->depth++;
 
9773
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9774
                ndr->depth--;
 
9775
        }
 
9776
        ndr->depth--;
 
9777
}
 
9778
 
 
9779
static enum ndr_err_code ndr_push_samr_QueryDomainInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo2 *r)
 
9780
{
 
9781
        if (flags & NDR_IN) {
 
9782
                if (r->in.domain_handle == NULL) {
 
9783
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9784
                }
 
9785
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9786
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
9787
        }
 
9788
        if (flags & NDR_OUT) {
 
9789
                if (r->out.info == NULL) {
 
9790
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9791
                }
 
9792
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
 
9793
                if (*r->out.info) {
 
9794
                        NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
 
9795
                        NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
9796
                }
 
9797
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9798
        }
 
9799
        return NDR_ERR_SUCCESS;
 
9800
}
 
9801
 
 
9802
static enum ndr_err_code ndr_pull_samr_QueryDomainInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo2 *r)
 
9803
{
 
9804
        uint32_t _ptr_info;
 
9805
        TALLOC_CTX *_mem_save_domain_handle_0;
 
9806
        TALLOC_CTX *_mem_save_info_0;
 
9807
        TALLOC_CTX *_mem_save_info_1;
 
9808
        if (flags & NDR_IN) {
 
9809
                ZERO_STRUCT(r->out);
 
9810
 
 
9811
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9812
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
9813
                }
 
9814
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9815
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
9816
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9817
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9818
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
9819
                NDR_PULL_ALLOC(ndr, r->out.info);
 
9820
                ZERO_STRUCTP(r->out.info);
 
9821
        }
 
9822
        if (flags & NDR_OUT) {
 
9823
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9824
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
9825
                }
 
9826
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9827
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
9828
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 
9829
                if (_ptr_info) {
 
9830
                        NDR_PULL_ALLOC(ndr, *r->out.info);
 
9831
                } else {
 
9832
                        *r->out.info = NULL;
 
9833
                }
 
9834
                if (*r->out.info) {
 
9835
                        _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
9836
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
 
9837
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
 
9838
                        NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
9839
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
 
9840
                }
 
9841
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
9842
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9843
        }
 
9844
        return NDR_ERR_SUCCESS;
 
9845
}
 
9846
 
 
9847
_PUBLIC_ void ndr_print_samr_QueryDomainInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo2 *r)
 
9848
{
 
9849
        ndr_print_struct(ndr, name, "samr_QueryDomainInfo2");
 
9850
        ndr->depth++;
 
9851
        if (flags & NDR_SET_VALUES) {
 
9852
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9853
        }
 
9854
        if (flags & NDR_IN) {
 
9855
                ndr_print_struct(ndr, "in", "samr_QueryDomainInfo2");
 
9856
                ndr->depth++;
 
9857
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
9858
                ndr->depth++;
 
9859
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
9860
                ndr->depth--;
 
9861
                ndr_print_uint16(ndr, "level", r->in.level);
 
9862
                ndr->depth--;
 
9863
        }
 
9864
        if (flags & NDR_OUT) {
 
9865
                ndr_print_struct(ndr, "out", "samr_QueryDomainInfo2");
 
9866
                ndr->depth++;
 
9867
                ndr_print_ptr(ndr, "info", r->out.info);
 
9868
                ndr->depth++;
 
9869
                ndr_print_ptr(ndr, "info", *r->out.info);
 
9870
                ndr->depth++;
 
9871
                if (*r->out.info) {
 
9872
                        ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
 
9873
                        ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
 
9874
                }
 
9875
                ndr->depth--;
 
9876
                ndr->depth--;
 
9877
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9878
                ndr->depth--;
 
9879
        }
 
9880
        ndr->depth--;
 
9881
}
 
9882
 
 
9883
static enum ndr_err_code ndr_push_samr_QueryUserInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo2 *r)
 
9884
{
 
9885
        if (flags & NDR_IN) {
 
9886
                if (r->in.user_handle == NULL) {
 
9887
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9888
                }
 
9889
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9890
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
9891
        }
 
9892
        if (flags & NDR_OUT) {
 
9893
                if (r->out.info == NULL) {
 
9894
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9895
                }
 
9896
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
 
9897
                if (*r->out.info) {
 
9898
                        NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
 
9899
                        NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
9900
                }
 
9901
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9902
        }
 
9903
        return NDR_ERR_SUCCESS;
 
9904
}
 
9905
 
 
9906
static enum ndr_err_code ndr_pull_samr_QueryUserInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo2 *r)
 
9907
{
 
9908
        uint32_t _ptr_info;
 
9909
        TALLOC_CTX *_mem_save_user_handle_0;
 
9910
        TALLOC_CTX *_mem_save_info_0;
 
9911
        TALLOC_CTX *_mem_save_info_1;
 
9912
        if (flags & NDR_IN) {
 
9913
                ZERO_STRUCT(r->out);
 
9914
 
 
9915
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9916
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
9917
                }
 
9918
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9919
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
9920
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9921
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9922
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
9923
                NDR_PULL_ALLOC(ndr, r->out.info);
 
9924
                ZERO_STRUCTP(r->out.info);
 
9925
        }
 
9926
        if (flags & NDR_OUT) {
 
9927
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9928
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
9929
                }
 
9930
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9931
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
9932
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 
9933
                if (_ptr_info) {
 
9934
                        NDR_PULL_ALLOC(ndr, *r->out.info);
 
9935
                } else {
 
9936
                        *r->out.info = NULL;
 
9937
                }
 
9938
                if (*r->out.info) {
 
9939
                        _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
9940
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
 
9941
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
 
9942
                        NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
9943
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
 
9944
                }
 
9945
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
9946
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9947
        }
 
9948
        return NDR_ERR_SUCCESS;
 
9949
}
 
9950
 
 
9951
_PUBLIC_ void ndr_print_samr_QueryUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo2 *r)
 
9952
{
 
9953
        ndr_print_struct(ndr, name, "samr_QueryUserInfo2");
 
9954
        ndr->depth++;
 
9955
        if (flags & NDR_SET_VALUES) {
 
9956
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9957
        }
 
9958
        if (flags & NDR_IN) {
 
9959
                ndr_print_struct(ndr, "in", "samr_QueryUserInfo2");
 
9960
                ndr->depth++;
 
9961
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
9962
                ndr->depth++;
 
9963
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
9964
                ndr->depth--;
 
9965
                ndr_print_uint16(ndr, "level", r->in.level);
 
9966
                ndr->depth--;
 
9967
        }
 
9968
        if (flags & NDR_OUT) {
 
9969
                ndr_print_struct(ndr, "out", "samr_QueryUserInfo2");
 
9970
                ndr->depth++;
 
9971
                ndr_print_ptr(ndr, "info", r->out.info);
 
9972
                ndr->depth++;
 
9973
                ndr_print_ptr(ndr, "info", *r->out.info);
 
9974
                ndr->depth++;
 
9975
                if (*r->out.info) {
 
9976
                        ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
 
9977
                        ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
 
9978
                }
 
9979
                ndr->depth--;
 
9980
                ndr->depth--;
 
9981
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9982
                ndr->depth--;
 
9983
        }
 
9984
        ndr->depth--;
 
9985
}
 
9986
 
 
9987
static enum ndr_err_code ndr_push_samr_QueryDisplayInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo2 *r)
 
9988
{
 
9989
        if (flags & NDR_IN) {
 
9990
                if (r->in.domain_handle == NULL) {
 
9991
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9992
                }
 
9993
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9994
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
9995
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
 
9996
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
 
9997
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
 
9998
        }
 
9999
        if (flags & NDR_OUT) {
 
10000
                if (r->out.total_size == NULL) {
 
10001
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10002
                }
 
10003
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
 
10004
                if (r->out.returned_size == NULL) {
 
10005
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10006
                }
 
10007
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
 
10008
                if (r->out.info == NULL) {
 
10009
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10010
                }
 
10011
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
 
10012
                NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 
10013
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10014
        }
 
10015
        return NDR_ERR_SUCCESS;
 
10016
}
 
10017
 
 
10018
static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo2 *r)
 
10019
{
 
10020
        TALLOC_CTX *_mem_save_domain_handle_0;
 
10021
        TALLOC_CTX *_mem_save_total_size_0;
 
10022
        TALLOC_CTX *_mem_save_returned_size_0;
 
10023
        TALLOC_CTX *_mem_save_info_0;
 
10024
        if (flags & NDR_IN) {
 
10025
                ZERO_STRUCT(r->out);
 
10026
 
 
10027
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10028
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
10029
                }
 
10030
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10031
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
10032
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10033
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10034
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
10035
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
 
10036
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
 
10037
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
 
10038
                NDR_PULL_ALLOC(ndr, r->out.total_size);
 
10039
                ZERO_STRUCTP(r->out.total_size);
 
10040
                NDR_PULL_ALLOC(ndr, r->out.returned_size);
 
10041
                ZERO_STRUCTP(r->out.returned_size);
 
10042
                NDR_PULL_ALLOC(ndr, r->out.info);
 
10043
                ZERO_STRUCTP(r->out.info);
 
10044
        }
 
10045
        if (flags & NDR_OUT) {
 
10046
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10047
                        NDR_PULL_ALLOC(ndr, r->out.total_size);
 
10048
                }
 
10049
                _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10050
                NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
 
10051
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
 
10052
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
 
10053
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10054
                        NDR_PULL_ALLOC(ndr, r->out.returned_size);
 
10055
                }
 
10056
                _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10057
                NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
 
10058
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
 
10059
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
 
10060
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10061
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
10062
                }
 
10063
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10064
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
10065
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
 
10066
                NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 
10067
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
10068
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10069
        }
 
10070
        return NDR_ERR_SUCCESS;
 
10071
}
 
10072
 
 
10073
_PUBLIC_ void ndr_print_samr_QueryDisplayInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo2 *r)
 
10074
{
 
10075
        ndr_print_struct(ndr, name, "samr_QueryDisplayInfo2");
 
10076
        ndr->depth++;
 
10077
        if (flags & NDR_SET_VALUES) {
 
10078
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10079
        }
 
10080
        if (flags & NDR_IN) {
 
10081
                ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo2");
 
10082
                ndr->depth++;
 
10083
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
10084
                ndr->depth++;
 
10085
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
10086
                ndr->depth--;
 
10087
                ndr_print_uint16(ndr, "level", r->in.level);
 
10088
                ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
 
10089
                ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
 
10090
                ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
 
10091
                ndr->depth--;
 
10092
        }
 
10093
        if (flags & NDR_OUT) {
 
10094
                ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo2");
 
10095
                ndr->depth++;
 
10096
                ndr_print_ptr(ndr, "total_size", r->out.total_size);
 
10097
                ndr->depth++;
 
10098
                ndr_print_uint32(ndr, "total_size", *r->out.total_size);
 
10099
                ndr->depth--;
 
10100
                ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
 
10101
                ndr->depth++;
 
10102
                ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
 
10103
                ndr->depth--;
 
10104
                ndr_print_ptr(ndr, "info", r->out.info);
 
10105
                ndr->depth++;
 
10106
                ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
 
10107
                ndr_print_samr_DispInfo(ndr, "info", r->out.info);
 
10108
                ndr->depth--;
 
10109
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10110
                ndr->depth--;
 
10111
        }
 
10112
        ndr->depth--;
 
10113
}
 
10114
 
 
10115
static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex2(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
 
10116
{
 
10117
        if (flags & NDR_IN) {
 
10118
                if (r->in.domain_handle == NULL) {
 
10119
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10120
                }
 
10121
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10122
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
10123
                if (r->in.name == NULL) {
 
10124
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10125
                }
 
10126
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
10127
        }
 
10128
        if (flags & NDR_OUT) {
 
10129
                if (r->out.idx == NULL) {
 
10130
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10131
                }
 
10132
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
 
10133
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10134
        }
 
10135
        return NDR_ERR_SUCCESS;
 
10136
}
 
10137
 
 
10138
static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex2(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex2 *r)
 
10139
{
 
10140
        TALLOC_CTX *_mem_save_domain_handle_0;
 
10141
        TALLOC_CTX *_mem_save_name_0;
 
10142
        TALLOC_CTX *_mem_save_idx_0;
 
10143
        if (flags & NDR_IN) {
 
10144
                ZERO_STRUCT(r->out);
 
10145
 
 
10146
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10147
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
10148
                }
 
10149
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10150
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
10151
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10152
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10153
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
10154
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10155
                        NDR_PULL_ALLOC(ndr, r->in.name);
 
10156
                }
 
10157
                _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10158
                NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
 
10159
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
10160
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
 
10161
                NDR_PULL_ALLOC(ndr, r->out.idx);
 
10162
                ZERO_STRUCTP(r->out.idx);
 
10163
        }
 
10164
        if (flags & NDR_OUT) {
 
10165
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10166
                        NDR_PULL_ALLOC(ndr, r->out.idx);
 
10167
                }
 
10168
                _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10169
                NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
 
10170
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
 
10171
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
 
10172
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10173
        }
 
10174
        return NDR_ERR_SUCCESS;
 
10175
}
 
10176
 
 
10177
_PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex2(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
 
10178
{
 
10179
        ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex2");
 
10180
        ndr->depth++;
 
10181
        if (flags & NDR_SET_VALUES) {
 
10182
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10183
        }
 
10184
        if (flags & NDR_IN) {
 
10185
                ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex2");
 
10186
                ndr->depth++;
 
10187
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
10188
                ndr->depth++;
 
10189
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
10190
                ndr->depth--;
 
10191
                ndr_print_uint16(ndr, "level", r->in.level);
 
10192
                ndr_print_ptr(ndr, "name", r->in.name);
 
10193
                ndr->depth++;
 
10194
                ndr_print_lsa_String(ndr, "name", r->in.name);
 
10195
                ndr->depth--;
 
10196
                ndr->depth--;
 
10197
        }
 
10198
        if (flags & NDR_OUT) {
 
10199
                ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex2");
 
10200
                ndr->depth++;
 
10201
                ndr_print_ptr(ndr, "idx", r->out.idx);
 
10202
                ndr->depth++;
 
10203
                ndr_print_uint32(ndr, "idx", *r->out.idx);
 
10204
                ndr->depth--;
 
10205
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10206
                ndr->depth--;
 
10207
        }
 
10208
        ndr->depth--;
 
10209
}
 
10210
 
 
10211
static enum ndr_err_code ndr_push_samr_CreateUser2(struct ndr_push *ndr, int flags, const struct samr_CreateUser2 *r)
 
10212
{
 
10213
        if (flags & NDR_IN) {
 
10214
                if (r->in.domain_handle == NULL) {
 
10215
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10216
                }
 
10217
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10218
                if (r->in.account_name == NULL) {
 
10219
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10220
                }
 
10221
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
 
10222
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
 
10223
                NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
10224
        }
 
10225
        if (flags & NDR_OUT) {
 
10226
                if (r->out.user_handle == NULL) {
 
10227
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10228
                }
 
10229
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
10230
                if (r->out.access_granted == NULL) {
 
10231
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10232
                }
 
10233
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.access_granted));
 
10234
                if (r->out.rid == NULL) {
 
10235
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10236
                }
 
10237
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
 
10238
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10239
        }
 
10240
        return NDR_ERR_SUCCESS;
 
10241
}
 
10242
 
 
10243
static enum ndr_err_code ndr_pull_samr_CreateUser2(struct ndr_pull *ndr, int flags, struct samr_CreateUser2 *r)
 
10244
{
 
10245
        TALLOC_CTX *_mem_save_domain_handle_0;
 
10246
        TALLOC_CTX *_mem_save_account_name_0;
 
10247
        TALLOC_CTX *_mem_save_user_handle_0;
 
10248
        TALLOC_CTX *_mem_save_access_granted_0;
 
10249
        TALLOC_CTX *_mem_save_rid_0;
 
10250
        if (flags & NDR_IN) {
 
10251
                ZERO_STRUCT(r->out);
 
10252
 
 
10253
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10254
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
10255
                }
 
10256
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10257
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
10258
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10259
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10260
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10261
                        NDR_PULL_ALLOC(ndr, r->in.account_name);
 
10262
                }
 
10263
                _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10264
                NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
 
10265
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
 
10266
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
 
10267
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
 
10268
                NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
10269
                NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
10270
                ZERO_STRUCTP(r->out.user_handle);
 
10271
                NDR_PULL_ALLOC(ndr, r->out.access_granted);
 
10272
                ZERO_STRUCTP(r->out.access_granted);
 
10273
                NDR_PULL_ALLOC(ndr, r->out.rid);
 
10274
                ZERO_STRUCTP(r->out.rid);
 
10275
        }
 
10276
        if (flags & NDR_OUT) {
 
10277
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10278
                        NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
10279
                }
 
10280
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10281
                NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
10282
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
10283
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10284
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10285
                        NDR_PULL_ALLOC(ndr, r->out.access_granted);
 
10286
                }
 
10287
                _mem_save_access_granted_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10288
                NDR_PULL_SET_MEM_CTX(ndr, r->out.access_granted, LIBNDR_FLAG_REF_ALLOC);
 
10289
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.access_granted));
 
10290
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_access_granted_0, LIBNDR_FLAG_REF_ALLOC);
 
10291
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10292
                        NDR_PULL_ALLOC(ndr, r->out.rid);
 
10293
                }
 
10294
                _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10295
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
 
10296
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
 
10297
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
 
10298
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10299
        }
 
10300
        return NDR_ERR_SUCCESS;
 
10301
}
 
10302
 
 
10303
_PUBLIC_ void ndr_print_samr_CreateUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser2 *r)
 
10304
{
 
10305
        ndr_print_struct(ndr, name, "samr_CreateUser2");
 
10306
        ndr->depth++;
 
10307
        if (flags & NDR_SET_VALUES) {
 
10308
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10309
        }
 
10310
        if (flags & NDR_IN) {
 
10311
                ndr_print_struct(ndr, "in", "samr_CreateUser2");
 
10312
                ndr->depth++;
 
10313
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
10314
                ndr->depth++;
 
10315
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
10316
                ndr->depth--;
 
10317
                ndr_print_ptr(ndr, "account_name", r->in.account_name);
 
10318
                ndr->depth++;
 
10319
                ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
 
10320
                ndr->depth--;
 
10321
                ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
 
10322
                ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
 
10323
                ndr->depth--;
 
10324
        }
 
10325
        if (flags & NDR_OUT) {
 
10326
                ndr_print_struct(ndr, "out", "samr_CreateUser2");
 
10327
                ndr->depth++;
 
10328
                ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
 
10329
                ndr->depth++;
 
10330
                ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
 
10331
                ndr->depth--;
 
10332
                ndr_print_ptr(ndr, "access_granted", r->out.access_granted);
 
10333
                ndr->depth++;
 
10334
                ndr_print_uint32(ndr, "access_granted", *r->out.access_granted);
 
10335
                ndr->depth--;
 
10336
                ndr_print_ptr(ndr, "rid", r->out.rid);
 
10337
                ndr->depth++;
 
10338
                ndr_print_uint32(ndr, "rid", *r->out.rid);
 
10339
                ndr->depth--;
 
10340
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10341
                ndr->depth--;
 
10342
        }
 
10343
        ndr->depth--;
 
10344
}
 
10345
 
 
10346
static enum ndr_err_code ndr_push_samr_QueryDisplayInfo3(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo3 *r)
 
10347
{
 
10348
        if (flags & NDR_IN) {
 
10349
                if (r->in.domain_handle == NULL) {
 
10350
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10351
                }
 
10352
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10353
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
10354
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
 
10355
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
 
10356
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
 
10357
        }
 
10358
        if (flags & NDR_OUT) {
 
10359
                if (r->out.total_size == NULL) {
 
10360
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10361
                }
 
10362
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
 
10363
                if (r->out.returned_size == NULL) {
 
10364
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10365
                }
 
10366
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
 
10367
                if (r->out.info == NULL) {
 
10368
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10369
                }
 
10370
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
 
10371
                NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 
10372
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10373
        }
 
10374
        return NDR_ERR_SUCCESS;
 
10375
}
 
10376
 
 
10377
static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo3(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo3 *r)
 
10378
{
 
10379
        TALLOC_CTX *_mem_save_domain_handle_0;
 
10380
        TALLOC_CTX *_mem_save_total_size_0;
 
10381
        TALLOC_CTX *_mem_save_returned_size_0;
 
10382
        TALLOC_CTX *_mem_save_info_0;
 
10383
        if (flags & NDR_IN) {
 
10384
                ZERO_STRUCT(r->out);
 
10385
 
 
10386
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10387
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
10388
                }
 
10389
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10390
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
10391
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10392
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10393
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
10394
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
 
10395
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
 
10396
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
 
10397
                NDR_PULL_ALLOC(ndr, r->out.total_size);
 
10398
                ZERO_STRUCTP(r->out.total_size);
 
10399
                NDR_PULL_ALLOC(ndr, r->out.returned_size);
 
10400
                ZERO_STRUCTP(r->out.returned_size);
 
10401
                NDR_PULL_ALLOC(ndr, r->out.info);
 
10402
                ZERO_STRUCTP(r->out.info);
 
10403
        }
 
10404
        if (flags & NDR_OUT) {
 
10405
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10406
                        NDR_PULL_ALLOC(ndr, r->out.total_size);
 
10407
                }
 
10408
                _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10409
                NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
 
10410
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
 
10411
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
 
10412
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10413
                        NDR_PULL_ALLOC(ndr, r->out.returned_size);
 
10414
                }
 
10415
                _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10416
                NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
 
10417
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
 
10418
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
 
10419
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10420
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
10421
                }
 
10422
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10423
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
10424
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
 
10425
                NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 
10426
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
10427
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10428
        }
 
10429
        return NDR_ERR_SUCCESS;
 
10430
}
 
10431
 
 
10432
_PUBLIC_ void ndr_print_samr_QueryDisplayInfo3(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo3 *r)
 
10433
{
 
10434
        ndr_print_struct(ndr, name, "samr_QueryDisplayInfo3");
 
10435
        ndr->depth++;
 
10436
        if (flags & NDR_SET_VALUES) {
 
10437
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10438
        }
 
10439
        if (flags & NDR_IN) {
 
10440
                ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo3");
 
10441
                ndr->depth++;
 
10442
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
10443
                ndr->depth++;
 
10444
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
10445
                ndr->depth--;
 
10446
                ndr_print_uint16(ndr, "level", r->in.level);
 
10447
                ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
 
10448
                ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
 
10449
                ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
 
10450
                ndr->depth--;
 
10451
        }
 
10452
        if (flags & NDR_OUT) {
 
10453
                ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo3");
 
10454
                ndr->depth++;
 
10455
                ndr_print_ptr(ndr, "total_size", r->out.total_size);
 
10456
                ndr->depth++;
 
10457
                ndr_print_uint32(ndr, "total_size", *r->out.total_size);
 
10458
                ndr->depth--;
 
10459
                ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
 
10460
                ndr->depth++;
 
10461
                ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
 
10462
                ndr->depth--;
 
10463
                ndr_print_ptr(ndr, "info", r->out.info);
 
10464
                ndr->depth++;
 
10465
                ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
 
10466
                ndr_print_samr_DispInfo(ndr, "info", r->out.info);
 
10467
                ndr->depth--;
 
10468
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10469
                ndr->depth--;
 
10470
        }
 
10471
        ndr->depth--;
 
10472
}
 
10473
 
 
10474
static enum ndr_err_code ndr_push_samr_AddMultipleMembersToAlias(struct ndr_push *ndr, int flags, const struct samr_AddMultipleMembersToAlias *r)
 
10475
{
 
10476
        if (flags & NDR_IN) {
 
10477
                if (r->in.alias_handle == NULL) {
 
10478
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10479
                }
 
10480
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
10481
                if (r->in.sids == NULL) {
 
10482
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10483
                }
 
10484
                NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
 
10485
        }
 
10486
        if (flags & NDR_OUT) {
 
10487
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10488
        }
 
10489
        return NDR_ERR_SUCCESS;
 
10490
}
 
10491
 
 
10492
static enum ndr_err_code ndr_pull_samr_AddMultipleMembersToAlias(struct ndr_pull *ndr, int flags, struct samr_AddMultipleMembersToAlias *r)
 
10493
{
 
10494
        TALLOC_CTX *_mem_save_alias_handle_0;
 
10495
        TALLOC_CTX *_mem_save_sids_0;
 
10496
        if (flags & NDR_IN) {
 
10497
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10498
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
10499
                }
 
10500
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10501
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
10502
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
10503
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10504
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10505
                        NDR_PULL_ALLOC(ndr, r->in.sids);
 
10506
                }
 
10507
                _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10508
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
 
10509
                NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
 
10510
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
 
10511
        }
 
10512
        if (flags & NDR_OUT) {
 
10513
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10514
        }
 
10515
        return NDR_ERR_SUCCESS;
 
10516
}
 
10517
 
 
10518
_PUBLIC_ void ndr_print_samr_AddMultipleMembersToAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddMultipleMembersToAlias *r)
 
10519
{
 
10520
        ndr_print_struct(ndr, name, "samr_AddMultipleMembersToAlias");
 
10521
        ndr->depth++;
 
10522
        if (flags & NDR_SET_VALUES) {
 
10523
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10524
        }
 
10525
        if (flags & NDR_IN) {
 
10526
                ndr_print_struct(ndr, "in", "samr_AddMultipleMembersToAlias");
 
10527
                ndr->depth++;
 
10528
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
10529
                ndr->depth++;
 
10530
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
10531
                ndr->depth--;
 
10532
                ndr_print_ptr(ndr, "sids", r->in.sids);
 
10533
                ndr->depth++;
 
10534
                ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
 
10535
                ndr->depth--;
 
10536
                ndr->depth--;
 
10537
        }
 
10538
        if (flags & NDR_OUT) {
 
10539
                ndr_print_struct(ndr, "out", "samr_AddMultipleMembersToAlias");
 
10540
                ndr->depth++;
 
10541
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10542
                ndr->depth--;
 
10543
        }
 
10544
        ndr->depth--;
 
10545
}
 
10546
 
 
10547
static enum ndr_err_code ndr_push_samr_RemoveMultipleMembersFromAlias(struct ndr_push *ndr, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
 
10548
{
 
10549
        if (flags & NDR_IN) {
 
10550
                if (r->in.alias_handle == NULL) {
 
10551
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10552
                }
 
10553
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
10554
                if (r->in.sids == NULL) {
 
10555
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10556
                }
 
10557
                NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
 
10558
        }
 
10559
        if (flags & NDR_OUT) {
 
10560
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10561
        }
 
10562
        return NDR_ERR_SUCCESS;
 
10563
}
 
10564
 
 
10565
static enum ndr_err_code ndr_pull_samr_RemoveMultipleMembersFromAlias(struct ndr_pull *ndr, int flags, struct samr_RemoveMultipleMembersFromAlias *r)
 
10566
{
 
10567
        TALLOC_CTX *_mem_save_alias_handle_0;
 
10568
        TALLOC_CTX *_mem_save_sids_0;
 
10569
        if (flags & NDR_IN) {
 
10570
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10571
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
10572
                }
 
10573
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10574
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
10575
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
10576
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10577
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10578
                        NDR_PULL_ALLOC(ndr, r->in.sids);
 
10579
                }
 
10580
                _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10581
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
 
10582
                NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
 
10583
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
 
10584
        }
 
10585
        if (flags & NDR_OUT) {
 
10586
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10587
        }
 
10588
        return NDR_ERR_SUCCESS;
 
10589
}
 
10590
 
 
10591
_PUBLIC_ void ndr_print_samr_RemoveMultipleMembersFromAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
 
10592
{
 
10593
        ndr_print_struct(ndr, name, "samr_RemoveMultipleMembersFromAlias");
 
10594
        ndr->depth++;
 
10595
        if (flags & NDR_SET_VALUES) {
 
10596
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10597
        }
 
10598
        if (flags & NDR_IN) {
 
10599
                ndr_print_struct(ndr, "in", "samr_RemoveMultipleMembersFromAlias");
 
10600
                ndr->depth++;
 
10601
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
10602
                ndr->depth++;
 
10603
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
10604
                ndr->depth--;
 
10605
                ndr_print_ptr(ndr, "sids", r->in.sids);
 
10606
                ndr->depth++;
 
10607
                ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
 
10608
                ndr->depth--;
 
10609
                ndr->depth--;
 
10610
        }
 
10611
        if (flags & NDR_OUT) {
 
10612
                ndr_print_struct(ndr, "out", "samr_RemoveMultipleMembersFromAlias");
 
10613
                ndr->depth++;
 
10614
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10615
                ndr->depth--;
 
10616
        }
 
10617
        ndr->depth--;
 
10618
}
 
10619
 
 
10620
static enum ndr_err_code ndr_push_samr_OemChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_OemChangePasswordUser2 *r)
 
10621
{
 
10622
        if (flags & NDR_IN) {
 
10623
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
 
10624
                if (r->in.server) {
 
10625
                        NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
 
10626
                }
 
10627
                if (r->in.account == NULL) {
 
10628
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10629
                }
 
10630
                NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
 
10631
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
 
10632
                if (r->in.password) {
 
10633
                        NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
 
10634
                }
 
10635
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
 
10636
                if (r->in.hash) {
 
10637
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
 
10638
                }
 
10639
        }
 
10640
        if (flags & NDR_OUT) {
 
10641
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10642
        }
 
10643
        return NDR_ERR_SUCCESS;
 
10644
}
 
10645
 
 
10646
static enum ndr_err_code ndr_pull_samr_OemChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_OemChangePasswordUser2 *r)
 
10647
{
 
10648
        uint32_t _ptr_server;
 
10649
        uint32_t _ptr_password;
 
10650
        uint32_t _ptr_hash;
 
10651
        TALLOC_CTX *_mem_save_server_0;
 
10652
        TALLOC_CTX *_mem_save_account_0;
 
10653
        TALLOC_CTX *_mem_save_password_0;
 
10654
        TALLOC_CTX *_mem_save_hash_0;
 
10655
        if (flags & NDR_IN) {
 
10656
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
 
10657
                if (_ptr_server) {
 
10658
                        NDR_PULL_ALLOC(ndr, r->in.server);
 
10659
                } else {
 
10660
                        r->in.server = NULL;
 
10661
                }
 
10662
                if (r->in.server) {
 
10663
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10664
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
 
10665
                        NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
 
10666
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
 
10667
                }
 
10668
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10669
                        NDR_PULL_ALLOC(ndr, r->in.account);
 
10670
                }
 
10671
                _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10672
                NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
 
10673
                NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
 
10674
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
 
10675
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
 
10676
                if (_ptr_password) {
 
10677
                        NDR_PULL_ALLOC(ndr, r->in.password);
 
10678
                } else {
 
10679
                        r->in.password = NULL;
 
10680
                }
 
10681
                if (r->in.password) {
 
10682
                        _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10683
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
 
10684
                        NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
 
10685
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
 
10686
                }
 
10687
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
 
10688
                if (_ptr_hash) {
 
10689
                        NDR_PULL_ALLOC(ndr, r->in.hash);
 
10690
                } else {
 
10691
                        r->in.hash = NULL;
 
10692
                }
 
10693
                if (r->in.hash) {
 
10694
                        _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10695
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
 
10696
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
 
10697
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
 
10698
                }
 
10699
        }
 
10700
        if (flags & NDR_OUT) {
 
10701
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10702
        }
 
10703
        return NDR_ERR_SUCCESS;
 
10704
}
 
10705
 
 
10706
_PUBLIC_ void ndr_print_samr_OemChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_OemChangePasswordUser2 *r)
 
10707
{
 
10708
        ndr_print_struct(ndr, name, "samr_OemChangePasswordUser2");
 
10709
        ndr->depth++;
 
10710
        if (flags & NDR_SET_VALUES) {
 
10711
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10712
        }
 
10713
        if (flags & NDR_IN) {
 
10714
                ndr_print_struct(ndr, "in", "samr_OemChangePasswordUser2");
 
10715
                ndr->depth++;
 
10716
                ndr_print_ptr(ndr, "server", r->in.server);
 
10717
                ndr->depth++;
 
10718
                if (r->in.server) {
 
10719
                        ndr_print_lsa_AsciiString(ndr, "server", r->in.server);
 
10720
                }
 
10721
                ndr->depth--;
 
10722
                ndr_print_ptr(ndr, "account", r->in.account);
 
10723
                ndr->depth++;
 
10724
                ndr_print_lsa_AsciiString(ndr, "account", r->in.account);
 
10725
                ndr->depth--;
 
10726
                ndr_print_ptr(ndr, "password", r->in.password);
 
10727
                ndr->depth++;
 
10728
                if (r->in.password) {
 
10729
                        ndr_print_samr_CryptPassword(ndr, "password", r->in.password);
 
10730
                }
 
10731
                ndr->depth--;
 
10732
                ndr_print_ptr(ndr, "hash", r->in.hash);
 
10733
                ndr->depth++;
 
10734
                if (r->in.hash) {
 
10735
                        ndr_print_samr_Password(ndr, "hash", r->in.hash);
 
10736
                }
 
10737
                ndr->depth--;
 
10738
                ndr->depth--;
 
10739
        }
 
10740
        if (flags & NDR_OUT) {
 
10741
                ndr_print_struct(ndr, "out", "samr_OemChangePasswordUser2");
 
10742
                ndr->depth++;
 
10743
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10744
                ndr->depth--;
 
10745
        }
 
10746
        ndr->depth--;
 
10747
}
 
10748
 
 
10749
static enum ndr_err_code ndr_push_samr_ChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser2 *r)
 
10750
{
 
10751
        if (flags & NDR_IN) {
 
10752
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
 
10753
                if (r->in.server) {
 
10754
                        NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
 
10755
                }
 
10756
                if (r->in.account == NULL) {
 
10757
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10758
                }
 
10759
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
 
10760
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
 
10761
                if (r->in.nt_password) {
 
10762
                        NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
 
10763
                }
 
10764
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
 
10765
                if (r->in.nt_verifier) {
 
10766
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
 
10767
                }
 
10768
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
 
10769
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
 
10770
                if (r->in.lm_password) {
 
10771
                        NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
 
10772
                }
 
10773
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
 
10774
                if (r->in.lm_verifier) {
 
10775
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
 
10776
                }
 
10777
        }
 
10778
        if (flags & NDR_OUT) {
 
10779
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10780
        }
 
10781
        return NDR_ERR_SUCCESS;
 
10782
}
 
10783
 
 
10784
static enum ndr_err_code ndr_pull_samr_ChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser2 *r)
 
10785
{
 
10786
        uint32_t _ptr_server;
 
10787
        uint32_t _ptr_nt_password;
 
10788
        uint32_t _ptr_nt_verifier;
 
10789
        uint32_t _ptr_lm_password;
 
10790
        uint32_t _ptr_lm_verifier;
 
10791
        TALLOC_CTX *_mem_save_server_0;
 
10792
        TALLOC_CTX *_mem_save_account_0;
 
10793
        TALLOC_CTX *_mem_save_nt_password_0;
 
10794
        TALLOC_CTX *_mem_save_nt_verifier_0;
 
10795
        TALLOC_CTX *_mem_save_lm_password_0;
 
10796
        TALLOC_CTX *_mem_save_lm_verifier_0;
 
10797
        if (flags & NDR_IN) {
 
10798
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
 
10799
                if (_ptr_server) {
 
10800
                        NDR_PULL_ALLOC(ndr, r->in.server);
 
10801
                } else {
 
10802
                        r->in.server = NULL;
 
10803
                }
 
10804
                if (r->in.server) {
 
10805
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10806
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
 
10807
                        NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
 
10808
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
 
10809
                }
 
10810
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10811
                        NDR_PULL_ALLOC(ndr, r->in.account);
 
10812
                }
 
10813
                _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10814
                NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
 
10815
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
 
10816
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
 
10817
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
 
10818
                if (_ptr_nt_password) {
 
10819
                        NDR_PULL_ALLOC(ndr, r->in.nt_password);
 
10820
                } else {
 
10821
                        r->in.nt_password = NULL;
 
10822
                }
 
10823
                if (r->in.nt_password) {
 
10824
                        _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10825
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
 
10826
                        NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
 
10827
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
 
10828
                }
 
10829
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
 
10830
                if (_ptr_nt_verifier) {
 
10831
                        NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
 
10832
                } else {
 
10833
                        r->in.nt_verifier = NULL;
 
10834
                }
 
10835
                if (r->in.nt_verifier) {
 
10836
                        _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10837
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
 
10838
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
 
10839
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
 
10840
                }
 
10841
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
 
10842
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
 
10843
                if (_ptr_lm_password) {
 
10844
                        NDR_PULL_ALLOC(ndr, r->in.lm_password);
 
10845
                } else {
 
10846
                        r->in.lm_password = NULL;
 
10847
                }
 
10848
                if (r->in.lm_password) {
 
10849
                        _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10850
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
 
10851
                        NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
 
10852
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
 
10853
                }
 
10854
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
 
10855
                if (_ptr_lm_verifier) {
 
10856
                        NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
 
10857
                } else {
 
10858
                        r->in.lm_verifier = NULL;
 
10859
                }
 
10860
                if (r->in.lm_verifier) {
 
10861
                        _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10862
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
 
10863
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
 
10864
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
 
10865
                }
 
10866
        }
 
10867
        if (flags & NDR_OUT) {
 
10868
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10869
        }
 
10870
        return NDR_ERR_SUCCESS;
 
10871
}
 
10872
 
 
10873
_PUBLIC_ void ndr_print_samr_ChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser2 *r)
 
10874
{
 
10875
        ndr_print_struct(ndr, name, "samr_ChangePasswordUser2");
 
10876
        ndr->depth++;
 
10877
        if (flags & NDR_SET_VALUES) {
 
10878
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10879
        }
 
10880
        if (flags & NDR_IN) {
 
10881
                ndr_print_struct(ndr, "in", "samr_ChangePasswordUser2");
 
10882
                ndr->depth++;
 
10883
                ndr_print_ptr(ndr, "server", r->in.server);
 
10884
                ndr->depth++;
 
10885
                if (r->in.server) {
 
10886
                        ndr_print_lsa_String(ndr, "server", r->in.server);
 
10887
                }
 
10888
                ndr->depth--;
 
10889
                ndr_print_ptr(ndr, "account", r->in.account);
 
10890
                ndr->depth++;
 
10891
                ndr_print_lsa_String(ndr, "account", r->in.account);
 
10892
                ndr->depth--;
 
10893
                ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
 
10894
                ndr->depth++;
 
10895
                if (r->in.nt_password) {
 
10896
                        ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
 
10897
                }
 
10898
                ndr->depth--;
 
10899
                ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
 
10900
                ndr->depth++;
 
10901
                if (r->in.nt_verifier) {
 
10902
                        ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
 
10903
                }
 
10904
                ndr->depth--;
 
10905
                ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
 
10906
                ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
 
10907
                ndr->depth++;
 
10908
                if (r->in.lm_password) {
 
10909
                        ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
 
10910
                }
 
10911
                ndr->depth--;
 
10912
                ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
 
10913
                ndr->depth++;
 
10914
                if (r->in.lm_verifier) {
 
10915
                        ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
 
10916
                }
 
10917
                ndr->depth--;
 
10918
                ndr->depth--;
 
10919
        }
 
10920
        if (flags & NDR_OUT) {
 
10921
                ndr_print_struct(ndr, "out", "samr_ChangePasswordUser2");
 
10922
                ndr->depth++;
 
10923
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10924
                ndr->depth--;
 
10925
        }
 
10926
        ndr->depth--;
 
10927
}
 
10928
 
 
10929
static enum ndr_err_code ndr_push_samr_GetDomPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetDomPwInfo *r)
 
10930
{
 
10931
        if (flags & NDR_IN) {
 
10932
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.domain_name));
 
10933
                if (r->in.domain_name) {
 
10934
                        NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
 
10935
                }
 
10936
        }
 
10937
        if (flags & NDR_OUT) {
 
10938
                if (r->out.info == NULL) {
 
10939
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10940
                }
 
10941
                NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
 
10942
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10943
        }
 
10944
        return NDR_ERR_SUCCESS;
 
10945
}
 
10946
 
 
10947
static enum ndr_err_code ndr_pull_samr_GetDomPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetDomPwInfo *r)
 
10948
{
 
10949
        uint32_t _ptr_domain_name;
 
10950
        TALLOC_CTX *_mem_save_domain_name_0;
 
10951
        TALLOC_CTX *_mem_save_info_0;
 
10952
        if (flags & NDR_IN) {
 
10953
                ZERO_STRUCT(r->out);
 
10954
 
 
10955
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 
10956
                if (_ptr_domain_name) {
 
10957
                        NDR_PULL_ALLOC(ndr, r->in.domain_name);
 
10958
                } else {
 
10959
                        r->in.domain_name = NULL;
 
10960
                }
 
10961
                if (r->in.domain_name) {
 
10962
                        _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10963
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, 0);
 
10964
                        NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
 
10965
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 
10966
                }
 
10967
                NDR_PULL_ALLOC(ndr, r->out.info);
 
10968
                ZERO_STRUCTP(r->out.info);
 
10969
        }
 
10970
        if (flags & NDR_OUT) {
 
10971
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10972
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
10973
                }
 
10974
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10975
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
10976
                NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
 
10977
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
10978
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10979
        }
 
10980
        return NDR_ERR_SUCCESS;
 
10981
}
 
10982
 
 
10983
_PUBLIC_ void ndr_print_samr_GetDomPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDomPwInfo *r)
 
10984
{
 
10985
        ndr_print_struct(ndr, name, "samr_GetDomPwInfo");
 
10986
        ndr->depth++;
 
10987
        if (flags & NDR_SET_VALUES) {
 
10988
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10989
        }
 
10990
        if (flags & NDR_IN) {
 
10991
                ndr_print_struct(ndr, "in", "samr_GetDomPwInfo");
 
10992
                ndr->depth++;
 
10993
                ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
 
10994
                ndr->depth++;
 
10995
                if (r->in.domain_name) {
 
10996
                        ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
 
10997
                }
 
10998
                ndr->depth--;
 
10999
                ndr->depth--;
 
11000
        }
 
11001
        if (flags & NDR_OUT) {
 
11002
                ndr_print_struct(ndr, "out", "samr_GetDomPwInfo");
 
11003
                ndr->depth++;
 
11004
                ndr_print_ptr(ndr, "info", r->out.info);
 
11005
                ndr->depth++;
 
11006
                ndr_print_samr_PwInfo(ndr, "info", r->out.info);
 
11007
                ndr->depth--;
 
11008
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11009
                ndr->depth--;
 
11010
        }
 
11011
        ndr->depth--;
 
11012
}
 
11013
 
 
11014
static enum ndr_err_code ndr_push_samr_Connect2(struct ndr_push *ndr, int flags, const struct samr_Connect2 *r)
 
11015
{
 
11016
        if (flags & NDR_IN) {
 
11017
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 
11018
                if (r->in.system_name) {
 
11019
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
11020
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 
11021
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
11022
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.system_name, ndr_charset_length(r->in.system_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 
11023
                }
 
11024
                NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
11025
        }
 
11026
        if (flags & NDR_OUT) {
 
11027
                if (r->out.connect_handle == NULL) {
 
11028
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11029
                }
 
11030
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
11031
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11032
        }
 
11033
        return NDR_ERR_SUCCESS;
 
11034
}
 
11035
 
 
11036
static enum ndr_err_code ndr_pull_samr_Connect2(struct ndr_pull *ndr, int flags, struct samr_Connect2 *r)
 
11037
{
 
11038
        uint32_t _ptr_system_name;
 
11039
        TALLOC_CTX *_mem_save_system_name_0;
 
11040
        TALLOC_CTX *_mem_save_connect_handle_0;
 
11041
        if (flags & NDR_IN) {
 
11042
                ZERO_STRUCT(r->out);
 
11043
 
 
11044
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 
11045
                if (_ptr_system_name) {
 
11046
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
 
11047
                } else {
 
11048
                        r->in.system_name = NULL;
 
11049
                }
 
11050
                if (r->in.system_name) {
 
11051
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11052
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 
11053
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
 
11054
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
 
11055
                        if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
 
11056
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));
 
11057
                        }
 
11058
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
 
11059
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));
 
11060
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 
11061
                }
 
11062
                NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
11063
                NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
11064
                ZERO_STRUCTP(r->out.connect_handle);
 
11065
        }
 
11066
        if (flags & NDR_OUT) {
 
11067
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11068
                        NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
11069
                }
 
11070
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11071
                NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
11072
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
11073
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
11074
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11075
        }
 
11076
        return NDR_ERR_SUCCESS;
 
11077
}
 
11078
 
 
11079
_PUBLIC_ void ndr_print_samr_Connect2(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect2 *r)
 
11080
{
 
11081
        ndr_print_struct(ndr, name, "samr_Connect2");
 
11082
        ndr->depth++;
 
11083
        if (flags & NDR_SET_VALUES) {
 
11084
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11085
        }
 
11086
        if (flags & NDR_IN) {
 
11087
                ndr_print_struct(ndr, "in", "samr_Connect2");
 
11088
                ndr->depth++;
 
11089
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
 
11090
                ndr->depth++;
 
11091
                if (r->in.system_name) {
 
11092
                        ndr_print_string(ndr, "system_name", r->in.system_name);
 
11093
                }
 
11094
                ndr->depth--;
 
11095
                ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
 
11096
                ndr->depth--;
 
11097
        }
 
11098
        if (flags & NDR_OUT) {
 
11099
                ndr_print_struct(ndr, "out", "samr_Connect2");
 
11100
                ndr->depth++;
 
11101
                ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
 
11102
                ndr->depth++;
 
11103
                ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
 
11104
                ndr->depth--;
 
11105
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11106
                ndr->depth--;
 
11107
        }
 
11108
        ndr->depth--;
 
11109
}
 
11110
 
 
11111
_PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo2(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo2 *r)
 
11112
{
 
11113
        if (flags & NDR_IN) {
 
11114
                if (r->in.user_handle == NULL) {
 
11115
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11116
                }
 
11117
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
11118
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
11119
                if (r->in.info == NULL) {
 
11120
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11121
                }
 
11122
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
 
11123
                NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
11124
        }
 
11125
        if (flags & NDR_OUT) {
 
11126
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11127
        }
 
11128
        return NDR_ERR_SUCCESS;
 
11129
}
 
11130
 
 
11131
_PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo2(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo2 *r)
 
11132
{
 
11133
        TALLOC_CTX *_mem_save_user_handle_0;
 
11134
        TALLOC_CTX *_mem_save_info_0;
 
11135
        if (flags & NDR_IN) {
 
11136
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11137
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
11138
                }
 
11139
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11140
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
11141
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
11142
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
11143
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
11144
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11145
                        NDR_PULL_ALLOC(ndr, r->in.info);
 
11146
                }
 
11147
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11148
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
 
11149
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
 
11150
                NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
11151
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
11152
        }
 
11153
        if (flags & NDR_OUT) {
 
11154
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11155
        }
 
11156
        return NDR_ERR_SUCCESS;
 
11157
}
 
11158
 
 
11159
_PUBLIC_ void ndr_print_samr_SetUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo2 *r)
 
11160
{
 
11161
        ndr_print_struct(ndr, name, "samr_SetUserInfo2");
 
11162
        ndr->depth++;
 
11163
        if (flags & NDR_SET_VALUES) {
 
11164
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11165
        }
 
11166
        if (flags & NDR_IN) {
 
11167
                ndr_print_struct(ndr, "in", "samr_SetUserInfo2");
 
11168
                ndr->depth++;
 
11169
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
11170
                ndr->depth++;
 
11171
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
11172
                ndr->depth--;
 
11173
                ndr_print_uint16(ndr, "level", r->in.level);
 
11174
                ndr_print_ptr(ndr, "info", r->in.info);
 
11175
                ndr->depth++;
 
11176
                ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
 
11177
                ndr_print_samr_UserInfo(ndr, "info", r->in.info);
 
11178
                ndr->depth--;
 
11179
                ndr->depth--;
 
11180
        }
 
11181
        if (flags & NDR_OUT) {
 
11182
                ndr_print_struct(ndr, "out", "samr_SetUserInfo2");
 
11183
                ndr->depth++;
 
11184
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11185
                ndr->depth--;
 
11186
        }
 
11187
        ndr->depth--;
 
11188
}
 
11189
 
 
11190
static enum ndr_err_code ndr_push_samr_SetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_SetBootKeyInformation *r)
 
11191
{
 
11192
        if (flags & NDR_IN) {
 
11193
                if (r->in.connect_handle == NULL) {
 
11194
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11195
                }
 
11196
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
11197
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
 
11198
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
 
11199
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
 
11200
        }
 
11201
        if (flags & NDR_OUT) {
 
11202
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11203
        }
 
11204
        return NDR_ERR_SUCCESS;
 
11205
}
 
11206
 
 
11207
static enum ndr_err_code ndr_pull_samr_SetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_SetBootKeyInformation *r)
 
11208
{
 
11209
        TALLOC_CTX *_mem_save_connect_handle_0;
 
11210
        if (flags & NDR_IN) {
 
11211
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11212
                        NDR_PULL_ALLOC(ndr, r->in.connect_handle);
 
11213
                }
 
11214
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11215
                NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
11216
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
11217
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
11218
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
 
11219
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
 
11220
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
 
11221
        }
 
11222
        if (flags & NDR_OUT) {
 
11223
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11224
        }
 
11225
        return NDR_ERR_SUCCESS;
 
11226
}
 
11227
 
 
11228
_PUBLIC_ void ndr_print_samr_SetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetBootKeyInformation *r)
 
11229
{
 
11230
        ndr_print_struct(ndr, name, "samr_SetBootKeyInformation");
 
11231
        ndr->depth++;
 
11232
        if (flags & NDR_SET_VALUES) {
 
11233
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11234
        }
 
11235
        if (flags & NDR_IN) {
 
11236
                ndr_print_struct(ndr, "in", "samr_SetBootKeyInformation");
 
11237
                ndr->depth++;
 
11238
                ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
 
11239
                ndr->depth++;
 
11240
                ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
 
11241
                ndr->depth--;
 
11242
                ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
 
11243
                ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
 
11244
                ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
 
11245
                ndr->depth--;
 
11246
        }
 
11247
        if (flags & NDR_OUT) {
 
11248
                ndr_print_struct(ndr, "out", "samr_SetBootKeyInformation");
 
11249
                ndr->depth++;
 
11250
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11251
                ndr->depth--;
 
11252
        }
 
11253
        ndr->depth--;
 
11254
}
 
11255
 
 
11256
static enum ndr_err_code ndr_push_samr_GetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_GetBootKeyInformation *r)
 
11257
{
 
11258
        if (flags & NDR_IN) {
 
11259
                if (r->in.domain_handle == NULL) {
 
11260
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11261
                }
 
11262
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
11263
        }
 
11264
        if (flags & NDR_OUT) {
 
11265
                if (r->out.unknown == NULL) {
 
11266
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11267
                }
 
11268
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.unknown));
 
11269
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11270
        }
 
11271
        return NDR_ERR_SUCCESS;
 
11272
}
 
11273
 
 
11274
static enum ndr_err_code ndr_pull_samr_GetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_GetBootKeyInformation *r)
 
11275
{
 
11276
        TALLOC_CTX *_mem_save_domain_handle_0;
 
11277
        TALLOC_CTX *_mem_save_unknown_0;
 
11278
        if (flags & NDR_IN) {
 
11279
                ZERO_STRUCT(r->out);
 
11280
 
 
11281
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11282
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
11283
                }
 
11284
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11285
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
11286
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
11287
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
11288
                NDR_PULL_ALLOC(ndr, r->out.unknown);
 
11289
                ZERO_STRUCTP(r->out.unknown);
 
11290
        }
 
11291
        if (flags & NDR_OUT) {
 
11292
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11293
                        NDR_PULL_ALLOC(ndr, r->out.unknown);
 
11294
                }
 
11295
                _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11296
                NDR_PULL_SET_MEM_CTX(ndr, r->out.unknown, LIBNDR_FLAG_REF_ALLOC);
 
11297
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.unknown));
 
11298
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, LIBNDR_FLAG_REF_ALLOC);
 
11299
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11300
        }
 
11301
        return NDR_ERR_SUCCESS;
 
11302
}
 
11303
 
 
11304
_PUBLIC_ void ndr_print_samr_GetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetBootKeyInformation *r)
 
11305
{
 
11306
        ndr_print_struct(ndr, name, "samr_GetBootKeyInformation");
 
11307
        ndr->depth++;
 
11308
        if (flags & NDR_SET_VALUES) {
 
11309
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11310
        }
 
11311
        if (flags & NDR_IN) {
 
11312
                ndr_print_struct(ndr, "in", "samr_GetBootKeyInformation");
 
11313
                ndr->depth++;
 
11314
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
11315
                ndr->depth++;
 
11316
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
11317
                ndr->depth--;
 
11318
                ndr->depth--;
 
11319
        }
 
11320
        if (flags & NDR_OUT) {
 
11321
                ndr_print_struct(ndr, "out", "samr_GetBootKeyInformation");
 
11322
                ndr->depth++;
 
11323
                ndr_print_ptr(ndr, "unknown", r->out.unknown);
 
11324
                ndr->depth++;
 
11325
                ndr_print_uint32(ndr, "unknown", *r->out.unknown);
 
11326
                ndr->depth--;
 
11327
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11328
                ndr->depth--;
 
11329
        }
 
11330
        ndr->depth--;
 
11331
}
 
11332
 
 
11333
static enum ndr_err_code ndr_push_samr_Connect3(struct ndr_push *ndr, int flags, const struct samr_Connect3 *r)
 
11334
{
 
11335
        if (flags & NDR_IN) {
 
11336
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 
11337
                if (r->in.system_name) {
 
11338
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
11339
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 
11340
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
11341
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.system_name, ndr_charset_length(r->in.system_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 
11342
                }
 
11343
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
 
11344
                NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
11345
        }
 
11346
        if (flags & NDR_OUT) {
 
11347
                if (r->out.connect_handle == NULL) {
 
11348
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11349
                }
 
11350
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
11351
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11352
        }
 
11353
        return NDR_ERR_SUCCESS;
 
11354
}
 
11355
 
 
11356
static enum ndr_err_code ndr_pull_samr_Connect3(struct ndr_pull *ndr, int flags, struct samr_Connect3 *r)
 
11357
{
 
11358
        uint32_t _ptr_system_name;
 
11359
        TALLOC_CTX *_mem_save_system_name_0;
 
11360
        TALLOC_CTX *_mem_save_connect_handle_0;
 
11361
        if (flags & NDR_IN) {
 
11362
                ZERO_STRUCT(r->out);
 
11363
 
 
11364
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 
11365
                if (_ptr_system_name) {
 
11366
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
 
11367
                } else {
 
11368
                        r->in.system_name = NULL;
 
11369
                }
 
11370
                if (r->in.system_name) {
 
11371
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11372
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 
11373
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
 
11374
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
 
11375
                        if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
 
11376
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));
 
11377
                        }
 
11378
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
 
11379
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));
 
11380
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 
11381
                }
 
11382
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
 
11383
                NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
11384
                NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
11385
                ZERO_STRUCTP(r->out.connect_handle);
 
11386
        }
 
11387
        if (flags & NDR_OUT) {
 
11388
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11389
                        NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
11390
                }
 
11391
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11392
                NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
11393
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
11394
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
11395
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11396
        }
 
11397
        return NDR_ERR_SUCCESS;
 
11398
}
 
11399
 
 
11400
_PUBLIC_ void ndr_print_samr_Connect3(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect3 *r)
 
11401
{
 
11402
        ndr_print_struct(ndr, name, "samr_Connect3");
 
11403
        ndr->depth++;
 
11404
        if (flags & NDR_SET_VALUES) {
 
11405
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11406
        }
 
11407
        if (flags & NDR_IN) {
 
11408
                ndr_print_struct(ndr, "in", "samr_Connect3");
 
11409
                ndr->depth++;
 
11410
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
 
11411
                ndr->depth++;
 
11412
                if (r->in.system_name) {
 
11413
                        ndr_print_string(ndr, "system_name", r->in.system_name);
 
11414
                }
 
11415
                ndr->depth--;
 
11416
                ndr_print_uint32(ndr, "unknown", r->in.unknown);
 
11417
                ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
 
11418
                ndr->depth--;
 
11419
        }
 
11420
        if (flags & NDR_OUT) {
 
11421
                ndr_print_struct(ndr, "out", "samr_Connect3");
 
11422
                ndr->depth++;
 
11423
                ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
 
11424
                ndr->depth++;
 
11425
                ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
 
11426
                ndr->depth--;
 
11427
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11428
                ndr->depth--;
 
11429
        }
 
11430
        ndr->depth--;
 
11431
}
 
11432
 
 
11433
static enum ndr_err_code ndr_push_samr_Connect4(struct ndr_push *ndr, int flags, const struct samr_Connect4 *r)
 
11434
{
 
11435
        if (flags & NDR_IN) {
 
11436
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 
11437
                if (r->in.system_name) {
 
11438
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
11439
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 
11440
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
11441
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.system_name, ndr_charset_length(r->in.system_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 
11442
                }
 
11443
                NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->in.client_version));
 
11444
                NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
11445
        }
 
11446
        if (flags & NDR_OUT) {
 
11447
                if (r->out.connect_handle == NULL) {
 
11448
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11449
                }
 
11450
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
11451
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11452
        }
 
11453
        return NDR_ERR_SUCCESS;
 
11454
}
 
11455
 
 
11456
static enum ndr_err_code ndr_pull_samr_Connect4(struct ndr_pull *ndr, int flags, struct samr_Connect4 *r)
 
11457
{
 
11458
        uint32_t _ptr_system_name;
 
11459
        TALLOC_CTX *_mem_save_system_name_0;
 
11460
        TALLOC_CTX *_mem_save_connect_handle_0;
 
11461
        if (flags & NDR_IN) {
 
11462
                ZERO_STRUCT(r->out);
 
11463
 
 
11464
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 
11465
                if (_ptr_system_name) {
 
11466
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
 
11467
                } else {
 
11468
                        r->in.system_name = NULL;
 
11469
                }
 
11470
                if (r->in.system_name) {
 
11471
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11472
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 
11473
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
 
11474
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
 
11475
                        if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
 
11476
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));
 
11477
                        }
 
11478
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
 
11479
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));
 
11480
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 
11481
                }
 
11482
                NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->in.client_version));
 
11483
                NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
11484
                NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
11485
                ZERO_STRUCTP(r->out.connect_handle);
 
11486
        }
 
11487
        if (flags & NDR_OUT) {
 
11488
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11489
                        NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
11490
                }
 
11491
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11492
                NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
11493
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
11494
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
11495
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11496
        }
 
11497
        return NDR_ERR_SUCCESS;
 
11498
}
 
11499
 
 
11500
_PUBLIC_ void ndr_print_samr_Connect4(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect4 *r)
 
11501
{
 
11502
        ndr_print_struct(ndr, name, "samr_Connect4");
 
11503
        ndr->depth++;
 
11504
        if (flags & NDR_SET_VALUES) {
 
11505
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11506
        }
 
11507
        if (flags & NDR_IN) {
 
11508
                ndr_print_struct(ndr, "in", "samr_Connect4");
 
11509
                ndr->depth++;
 
11510
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
 
11511
                ndr->depth++;
 
11512
                if (r->in.system_name) {
 
11513
                        ndr_print_string(ndr, "system_name", r->in.system_name);
 
11514
                }
 
11515
                ndr->depth--;
 
11516
                ndr_print_samr_ConnectVersion(ndr, "client_version", r->in.client_version);
 
11517
                ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
 
11518
                ndr->depth--;
 
11519
        }
 
11520
        if (flags & NDR_OUT) {
 
11521
                ndr_print_struct(ndr, "out", "samr_Connect4");
 
11522
                ndr->depth++;
 
11523
                ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
 
11524
                ndr->depth++;
 
11525
                ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
 
11526
                ndr->depth--;
 
11527
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11528
                ndr->depth--;
 
11529
        }
 
11530
        ndr->depth--;
 
11531
}
 
11532
 
 
11533
static enum ndr_err_code ndr_push_samr_ChangePasswordUser3(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser3 *r)
 
11534
{
 
11535
        if (flags & NDR_IN) {
 
11536
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
 
11537
                if (r->in.server) {
 
11538
                        NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
 
11539
                }
 
11540
                if (r->in.account == NULL) {
 
11541
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11542
                }
 
11543
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
 
11544
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
 
11545
                if (r->in.nt_password) {
 
11546
                        NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
 
11547
                }
 
11548
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
 
11549
                if (r->in.nt_verifier) {
 
11550
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
 
11551
                }
 
11552
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
 
11553
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
 
11554
                if (r->in.lm_password) {
 
11555
                        NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
 
11556
                }
 
11557
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
 
11558
                if (r->in.lm_verifier) {
 
11559
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
 
11560
                }
 
11561
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password3));
 
11562
                if (r->in.password3) {
 
11563
                        NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
 
11564
                }
 
11565
        }
 
11566
        if (flags & NDR_OUT) {
 
11567
                if (r->out.dominfo == NULL) {
 
11568
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11569
                }
 
11570
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.dominfo));
 
11571
                if (*r->out.dominfo) {
 
11572
                        NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
 
11573
                }
 
11574
                if (r->out.reject == NULL) {
 
11575
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11576
                }
 
11577
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.reject));
 
11578
                if (*r->out.reject) {
 
11579
                        NDR_CHECK(ndr_push_samr_ChangeReject(ndr, NDR_SCALARS, *r->out.reject));
 
11580
                }
 
11581
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11582
        }
 
11583
        return NDR_ERR_SUCCESS;
 
11584
}
 
11585
 
 
11586
static enum ndr_err_code ndr_pull_samr_ChangePasswordUser3(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser3 *r)
 
11587
{
 
11588
        uint32_t _ptr_server;
 
11589
        uint32_t _ptr_nt_password;
 
11590
        uint32_t _ptr_nt_verifier;
 
11591
        uint32_t _ptr_lm_password;
 
11592
        uint32_t _ptr_lm_verifier;
 
11593
        uint32_t _ptr_password3;
 
11594
        uint32_t _ptr_dominfo;
 
11595
        uint32_t _ptr_reject;
 
11596
        TALLOC_CTX *_mem_save_server_0;
 
11597
        TALLOC_CTX *_mem_save_account_0;
 
11598
        TALLOC_CTX *_mem_save_nt_password_0;
 
11599
        TALLOC_CTX *_mem_save_nt_verifier_0;
 
11600
        TALLOC_CTX *_mem_save_lm_password_0;
 
11601
        TALLOC_CTX *_mem_save_lm_verifier_0;
 
11602
        TALLOC_CTX *_mem_save_password3_0;
 
11603
        TALLOC_CTX *_mem_save_dominfo_0;
 
11604
        TALLOC_CTX *_mem_save_dominfo_1;
 
11605
        TALLOC_CTX *_mem_save_reject_0;
 
11606
        TALLOC_CTX *_mem_save_reject_1;
 
11607
        if (flags & NDR_IN) {
 
11608
                ZERO_STRUCT(r->out);
 
11609
 
 
11610
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
 
11611
                if (_ptr_server) {
 
11612
                        NDR_PULL_ALLOC(ndr, r->in.server);
 
11613
                } else {
 
11614
                        r->in.server = NULL;
 
11615
                }
 
11616
                if (r->in.server) {
 
11617
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11618
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
 
11619
                        NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
 
11620
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
 
11621
                }
 
11622
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11623
                        NDR_PULL_ALLOC(ndr, r->in.account);
 
11624
                }
 
11625
                _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11626
                NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
 
11627
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
 
11628
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
 
11629
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
 
11630
                if (_ptr_nt_password) {
 
11631
                        NDR_PULL_ALLOC(ndr, r->in.nt_password);
 
11632
                } else {
 
11633
                        r->in.nt_password = NULL;
 
11634
                }
 
11635
                if (r->in.nt_password) {
 
11636
                        _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11637
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
 
11638
                        NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
 
11639
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
 
11640
                }
 
11641
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
 
11642
                if (_ptr_nt_verifier) {
 
11643
                        NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
 
11644
                } else {
 
11645
                        r->in.nt_verifier = NULL;
 
11646
                }
 
11647
                if (r->in.nt_verifier) {
 
11648
                        _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11649
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
 
11650
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
 
11651
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
 
11652
                }
 
11653
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
 
11654
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
 
11655
                if (_ptr_lm_password) {
 
11656
                        NDR_PULL_ALLOC(ndr, r->in.lm_password);
 
11657
                } else {
 
11658
                        r->in.lm_password = NULL;
 
11659
                }
 
11660
                if (r->in.lm_password) {
 
11661
                        _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11662
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
 
11663
                        NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
 
11664
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
 
11665
                }
 
11666
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
 
11667
                if (_ptr_lm_verifier) {
 
11668
                        NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
 
11669
                } else {
 
11670
                        r->in.lm_verifier = NULL;
 
11671
                }
 
11672
                if (r->in.lm_verifier) {
 
11673
                        _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11674
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
 
11675
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
 
11676
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
 
11677
                }
 
11678
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password3));
 
11679
                if (_ptr_password3) {
 
11680
                        NDR_PULL_ALLOC(ndr, r->in.password3);
 
11681
                } else {
 
11682
                        r->in.password3 = NULL;
 
11683
                }
 
11684
                if (r->in.password3) {
 
11685
                        _mem_save_password3_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11686
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.password3, 0);
 
11687
                        NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
 
11688
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password3_0, 0);
 
11689
                }
 
11690
                NDR_PULL_ALLOC(ndr, r->out.dominfo);
 
11691
                ZERO_STRUCTP(r->out.dominfo);
 
11692
                NDR_PULL_ALLOC(ndr, r->out.reject);
 
11693
                ZERO_STRUCTP(r->out.reject);
 
11694
        }
 
11695
        if (flags & NDR_OUT) {
 
11696
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11697
                        NDR_PULL_ALLOC(ndr, r->out.dominfo);
 
11698
                }
 
11699
                _mem_save_dominfo_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11700
                NDR_PULL_SET_MEM_CTX(ndr, r->out.dominfo, LIBNDR_FLAG_REF_ALLOC);
 
11701
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dominfo));
 
11702
                if (_ptr_dominfo) {
 
11703
                        NDR_PULL_ALLOC(ndr, *r->out.dominfo);
 
11704
                } else {
 
11705
                        *r->out.dominfo = NULL;
 
11706
                }
 
11707
                if (*r->out.dominfo) {
 
11708
                        _mem_save_dominfo_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
11709
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.dominfo, 0);
 
11710
                        NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
 
11711
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_1, 0);
 
11712
                }
 
11713
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_0, LIBNDR_FLAG_REF_ALLOC);
 
11714
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11715
                        NDR_PULL_ALLOC(ndr, r->out.reject);
 
11716
                }
 
11717
                _mem_save_reject_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11718
                NDR_PULL_SET_MEM_CTX(ndr, r->out.reject, LIBNDR_FLAG_REF_ALLOC);
 
11719
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_reject));
 
11720
                if (_ptr_reject) {
 
11721
                        NDR_PULL_ALLOC(ndr, *r->out.reject);
 
11722
                } else {
 
11723
                        *r->out.reject = NULL;
 
11724
                }
 
11725
                if (*r->out.reject) {
 
11726
                        _mem_save_reject_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
11727
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.reject, 0);
 
11728
                        NDR_CHECK(ndr_pull_samr_ChangeReject(ndr, NDR_SCALARS, *r->out.reject));
 
11729
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_1, 0);
 
11730
                }
 
11731
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_0, LIBNDR_FLAG_REF_ALLOC);
 
11732
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11733
        }
 
11734
        return NDR_ERR_SUCCESS;
 
11735
}
 
11736
 
 
11737
_PUBLIC_ void ndr_print_samr_ChangePasswordUser3(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser3 *r)
 
11738
{
 
11739
        ndr_print_struct(ndr, name, "samr_ChangePasswordUser3");
 
11740
        ndr->depth++;
 
11741
        if (flags & NDR_SET_VALUES) {
 
11742
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11743
        }
 
11744
        if (flags & NDR_IN) {
 
11745
                ndr_print_struct(ndr, "in", "samr_ChangePasswordUser3");
 
11746
                ndr->depth++;
 
11747
                ndr_print_ptr(ndr, "server", r->in.server);
 
11748
                ndr->depth++;
 
11749
                if (r->in.server) {
 
11750
                        ndr_print_lsa_String(ndr, "server", r->in.server);
 
11751
                }
 
11752
                ndr->depth--;
 
11753
                ndr_print_ptr(ndr, "account", r->in.account);
 
11754
                ndr->depth++;
 
11755
                ndr_print_lsa_String(ndr, "account", r->in.account);
 
11756
                ndr->depth--;
 
11757
                ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
 
11758
                ndr->depth++;
 
11759
                if (r->in.nt_password) {
 
11760
                        ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
 
11761
                }
 
11762
                ndr->depth--;
 
11763
                ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
 
11764
                ndr->depth++;
 
11765
                if (r->in.nt_verifier) {
 
11766
                        ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
 
11767
                }
 
11768
                ndr->depth--;
 
11769
                ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
 
11770
                ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
 
11771
                ndr->depth++;
 
11772
                if (r->in.lm_password) {
 
11773
                        ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
 
11774
                }
 
11775
                ndr->depth--;
 
11776
                ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
 
11777
                ndr->depth++;
 
11778
                if (r->in.lm_verifier) {
 
11779
                        ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
 
11780
                }
 
11781
                ndr->depth--;
 
11782
                ndr_print_ptr(ndr, "password3", r->in.password3);
 
11783
                ndr->depth++;
 
11784
                if (r->in.password3) {
 
11785
                        ndr_print_samr_CryptPassword(ndr, "password3", r->in.password3);
 
11786
                }
 
11787
                ndr->depth--;
 
11788
                ndr->depth--;
 
11789
        }
 
11790
        if (flags & NDR_OUT) {
 
11791
                ndr_print_struct(ndr, "out", "samr_ChangePasswordUser3");
 
11792
                ndr->depth++;
 
11793
                ndr_print_ptr(ndr, "dominfo", r->out.dominfo);
 
11794
                ndr->depth++;
 
11795
                ndr_print_ptr(ndr, "dominfo", *r->out.dominfo);
 
11796
                ndr->depth++;
 
11797
                if (*r->out.dominfo) {
 
11798
                        ndr_print_samr_DomInfo1(ndr, "dominfo", *r->out.dominfo);
 
11799
                }
 
11800
                ndr->depth--;
 
11801
                ndr->depth--;
 
11802
                ndr_print_ptr(ndr, "reject", r->out.reject);
 
11803
                ndr->depth++;
 
11804
                ndr_print_ptr(ndr, "reject", *r->out.reject);
 
11805
                ndr->depth++;
 
11806
                if (*r->out.reject) {
 
11807
                        ndr_print_samr_ChangeReject(ndr, "reject", *r->out.reject);
 
11808
                }
 
11809
                ndr->depth--;
 
11810
                ndr->depth--;
 
11811
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11812
                ndr->depth--;
 
11813
        }
 
11814
        ndr->depth--;
 
11815
}
 
11816
 
 
11817
_PUBLIC_ enum ndr_err_code ndr_push_samr_Connect5(struct ndr_push *ndr, int flags, const struct samr_Connect5 *r)
 
11818
{
 
11819
        if (flags & NDR_IN) {
 
11820
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 
11821
                if (r->in.system_name) {
 
11822
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
11823
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 
11824
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
11825
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.system_name, ndr_charset_length(r->in.system_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 
11826
                }
 
11827
                NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
11828
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level_in));
 
11829
                if (r->in.info_in == NULL) {
 
11830
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11831
                }
 
11832
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info_in, r->in.level_in));
 
11833
                NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
 
11834
        }
 
11835
        if (flags & NDR_OUT) {
 
11836
                if (r->out.level_out == NULL) {
 
11837
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11838
                }
 
11839
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
 
11840
                if (r->out.info_out == NULL) {
 
11841
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11842
                }
 
11843
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
 
11844
                NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
 
11845
                if (r->out.connect_handle == NULL) {
 
11846
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11847
                }
 
11848
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
11849
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11850
        }
 
11851
        return NDR_ERR_SUCCESS;
 
11852
}
 
11853
 
 
11854
_PUBLIC_ enum ndr_err_code ndr_pull_samr_Connect5(struct ndr_pull *ndr, int flags, struct samr_Connect5 *r)
 
11855
{
 
11856
        uint32_t _ptr_system_name;
 
11857
        TALLOC_CTX *_mem_save_system_name_0;
 
11858
        TALLOC_CTX *_mem_save_info_in_0;
 
11859
        TALLOC_CTX *_mem_save_level_out_0;
 
11860
        TALLOC_CTX *_mem_save_info_out_0;
 
11861
        TALLOC_CTX *_mem_save_connect_handle_0;
 
11862
        if (flags & NDR_IN) {
 
11863
                ZERO_STRUCT(r->out);
 
11864
 
 
11865
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 
11866
                if (_ptr_system_name) {
 
11867
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
 
11868
                } else {
 
11869
                        r->in.system_name = NULL;
 
11870
                }
 
11871
                if (r->in.system_name) {
 
11872
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11873
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 
11874
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
 
11875
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
 
11876
                        if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
 
11877
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));
 
11878
                        }
 
11879
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
 
11880
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));
 
11881
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 
11882
                }
 
11883
                NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
11884
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level_in));
 
11885
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11886
                        NDR_PULL_ALLOC(ndr, r->in.info_in);
 
11887
                }
 
11888
                _mem_save_info_in_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11889
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info_in, LIBNDR_FLAG_REF_ALLOC);
 
11890
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info_in, r->in.level_in));
 
11891
                NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
 
11892
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_in_0, LIBNDR_FLAG_REF_ALLOC);
 
11893
                NDR_PULL_ALLOC(ndr, r->out.level_out);
 
11894
                ZERO_STRUCTP(r->out.level_out);
 
11895
                NDR_PULL_ALLOC(ndr, r->out.info_out);
 
11896
                ZERO_STRUCTP(r->out.info_out);
 
11897
                NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
11898
                ZERO_STRUCTP(r->out.connect_handle);
 
11899
        }
 
11900
        if (flags & NDR_OUT) {
 
11901
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11902
                        NDR_PULL_ALLOC(ndr, r->out.level_out);
 
11903
                }
 
11904
                _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11905
                NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
 
11906
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
 
11907
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
 
11908
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11909
                        NDR_PULL_ALLOC(ndr, r->out.info_out);
 
11910
                }
 
11911
                _mem_save_info_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11912
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info_out, LIBNDR_FLAG_REF_ALLOC);
 
11913
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
 
11914
                NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
 
11915
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_out_0, LIBNDR_FLAG_REF_ALLOC);
 
11916
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11917
                        NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
11918
                }
 
11919
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11920
                NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
11921
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
11922
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
11923
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11924
        }
 
11925
        return NDR_ERR_SUCCESS;
 
11926
}
 
11927
 
 
11928
_PUBLIC_ void ndr_print_samr_Connect5(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect5 *r)
 
11929
{
 
11930
        ndr_print_struct(ndr, name, "samr_Connect5");
 
11931
        ndr->depth++;
 
11932
        if (flags & NDR_SET_VALUES) {
 
11933
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11934
        }
 
11935
        if (flags & NDR_IN) {
 
11936
                ndr_print_struct(ndr, "in", "samr_Connect5");
 
11937
                ndr->depth++;
 
11938
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
 
11939
                ndr->depth++;
 
11940
                if (r->in.system_name) {
 
11941
                        ndr_print_string(ndr, "system_name", r->in.system_name);
 
11942
                }
 
11943
                ndr->depth--;
 
11944
                ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
 
11945
                ndr_print_uint32(ndr, "level_in", r->in.level_in);
 
11946
                ndr_print_ptr(ndr, "info_in", r->in.info_in);
 
11947
                ndr->depth++;
 
11948
                ndr_print_set_switch_value(ndr, r->in.info_in, r->in.level_in);
 
11949
                ndr_print_samr_ConnectInfo(ndr, "info_in", r->in.info_in);
 
11950
                ndr->depth--;
 
11951
                ndr->depth--;
 
11952
        }
 
11953
        if (flags & NDR_OUT) {
 
11954
                ndr_print_struct(ndr, "out", "samr_Connect5");
 
11955
                ndr->depth++;
 
11956
                ndr_print_ptr(ndr, "level_out", r->out.level_out);
 
11957
                ndr->depth++;
 
11958
                ndr_print_uint32(ndr, "level_out", *r->out.level_out);
 
11959
                ndr->depth--;
 
11960
                ndr_print_ptr(ndr, "info_out", r->out.info_out);
 
11961
                ndr->depth++;
 
11962
                ndr_print_set_switch_value(ndr, r->out.info_out, *r->out.level_out);
 
11963
                ndr_print_samr_ConnectInfo(ndr, "info_out", r->out.info_out);
 
11964
                ndr->depth--;
 
11965
                ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
 
11966
                ndr->depth++;
 
11967
                ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
 
11968
                ndr->depth--;
 
11969
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11970
                ndr->depth--;
 
11971
        }
 
11972
        ndr->depth--;
 
11973
}
 
11974
 
 
11975
static enum ndr_err_code ndr_push_samr_RidToSid(struct ndr_push *ndr, int flags, const struct samr_RidToSid *r)
 
11976
{
 
11977
        if (flags & NDR_IN) {
 
11978
                if (r->in.domain_handle == NULL) {
 
11979
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11980
                }
 
11981
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
11982
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
 
11983
        }
 
11984
        if (flags & NDR_OUT) {
 
11985
                if (r->out.sid == NULL) {
 
11986
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11987
                }
 
11988
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
 
11989
                if (*r->out.sid) {
 
11990
                        NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
 
11991
                }
 
11992
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11993
        }
 
11994
        return NDR_ERR_SUCCESS;
 
11995
}
 
11996
 
 
11997
static enum ndr_err_code ndr_pull_samr_RidToSid(struct ndr_pull *ndr, int flags, struct samr_RidToSid *r)
 
11998
{
 
11999
        uint32_t _ptr_sid;
 
12000
        TALLOC_CTX *_mem_save_domain_handle_0;
 
12001
        TALLOC_CTX *_mem_save_sid_0;
 
12002
        TALLOC_CTX *_mem_save_sid_1;
 
12003
        if (flags & NDR_IN) {
 
12004
                ZERO_STRUCT(r->out);
 
12005
 
 
12006
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
12007
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
12008
                }
 
12009
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12010
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
12011
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
12012
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
12013
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
 
12014
                NDR_PULL_ALLOC(ndr, r->out.sid);
 
12015
                ZERO_STRUCTP(r->out.sid);
 
12016
        }
 
12017
        if (flags & NDR_OUT) {
 
12018
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
12019
                        NDR_PULL_ALLOC(ndr, r->out.sid);
 
12020
                }
 
12021
                _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12022
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
 
12023
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
 
12024
                if (_ptr_sid) {
 
12025
                        NDR_PULL_ALLOC(ndr, *r->out.sid);
 
12026
                } else {
 
12027
                        *r->out.sid = NULL;
 
12028
                }
 
12029
                if (*r->out.sid) {
 
12030
                        _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
12031
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
 
12032
                        NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
 
12033
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
 
12034
                }
 
12035
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 
12036
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
12037
        }
 
12038
        return NDR_ERR_SUCCESS;
 
12039
}
 
12040
 
 
12041
_PUBLIC_ void ndr_print_samr_RidToSid(struct ndr_print *ndr, const char *name, int flags, const struct samr_RidToSid *r)
 
12042
{
 
12043
        ndr_print_struct(ndr, name, "samr_RidToSid");
 
12044
        ndr->depth++;
 
12045
        if (flags & NDR_SET_VALUES) {
 
12046
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
12047
        }
 
12048
        if (flags & NDR_IN) {
 
12049
                ndr_print_struct(ndr, "in", "samr_RidToSid");
 
12050
                ndr->depth++;
 
12051
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
12052
                ndr->depth++;
 
12053
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
12054
                ndr->depth--;
 
12055
                ndr_print_uint32(ndr, "rid", r->in.rid);
 
12056
                ndr->depth--;
 
12057
        }
 
12058
        if (flags & NDR_OUT) {
 
12059
                ndr_print_struct(ndr, "out", "samr_RidToSid");
 
12060
                ndr->depth++;
 
12061
                ndr_print_ptr(ndr, "sid", r->out.sid);
 
12062
                ndr->depth++;
 
12063
                ndr_print_ptr(ndr, "sid", *r->out.sid);
 
12064
                ndr->depth++;
 
12065
                if (*r->out.sid) {
 
12066
                        ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
 
12067
                }
 
12068
                ndr->depth--;
 
12069
                ndr->depth--;
 
12070
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
12071
                ndr->depth--;
 
12072
        }
 
12073
        ndr->depth--;
 
12074
}
 
12075
 
 
12076
static enum ndr_err_code ndr_push_samr_SetDsrmPassword(struct ndr_push *ndr, int flags, const struct samr_SetDsrmPassword *r)
 
12077
{
 
12078
        if (flags & NDR_IN) {
 
12079
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.name));
 
12080
                if (r->in.name) {
 
12081
                        NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
12082
                }
 
12083
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
 
12084
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
 
12085
                if (r->in.hash) {
 
12086
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
 
12087
                }
 
12088
        }
 
12089
        if (flags & NDR_OUT) {
 
12090
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
12091
        }
 
12092
        return NDR_ERR_SUCCESS;
 
12093
}
 
12094
 
 
12095
static enum ndr_err_code ndr_pull_samr_SetDsrmPassword(struct ndr_pull *ndr, int flags, struct samr_SetDsrmPassword *r)
 
12096
{
 
12097
        uint32_t _ptr_name;
 
12098
        uint32_t _ptr_hash;
 
12099
        TALLOC_CTX *_mem_save_name_0;
 
12100
        TALLOC_CTX *_mem_save_hash_0;
 
12101
        if (flags & NDR_IN) {
 
12102
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 
12103
                if (_ptr_name) {
 
12104
                        NDR_PULL_ALLOC(ndr, r->in.name);
 
12105
                } else {
 
12106
                        r->in.name = NULL;
 
12107
                }
 
12108
                if (r->in.name) {
 
12109
                        _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12110
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.name, 0);
 
12111
                        NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
12112
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 
12113
                }
 
12114
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
 
12115
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
 
12116
                if (_ptr_hash) {
 
12117
                        NDR_PULL_ALLOC(ndr, r->in.hash);
 
12118
                } else {
 
12119
                        r->in.hash = NULL;
 
12120
                }
 
12121
                if (r->in.hash) {
 
12122
                        _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12123
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
 
12124
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
 
12125
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
 
12126
                }
 
12127
        }
 
12128
        if (flags & NDR_OUT) {
 
12129
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
12130
        }
 
12131
        return NDR_ERR_SUCCESS;
 
12132
}
 
12133
 
 
12134
_PUBLIC_ void ndr_print_samr_SetDsrmPassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDsrmPassword *r)
 
12135
{
 
12136
        ndr_print_struct(ndr, name, "samr_SetDsrmPassword");
 
12137
        ndr->depth++;
 
12138
        if (flags & NDR_SET_VALUES) {
 
12139
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
12140
        }
 
12141
        if (flags & NDR_IN) {
 
12142
                ndr_print_struct(ndr, "in", "samr_SetDsrmPassword");
 
12143
                ndr->depth++;
 
12144
                ndr_print_ptr(ndr, "name", r->in.name);
 
12145
                ndr->depth++;
 
12146
                if (r->in.name) {
 
12147
                        ndr_print_lsa_String(ndr, "name", r->in.name);
 
12148
                }
 
12149
                ndr->depth--;
 
12150
                ndr_print_uint32(ndr, "unknown", r->in.unknown);
 
12151
                ndr_print_ptr(ndr, "hash", r->in.hash);
 
12152
                ndr->depth++;
 
12153
                if (r->in.hash) {
 
12154
                        ndr_print_samr_Password(ndr, "hash", r->in.hash);
 
12155
                }
 
12156
                ndr->depth--;
 
12157
                ndr->depth--;
 
12158
        }
 
12159
        if (flags & NDR_OUT) {
 
12160
                ndr_print_struct(ndr, "out", "samr_SetDsrmPassword");
 
12161
                ndr->depth++;
 
12162
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
12163
                ndr->depth--;
 
12164
        }
 
12165
        ndr->depth--;
 
12166
}
 
12167
 
 
12168
static enum ndr_err_code ndr_push_samr_ValidatePassword(struct ndr_push *ndr, int flags, const struct samr_ValidatePassword *r)
 
12169
{
 
12170
        if (flags & NDR_IN) {
 
12171
                NDR_CHECK(ndr_push_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, r->in.level));
 
12172
                if (r->in.req == NULL) {
 
12173
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
12174
                }
 
12175
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
 
12176
                NDR_CHECK(ndr_push_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
 
12177
        }
 
12178
        if (flags & NDR_OUT) {
 
12179
                if (r->out.rep == NULL) {
 
12180
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
12181
                }
 
12182
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rep));
 
12183
                if (*r->out.rep) {
 
12184
                        NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.rep, r->in.level));
 
12185
                        NDR_CHECK(ndr_push_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
 
12186
                }
 
12187
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
12188
        }
 
12189
        return NDR_ERR_SUCCESS;
 
12190
}
 
12191
 
 
12192
static enum ndr_err_code ndr_pull_samr_ValidatePassword(struct ndr_pull *ndr, int flags, struct samr_ValidatePassword *r)
 
12193
{
 
12194
        uint32_t _ptr_rep;
 
12195
        TALLOC_CTX *_mem_save_req_0;
 
12196
        TALLOC_CTX *_mem_save_rep_0;
 
12197
        TALLOC_CTX *_mem_save_rep_1;
 
12198
        if (flags & NDR_IN) {
 
12199
                ZERO_STRUCT(r->out);
 
12200
 
 
12201
                NDR_CHECK(ndr_pull_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, &r->in.level));
 
12202
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
12203
                        NDR_PULL_ALLOC(ndr, r->in.req);
 
12204
                }
 
12205
                _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12206
                NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
 
12207
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
 
12208
                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
 
12209
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
 
12210
                NDR_PULL_ALLOC(ndr, r->out.rep);
 
12211
                ZERO_STRUCTP(r->out.rep);
 
12212
        }
 
12213
        if (flags & NDR_OUT) {
 
12214
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
12215
                        NDR_PULL_ALLOC(ndr, r->out.rep);
 
12216
                }
 
12217
                _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12218
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
 
12219
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rep));
 
12220
                if (_ptr_rep) {
 
12221
                        NDR_PULL_ALLOC(ndr, *r->out.rep);
 
12222
                } else {
 
12223
                        *r->out.rep = NULL;
 
12224
                }
 
12225
                if (*r->out.rep) {
 
12226
                        _mem_save_rep_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
12227
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.rep, 0);
 
12228
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.rep, r->in.level));
 
12229
                        NDR_CHECK(ndr_pull_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
 
12230
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_1, 0);
 
12231
                }
 
12232
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
 
12233
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
12234
        }
 
12235
        return NDR_ERR_SUCCESS;
 
12236
}
 
12237
 
 
12238
_PUBLIC_ void ndr_print_samr_ValidatePassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_ValidatePassword *r)
 
12239
{
 
12240
        ndr_print_struct(ndr, name, "samr_ValidatePassword");
 
12241
        ndr->depth++;
 
12242
        if (flags & NDR_SET_VALUES) {
 
12243
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
12244
        }
 
12245
        if (flags & NDR_IN) {
 
12246
                ndr_print_struct(ndr, "in", "samr_ValidatePassword");
 
12247
                ndr->depth++;
 
12248
                ndr_print_samr_ValidatePasswordLevel(ndr, "level", r->in.level);
 
12249
                ndr_print_ptr(ndr, "req", r->in.req);
 
12250
                ndr->depth++;
 
12251
                ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
 
12252
                ndr_print_samr_ValidatePasswordReq(ndr, "req", r->in.req);
 
12253
                ndr->depth--;
 
12254
                ndr->depth--;
 
12255
        }
 
12256
        if (flags & NDR_OUT) {
 
12257
                ndr_print_struct(ndr, "out", "samr_ValidatePassword");
 
12258
                ndr->depth++;
 
12259
                ndr_print_ptr(ndr, "rep", r->out.rep);
 
12260
                ndr->depth++;
 
12261
                ndr_print_ptr(ndr, "rep", *r->out.rep);
 
12262
                ndr->depth++;
 
12263
                if (*r->out.rep) {
 
12264
                        ndr_print_set_switch_value(ndr, *r->out.rep, r->in.level);
 
12265
                        ndr_print_samr_ValidatePasswordRep(ndr, "rep", *r->out.rep);
 
12266
                }
 
12267
                ndr->depth--;
 
12268
                ndr->depth--;
 
12269
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
12270
                ndr->depth--;
 
12271
        }
 
12272
        ndr->depth--;
 
12273
}
 
12274
 
 
12275
static const struct ndr_interface_call samr_calls[] = {
 
12276
        {
 
12277
                "samr_Connect",
 
12278
                sizeof(struct samr_Connect),
 
12279
                (ndr_push_flags_fn_t) ndr_push_samr_Connect,
 
12280
                (ndr_pull_flags_fn_t) ndr_pull_samr_Connect,
 
12281
                (ndr_print_function_t) ndr_print_samr_Connect,
 
12282
                false,
 
12283
        },
 
12284
        {
 
12285
                "samr_Close",
 
12286
                sizeof(struct samr_Close),
 
12287
                (ndr_push_flags_fn_t) ndr_push_samr_Close,
 
12288
                (ndr_pull_flags_fn_t) ndr_pull_samr_Close,
 
12289
                (ndr_print_function_t) ndr_print_samr_Close,
 
12290
                false,
 
12291
        },
 
12292
        {
 
12293
                "samr_SetSecurity",
 
12294
                sizeof(struct samr_SetSecurity),
 
12295
                (ndr_push_flags_fn_t) ndr_push_samr_SetSecurity,
 
12296
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetSecurity,
 
12297
                (ndr_print_function_t) ndr_print_samr_SetSecurity,
 
12298
                false,
 
12299
        },
 
12300
        {
 
12301
                "samr_QuerySecurity",
 
12302
                sizeof(struct samr_QuerySecurity),
 
12303
                (ndr_push_flags_fn_t) ndr_push_samr_QuerySecurity,
 
12304
                (ndr_pull_flags_fn_t) ndr_pull_samr_QuerySecurity,
 
12305
                (ndr_print_function_t) ndr_print_samr_QuerySecurity,
 
12306
                false,
 
12307
        },
 
12308
        {
 
12309
                "samr_Shutdown",
 
12310
                sizeof(struct samr_Shutdown),
 
12311
                (ndr_push_flags_fn_t) ndr_push_samr_Shutdown,
 
12312
                (ndr_pull_flags_fn_t) ndr_pull_samr_Shutdown,
 
12313
                (ndr_print_function_t) ndr_print_samr_Shutdown,
 
12314
                false,
 
12315
        },
 
12316
        {
 
12317
                "samr_LookupDomain",
 
12318
                sizeof(struct samr_LookupDomain),
 
12319
                (ndr_push_flags_fn_t) ndr_push_samr_LookupDomain,
 
12320
                (ndr_pull_flags_fn_t) ndr_pull_samr_LookupDomain,
 
12321
                (ndr_print_function_t) ndr_print_samr_LookupDomain,
 
12322
                false,
 
12323
        },
 
12324
        {
 
12325
                "samr_EnumDomains",
 
12326
                sizeof(struct samr_EnumDomains),
 
12327
                (ndr_push_flags_fn_t) ndr_push_samr_EnumDomains,
 
12328
                (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomains,
 
12329
                (ndr_print_function_t) ndr_print_samr_EnumDomains,
 
12330
                false,
 
12331
        },
 
12332
        {
 
12333
                "samr_OpenDomain",
 
12334
                sizeof(struct samr_OpenDomain),
 
12335
                (ndr_push_flags_fn_t) ndr_push_samr_OpenDomain,
 
12336
                (ndr_pull_flags_fn_t) ndr_pull_samr_OpenDomain,
 
12337
                (ndr_print_function_t) ndr_print_samr_OpenDomain,
 
12338
                false,
 
12339
        },
 
12340
        {
 
12341
                "samr_QueryDomainInfo",
 
12342
                sizeof(struct samr_QueryDomainInfo),
 
12343
                (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo,
 
12344
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo,
 
12345
                (ndr_print_function_t) ndr_print_samr_QueryDomainInfo,
 
12346
                false,
 
12347
        },
 
12348
        {
 
12349
                "samr_SetDomainInfo",
 
12350
                sizeof(struct samr_SetDomainInfo),
 
12351
                (ndr_push_flags_fn_t) ndr_push_samr_SetDomainInfo,
 
12352
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetDomainInfo,
 
12353
                (ndr_print_function_t) ndr_print_samr_SetDomainInfo,
 
12354
                false,
 
12355
        },
 
12356
        {
 
12357
                "samr_CreateDomainGroup",
 
12358
                sizeof(struct samr_CreateDomainGroup),
 
12359
                (ndr_push_flags_fn_t) ndr_push_samr_CreateDomainGroup,
 
12360
                (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomainGroup,
 
12361
                (ndr_print_function_t) ndr_print_samr_CreateDomainGroup,
 
12362
                false,
 
12363
        },
 
12364
        {
 
12365
                "samr_EnumDomainGroups",
 
12366
                sizeof(struct samr_EnumDomainGroups),
 
12367
                (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainGroups,
 
12368
                (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainGroups,
 
12369
                (ndr_print_function_t) ndr_print_samr_EnumDomainGroups,
 
12370
                false,
 
12371
        },
 
12372
        {
 
12373
                "samr_CreateUser",
 
12374
                sizeof(struct samr_CreateUser),
 
12375
                (ndr_push_flags_fn_t) ndr_push_samr_CreateUser,
 
12376
                (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser,
 
12377
                (ndr_print_function_t) ndr_print_samr_CreateUser,
 
12378
                false,
 
12379
        },
 
12380
        {
 
12381
                "samr_EnumDomainUsers",
 
12382
                sizeof(struct samr_EnumDomainUsers),
 
12383
                (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainUsers,
 
12384
                (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainUsers,
 
12385
                (ndr_print_function_t) ndr_print_samr_EnumDomainUsers,
 
12386
                false,
 
12387
        },
 
12388
        {
 
12389
                "samr_CreateDomAlias",
 
12390
                sizeof(struct samr_CreateDomAlias),
 
12391
                (ndr_push_flags_fn_t) ndr_push_samr_CreateDomAlias,
 
12392
                (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomAlias,
 
12393
                (ndr_print_function_t) ndr_print_samr_CreateDomAlias,
 
12394
                false,
 
12395
        },
 
12396
        {
 
12397
                "samr_EnumDomainAliases",
 
12398
                sizeof(struct samr_EnumDomainAliases),
 
12399
                (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainAliases,
 
12400
                (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainAliases,
 
12401
                (ndr_print_function_t) ndr_print_samr_EnumDomainAliases,
 
12402
                false,
 
12403
        },
 
12404
        {
 
12405
                "samr_GetAliasMembership",
 
12406
                sizeof(struct samr_GetAliasMembership),
 
12407
                (ndr_push_flags_fn_t) ndr_push_samr_GetAliasMembership,
 
12408
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetAliasMembership,
 
12409
                (ndr_print_function_t) ndr_print_samr_GetAliasMembership,
 
12410
                false,
 
12411
        },
 
12412
        {
 
12413
                "samr_LookupNames",
 
12414
                sizeof(struct samr_LookupNames),
 
12415
                (ndr_push_flags_fn_t) ndr_push_samr_LookupNames,
 
12416
                (ndr_pull_flags_fn_t) ndr_pull_samr_LookupNames,
 
12417
                (ndr_print_function_t) ndr_print_samr_LookupNames,
 
12418
                false,
 
12419
        },
 
12420
        {
 
12421
                "samr_LookupRids",
 
12422
                sizeof(struct samr_LookupRids),
 
12423
                (ndr_push_flags_fn_t) ndr_push_samr_LookupRids,
 
12424
                (ndr_pull_flags_fn_t) ndr_pull_samr_LookupRids,
 
12425
                (ndr_print_function_t) ndr_print_samr_LookupRids,
 
12426
                false,
 
12427
        },
 
12428
        {
 
12429
                "samr_OpenGroup",
 
12430
                sizeof(struct samr_OpenGroup),
 
12431
                (ndr_push_flags_fn_t) ndr_push_samr_OpenGroup,
 
12432
                (ndr_pull_flags_fn_t) ndr_pull_samr_OpenGroup,
 
12433
                (ndr_print_function_t) ndr_print_samr_OpenGroup,
 
12434
                false,
 
12435
        },
 
12436
        {
 
12437
                "samr_QueryGroupInfo",
 
12438
                sizeof(struct samr_QueryGroupInfo),
 
12439
                (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupInfo,
 
12440
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupInfo,
 
12441
                (ndr_print_function_t) ndr_print_samr_QueryGroupInfo,
 
12442
                false,
 
12443
        },
 
12444
        {
 
12445
                "samr_SetGroupInfo",
 
12446
                sizeof(struct samr_SetGroupInfo),
 
12447
                (ndr_push_flags_fn_t) ndr_push_samr_SetGroupInfo,
 
12448
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetGroupInfo,
 
12449
                (ndr_print_function_t) ndr_print_samr_SetGroupInfo,
 
12450
                false,
 
12451
        },
 
12452
        {
 
12453
                "samr_AddGroupMember",
 
12454
                sizeof(struct samr_AddGroupMember),
 
12455
                (ndr_push_flags_fn_t) ndr_push_samr_AddGroupMember,
 
12456
                (ndr_pull_flags_fn_t) ndr_pull_samr_AddGroupMember,
 
12457
                (ndr_print_function_t) ndr_print_samr_AddGroupMember,
 
12458
                false,
 
12459
        },
 
12460
        {
 
12461
                "samr_DeleteDomainGroup",
 
12462
                sizeof(struct samr_DeleteDomainGroup),
 
12463
                (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomainGroup,
 
12464
                (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomainGroup,
 
12465
                (ndr_print_function_t) ndr_print_samr_DeleteDomainGroup,
 
12466
                false,
 
12467
        },
 
12468
        {
 
12469
                "samr_DeleteGroupMember",
 
12470
                sizeof(struct samr_DeleteGroupMember),
 
12471
                (ndr_push_flags_fn_t) ndr_push_samr_DeleteGroupMember,
 
12472
                (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteGroupMember,
 
12473
                (ndr_print_function_t) ndr_print_samr_DeleteGroupMember,
 
12474
                false,
 
12475
        },
 
12476
        {
 
12477
                "samr_QueryGroupMember",
 
12478
                sizeof(struct samr_QueryGroupMember),
 
12479
                (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupMember,
 
12480
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupMember,
 
12481
                (ndr_print_function_t) ndr_print_samr_QueryGroupMember,
 
12482
                false,
 
12483
        },
 
12484
        {
 
12485
                "samr_SetMemberAttributesOfGroup",
 
12486
                sizeof(struct samr_SetMemberAttributesOfGroup),
 
12487
                (ndr_push_flags_fn_t) ndr_push_samr_SetMemberAttributesOfGroup,
 
12488
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetMemberAttributesOfGroup,
 
12489
                (ndr_print_function_t) ndr_print_samr_SetMemberAttributesOfGroup,
 
12490
                false,
 
12491
        },
 
12492
        {
 
12493
                "samr_OpenAlias",
 
12494
                sizeof(struct samr_OpenAlias),
 
12495
                (ndr_push_flags_fn_t) ndr_push_samr_OpenAlias,
 
12496
                (ndr_pull_flags_fn_t) ndr_pull_samr_OpenAlias,
 
12497
                (ndr_print_function_t) ndr_print_samr_OpenAlias,
 
12498
                false,
 
12499
        },
 
12500
        {
 
12501
                "samr_QueryAliasInfo",
 
12502
                sizeof(struct samr_QueryAliasInfo),
 
12503
                (ndr_push_flags_fn_t) ndr_push_samr_QueryAliasInfo,
 
12504
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryAliasInfo,
 
12505
                (ndr_print_function_t) ndr_print_samr_QueryAliasInfo,
 
12506
                false,
 
12507
        },
 
12508
        {
 
12509
                "samr_SetAliasInfo",
 
12510
                sizeof(struct samr_SetAliasInfo),
 
12511
                (ndr_push_flags_fn_t) ndr_push_samr_SetAliasInfo,
 
12512
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetAliasInfo,
 
12513
                (ndr_print_function_t) ndr_print_samr_SetAliasInfo,
 
12514
                false,
 
12515
        },
 
12516
        {
 
12517
                "samr_DeleteDomAlias",
 
12518
                sizeof(struct samr_DeleteDomAlias),
 
12519
                (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomAlias,
 
12520
                (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomAlias,
 
12521
                (ndr_print_function_t) ndr_print_samr_DeleteDomAlias,
 
12522
                false,
 
12523
        },
 
12524
        {
 
12525
                "samr_AddAliasMember",
 
12526
                sizeof(struct samr_AddAliasMember),
 
12527
                (ndr_push_flags_fn_t) ndr_push_samr_AddAliasMember,
 
12528
                (ndr_pull_flags_fn_t) ndr_pull_samr_AddAliasMember,
 
12529
                (ndr_print_function_t) ndr_print_samr_AddAliasMember,
 
12530
                false,
 
12531
        },
 
12532
        {
 
12533
                "samr_DeleteAliasMember",
 
12534
                sizeof(struct samr_DeleteAliasMember),
 
12535
                (ndr_push_flags_fn_t) ndr_push_samr_DeleteAliasMember,
 
12536
                (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteAliasMember,
 
12537
                (ndr_print_function_t) ndr_print_samr_DeleteAliasMember,
 
12538
                false,
 
12539
        },
 
12540
        {
 
12541
                "samr_GetMembersInAlias",
 
12542
                sizeof(struct samr_GetMembersInAlias),
 
12543
                (ndr_push_flags_fn_t) ndr_push_samr_GetMembersInAlias,
 
12544
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetMembersInAlias,
 
12545
                (ndr_print_function_t) ndr_print_samr_GetMembersInAlias,
 
12546
                false,
 
12547
        },
 
12548
        {
 
12549
                "samr_OpenUser",
 
12550
                sizeof(struct samr_OpenUser),
 
12551
                (ndr_push_flags_fn_t) ndr_push_samr_OpenUser,
 
12552
                (ndr_pull_flags_fn_t) ndr_pull_samr_OpenUser,
 
12553
                (ndr_print_function_t) ndr_print_samr_OpenUser,
 
12554
                false,
 
12555
        },
 
12556
        {
 
12557
                "samr_DeleteUser",
 
12558
                sizeof(struct samr_DeleteUser),
 
12559
                (ndr_push_flags_fn_t) ndr_push_samr_DeleteUser,
 
12560
                (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteUser,
 
12561
                (ndr_print_function_t) ndr_print_samr_DeleteUser,
 
12562
                false,
 
12563
        },
 
12564
        {
 
12565
                "samr_QueryUserInfo",
 
12566
                sizeof(struct samr_QueryUserInfo),
 
12567
                (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo,
 
12568
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo,
 
12569
                (ndr_print_function_t) ndr_print_samr_QueryUserInfo,
 
12570
                false,
 
12571
        },
 
12572
        {
 
12573
                "samr_SetUserInfo",
 
12574
                sizeof(struct samr_SetUserInfo),
 
12575
                (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo,
 
12576
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo,
 
12577
                (ndr_print_function_t) ndr_print_samr_SetUserInfo,
 
12578
                false,
 
12579
        },
 
12580
        {
 
12581
                "samr_ChangePasswordUser",
 
12582
                sizeof(struct samr_ChangePasswordUser),
 
12583
                (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser,
 
12584
                (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser,
 
12585
                (ndr_print_function_t) ndr_print_samr_ChangePasswordUser,
 
12586
                false,
 
12587
        },
 
12588
        {
 
12589
                "samr_GetGroupsForUser",
 
12590
                sizeof(struct samr_GetGroupsForUser),
 
12591
                (ndr_push_flags_fn_t) ndr_push_samr_GetGroupsForUser,
 
12592
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetGroupsForUser,
 
12593
                (ndr_print_function_t) ndr_print_samr_GetGroupsForUser,
 
12594
                false,
 
12595
        },
 
12596
        {
 
12597
                "samr_QueryDisplayInfo",
 
12598
                sizeof(struct samr_QueryDisplayInfo),
 
12599
                (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo,
 
12600
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo,
 
12601
                (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo,
 
12602
                false,
 
12603
        },
 
12604
        {
 
12605
                "samr_GetDisplayEnumerationIndex",
 
12606
                sizeof(struct samr_GetDisplayEnumerationIndex),
 
12607
                (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex,
 
12608
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex,
 
12609
                (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex,
 
12610
                false,
 
12611
        },
 
12612
        {
 
12613
                "samr_TestPrivateFunctionsDomain",
 
12614
                sizeof(struct samr_TestPrivateFunctionsDomain),
 
12615
                (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsDomain,
 
12616
                (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsDomain,
 
12617
                (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsDomain,
 
12618
                false,
 
12619
        },
 
12620
        {
 
12621
                "samr_TestPrivateFunctionsUser",
 
12622
                sizeof(struct samr_TestPrivateFunctionsUser),
 
12623
                (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsUser,
 
12624
                (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsUser,
 
12625
                (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsUser,
 
12626
                false,
 
12627
        },
 
12628
        {
 
12629
                "samr_GetUserPwInfo",
 
12630
                sizeof(struct samr_GetUserPwInfo),
 
12631
                (ndr_push_flags_fn_t) ndr_push_samr_GetUserPwInfo,
 
12632
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetUserPwInfo,
 
12633
                (ndr_print_function_t) ndr_print_samr_GetUserPwInfo,
 
12634
                false,
 
12635
        },
 
12636
        {
 
12637
                "samr_RemoveMemberFromForeignDomain",
 
12638
                sizeof(struct samr_RemoveMemberFromForeignDomain),
 
12639
                (ndr_push_flags_fn_t) ndr_push_samr_RemoveMemberFromForeignDomain,
 
12640
                (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMemberFromForeignDomain,
 
12641
                (ndr_print_function_t) ndr_print_samr_RemoveMemberFromForeignDomain,
 
12642
                false,
 
12643
        },
 
12644
        {
 
12645
                "samr_QueryDomainInfo2",
 
12646
                sizeof(struct samr_QueryDomainInfo2),
 
12647
                (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo2,
 
12648
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo2,
 
12649
                (ndr_print_function_t) ndr_print_samr_QueryDomainInfo2,
 
12650
                false,
 
12651
        },
 
12652
        {
 
12653
                "samr_QueryUserInfo2",
 
12654
                sizeof(struct samr_QueryUserInfo2),
 
12655
                (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo2,
 
12656
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo2,
 
12657
                (ndr_print_function_t) ndr_print_samr_QueryUserInfo2,
 
12658
                false,
 
12659
        },
 
12660
        {
 
12661
                "samr_QueryDisplayInfo2",
 
12662
                sizeof(struct samr_QueryDisplayInfo2),
 
12663
                (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo2,
 
12664
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo2,
 
12665
                (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo2,
 
12666
                false,
 
12667
        },
 
12668
        {
 
12669
                "samr_GetDisplayEnumerationIndex2",
 
12670
                sizeof(struct samr_GetDisplayEnumerationIndex2),
 
12671
                (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex2,
 
12672
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex2,
 
12673
                (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex2,
 
12674
                false,
 
12675
        },
 
12676
        {
 
12677
                "samr_CreateUser2",
 
12678
                sizeof(struct samr_CreateUser2),
 
12679
                (ndr_push_flags_fn_t) ndr_push_samr_CreateUser2,
 
12680
                (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser2,
 
12681
                (ndr_print_function_t) ndr_print_samr_CreateUser2,
 
12682
                false,
 
12683
        },
 
12684
        {
 
12685
                "samr_QueryDisplayInfo3",
 
12686
                sizeof(struct samr_QueryDisplayInfo3),
 
12687
                (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo3,
 
12688
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo3,
 
12689
                (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo3,
 
12690
                false,
 
12691
        },
 
12692
        {
 
12693
                "samr_AddMultipleMembersToAlias",
 
12694
                sizeof(struct samr_AddMultipleMembersToAlias),
 
12695
                (ndr_push_flags_fn_t) ndr_push_samr_AddMultipleMembersToAlias,
 
12696
                (ndr_pull_flags_fn_t) ndr_pull_samr_AddMultipleMembersToAlias,
 
12697
                (ndr_print_function_t) ndr_print_samr_AddMultipleMembersToAlias,
 
12698
                false,
 
12699
        },
 
12700
        {
 
12701
                "samr_RemoveMultipleMembersFromAlias",
 
12702
                sizeof(struct samr_RemoveMultipleMembersFromAlias),
 
12703
                (ndr_push_flags_fn_t) ndr_push_samr_RemoveMultipleMembersFromAlias,
 
12704
                (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMultipleMembersFromAlias,
 
12705
                (ndr_print_function_t) ndr_print_samr_RemoveMultipleMembersFromAlias,
 
12706
                false,
 
12707
        },
 
12708
        {
 
12709
                "samr_OemChangePasswordUser2",
 
12710
                sizeof(struct samr_OemChangePasswordUser2),
 
12711
                (ndr_push_flags_fn_t) ndr_push_samr_OemChangePasswordUser2,
 
12712
                (ndr_pull_flags_fn_t) ndr_pull_samr_OemChangePasswordUser2,
 
12713
                (ndr_print_function_t) ndr_print_samr_OemChangePasswordUser2,
 
12714
                false,
 
12715
        },
 
12716
        {
 
12717
                "samr_ChangePasswordUser2",
 
12718
                sizeof(struct samr_ChangePasswordUser2),
 
12719
                (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser2,
 
12720
                (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser2,
 
12721
                (ndr_print_function_t) ndr_print_samr_ChangePasswordUser2,
 
12722
                false,
 
12723
        },
 
12724
        {
 
12725
                "samr_GetDomPwInfo",
 
12726
                sizeof(struct samr_GetDomPwInfo),
 
12727
                (ndr_push_flags_fn_t) ndr_push_samr_GetDomPwInfo,
 
12728
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetDomPwInfo,
 
12729
                (ndr_print_function_t) ndr_print_samr_GetDomPwInfo,
 
12730
                false,
 
12731
        },
 
12732
        {
 
12733
                "samr_Connect2",
 
12734
                sizeof(struct samr_Connect2),
 
12735
                (ndr_push_flags_fn_t) ndr_push_samr_Connect2,
 
12736
                (ndr_pull_flags_fn_t) ndr_pull_samr_Connect2,
 
12737
                (ndr_print_function_t) ndr_print_samr_Connect2,
 
12738
                false,
 
12739
        },
 
12740
        {
 
12741
                "samr_SetUserInfo2",
 
12742
                sizeof(struct samr_SetUserInfo2),
 
12743
                (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo2,
 
12744
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo2,
 
12745
                (ndr_print_function_t) ndr_print_samr_SetUserInfo2,
 
12746
                false,
 
12747
        },
 
12748
        {
 
12749
                "samr_SetBootKeyInformation",
 
12750
                sizeof(struct samr_SetBootKeyInformation),
 
12751
                (ndr_push_flags_fn_t) ndr_push_samr_SetBootKeyInformation,
 
12752
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetBootKeyInformation,
 
12753
                (ndr_print_function_t) ndr_print_samr_SetBootKeyInformation,
 
12754
                false,
 
12755
        },
 
12756
        {
 
12757
                "samr_GetBootKeyInformation",
 
12758
                sizeof(struct samr_GetBootKeyInformation),
 
12759
                (ndr_push_flags_fn_t) ndr_push_samr_GetBootKeyInformation,
 
12760
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetBootKeyInformation,
 
12761
                (ndr_print_function_t) ndr_print_samr_GetBootKeyInformation,
 
12762
                false,
 
12763
        },
 
12764
        {
 
12765
                "samr_Connect3",
 
12766
                sizeof(struct samr_Connect3),
 
12767
                (ndr_push_flags_fn_t) ndr_push_samr_Connect3,
 
12768
                (ndr_pull_flags_fn_t) ndr_pull_samr_Connect3,
 
12769
                (ndr_print_function_t) ndr_print_samr_Connect3,
 
12770
                false,
 
12771
        },
 
12772
        {
 
12773
                "samr_Connect4",
 
12774
                sizeof(struct samr_Connect4),
 
12775
                (ndr_push_flags_fn_t) ndr_push_samr_Connect4,
 
12776
                (ndr_pull_flags_fn_t) ndr_pull_samr_Connect4,
 
12777
                (ndr_print_function_t) ndr_print_samr_Connect4,
 
12778
                false,
 
12779
        },
 
12780
        {
 
12781
                "samr_ChangePasswordUser3",
 
12782
                sizeof(struct samr_ChangePasswordUser3),
 
12783
                (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser3,
 
12784
                (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser3,
 
12785
                (ndr_print_function_t) ndr_print_samr_ChangePasswordUser3,
 
12786
                false,
 
12787
        },
 
12788
        {
 
12789
                "samr_Connect5",
 
12790
                sizeof(struct samr_Connect5),
 
12791
                (ndr_push_flags_fn_t) ndr_push_samr_Connect5,
 
12792
                (ndr_pull_flags_fn_t) ndr_pull_samr_Connect5,
 
12793
                (ndr_print_function_t) ndr_print_samr_Connect5,
 
12794
                false,
 
12795
        },
 
12796
        {
 
12797
                "samr_RidToSid",
 
12798
                sizeof(struct samr_RidToSid),
 
12799
                (ndr_push_flags_fn_t) ndr_push_samr_RidToSid,
 
12800
                (ndr_pull_flags_fn_t) ndr_pull_samr_RidToSid,
 
12801
                (ndr_print_function_t) ndr_print_samr_RidToSid,
 
12802
                false,
 
12803
        },
 
12804
        {
 
12805
                "samr_SetDsrmPassword",
 
12806
                sizeof(struct samr_SetDsrmPassword),
 
12807
                (ndr_push_flags_fn_t) ndr_push_samr_SetDsrmPassword,
 
12808
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetDsrmPassword,
 
12809
                (ndr_print_function_t) ndr_print_samr_SetDsrmPassword,
 
12810
                false,
 
12811
        },
 
12812
        {
 
12813
                "samr_ValidatePassword",
 
12814
                sizeof(struct samr_ValidatePassword),
 
12815
                (ndr_push_flags_fn_t) ndr_push_samr_ValidatePassword,
 
12816
                (ndr_pull_flags_fn_t) ndr_pull_samr_ValidatePassword,
 
12817
                (ndr_print_function_t) ndr_print_samr_ValidatePassword,
 
12818
                false,
 
12819
        },
 
12820
        { NULL, 0, NULL, NULL, NULL, false }
 
12821
};
 
12822
 
 
12823
static const char * const samr_endpoint_strings[] = {
 
12824
        "ncacn_np:[\\pipe\\samr]", 
 
12825
        "ncacn_ip_tcp:", 
 
12826
        "ncalrpc:", 
 
12827
};
 
12828
 
 
12829
static const struct ndr_interface_string_array samr_endpoints = {
 
12830
        .count  = 3,
 
12831
        .names  = samr_endpoint_strings
 
12832
};
 
12833
 
 
12834
static const char * const samr_authservice_strings[] = {
 
12835
        "host", 
 
12836
};
 
12837
 
 
12838
static const struct ndr_interface_string_array samr_authservices = {
 
12839
        .count  = 1,
 
12840
        .names  = samr_authservice_strings
 
12841
};
 
12842
 
 
12843
 
 
12844
const struct ndr_interface_table ndr_table_samr = {
 
12845
        .name           = "samr",
 
12846
        .syntax_id      = {
 
12847
                {0x12345778,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xac}},
 
12848
                NDR_SAMR_VERSION
 
12849
        },
 
12850
        .helpstring     = NDR_SAMR_HELPSTRING,
 
12851
        .num_calls      = 68,
 
12852
        .calls          = samr_calls,
 
12853
        .endpoints      = &samr_endpoints,
 
12854
        .authservices   = &samr_authservices
 
12855
};
 
12856